js之运算符（算术运算符）

　　Javascript中的运算符大多是由标点符号少数由关键字表示。可以根据其操作数的个数进行分类.大多数运算符是一个二元运算符，将两个表达式合成一个比较复杂的表达式。还有需要注意的一点是运算符的优先级，它控制着运算符的执行顺序，优先级高的运算符的执行总是优先于运算符低的运算符。进行以下大致的分类：

一、算术运算符

　　算术运算符包括一元算术运算符和二元算术运算符两种。

　　1、一元运算符

　　　　一元算术运算符包括一元加法(+)、一元减法(-)、递增(++)和递减(--)。只对一个表达式执行操作，并产生一个新值。

　　+/-：一元加减运算符

　　　　一元加法运算符把操作数转换为数字或者是NaN(用函数Number());

　　　　一元减法运算符它会根据需要把操作数转换为数字，然后改变运算结果的符号。

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

<script>
        var a=25;
        var b='1.1';
        var c=false;
        var d=1.1;
        var e=NaN;
        var f=undefined;

        a=+a;
        b=+b;
        c=+c;
        d=+d;
        e=+e;
        f=+f;
        a1=-a;
        b1=-b;
        c1=-c;
        d1=-d;
        e1=-e;
        f1=-f;
        console.log(a,b,c,d,e,f);//25 1.1 0 1.1 NaN NaN
        console.log(a1,b1,c1,d1,e1,f1);//-25 -1.1 -0 -1.1 NaN NaN
    </script>

　　　++/--:递增和递减

　　　　运算符对其操作数进行加1或者是减1的操作，操作数是一个左值（value）。运算符将操作数转换为数字，然后给数字加1或者是减1，并将加1或减1后的数值重新赋值给变量，数组元素或者对象属性。

　　　　"++"运算符的返回值依赖于它相对于操作数的位置。当运算符在操作数之前称为”前增量“运算符，当运算符在操作数之后称为”后增量“。

　　　　如果只操作自己：++放在前面还是后面是一样的，让自己加1；

　　　　　　　　　　　　--放在操作符的前面或者后面是一样的，让自己减1；

　　　　如果是操作别人（在赋值给其它的变量）：

　　　　　　++放在后面，先把自己赋值给另外一个变量，自己再加1；++放在前面，先把自己加1赋值给另外一个变量，然后自己再加一个1；

　　　　　　--放在后面，先把自己赋值给另外一个变量，自己再减1；--放在前面，先把自己减1然后赋值给另外一个变量，然后自己再减一个1；

　　　　不管是前增还是后增，这个运算符通常用在for循环中，用于控制循环内的计数器

 <script>
        var n = 10;
        var b = 20;
        n++;        //11
        n--;        //10
        b--;        //19
        --b;        //18
        //console.log(n,b);

        var c1=1;         //2
        var d1=c1++;      //1
        var c2=1;         //2
        var d2=++c2;      //2
        console.log(c1,d1,c2,d2); 

        var e1=0;       //-1
        var f1=--e1;    //-1
        var e2=0;       //-1
        var f2=e2--;       //0
        console.log(e1,f1,e2,f2);
    </script>

　　2、二元运算符

　　　　二元运算符包括+，-，*，、/，%（求余）

　　　　加法（+）：

　　　　　　在多数的程序设计语言中，加法通常是简单的数字运算符，但在Javascript中，加法可以进行数字和数字的相加，也可进行字符串的相加。所有其它类型的值都会自动转换成这两种类型的值（这其中涉及到隐式类型的转换，toNumber()将值转换为数字，toString()将值转换成字符串）。

　　　　　　遵循如下的规则：

　　　　　　　　如果其中一个操作数是对象，则对象会转换成原始值，日期对象通过toString()进行转换，其它对象能过valueOf()方法进行转换。由于多数对象valueOf()方法无法返回一个原始值，所以还是通过toString()方法来执行转换，转成一个字符串；

　　　　　　　　【注意】：除了单数值数组会转换为数字外

　　　　　　　　在进行了对象到原始值的转换后，如果其中一个操作数是字符串，另一个操作数也会转换成字符串，进行字符串连接；否则，两个操作数都将转换成数字或NaN，进行加法操作。

　　　　　　知识点回顾：

　　　　　　　　在Javascript有两种类型的值：原始值（primitives）:undefined, null, boolean, number,string        对象（object）:Array, function

　　　　　　　　从上面在原则中我们可以看出加法运算会触发三种类型的转换：转为原始值，转为数字，转为字符串。

　　　　　　　　转原始值能过ToPrimitive()方法：如果是一个原始值，则直接返回，如果是一个对象，则用obj.value()方法，如果返回的是原始值，那就是这个原始值，如不是调用obj.toString()方法，如果返回值是一个原始值，那就返回这个原始值，再不是那就是抛出异常。

 <script>
        var a = 1;
        var b = '';
        var c = '1';
        var d = [1, 2];
        var e = NaN;
        var f = undefined;
        var g = false;
        var h = {
            valueof: function () {
                return vuleof;
            }
        }
        var n=[2];
        var m=null;

        //原生对象转成字符串
        console.log(a, a + b); //1 "1"
        console.log(a, a + c);//1 "11"
        console.log(a, a + d);//1 "11,2"
        console.log(a, a + e);//1 NaN
        console.log(a, a + f);//1 NaN
        console.log(a, a + g);//1 1
        console.log(a, a + h);//1 "1[object Object]"
        console.log(a+new Date());// 1Wed Nov 06 2019 10:04:45 GMT+0800 (中国标准时间)

        //特例：单数值组和valueof()返回为数值的自定义对象会转换为数值
        console.log(a,a+n); //1 "12"
        //如果进行算术加法，undefined转换成'undefined',null转换成'null',false转换成0，true转换成1
        console.log(f+f);  //NaN
        console.log(e+e); //NaN
        console.log(g+g); //0

        //如果进行字符串连接，undefined转换成'undefined',null转换成'null',false转换为'false'，true转换为'true'
        console.log(c+d);
        console.log(c+e);
        console.log(c+f);
        console.log(c+g);
        console.log(c+m);
        //所以利用加号运算的特性，可以+任意的字符串

　　　　减法（-）：

　　　　　　减法的话只涉及到数字的减法运算，使用Number()转型函数将非数值类型转为数值或者是NaN.

  <script>
        //　undefined转换为NaN，null转换为0，false转换为0，true转换为1
        console.log(1-{});//NaN
        console.log(1-[]);//1
        console.log(1-[1,2]);//NaN
        console.log(1-NaN);//NaN
        console.log(1-undefined);  //NaN
    </script>

　　　　乖法（*）：

　　　　　　用于计算两个数值的乖积，会通过Numbe()方法将非数值转换成数值或者是NaN.

 <script>
        console.log(1*{});//NaN
        console.log(1*[]);//0
        console.log(1*[1,2]);//NaN
        console.log(1*NaN);//NaN
        console.log(1*undefined);  //NaN
    </script>

　　　　除法（/）:

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

<script>
        console.log(1/{});//NaN
        console.log(1/[]);//Infinity
        console.log(1/[1,2]);//NaN
        console.log(1/NaN);//NaN
        console.log(1/undefined);  //NaN
    </script>　　

　　　　求模（%)：

　　　　　　取模的时候如果前面的数字比后面的小，那得到的值就是前面的数字，求模结果与第一个操作数的符号保持一致，前面的数字为infinity，后面的数字为0时，结果为NaN。

<script>
        console.log(3%5);//3
        console.log(-5%1);//0
        console.log(1%{});//NaN
        console.log(1%[]);//Infinity
        console.log(1%[1,2]);//NaN
        console.log(1%NaN);//NaN
        console.log(1%undefined);  //NaN
    </script>