- Operators
- Addition Operator
- Assignment Operator
- Bitwise AND Operator
- Bitwise Exclusive-Or (XOR) Operator
- Bitwise OR Operator
- Bitwise Negate Operator
- Concatenation Operator
- Conditional Operator
- Division Operator
- Equality Operator
- Greater Than Operator
- Greater Than or Equal Operator
- Inequality Operator
- Less Than Operator
- Less Than or Equal Operator
- Logical AND Operator
- Logical NOT Operator
- Logical OR Operator
- Modulo Operator
- Multiplication Operator
- Negation Operator
- Post-Decrement Operator
- Post-Increment Operator
- Pre-Decrement Operator
- Pre-Increment Operator
- Shift Left Operator
- Sign-Propagating Shift Right Operator
- Shorthand Assignment Operator
- Subtraction Operator
- Zero-Fill Shift Right Operator

- Order of precedence

JavaScript expressions use special symbols called operators to perform arithmetic and string manipulation. This appendix explains what the various operators do, as well as operator precedence (which operator is used first).

Operators may be unary, binary, or ternary. A unary operator uses a single value, or operand. A binary operator uses two operands. A ternary operator uses three operands.

The addition operator is a binary operator. The syntax is

operand1+operand2

The value of this expression is the arithmetic sum of *operand1* and
*operand2*.

Example:

var tmp = 4 + 7.3;

In this example, *operand1* is 4 and *operand2* is 7.3. tmp is set
to 11.3, the arithmetic sum of *operand1* (4) and *operand2* (7.3).

The assignment operator is a binary operator. The syntax is

operand1=operand2

The value of this expression is that of *operand2*. The value of
*operand2* is copied to *operand1*.

Example:

var tmp = 2;

In this example, *operand1* is tmp and *operand2* is 2.
*operand1* (tmp) is set to the value of *operand2* (2).

The bitwise AND operator is a binary operator. The syntax is

operand1&operand2

You obtain the result of this expression by treating *operand1*,
*operand2*, and the result as sets of 32 bits. Each bit of the result is
the corresponding bits of *operand1* and *operand2* ANDed together.
The result of AND on two bits is 1 if both bits are 1, and 0 otherwise.

Example:

var tmp = 79 & 31;

In this example, *operand1* is 79 (00000000000000000000000001001111) and
*operand2* is 31 (00000000000000000000000000011111). tmp is set to 15
(00000000000000000000000000001111).

The bitwise exclusive-or (XOR) operator is a binary operator. The syntax is

operand1^operand2

You obtain the result of this expression by treating *operand1*,
*operand2*, and the result as sets of 32 bits. Each bit of the result is
the corresponding bits of *operand1* and *operand2* XORed together.
The result of XOR on two bits is 1 if only one of the bits is 1, and 0 if both
bits are identical.

Example:

var tmp = 79 ^ 96;

In this example, *operand1* is 79 (00000000000000000000000001001111) and
*operand2* is 96 (00000000000000000000000001100000). tmp is set to 47
(00000000000000000000000000101111).

The bitwise OR operator is a binary operator. The syntax is

operand1|operand2

You obtain the result of this expression by treating *operand1*,
*operand2*, and the result as sets of 32 bits. Each bit of the result is
the corresponding bits of *operand1* and *operand2* ORed together. The
result of OR on two bits is 1 if either bit is 1, and 0 if both bits are 0.

Example:

var tmp = 79 | 96;

In this example, *operand1* is 79 (00000000000000000000000001001111) and
*operand2* is 96 (00000000000000000000000001100000). tmp is set to 111
(00000000000000000000000001101111).

The bitwise negate operator is a unary operator. The syntax is

~operand1

You obtain the result of this expression by treating *operand1* and the
result as sets of 32 bits. Each bit of the result is the inverse of the
corresponding bit of *operand1*.

Example:

var tmp = ~79;

In this example, *operand1* is 79 (00000000000000000000000001001111).
tmp is set to -80 (11111111111111111111111110110000).

The concatenation operator is binary. The syntax is

operand1+operand2

The result of this expression is a string that concatenates the contents of
the string *operand1* and the string *operand2*.

Example:

var tmp = "Hello" + " world";

In this example, *operand1* is "Hello" and *operand2* is " world".
The result is "Hello world".

The conditional operator is the only ternary operator. The syntax is

operand1?operand2:operand3

The value of this expression depends on *operand1*. If *operand1*
evaluates as true, the value is *operand2*. Otherwise, the value is
*operand3*.

Example:

var tmp = (x == 1)? 7.2 : foo();

In this example, *operand1* is (x == 1), *operand2* is 7.2, and
*operand3* is foo(). If *operand1* is true (x is equal to 1), tmp is
set to *operand2* (7.2). If *operand1* is false (x is not equal to 1),
tmp is set to *operand3* (the return value of foo()).

The division operator is binary. The syntax is

operand1/operand2

The value of this expression is the value of *operand1* divided by
*operand2*. *operand2* cannot be equal to 0.

Example:

var tmp = 24 / 5;

In this example, *operand1* is 24 and *operand2* is 5. tmp is set
to *operand1* divided by *operand2*, which is 4.8.

The equality operator is binary. The syntax is

operand1==operand2

The value of this expression is true if *operand1* is equal to
*operand2*, and false if *operand1* is not equal to *operand2*.

Example:

var tmp = (foo == bar);

In this example, *operand1* is foo and *operand2* is bar. If foo
and bar are equal, tmp is set to true. Otherwise, tmp is set to false.

The greater than operator is binary. The syntax is

operand1>operand2

The value of this expression is true if *operand1* is greater than
*operand2*, and false if *operand1* is less than or equal to
*operand2*.

Example:

var tmp = (foo > bar);

In this example, *operand1* is foo and *operand2* is bar. If foo is
greater than bar, tmp is set to true. Otherwise, tmp is set to false.

The greater than or equal operator is binary. The syntax is

operand1>=operand2

The value of this expression is true if *operand1* is greater than or
equal to *operand2*, and false if *operand1* is less than
*operand2*.

Example:

var tmp = (foo >= bar);

In this example, *operand1* is foo and *operand2* is bar. If foo is
greater than or equal to bar, tmp is set to true. Otherwise, tmp is set to
false.

The inequality operator is binary. The syntax is

operand1!=operand2

The value of this expression is true if *operand1* is not equal to
*operand2*, and false if *operand1* is equal to *operand2*.

Example:

var tmp = (foo != bar);

In this example, *operand1* is foo and *operand2* is bar. If foo
and bar are not equal, tmp is set to true. Otherwise, tmp is set to false.

The less than operator is binary. The syntax is

operand1<operand2

The value of this expression is true if *operand1* is less than
*operand2*, and false if *operand1* is greater than or equal to
*operand2*.

Example:

var tmp = (foo < bar);

In this example, *operand1* is foo and *operand2* is bar. If foo is
less than bar, tmp is set to true. Otherwise, tmp is set to false.

The less than or equal operator is binary. The syntax is

operand1<=operand2

The value of this expression is true if *operand1* is less than or equal
to *operand2*, and false if *operand1* is greater than
*operand2*.

Example:

var tmp = (foo <= bar);

In this example, *operand1* is foo and *operand2* is bar. If foo is
less than or equal to bar, tmp is set to true. Otherwise, tmp is set to false.

The logical AND operator is binary. The syntax is

operand1&&operand2

This expression is true if both *operand1* and *operand2* are true;
otherwise, it's false.

Example:

var tmp = foo && bar;

In this example, *operand1* is foo and *operand2* is bar. tmp is
set to true if both foo and bar are true, and false if either foo or bar is
false.

The logical NOT operator is unary. The syntax is

!operand1

This expression is true if *operand1* is false; otherwise, it's false.

Example:

var tmp = !bar;

In this example, *operand1* is bar. tmp is set to true if bar is false,
and false if bar is true.

The logical OR operator is binary. The syntax is

operand1||operand2

This expression is true if either *operand1* or *operand2* is true;
otherwise, it's false.

Example:

var tmp = foo || bar;

In this example, *operand1* is foo and *operand2* is bar. tmp is
set to true if either foo or bar is true, and false if both foo and bar are
false.

The modulo operator is binary. The syntax is

operand1%operand2

The value of this expression is the remainder of performing an integer
division of *operand1* by *operand2*. *operand2* cannot be equal
to 0. The absolute value of the result will be less than the absolute value of
*operand2*, and the sign of the result will be the same as the sign of
*operand1*.

Example:

var tmp = 12.1 % 3.7

In this example, *operand1* is 12.1 and *operand2* is 3.7. tmp is
set to the remainder of dividing *operand1* divided by *operand2*.
12.1 divided by 3.7 is 3 with a remainder of 1, so tmp is set to 1.

The multiplication operator is binary. The syntax is

operand1*operand2

The value of this expression is the value of *operand1* multiplied by
*operand2*.

Example:

var tmp = foo * bar;

In this example, *operand1* is foo and *operand2* is bar. tmp is
set to the product of *operand1* (foo) multiplied by *operand2* (bar).

The negation operator is unary. The syntax is

-operand1

The value of this expression is the value of *operand1* subtracted from
0.

Example:

var tmp = -foo;

In this example, *operand1* is foo. If *operand1* (foo) is equal to
3, tmp is set to -3 (the value of foo subtracted from 0).

It is customary not to include spaces between the operator and the operand.

The post-decrement operator is unary. The syntax is

operand1--

The value of this expression is *operand1*. As a side effect, 1 is
subtracted from *operand1*.

Example:

var tmp = foo--;

In this example, *operand1* is foo. tmp is set to foo, and foo is set to
foo - 1.

The result of this expression

foo = foo--;

is not defined.

It is customary not to include spaces between the operator and the operand.

The post-increment operator is unary. The syntax is

operand1++

The value of this expression is *operand1*. As a side effect, 1 is added
to *operand1*.

Example:

var tmp = foo++;

In this example, *operand1* is foo. tmp is set to foo, and foo is set to
foo + 1.

The result of this expression:

foo = foo++;

is not defined.

It is customary not to include spaces between the operator and the operand.

The pre-decrement operator is unary. The syntax is

--operand1

The value of this expression is *operand1* minus 1. As a side effect, 1
is subtracted from *operand1*.

Example:

var tmp = --foo;

In this example, *operand1* is foo. tmp is set to foo - 1, and foo is
set to foo - 1.

The result of this expression:

foo = --foo;

is not defined.

It is customary not to include spaces between the operator and the operand.

The pre-increment operator is unary. The syntax is

++operand1

The value of this expression is 1 plus *operand1*. As a side effect, 1
is added to *operand1*.

Example:

var tmp = ++foo;

In this example, *operand1* is foo. tmp is set to foo + 1, and foo is
set to foo + 1.

The result of this expression:

foo = ++foo;

is not defined.

It is customary not to include spaces between the operator and the operand.

The shift left operator is binary. The syntax is

operand1<<operand2

You obtain the result of the expression by treating *operand1* as a set
of 32 bits and shifting the bits left by the value in *operand2*.
High-order bits are discarded, and the low-order bits are filled with 0's.

Example:

var tmp = 31 << 3;

In this example, *operand1* is 31 (00000000000000000000000000011111) and
*operand2* is 3. tmp is set to 248 (00000000000000000000000011111000).

The sign-propagating shift right operator is binary. The syntax is

operand1>>operand2

You obtain the result of the expression by treating *operand1* as a set
of 32 bits and shifting the bits right by the value in *operand2*.
High-order bits are copied from the highest-order bit (which dictates the sign
of the value, hence sign-propagating), and low-order bits are discarded.

Example:

var tmp = -9 >> 2;

In this example, *operand1* is -9 (11111111111111111111111111110111) and
*operand2* is 2. tmp is set to -3 (11111111111111111111111111111101).

The shorthand assignment operator is a binary operator. The syntax is

operand1op=operand2

The value of this expression is the value of *operand1* *op*
*operand2*, where *op* can be addition (+), bitwise and (&),
bitwise exclusive-or (^), bitwise or (|), division (/), modulo (%),
multiplication (*), shift left (<<), sign-propagating shift right
(>>), subtraction(-), or zero-fill shift right (>>>). As a side
effect, *operand1* is also assigned the result of *operand1* *op*
*operand1*. This is equivalent to:

operand1=operand1opoperand2

Example:

tmp += 2;

In this example, *operand1* is tmp, *op* is +, and *operand2*
is 2. *operand2* (2) is added to *operand1* (tmp).

The subtraction operator is binary. The syntax is

operand1-operand2

The value of this expression is the value of *operand2* subtracted from
*operand1*.

Example:

var tmp = 14 - foo();

In this example, *operand1* is 14 and *operand2* is foo(). tmp is
set to the value of *operand2* (the return value of foo()) subtracted from
*operand1* (14).

The zero-fill shift right operator is binary. The syntax is

operand1>>>operand2

You obtain the result of the expression by treating *operand1* as a set
of 32 bits and shifting the bits right by the value in *operand2*.
High-order bits are filled with 0's (hence zero-fill), and low-order bits are
discarded.

Example:

var tmp =-9 >>> 2;

In this example, *operand1* is -9 (11111111111111111111111111110111) and
*operand2* is 2. tmp is set to 1,073,741,821
(00111111111111111111111111111101).

The order of precedence determines the order in which the browser applies operators to operands when evaluating an expression. This determines how to evaluate an expression such as:

var tmp = 4 + 5 * 6;

If you assume that addition has higher priority than multiplication, tmp has the value 54 (4 + 5 * 6 = 9 * 6 = 54). If you assume that multiplication has higher priority than addition, tmp has the value 34 (4 + 5 * 6 = 4 + 30 = 34).

The order of precedence, from highest (perform first) to lowest (perform last) is

- Bitwise negate, logical not, negate, post-decrement, post-increment, pre-decrement, pre-increment
- Division, modulo, multiplication
- Addition, concatenation, subtraction
- Shift left, sign-propagating shift right, zero-fill shift right
- Greater than, greater than or equal, less than, less than or equal
- Equality, inequality
- Bitwise and
- Bitwise exclusive-or
- Bitwise or
- Logical and
- Logical or
- Conditional
- Assignment, shorthand assignment

You can override the order of precedence by using parentheses to block off subexpressions that the browser must evaluate first.