03-JS运算符

03-JS运算符

运算符（Operators，也翻译为操作符），是发起运算的最简单形式。

我们将运算符大致进行如下分类：

数学运算符（Arithmetic operators）

比较运算符（Comparison operators）

逻辑运算符（Logical operators）

赋值运算符（Assignment operators）

按位运算符（Bitwise operators）

条件（三元运算符）（Conditional operators）

（一）数学运算符

加 + 减 - 乘 * 除 / 取余数 % 括号（）

下面的结果都是3：

<script>
    console.log(1 + 2);
    console.log(8 - 5);
    console.log(1.2 * 2);
    console.log(12 / 4);
    console.log(13 % 2);
  </script>

取余数这个运算，实际上也是除，要的是余数：

// 取余数
    console.log(12 % 3);  //0
    console.log(121 % 11);  //0
    console.log(5 % 8);  //5
    console.log(8 % 5);  //3
    console.log(5 % 5);   //0
    // 测试
    console.log(1 % 0);  //NaN

默认的计算顺序，先乘除，后加减。乘除取余是平级，先遇见谁，就算谁。

console.log(1 + 2 * 3);  //7
console.log(1 + 2 * 3 % 3);  //1
console.log(1 + 2 % 3 * 3);  //7

我们可以用小括号来改变计算先后顺序，注意没有中括号和大括号，一律用小括号。

var a = 4 * (3 + (1 + 2)*3)；
console.log(a);  

1.隐式转换

所有带字符串的运算都会尽可能的转为数字进行计算，加号比较特殊。（加号在字符串中有拼接的意思）

数学运算符的正统，是number和number的数学运算，结果是number。出于面试的考虑，会有一些奇奇怪怪的运算。

（1）发生隐式转换

数学运算中，只有纯字符串、布尔值、null能够帮你进行隐式转换

// 隐式转换：就是没有写parseInt()、parseFloat()自己帮你格式转换
    console.log(3 * "8");  //24
    console.log("3" * "8");   //24
    console.log("48" / "2");   //24
    console.log("24" % 55);    //24
    // 隐式转换的时候null将被转为0
    console.log(3 * null);    //0
    // 隐式转换的时候false将被转为0
    console.log(3 * false);    //0
    // 隐式转换的时候true将被转为1
    console.log(3 * true);    //3

（2）不能隐式转换

不纯的字符串和undefined是不能帮你进行隐式转换的，结果都是NaN,没办法计算。

//数学运算中，不纯的字符串没法隐式转换
console.log(3 * "八天")； //NaN
//数学运算中，undefined不能进行隐式转换
console.log(3 * undefined);  //NaN

(3)加法的特殊性

加法比较特殊，因为+同时是加法和连字符的符号，所以加法在面对字符串的时候没有隐式转换，就是字符串拼接

数学运算，字符串拼接。

任何数据类型加字符串都等于字符串。

// 加法对于字符串没有隐式转换
    console.log(3 * "8");  //38
    console.log(3 + undefined);  //NaN
    console.log(3 + null);  //3
    console.log(3 + false);  //3
    console.log(3 + true);  //4

总结：

无论哪种运算，只要出现了undefined参与运算，结果都是NaN。

然后纯数字字符串("4")、false、true、null都能进行隐式转换。

加号比较特殊，面对纯数字字符串("4")没有隐式转换的

2.特殊数字的计算

特殊的数字运算，就是NaN、Infinity参与的运算，面试题经常考，但实战中可能一辈子都用不到

举几个例子：

Infinity + 1000  //Infinity
    Infinity - 1000  //Infinity
    Infinity / 1000  //Infinity
    Infinity - Infinity  //NaN
    Infinity / Infinity  //NaN
    Infinity * Infinity  //Infinity
    0  /  0    //NaN
    6  /  0    //Infinity
    NaN  /  8    //NaN

3.补充几个数学API

（1）一个数的n次幂

Nath.pow(4,3);

Math就是数学（是一个内置对象），pow就是power乘方（是它的一个方法）

（2）开根号

Nath.pow(81);

例子：

var a = Math.pow(3,2 + Math.pow(3,4));
    console.log(a);  //3.99083839418734e+39

（二）比较（关系）运算符

">" 大于

"<" 小于

">=" 大于等于

"<=" 小于等于

"==" 等于

"!=" 不等于判断两个值是否不相等

=== 全等于 判断两个值是否严格相等

!== 不全等 判断两个值是否严格不相等

1.正统的数字比较

关系运算符的正统，number和number进行数学运算，得到的答案boolean。

	console.log(8 > 6);  //true
    console.log(7 > 5);  //false
    console.log(8 >= 7);  //true
    console.log(8 >= 8);   //true
    console.log(5 <= 8);   //true
    console.log(5 <= 5);   //true
    console.log(5 <= 4);   //false

实例中结果是布尔类型，boolean类型只有两个值，就是true和false。表示真、假。

==我们叫做“相等判断”，它会帮你进行一个隐式转换，尽可能的得到true的答案：

 	//==表示相等，会帮你进行隐式转换
	console.log(6 == 8);  //false
    console.log(6 == 6);   //true
    console.log(6 == "6");   //true
    console.log("6" == 6);   //true

=== 我们叫做“全等判断”，不仅仅比较数值是否相等，还比较类型是否相等，没有隐式转换。

//===表示全等，不仅仅比较数值是否相等，还会比较类型是否相等
	console.log(6 === 6);   //true
    console.log(6 === "6");   //false
    console.log("6" === 6);   //false

!=是的反面，如果运算是true,那么!=就是false

!是=的反面，如果=运算是true，那么!就是false

2.string和string也能够进行关系运算

比较的就是字符编码即unicode编码值顺序。字符编码顺序，就是数字、大写字母、小写字母。

	"a" < "b"  //true
    "A" < "B"  //true
    "A" < "a"  //true 大写字母在字符集里面是在小写字母前面
    "1" < "A"  //true 数字在字母前端
    "blank" < "blue"  //true 因为一位一位比，直到比出大小
    "23" < "3"  //true 因为string和string比，比的是字符编码顺序

3.与数字进行关系运算时，纯数字字符串被转为数字，null转换为0，true转换为1，false转换为0

注意：null不能进行和0的相等判断

	null < 0.00001  //true
    null < -0.0001  //true
    null == 0  //false 具体原因，在讲解object时说明
    false == 0 //true
    true == 1 //true
    undefined == 0 //false
    "a" < 3  //false
    "a" > 3  //false  因为"a"会转为NaN
    "23" < 3  //false  因为"23"会转为23

4.NaN不等于自己，不全等于自己

NaN == NaN  //false
NaN === NaN //false
NaN != NaN //true
NaN !== NaN //true

5.其他类型的比较

null == undefined  //true
null === undefined  //false

注意：千万不要连续使用关系运算符

例如：我们想验证3大于2，2大于1：

3 > 2 > 1  //false

原理：

(3 > 2) >1

=true > 1 因为true会被当做1与1来进行比较

= false

也就是说，不能连接使用关系运算符！因为一旦连续使用了，实际上还是从左至右计算，所以就有上一步的boolean参与了下一步的运算。

总结：

1.如果比较的两个操作数都是数值，那么就进行数值比较

2.如果比较的两个操作数都是字符串，那么就会比较字符串编码值

3.如果有一个操作数是数字，另一个操作数就会被转换为数值进行比较

测试：

console.log(1 < 2 < 3);   //true

（三）逻辑运算符

逻辑运算符就三个

且 或 非

&& 逻辑与运算 （且）

|| 逻辑或运算（或）

！逻辑非运算 （非）

正统的来说，参与逻辑运算的Boolean和Boolean,得到的结果也是Boolean值，按照真值表来定

1.&&逻辑与的真值表

	a && b
a	b	结果
真	真	真
真	假	假
假	真	假
假	假	假

都真为真，有假就假

// 逻辑与运算符
    console.log(true && true);  //true
    console.log(true && false);  //false
    console.log(false && true);  //false
    console.log(false && false);  //false

2.|| 逻辑或的真值表

	a || b
a	b	结果
真	真	真
真	假	真
假	真	真
假	假	假

有真就真，都假才假

// 逻辑或运算符
    console.log(true || true);  //true
    console.log(true || false);  //true
    console.log(false || true);  //true
    console.log(false || false);  //false

3.! 逻辑非

//逻辑非运算
console.log(!true);  //false
console.log(!false);  //true
console.log(!!!!!!!!true);  //true

4.逻辑运算符的顺序

顺序：非、与、或

true || false && !true || false

解式 = true || false && false || false

= true || false || false

= true || false

= true

5.短路语法

（1）逻辑与的短路算法

计算逻辑与运算的时候，比如a && b ,a如果就是一个false，那么就不会管b是什么，直接输出false就行了，等于说直接输出a

也就是说，本质上计算机进行a && b运算的时候，不是在进行逻辑分析，而是在根据逻辑判断返回哪一个值

-- 短路语法。要么a被短路，要么b被短路

负性就是在隐式转换成布尔值的时候，转换为false叫负性。

false null 0 NaN "" undefined

正性的：除了负性的，全是正性的。也就是隐式转换为布尔值的时候，全部为true

	false && 8 //false
    // 因为计算机发现，且运算a已经是false了，直接输出false
    null && 8 //null
    // 因为计算机发现，且运算a已经是false了，直接扔出来null
    true && 8 //8
    // 因为计算机发现，且运算a已经是true了，所以结果就是b，直接扔出b
    12 && 13 //13
    // 因为计算机发现，12当做true，所以结果就是b，直接扔出b
    undefined && 哈哈 //undefined
    // 不报错，因为a已经是负性的了，所以直接扔出a，不管b
    哈哈 && undefined  //报错
    true && NaN  //NaN  扔后面

（2）逻辑或的短路算法

|| 逻辑或的短路也是类似的， a || b

计算机发现a是真，那么返回a；如果a是假，返回b

0 || 18  // 18 前面假，扔后面
18 || 0  // 18 前面真，扔前面
undefined || NaN // NaN  前面假，扔后面
NaN || undefined //undefined 前面假，仍后面

例子：

88 || 99 && 66 || 55

解式：

= 88 || 66 || 55

=88 || 55

=88

undefined && ("3" != 3) || NaN && null

解式：

=undefined && false || NaN && null

=undefined || NaN

= NaN

总结一下短路语法：

a && b ，a真执行b，a假执行a

a || b ,a真执行a，a假执行b

例子：根据年龄判断用户是否成年

	// 第一步 用户输入一个年龄
    var age = parseInt(prompt("请输入你的年龄"));
    // 第二步 输出
    (age >= 18) && alert("你已经成年了");
    (age < 18) && alert("你还没有成年");

    // 也可以这么写
    (age >= 18) || alert("你还没有成年");
    (age < 18) || alert("你已经成年了");

（四）赋值运算

= 赋值

+= 简单写法

-=

*=

/=

%=

++

--

赋值运算的参与者，一定是变量。赋值运算是先计算右边，然后将最终的值赋给左边。

1.++自增运算符

var e = 10;
e++;  //等价于 e=e+1
console.log(e); //11

++可以与输出语句写在一起，++写在变量前和写在变量后不是一个意思

a++:先用a的原值参与运算，然后a自己加1

++a：先给a自己加1，然后a的新值参与运算

var f = 10;
console.log(f++); //10  先引用原值，然后再加1

等价于

var f = 10;
console.log(f); //先输出f
f++；  //然后f加1

var g = 10;
console.log(++g); //11  先加一，然后再输出

++的特殊用法

var a = 8;
console.log(4 + a++); //12 先用原来的a的值计算，4+8，输出12，然后a再加1
console.log(a);

var i = 9;
console.log(++i % 5); //0 先把i加1，然后使用i进行精算，10 % 5
console.log(i); //10

var a = 10;
var b = ++a -1 + a++;
console.log(b + "" + a);  //2112 字符拼接
// 赋值的顺序，自右向左；计算的顺序，自左向右

2.-- 自减运算符

与自增运算符相同

练习：

var a = (10 * 3 - 4 / 2 + 1) % 2; 
var b =3;
b %=a + 3; 
console.log(a++); //1
console.log(--b); //2

var a = 123;
    var b = 234;
    // 请交换 a，b的值

    // 普通写法
    // 利用中间变量
    var c = a;
    a = b;
    b = c;
    
    // 方法二
    a = a + b;
    b = a - b;
    c = a - b;

（五）运算符的计算顺序

1.贴身的(++ -- !)

2.数学

3.比较

4.逻辑

5.赋值

var a = 3 < 8 && 8 < 14;  //true

解式：

= 3 < 8 && 8 < 14

= true && true

= true

注意：

像++ -- ! 这种只需要一个操作符参与的叫做一元运算符，同时一元操作符还包括+ -

两个操作符参与的叫二元运算符

三个操作符参与的叫做三元运算符

特殊一元操作符 + -

对于数值+ 没有变化，- 会将数值变为负数，如果数值为负数，那么结果就是正数。

var a = 1;
console.log(+a);
console.log(-a);

如果是非数字，就会像Number一样，将其他类型转换为数值类型

	console.log(+true); //1
    console.log(+false); //0
    console.log(+undefined); //NaN
    console.log(+null); //0
    console.log(+"33"); //33
    console.log(+"aa"); //NaN

	var n1 = 10, n2 = 20;
    var n = n1++;
    console.log("n = " + n); //10
    console.log("n1 = " + n1); //11
    var n = ++n1;
    console.log("n = " + n); //12
    console.log("n1 = " + n1); //12
    var n = n2--;
    console.log("n = " + n); //20
    console.log("n1 = " + n2);//19
    var n = --n2;
    console.log("n = " + n); //18
    console.log("n1 = " + n2);//18