All Categories :
JavaScript
Appendix D
JavaScript Operators
CONTENTS
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
operand1 op= 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 = operand1 op operand2
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.

Contact
reference@developer.com with questions or comments.
Copyright 1998
EarthWeb Inc., All rights reserved.
PLEASE READ THE ACCEPTABLE USAGE STATEMENT.
Copyright 1998 Macmillan Computer Publishing. All rights reserved.