JavaScript has a wealth of operators that are similar to C/C++ but with some additions to deal with weak typing and some minor omissions due to the fact the language generally does not access the disk or memory.
Note 
We take some liberty with the following categorization of operators. We believe that our categories (and placement of operators) make the operators easier to understand. 
Arithmetic operators operate on numbers, with one exception: +, which is overloaded and provides string concatenation as well. Tables A18, A19, and A20 detail the arithmetic operators found in JavaScript.
Operator 
Selfassignment Operator 
Operation 

+ 
+= 
Addition (also functions as string concatenation) 
– 
–= 
Subtraction 
* 
*= 
Multiplication 
/ 
/= 
Division 
% 
%= 
Modulus (the integer remainder when the first operand is divided by the second) 
Operator 
Description 

++ 
Autoincrement (increment the value by one and store) 
 
Autodecrement (decrement the value by one and store) 
Operator 
Description 

+ 
Has no effect on numbers but causes nonnumbers to be converted into numbers 
– 
Negation (changes the sign of the number or converts the expression to a number and then changes its sign) 
Bitwise operators operate upon integers in a bitbybit fashion. Most computers store negative numbers using their two’s complement representation, so you should exercise caution when performing bit operations on negative numbers. Most uses of JavaScript rarely involve bitwise operators but they are presented in Table A21 for those so inclined to use them.
Operator 
Selfassignment Operator 
Description 

<< 
<<= 
Bitwise left shift the first operand by the value of the second operand, zero filling “vacated” bit positions 
>> 
>>= 
Bitwise right shift the first operand by the value of the second operand, sign filling the “vacated” bit positions 
>>> 
>>>= 
Bitwise left right shift the first operand by the value of the second operand, zero filling “vacated” bit positions 
& 
&= 
Bitwise AND 
 
= 
Bitwise OR 
^ 
^= 
Bitwise XOR (exclusive OR) 
~ 
N/A 
Bitwise negation is a unary operator and takes only one value. It converts the number to a 32bit binary number, and then inverts 0 bits to 1 and 1 bits to 0 and converts back. 
Logical operators operate upon Boolean values and are used to construct conditional statements. Logical operators are shortcircuited in JavaScript, meaning that once a logical condition is guaranteed, none of the other subexpressions in a conditional expression are evaluated. They are evaluated left to right. Table A22 summarizes these operators.
Operator 
Description 
Example 

&& 
Logical AND 
true && false 
 
Logical OR 
true  false 
! 
Logical negation 
! true 
The conditional operator is a ternary operator popular among C programmers. Its syntax is
( expr1 ? expr2 : expr3 )
where expr1 is an expression evaluating to a Boolean and expr2 and expr3 are expressions. If expr1 evaluates true, then the expression takes on the value expr2; otherwise, it takes on the value expr3.
Type operators generally operate on objects or object properties. The most commonly used operators are new and typeof, but JavaScript supports a range of other type operators as well, summarized in Table A23.
Operator 
Description 
Example 

delete 
If the operand is an array element or object property, the operand is removed from the array or object. 
var myArray = [1,3,5]; 
instanceof 
Evaluates true if the first operand is an instance of the second operand. The second operand must be an object (for example, a constructor). 
var today = new Date(); 
in 
Evaluates true if the first operand (a string) is the name of a property of the second operand. The second operand must be an object (for example, a constructor). 
var robot = {jetpack:true} 
new 
Creates a new instance of the object given by the constructor operand. 
var today = new Date(); 
void 
Effectively undefines the value of its expression operand 
var myArray = [1,3,5]; 
Also included in the type operators is the propertyaccessing operator. To access a property property of an object object, the following two syntaxes are equivalent:
object.property
object["property"]
Note that the brackets above are “real” brackets (they do not imply an optional component).
The comma operator allows multiple statements to be carried out as one. The syntax of the operator is
statement1, statement2 [, statement3] ...
If used in an expression, its value is the value of the last statement. The comma is commonly used to separate variables in declarations or parameters in function calls.
Relational operators, as detailed in Table A24, are binary operators that compare two like types and evaluate to a Boolean indicating whether the relationship holds. If the two operands are not of the same type, type conversion is carried out so that the comparison can take place (see the section immediately following for more information).
Operator 
Description 

< 
Evaluates true if the first operand is less than the second 
<= 
Evaluates true if the first operand is less than or equal to the second 
> 
Evaluates true if the first operand is greater than the second 
>= 
Evaluates true if the first operand is greater than or equal to the second 
!= 
Evaluates true if the first operand is not equal to the second 
== 
Evaluates true if the first operand is equal to the second 
!== 
Evaluates true if the first operand is not equal to the second (and they have the same type) 
=== 
Evaluates true if the first operand is equal to the second (and they have the same type) 
A JavaScript implementation should carry out the following steps in order to compare two different types:
If both of the operands are strings, compare them lexicographically.
Convert both operands to numbers.
If either operand is NaN, return undefined (which in turn evaluates to false when converted to a Boolean).
If either operand is infinite or zero, evaluate the comparison using the rules that +0 and –0 compare false unless the relation includes equality, that Infinity is never less than any value, and that –Infinity is never more than any value.
Note 
Using the strict equality (===) or inequality (!==) operator on operands of two different types will always evaluate false. 
The lexicographic comparisons performed on strings adhere to the following guidelines. Note that a string of length n is a “prefix” of some other string of length n or more if they are identical in their first n characters. So, for example, a string is always a prefix of itself.
If two strings are identical, they are equal (note that there are some very rare exceptions when two strings created using different character sets might not compare equal, but this almost never happens).
If one string is a prefix of the other (and they are not identical), then it is “less than” the other. (For example, “a” is less than “aa.”)
If two strings are identical up to the nth (possibly 0^{th}) character, then the (n + 1)st character is examined. (For example, the third character of “abc” and “abd” would be examined if they were to be compared.)
If the numeric value of the character code under examination in the first string is less than that of the character in the second string, the first string is “less than” second. (The relation 1 < 9 < A < Z < a < z is often helpful for remembering which characters come “less” than others.)
JavaScript assigns a precedence and associativity to each operator so that expressions will be welldefined (that is, the same expression will always evaluate to the same value). Operators with higher precedence evaluate before operators with lower precedence. Associativity determines the order in which identical operators evaluate. Given the expression
a Ä b Ä c
a leftassociative operator would evaluate
(a Ä b) Ä c
while a rightassociative operator would evaluate
a Ä (b Ä c)
Table A25 summarizes operator precedence and associativity in JavaScript.
Precedence 
Associativity 
Operator 
Operator Meanings 

Highest 
Left 
., [ ], () 
Object property access, array or object property access, parenthesized expression 
Right 
++, ––, –, ~, !, delete, new, typeof, void 
Pre/post increment, pre/post decrement, arithmetic negation, bitwise negation, logical negation, removal of a property, object creation, getting data type, undefine a value 

Left 
*, /, % 
Multiplication, division, modulus 

Left 
+, – 
Addition (arithmetic) and concatenation (string), subtraction 

Left 
<<, >>, >>> 
Bitwise left shift, bitwise right shift, bitwise right shift with zero fill 

Left 
<, <=, >, >=, in, instanceof 
Less than, less than or equal to, greater than, greater than or equal to, object has property, object is an instance of 

Left 
==, !=, ===, !=== 
Equality, inequality, equality (with type checking), inequality (with type checking) 

Left 
& 
Bitwise AND 

Left 
^ 
Bitwise XOR 

Left 
 
Bitwise OR 

Left 
&& 
Logical AND 

Left 
 
Logical OR 

Right 
? : 
Conditional 

Right 
= 
Assignment 

Right 
*=, /=, %=, +=, –=, <<=, >>=, >>>=, &=, ^=, = 
Operation and selfassignment 

Lowest 
Left 
, 
Multiple evaluation 