运算符，刚接触你可能会感觉“它很小”，但真正接触下来才能体会它的“多样”与“奇妙”。

一元运算符

一元算术运算符用于一个单独的操作数，并产生一个新值。在javascript中，一元运算符具有很高的优先级，而且都是右结合(right-associative)。

1、一元加 与 一元减

（1）、一元加运算符以一个加号(+)表示，放在数值前面，对数值不会产生任何影响。

var num = 25;
num = +num; //25

在对非数值应用一元加运算符时，会调用Number()转型函数对这个值进行转换

var s1 = '01';
var s2 = '1.1';
var s3 = 'z';
var s4=-1;
var b = false;
var f = 1.1;
var o = {
    valueOf:function(){
        return -1;
    }
};

s1 = +s1;  //1
s2 = +s2;  //1.1
s3 = +s3;  //NaN
s4 = +s4;  //-1
b = +b;  //0
f = +f;  //1.1
o = +o;  //-1

console.log(1+ +“2”+"3"); //33  第一个+“2”中的加号是一元操作符，空格+"2”会变成数值2，因此1+ +“2”相当于1+2等于3.然后和后面的字符串3合并，就变成了“33”

注意：在new Date()前面使用一元加符号，可以把日期字符串，转换为日期毫秒数

console.log(new Date());//on Jul 11 2016 20:25:54 GMT+0800 (中国标准时间)
console.log(+new Date());//1468239954076

（2）、一元减运算符主要用于表示负数。
当一元减运算符用于非数值时，会对该值使用Number()转型函数进行转换，再将得到的数值转换成负数

var s1 = '01';
var s2 = '1.1';
var s3 = 'z';
var b = false;
var f = 1.1;
var o = {
    valueOf:function(){
        return -1;
    }
};

s1 = -s1;//-1
s2 = -s2;//-1.1
s3 = -s3;//NaN
b = -b;//0
f = -f;//-1.1
o = -o;//1

一元加和一元减运算符主要用于基本的算术运算，也可以用于转换数据类型。

2、前增量/前减量 与 后增量/后减量 运算符
++运算符 使变量自增1，放在变量a前为前置增量运算符，放在变量a后为后置增量运算符
–运算符使变量自减1，放在变量a前为前减量运算符，放在变量a后为后置减量运算符。

<script>
   var num=10;
   a=num++;
   console.log(num);// 输出11
   console.log(a)  ;// 输出10
   console.log(num++);  //输出11
   console.log(num);  //输出12
</script>

<script>
    var bnum=10;
    b = ++bnum;
    console.log(bnum);// 输出11
    console.log(b)  ;// 输出11
    console.log(++b);  //输出12
    console.log(bnum);  //输出11
</script>

从以上对比可以看出来：

前增量/前减量运算符 会先运行增量/减量运算，再进行赋值；
而后增量/前减量运算符会先进行赋值，再进行增量/减量运算。
换句话说，当++，或者--符号放在变量之前，其优先级会高于赋值运算符，反之 则低于赋值运算符。

一般来说：

  var x = 1;
  ++x;
  //相当于
  var x = 1;
  x = x +1;

但是++x并不总是和x = x+1完全一样，++运算符从不进行字符串连接操作，它总是会将操作数转换为数字并增1

  var x = '1';
  ++x;//2
  var x = '1';
  x = x + 1;//'11'

二元运算符

1、加法运算符
Javascript的加性运算符会在后台转换不同的数据类型。
（1）、如果两个操作数都是数值，按照常规的加法计算:

某个运算数是 NaN，那么结果为 NaN。
-Infinity 加 -Infinity，结果为 -Infinity。
Infinity 加 -Infinity，结果为 NaN。
+0 加 +0，结果为 +0。
-0 加 +0，结果为 +0。
-0 加 -0，结果为 -0。

例：
var a = 2;
console.log(a+NaN); //NaN 如果有一个操作数是NaN，则返回NaN
（注意：有时不是直接以NaN形态出现）
console.log("A"+"B"+3); //NaN    先把“A”和“B”用Number函数转换为数值，结果为NaN，任何数和NaN做加减法的结果都为NaN
console.log("A"+"B"+"3"); //NaN3    “A”和“B”用Number函数转换为数值，结果为NaN，然后和字符串“3”拼接

console.log(Infinity+Infinity);//Infinity
console.log(Infinity+(-Infinity));//NaN
console.log((-Infinity)+(-Infinity));//Infinity
console.log((+0)+(+0));//+0
console.log((+0)+(-0));//+0
console.log((-0)+(-0));//-0

（2）、如果有一个操作数是字符串

如果两个操作数都是字符串，相当于字符串拼接
如果只有一个操作数是字符串，则将另一个操作数转化为字符串，然后再执行字符串拼接 
如果有一个操作数是对象，数值或者布尔值，首先调用它们的toString()方法取得对应的字符串，然后执行拼接（包括null，undefined）

部分案例：

• String+String

   var a = '10',
   b = '20';
   console.log(a+b);  //1020

• String+Object

  var a = '10',
  b = {_key:20};
  console.log(a+b);  //10[object Object]
  //Object.prototype.toString()方法返回一个表示该对象的字符串。

• String+Number

  var a = '10',
  b = 20;
  console.log(a+b);  //1020

• String+Boolean

var a = true,
b = '20';
console.log(a+b);  //true20

• String+null

var a = null,
b = '20';
c =3;
console.log(a+b);  //null20
console.log(a+c);  //3  null数值转换为0

• String+undefined

var a = undefined,
b = '20';
console.log(a+b);  //undefined20
console.log(undefined+3);  //NaN

（3）、加法的独立操作

var a = 10,
b = 5;
var result = 'hello world 10 + 5 = ' + a + b;
console.log(result);  //'hello world 10 + 5 = 105'

var a = 10,
b = 5;
var result = 'hello world 10 + 5 = ' + (a + b);
console.log(result);  //'hello world 10 + 5 = 15'

//如果进行算术加法运算，undefined转换为NaN，null转换为0，false转换为0，true转换为1/
console.log(undefined + undefined);//NaN
console.log(null + null);//0
console.log(false + false);//0
console.log(true + true);//2
//如果进行字符串连接，undefined转换为'undefined'，null转换为'null'，false转换为'false'，true转换为'true'
console.log('' + undefined);//'undefined'
console.log('' + null);//'null'
console.log('' + false);//'false'
console.log('' + true);//'true'

//单数值数组和valueOf()返回值为数值的自定义对象会转换为数值
console.log(1 + []);//1
var o = {
    valueOf: function(){
        return -1;
    }
}
console.log(1 + o);//0

//其他原生对象则转换为字符串
console.log(1 + {});//'1[object Object]'
console.log(1 + [1,2]);//'11,2'
console.log(1 + new Date());//'1Thu Jun 16 2016 10:27:13 GMT+0800 (中国标准时间)'
console.log(1 + /0/);//'1/0/'

2、减法运算符
（1）、如果两个操作数都是数值，按照常规的减法计算:

某个运算数是 NaN，那么结果为 NaN。
Infinity 减 Infinity，结果为 NaN。
-Infinity 减 -Infinity，结果为 NaN。
Infinity 减 -Infinity，结果为 Infinity。
-Infinity 减 Infinity，结果为 -Infinity。
+0 减 +0，结果为 +0。
-0 减 -0，结果为 -0。
+0 减 -0，结果为 +0。
某个运算符不是数字，那么结果为 NaN。
如果运算数都是数字，那么执行常规的减法运算，并返回结果。

console.log(2-NaN); //NaN 如果有一个操作数是NaN，返回NaN
console.log(Infinity-Infinity); //NaN
console.log(-Infinity-(-Infinity)); //NaN
console.log(Infinity-(-Infinity));  //Infinity
console.log(-Infinity-Infinity);    //-Infinity
console.log(+0 - (+0)); //+0
console.log(-0 - (+0)); //-0
console.log(-0 - (-0)); //+0

（2）、如果有一个操作数不是数值

 如果有一个操作数是`字符串`，`布尔值`，`null`，`undefined`，则在后台调用`Number()`将其转化为数值，再进行减法运算。
 如果有一个操作数是对象 ，则调用对象的`valueOf()`方法取得表示该对象的数值。如果得到的值是NaN，减法结果是NaN。如果对象没有valueOf()方法，调用它的toString()方法，并将得到的字符串转化为数值.

• Number – String

var a = 10,
b = '10';
console.log(a-b); //0

var a = 10,
b = '';
console.log(a-b);   //10

var a = 10,
b = 'true',
c = 'false';
console.log(a-b);   //NaN
console.log(a-c);   //NaN

//Number('true') => NaN 或者 Number('false') => NaN  
//这里不能使用Number('false') == NaN  或者 Number('false') === NaN
//因为console.log(NaN == NaN) => false

当使用Number()进行数值转化，如果是一个字符串： 
1.如果字符串中只包含数字（包括前面带正负号）将其转化为十进制； 
2.如果字符串中包含有效的浮点格式，将其转化为对应的浮点数值； 
3.如果字符串中包含有效的16进制，将其转化为大小相同的十进制数值； 
4.如果字符串为空，则转化为0； 
5.如果字符串不符合以上条件，则转化为NaN

• Number – Boolean

var a = 10,
b = true,
c = false;
console.log(a-b);   //9
console.log(a-c);  //10 

• Number – null

var a = 10,
b = null;
console.log(a-b); //10

• Number – undefined

var a = 10,
b = undefined;
console.log(a-b);   //NaN

• Number – Object

var a = 10,
b = {_key:1};
console.log(a-b);   //NaN

console.log(1 - {});//NaN
console.log(1 - [1,2]);//NaN
console.log(1 - /0/);//NaN
console.log(1 - []);//1

3、乘法运算符
用于计算两个数值的乘积，会通过Number()转型函数将非数值类型转换为数值或NaN

+ Infinity * 0;  //NaN
- Infinity * 0;  //NaN
Infinity * 非0数值;  //Infinity或-Infinity
Infinity * Infinity;  //Infinity

4、除法运算符
执行第一个操作数除以第二个操作数的运算，也会通过Number()转型函数将非数值类型转换为数值或NaN

Infinity / Infinity;  //NaN
0 / 0;  //NaN
非0数值 / 0;  //Infinity或-Infinity
Infinity / 0;  //Infinity
Infinity / 非0数值;  //Infinity

5、求模运算符
求模(余数)操作符是由一个百分号(%)表示，是第一个操作数除以第二个操作数的余数

//r是余数，n是被除数，d是除数，
//q是整数，在n/d为负时为负，在n/d为正时为正，它应该在不超过n和d的商的前提下尽可能大
r = n - (d * q)

求模结果与第一个操作数的符号保持一致

console.log(5 % 2);//1
console.log(5 % -2);//1
console.log(-5 % 2);//-1
console.log(-5 % -2);//-1

被除数是Infinity，或除数是0，则求模结果是NaN

Infinity % 0 = NaN
Infinity % Infinity = NaN
Infinity % 非0数值 = NaN
非0数值 % 0 = NaN

在多数编程语言中，求模运算符只接受整数为操作数，而在ECMAScript中，还接受浮点操作数，但由于浮点数不是精确的值，无法得到完全准确的结果

console.log(6.5 % 2.1);//0.19999999999999973