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:
- 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.
- If either operand is an object, it is converted to a string.
- If both operands are boolean and the operation is ==, !=,
then proceed without a type conversion.
- 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.
- If both are numeric, but not of equal types. Give priority
to floating
point, then 64-bit integer, then integer, then boolean.