Speaking of operators, basically all kinds of programming languages will be involved, the use of similar methods. Here's a simple collation of JavaScript here today.
In general, operators are still relatively much more, can be divided into the following types:
 Unary operator
 Bitwise operators
 Boolean operators
 Multiplicative operator
 Additive operator
 Relational operators
 The Equal sex operator
 Conditional operator
 Assignment operator
 Comma operator
It can be said that as long as learning to become a language on these operators should be not unfamiliar, as long as there is logic or calculation will use the above operators, I have been relatively fragmented use, and never systematically learn and organize these operators how to use? What are the differences and connections between them? What are the skills to use? Today, we will study and explain the issues mentioned above.
Unary operator
Delete operator, deletes a reference to an object property or method that was previously defined, returns False when the deletion fails, and when does the deletion fail? The first cannot delete declared variables (variables, functions, function arguments), such as: var a = 1; second, methods that cannot delete the builtin objects, such as: Math.PI; The configurable value of the thirddefined variable property is false and cannot be deleted. It should be noted that under Ie68, the Delete window property reports a type error. Specifically, you can learn about the delete mechanism of JavaScript that you wrote before
The void operator, which returns undefine for any value, which is often used to avoid values that the output should not output. Our common is <a href= "javascript:void ();" > Point I </a> this link will have no effect, because the return of a undefine, do not perform a label of the default event, the equivalent of the execution of returns false.
The forward increment/front decrement operator, which refers to the value of the variable itself by 1 or minus 1. The post increment/post decrement operator, which refers to the value of the variable itself by 1 or minus 1. The difference is that if you assign a value to this operation, there is a difference:

var fnum = 1; var bnum = 1; var forward = ++fnum; //fnum = 2; forward = 2; var back = bnum++; //bnum = 2; back = 1 //减量运算符结果是类似的 
unary addition and unary subtraction operators, unary addition and subtraction are the same for numbers, mathematical addition and subtraction operations, but oneelement addition in the string has a magical effect. The data types involved in JavaScript conversion, interested students can also learn about one or two here.
Bitwise operators
Before learning the bitwise operator, you need to know that the bitwise operator operates at the bottom of the number (that is, the 32 digits of the number). ECMAScript integers are divided into two types: signed integers (allowing positive and negative numbers) and unsigned integers (only positive numbers are allowed). In ECMAScript, signed integers are used by default. This means that there are 31 digits representing the numeric value, one representing the symbol, where 0 is negative and 1 is a positive number. Negative numbers are also stored as binary code, but the form of binary complement is used. Then how to calculate the binary complement? First, the digital absolute value of the binary code is also called the original code, and then find the original code of the inverse code, and finally the counter Code plus 1 is the complement. Interestingly, ECMAScript is not displayed as a binary complement, but rather a binary code that displays the absolute value of the value before the minus sign.

var num1 = 18; var num2 = 18; num1.toString(2); // ‘10010’ num 2.toString(2); // ‘10010’ 
Understanding this foundation, you can learn the bit operators in JS.
The bitwise operator not, which is represented by ~, is calculated by first turning the operand into a 32digit number, then converting it to its inverse code, and finally turning the binary into a floating point. In fact, this process is still very difficult to transform, the bit is not in essence, is to the value of the negative and then minus 1 (here is said to be calculated by integer digits).
Bitwise operation and, which is represented by &, converts values into binary, and then bitwise and operations, with the following rules:
Digits in the first digit 
Number of digits in the second digit 
Results 
1 
1 
1 
1 
0 
0 
0 
1 
0 
0 
0 
0 
bitwise OR, which is represented by changing the numeric value to binary, and then by bitwise OR, the operation rules are as follows:
Digits in the first digit 
Number of digits in the second digit 
Results 
1 
1 
1 
1 
0 
1 
0 
1 
1 
0 
0 
0 
Bitwise operation XOR, which is represented by ^, converts numeric values into binary, and then bitwise XOR operations, with the following rules:
Digits in the first digit 
Number of digits in the second digit 
Results 
1 
1 
0 
1 
0 
1 
0 
1 
1 
0 
0 
0 
The left shift operation is a two less than (<<) number. It moves all digits in the number to the left by a specified number. After the move, the right 0, and then converted to decimal. Such as:

var num = 2; // 二进制为：’10' var newNum = num << 5; console.log(newNum); // 64 二进制为：’1000000’ 
The signed right shift operator, represented by two greaterthan sign (>>). It shifts all digits in a number to the right by the specified number, preserving the symbol bit. After the move, the left 0, and then converted to decimal. Such as:

var num = 64; // 二进制为：’1000000’ var newNum = num >> 5; console.log(newNum); //2 二进制为：’10’ 
The unsigned Right shift operator, represented by three greaterthan sign (>>>). The difference between this and a signed right shift is that the unsigned need to move the whole, so that a negative number becomes a positive number. So be careful when you use it.
Boolean operators
Before you learn, you need to know how other data types are converted to Boolean types, as follows:
Parameter type 
Results 
Undefine 
False 
Null 
False 
Boolean 
Do not convert 
Number 
0 is False,nan is false, others are true 
String 
Null string is False, others are true 
Object 
True 
Logical NOT operator, using! is a process of seeking for the non.
The logical AND operator, using && means that only two of the expressions on both sides are true, the result is true, and all other cases are false.
The logical OR operator, used to indicate that only two of the expressions on both sides are false, the result is false, and the other is true.
It should be noted that their operations are left to right if they are used in && and not in conditional statements. Such as:

1 && 2 //1为true，继续计算，2也为true，所以结果是2 0 && 1 //0为false，所以就不会向右计算了，结果就是0 1 2 //1为true，所以结果是1 0 1 //0为false，继续计算，1为true，所以结果为1 
Multiplicative operator
Multiplication operator, which is represented by the *, multiplication operation in mathematics.
The division operator, represented by a/number, is a division operation in mathematics.
The modulo operator, expressed in%, is rounded by the division operation in Mathematics.
Additive operator
Normal addition and subtraction calculations.
Relational operators
The general comparison method, with values greater than, less than, greater than or equal to, or less than or equal to.
Compare numbers and strings, if they are numeric strings, then convert to numbers and then size, and compare the sequence of character codes if a number is a string or two are strings.
The Equal sex operator
An equal sign and a nonequal sign, which requires an expression on both sides of the operator to be data type conversion. The rules are as follows:
The rules for performing type conversions are as follows:
If an operand is a Boolean value, convert it to a numeric value before checking for equality. False converts to 0,true 1.
If one of the operands is a string and the other is a number, try converting the string to a number before checking for equality.
If one of the operands is an object, and the other is a string, try to convert the object to a string before checking for equality.
If one of the operands is an object, and the other is a number, try converting the object to a number before checking for equality.
When compared, the operator also adheres to the following rules:
Value null and undefined equal.
You cannot convert null and undefined to other values when checking for equality.
If one of the operands is NaN, the equal sign returns false, and a nonequal sign returns TRUE.
If the two operands are objects, they are compared to their reference values. If two operands point to the same object, the equal sign returns TRUE, otherwise the two operands are unequal.
Important: Even if the two numbers are Nan, the equals sign returns false because, according to the rule, Nan is not equal to Nan.
The full equals sign and the non full equals sign, this is not the data type conversion in the operation, first determines the type to judge the value.
Conditional operator
Also known as the threemesh operator, three expressions, when only one expression is true, the result is the value of the second expression, and the first expression is false, and the result is the value of the third expression.
Assignment operator
We define variables that are most commonly used, using the = number. In addition, the main arithmetic operators can be used in conjunction with assignment operators. such as: *=, + + and so on.
Comma operator
The comma operator, in which you can perform multiple operations in a single statement. Comma operators are often used in variable declarations. Such as:

var a = 1, b = 2, c = 3; // a=1;b=2;c=3 var a = 1,2,3; // a=3 ，最后一个值 var d = (a=1,b=2,c=3); //d的值是什么呢？ 
Everyone touches less mainly bitwise operators, in fact bitwise operators are particularly handy in the handling of permissions