Sequence

Assignment

Conditional

Logical-or

| |

Logical-and

Bitwise-or

Bitwise-xor

Bitwise-and

Equality

Relational

Bitwise shift

Addition, substraction

Multiply, divide

Negation, increment, typeof

Call

New

Property

Returns the value of variable. See Identifier Syntax for the syntax of variables.

If variable doesn't exist, an error is signalled. This is not the same as referencing an existing variable whose value is the undefined value—which is legal and returns the undefined value.

When used in the body of a with statement, a variable reference is first looked up as a property of the current default value.

Returns the value of the name property of value, or the undefined value if this property is not defined. See Identifier Syntax for the syntax of name.

Examples:

Because name must be a valid identifier, this form cannot be used to access properties which don't have a valid identifier syntax. For example, the numeric properties of an array cannot be accessed this way:

For these properties, use the second syntax.

Same as the previous syntax, except that this time name is an evaluated expression which yields the property name.

Examples:

Assigns the value of expression to variable. If variable does not exist, it is created as a global variable.

Examples:

The whole expression returns the value of expression.

Assigns the value of expression to the given property.

If value doesn't have such a property, then if it is either an array or an object, the property is created; otherwise, an error is signalled.

Examples:

The whole expression returns the value of expression.

X = X+1

X++

Same as ++X, but returns the initial value of X instead of its new value.

X = X-1

Same as --X, but returns the initial value of X instead of its new value.

X += Y

X = X + Y

X -= Y

X = X - Y

X *= Y

X = X * Y

X /= Y

X = X / Y

X %= Y

X = X % Y

X <<= Y

X = X << Y

X >>= Y

X = X >> Y

X >>>= Y

X = X >>> Y

X &= Y

X = X & Y

X ^= Y

X = X ^ Y

X |= Y

X = X | Y

Calls function with the given arguments, and returns the result of the call.

Examples:

Function is typically either a variable reference or a property access, but it can be any arbitrary expression; the expression must yield a function value, or an error is signalled.

Examples:

When referenced in a method, returns the current calling object; when referenced in a constructor, returns the object currently being initialized. Otherwise, returns the global object. See Objects for examples.

Returns an array containing the arguments of the current function. When used outside of a function, an error is signalled.

For example, the following function returns the sum of all its arguments:

The call sum(1, 3, 5) returns 9.

new constructor(arg1, ..., argn)

Calls the constructor with the given arguments, and returns the created value.

Examples:

Constructor is typically a variable reference, but it can be any arbitrary expression.

Example:

typeof value

Returns a string representing the type of value, as follows:

"object"

"boolean"

"date"

"function"

"object"

"number"

"object"

"string"

"undefined"

delete variable

Delete the global variable variable. This doesn't mean that the value in variable is deleted, but that variable is removed from the global environment.

Example:

If variable is a local variable, an error is signalled; if variable is not a known variable, nothing happens.

The whole expression returns the true value.

Note for C/C++ programmers: This operator has a radically different meaning than in C++, where it is used to delete objects, not variables and properties.

delete value.name

delete value[name]

Remove the property name from the object value.

If value doesn't contain the name property, this expression does nothing. If the property does exist but cannot be deleted, an error is signalled. If value is not an object, an error is signalled.

The whole expression returns the true value.

expression1 , expression2

Evaluates sequentially expression1 and expression2, and returns the value of expression2. The value of expression1 is ignored.

The most common use for this operator is inside for loops, where it can be used to evaluate several expressions where a single expression is expected:

Arithmetic operators.

These operators perform the usual arithmetic operations. In addition, the + operator can be used to concatenate strings. See Numeric Operators and String Operators.

Equality operators.

These operators can be used to compare numbers and strings; see Numeric Operators and String Operators.

For other types of values, such as dates, arrays, objects, and so forth, the == operator is true if, and only if, X and Y are the exact same value. For example:

Relational operators.

These operators can be used to compare numbers and strings. See Numeric Operators and String Operators.

Bitwise operators.

See Numeric Operators.

Logical operators.

See Logical Operators.