Language Syntax

Embedded JavaScript is case sensitive and uses ASCII as its character set. White space between tokens is ignored with the exception that statements that omit trailing semicolons must be on a line by themselves.

Comments can use either the C commenting style with text between /* */ delimiters, or the C++ style may be used where text from // to the end of the line is regarded as a comment.

Identifiers are names used for variables and functions. Identifiers must begin with either a letter, and underscore '_' or a dollar sign. Identifiers must not use equal any reserved word from the table below:

Reserved Words

Embedded JavaScript regards all these words as reserved.

delete	else	false	for
function	if	in	new
null	return	this	true
var

Embedded JavaScript also regards these words as reserved. They are not yet implemented, but users should avoid them for future compatibility.

break	case	catch	continue
default	do	finally	instanceof
switch	throw	try	typeof
void	while	with

It is also recommended that you do not use any of the following words. ECMA may implement them in future standards

abstract	boolean	byte	char
class	const	debugger	double
enum	export	extends	final
float	goto	implements	import
int	interface	long	native
package	private	protected	public
short	static	super	synchronized
throws	transient	volatile

Primitive Data Types

Variables are declared either by the var keyword or by simply assigning a value to a new variable name. In JavaScript is is not essential to declare variables before using them. However, it is considered good practice to do so.

JavaScript does not have explicit type declarations. They are not given an explicit type when declared. The underling type of a variable is determined by the type of the data stored in the variable. For example:

var x;

x = "Hello World";

This will cause the variable x to store the string "Hello World". Embedded JavaScript will store this as the primitive String data type. If this variable is assigned an integer, the underlying type will be changed. For example:

x = 55;

The x variable will not hold an integer primitive type with a value of 55. If x is used in expressions, its value will be copied and converted to other types as required.

Embedded JavaScript supports the following primitive data types. These types can be combined in objects to create arbitrary structured data types.

• Boolean
• Floating Point
• Integer
• 64-bit Integer
• Strings

JavaScript will automatically convert variables from one type to another as required by the current expression.

Numeric Type

The ECMA standard specifies that JavaScript numerics are stored and manipulated as floating point entities. For embedded uses, this is often less than ideal. Consequently, EJS allows the default numeric type to be selected at build time. Binary releases typically select 32-bit integer as the default numeric type. Note that floating point can still be used and expressions can still be explicitly converted to floating point by multiplying by 1.0.

Boolean Type

A boolean value can be either true or false. Assigning either true or false to a variable or the result of a conditional expression will set the type of a variable to boolean. The following example will set x to true.

var y = 1;
var x = (y == 1);

EJS defines the global variables true and false with the appropriate boolean values.

Integer Type

The default numeric type for is a 32-bit integer and integer literals are 32-bit integers. Integer literals may be specified as octal values by prefixing with a '0' or hexadecimal by prefixing with 0x or 0X.

64-bit integers are also supported if the EJS is built with the default numeric type set to be 64-bit integers.

Floating Point Type

Floating point numbers are stored as C doubles. Floating point literals may be specified simply by using a decimal point in the literal. For example:

var pi = 3.14;

Floating point literals can also use an exponential notation of the form: floating number followed by 'e' or 'E', followed by an optional sign '+' or '-', followed by an integer exponent. I.e.

[digits] [.digits] [E|e] [(+|-)digits]

For example:

var pi = 3.14e1;
var pi = 314.0e-2;

Embedded JavaScript also defines two useful floating point constants. The global variable NaN is set to the "not a number" value. This value is the result when a math operation gives an undefined value or error. For example, divide by zero will result in the NaN value.

The other constant is Infinity. If a floating point operation overflows the largest possible floating number, the result is equal to the Infinity value.

String Type

JavaScript strings are immutable sequences of ASCII letters or escaped literals. They are primitive types and are not treated as objects. This means that they are always passed by value and not by reference. String literals may be enclosed in either single or double quotes.

JavaScript strings are easy to work with due to the inbuilt ability to append strings via the "+" operator. For example:

var str = "Happy Birthday " + name;

EJS supports the following escaped letters inside string literals:

Escape Sequence	Description
\b	Backspace (0x8)
\f	Form feed (0xc)
\n	New line (0xa)
\r	Carriage return (0xd)
\t	Horizontal tab (0x9)
\v	Vertical tab (0xb)
\uNNNN	Unicode character (0xNNNN)
\xNN	Hexadecimal characgter (0xNN)
\NNN	Octal character (ONNN)
\'	Literal single quote
\"	Literal double quote
\\	Literal backslash

Functions

A JavaScript function is a JavaScript that can be executed by name with supplied arguments. Functions are declared via the function keyword followed by optional arguments and a function body contained within braces. For example:

function myPoint(x, y)
{
    return x + y;
}

Functions can use a return statement to return an arbitrary value value. This may be a primitive type or it may be a reference to an object.

To invoke a function, the function name is used with the () operator following. The actual arguments are supplied within the "()" . The arguments to the function are evaluated left to right. For example:

var x = myPoint(1, y + 7);

Functions may also be assigned to properties of objects to create methods.

Scope and the Function Call Object

When functions are invoked, EJS creates a new set of local variables for use by the function. EJS also creates several objects to describe the function call.

The function call arguments are passed in as named parameters and they are also stored in the arguments[] array. The arguments array allows functions to be written to take a variable number of arguments.  For example:

function max()
{
    biggest = 0;
   
    for (i = 0; i < arguments.length; i++) {
        if (arguments[i] > biggest) {
            biggest = arguments[i];
        }
    }
}

EJS also defines a callee object property in the arguments object. The callee property has a length property member that stores the expected number of arguments by the function. For example:

function myFunc(x, y)
{
    if (arguments.callee.length != 2) {
        // Error
    }
}

NOTE: JavaScript and EJS do not validate the number of arguments supplied to a function at run-time.

Embedded JavaScript does not implement a few capabilities from the ECMA specification relating to functions. These include nested functions, the prototype property and the apply and call methods.

Variables

Variable Scope

JavaScript defines two scopes for variables: global and local. Global variables are shared among functions that execute in a single JavaScript program. Local variables are created for each function and are destroyed on function exit. Objects are created on an object heap and references to the objects may be stored in either the global or local variable stores.

As described earlier, JavaScript variables may be optionally declared via the var statement. When used inside a function, the variable is created in the local variable store. If used outside any function, the variable is created in the global store.

If a variable is assigned to without a prior var statement, then the variable is always created on the global store.

Undefined and Null

If a variable is declared but not assigned, its value is said to be undefined. For example:

var x;

This declares a variable x, but does not assign it a value. All such unassigned variables are set to the undefined value. Variables can be tested for equality with undefined. For example:

if (x == undefined) {
    // X does not yet have a value
}

Do not confuse undefined with null. The null value implies that a variables does not point to a valid object. You can assign null to a variable to disconnect the variable from pointing to an object.

Type Conversions

JavaScript will usually handle type conversions for you automatically. Adding a numeric to a string will cause the number to be converted to a string and appended to the left hand side string. Adding an integer to a floating point will cause the integer to be converted to a floating point prior to the arithmetic.

If you want to explicitly force a type conversion, use the following

Initial Type	Target Type	Action	Example
Integer	String	Add a string on the right	num + "";
String	Integer	Add a numeric on the right	1 + string;
Integer	Floating Point	Mulitply by 1.0	num * 1.0
Object	String	Invoke the toString method	o.toString()

Type Conversion Rules

Embedded JavaScript observes the following type conversion rules:

1. If the left operand is a string, the right hand operand will be converted to a string. If both operands are numeric, a numeric operation is done.
2. If either operand is an object, it is converted to a string.
3. If both operands are boolean and the operation is ==, !=, then proceed without a type conversion.
   
4. If one operand is a string and the other is a numeric, try to convert the string to a number. Otherwise, try to convert the numeric to a string.
5. If both are numeric, but not of equal types. Give priority to floating point, then 64-bit integer, then integer, then boolean.