JavaScript运算符（一）加减乘除、逻辑与或非 *** 作符

JavaScript运算符 递增 *** 作符

递增 *** 作符中，++就是自身加一的意思，++不管是在前还是在后（如a++/++a）都是自身加一。

区别：

​ ++a：++在前 表示先加一再赋值

​ a++：++在后，表示先赋值再加一

 	var a = 10;
    var b = 10;
    var c = a++;
    var d = ++b;
    console.log(a); //11
    console.log(b); //11
    console.log(c); //10
    console.log(d); //11

    var x = 10;
    var y = 10;
    var z = 10;
    console.log(++x + y + z++); //11+10+10=31
    console.log(x + ++y + z++); //11+11+11=33
    console.log(x++ + ++y + ++z); //11+12+13=36
    console.log(x); //12
    console.log(y); //12
    console.log(z); //13

注：输出时的++也要自身加一

递减 *** 作符

与递增 *** 作符 *** 作原理相同，–即自身减一。

   var a = 10;
    var b = 10;
    var c = a--;
    var d = --b;
    console.log(a); //9
    console.log(b); //9
    console.log(c); //10
    console.log(d); //9

    var x = 12;
    var y = 12;
    var z = 12;
    console.log(x++ + y-- + --z); //12+12+11=35
    console.log(--x + y++ + z++); //12+11+11=34
    console.log(x++ + --y + --z); //12+11+11=34
    console.log(x); //13
    console.log(y); //11
    console.log(z); //11

非number类型的递增

递增 *** 作与递减 *** 作不仅仅可以适用于数值，还可以在其它的数据类型下面使用，这一点是JS这种弱类型编程语言独有的特点。

*** 作原则：

一元 *** 作符的结果一定是一个Number类型如果是非数字执行的递增与递减 *** 作，则先将这个值进行Number()的转换NaN不参于运算，即使参于运算，结果也一定是NaN符号在后，先使用自己，再变化自己；符号在前，先变化自己，再使用自己

如：

 var str1 = "12";
    console.log(str1++); //12
    console.log(str1); //13
    console.log(typeof str1); //number

    var str2 = "bb1";
    console.log(str2++); //NaN
    console.log(str2); //NaN
    console.log(typeof str2); //number

    var str3 = "1.1";
    console.log(str3++); //1.1  第一步str3=number(str3)=1.1 第二步str3++
    console.log(str3); //2.1
    console.log(typeof str3);

    var bool1 = true;
    console.log(bool1++); //1
    console.log(bool1); //2
    console.log(typeof bool1); //number

    var nu1 = null;
    console.log(nu1++); //0
    console.log(nu1); //1
    console.log(typeof nu1); //number

    var und;
    console.log(und++); //NaN
    console.log(und); //NaN
    console.log(typeof und); //number

    var nu2 = '';
    console.log(typeof nu2); //string
    console.log(nu2++); //0
    console.log(typeof nu2); //number
    console.log(nu2); //1
    console.log(typeof nu2); //number

一元加减 *** 作符

*** 作原则：

结果一定是Number类型非数值的直接通过Number()去转换NaN不能于计算如果是一元减法 *** 作，则通过Number()转换以后，再乘以-1

如：

 	var a = 12;
    console.log(-a); //-12
    console.log(a); //12
    console.log(typeof a); //number

    var str = '';
    var str1 = +str;
    console.log(str1); //0
    console.log(str); //''
    console.log(typeof str); //string
    console.log(typeof str1); //number

    var bool = false;
    var bool1 = +bool;
    console.log(bool); //false
    console.log(bool1); //0
    console.log(typeof bool); //boolean
    console.log(typeof bool1); //number

    var nu = null;
    var nu1 = +nu;
    console.log(nu); //null
    console.log(nu1); //0
    console.log(typeof nu); //object
    console.log(typeof nu1); //number

    var un;
    var un1 = +un;
    console.log(un); //undefined
    console.log(un1); //NaN
    console.log(typeof un); //undefined
    console.log(typeof un1); //number

加法运算符

*** 作原则：

如果执行加法的时候有字符串，则结果一定是一个拼接型的字符串NaN不参与运算，只要参与计算，结果就是NaN在加法运算里面，字符串是老大，NaN是老二；俗称加法字符串优先

如：

 	var str = 'a';
    var str1 = 'b';
    console.log(str + str1); //ab
    console.log(typeof (str + str1)); //string

    var num1 = 5;
    var nul = null;
    console.log(num1 + nul); //5
    console.log(typeof (num1 + nul)); //number

    var un;
    console.log(num1 + un); //NaN
    console.log(typeof (num1 + un)); //number

    var na1 = NaN;
    console.log(num1 + na1); //NaN
    console.log(typeof (num1 + na1)); //number

    console.log(str1 + num1); //b5
    console.log(typeof (str1 + num1)); //string

    var bool1 = true;
    console.log(bool1 + num1); //6
    console.log(typeof (bool1 + num1)); //number

    console.log(bool1 + un); //NaN
    console.log(typeof (bool1 + un)); //number

减法运算符

*** 作原则：

减法 *** 作符得到的结果一定是一个Number类型NaN与任何值相减都是NaN如果执行减法的不是数字，则通过Number去转换一次减法里面数字是老大，NaN是老二，所以减法是数字优先

如：

    var str = '10';
    var str1 = '1';
    console.log(str - str1); //9
    console.log(typeof (str - str1)); //number

    var num1 = 5;
    var nul = null;
    console.log(num1 - nul); //5
    console.log(typeof (num1 - nul)); //number

    var un;
    console.log(num1 - un); //NaN
    console.log(typeof (num1 - un)); //number

    var na1 = NaN;
    console.log(num1 - na1); //NaN
    console.log(typeof (num1 - na1)); //number

乘法 *** 作符

乘法 *** 作符使用的是*来表示 ，它的结果与 *** 作原则与减法一样。

如：

	var str1 = '23a';
    var str2 = '5';
    console.log(str1 * str2); //NaN
    console.log(typeof (str1 * str2)); //number

    var bool1 = true;
    var bool2 = false;
    console.log(bool2 * str2); //0
    console.log(bool1 * str2); //5
    console.log(typeof (bool1 * str2)); //number

    var nu = null;
    console.log(nu * str2); //0
    console.log(typeof (nu * str2)); //number

    var un = undefined;
    console.log(un * str2); //NaN
    console.log(typeof (un * str2)); //number

除法 *** 作符

除法 *** 作符使用/来表示 ，它的 *** 作原则与减法 *** 作符一样。

注： 如果除数为0，则最终的结果为Infinity无穷大。

如：

	var str1 = '1';
    var str = '2';
    console.log(str1 / str);//0.5
    var bool = false;
    console.log(str / bool); //infinity
    console.log(typeof (str / bool)); //number
    var un = undefined;
    console.log(str / un); //NaN
    console.log(typeof (str / un)); //number
    //获取4/3的整数部分
    console.log(parseInt(4 / 3)); //1

取余 *** 作符

取余 *** 作符是针对两个数相除以后取余数，使用%来表示，它的 *** 作原则与减法 *** 作符一样。

注：如果取余的时候除数为0，则结果就是NaN。

如：

	var str1 = '4';
    var str2 = '3';
    console.log(str1 % str2); //1
    console.log(typeof (str1 % str2)); //number
    var str3 = '4a';
    console.log(str3 % str2); //NaN
    console.log(typeof (str3 % str2)); //number

//取出num的个位，十位，百位：
    var num = 123;
    //个位
    console.log(parseInt(num % 10)); //3
    //十位
    console.log(parseInt(num % 100 / 10)); //2
    //百位
    console.log(parseInt(num / 100)); //1

布尔 *** 作符

在布尔 *** 作符里面我们经常会涉及到Boolean类型的转换，所以我们一定要知道6个明确的false有哪些。

0、‘’(空字符串)、false、NaN、null、undefined

逻辑非 *** 作符

逻辑非 *** 作符使用的是!来表表示 ，执行的是非真即假，非假即真的过程。它的结果一定是一个布尔类型，如果 *** 作的这个数不是布尔类型，则通过Boolean去转换。

如：

 	var bool = false;
    console.log(!bool); //true

    var str = '';
    console.log(!str); //!false=true

    var nu = null;
    console.log(!nu); //!false =true

    var num = 0;
    console.log(!num); //true

    var na = NaN;
    console.log(!na); //true

    var und;
    console.log(!und); //true

逻辑运算符与

逻辑与 *** 作符我们使用的是&&这个符号，执行的是一假即假的原则，它的结果不一定是布尔类型。

非布尔类型的值在进行运算时，需要通过boolean去测试。

短路原则：当一个表达式如果已经能够得到结果了，就不会再向后去运算了。

简单来说：

表达式1 && 表达式2

表达式1为false时，结果就是表达式1

表达式1为true时，结果就是表达式2

如：

	var bool1 = true;
    var bool2 = false;
    console.log(bool1 && bool2); //false
    console.log(bool1 && bool1); //true

    //非boolean值
    console.log(NaN && 12); //NaN
    console.log(1 && 2); //2
    console.log('1' && ''); //''
    console.log(undefined && 12); //undefined

    var num = 11;
    console.log(undefined && num++); //undefined
    console.log(num);

    console.log(12 && num++); //11
    console.log(num); //12

    console.log(0 && '45'); //0
    console.log(null && '1'); //null

逻辑运算符或

逻辑或的 *** 作符使用||来表示 ，执行一真即真的 *** 作，它的结果不一定是布尔类型，如果 *** 作的数不是布尔类型则通过Boolean去测试。

或运算同样也有短路原则：如果表达式已经能得到结果，则不会继续向后面运算。

简单来说：

表达式1 && 表达式2

表达式1为false，或运算的结果就是表达式2

表达式1为true，或运算的结果就是表达式1

如：

  	var bool1 = true;
    var bool2 = false;
    console.log(bool1 || bool2); //true
    console.log(bool2 || bool2); //false

    //非布尔值

    console.log(1 || 2); //1
    console.log('' || 3); //3

    var num = 5;
    var num1 = 6;
    console.log(null || num++); //5
    console.log(num); //6

    console.log(1 || num1++); //1
    console.log(num1); //6

布尔 *** 作符的执行顺序

执行顺序为：先非!、再与&&、最后或||。

与运算：一假即假。

或运算：一真即真。

如：

  	console.log(true || "" && NaN);
    //先与后或 true || nan 即true
    console.log(123 || !"" || false);
    //先非或或 123||true||false  --> 123
    console.log(123 && NaN || null);
    //先与后或 nan||null -->null
    console.log("abc" || 123 && NaN);
    //先与后或 "abc"||nan -->"abc"
    console.log(null || 123 && undefined);
    //先与后或 null||undefined --> undefined