2-12 JavaScript操作符• %:取余，取模。 a / b = c 余 d，就说a % b = d。 • 运算

1.算数运算符

• + - * / % ()

• %:取余，取模。 a / b = c 余 d，就说a % b = d。

• 运算顺序：先算乘除取余、再算加减，有小括号先算小括号。

1.正常情况：数字与数字运算

2.非正常运算1

有特殊值字面量参与的运算。
NaN参与的运算：得到的结果都是NaN
Infinity参与的运算，视情况而定
工作中并不会使用特殊值运算，没有实际应用的意义，但是要了解，以防面试遇到。

// NaN参与
    console.log(NaN + 5); // NaN
    console.log(NaN * 5); // NaN
    console.log(NaN / 5); // NaN
    console.log(NaN % 5); // NaN

    // Infinity
    console.log(Infinity + 5); // Infinity
    console.log(Infinity - 5); // Infinity
    console.log(Infinity * 5); // Infinity
    console.log(Infinity / 5); // Infinity
    console.log(Infinity % 5); // NaN
    console.log(-Infinity + 5); // -Infinity
    console.log(-Infinity - 5); // -Infinity
    console.log(-Infinity * 5); // -Infinity
    console.log(-Infinity / 5); // -Infinity
    console.log(-Infinity % 5); // NaN
    console.log(5 / Infinity); // 0（无限趋近于0） 任何数除以Infinity都是0
    console.log(5 % Infinity); // 5
    console.log(Infinity + Infinity); // Infinity
    console.log(Infinity - Infinity); // NaN
    console.log(Infinity * Infinity); // Infinity
    console.log(Infinity / Infinity); // NaN
    console.log(Infinity % Infinity); // NaN

2.非正常运算3

其他类型的数据参与数学运算。
有字符串参与的 + 运算：+ 号变为连字符将前后连接成整体字符串。
隐式转换：除了字符串参与的 + 运算，其他情况下，所有其他数据类型参与数学运算时，计算机暗中将其他数据类型先自动转换成数字类型，再参与运算，这个过程中不需要使用parseInt()、Number() 等方法，过程是暗中进行，这就是一个隐式转换的过程。

其他的数据类型会隐式转换为数字类型：

对应数字：纯数字字符串会转为对应的数字”123”→123
转换为1： true
转换为0：false、null、 “”空字符串、空白字符串
转换为NaN：undefined、非空非纯数字字符串

    // 字符串参与
    console.log(1 + "12"); // 112 有字符串参与的 + 运算是字符串拼接
    console.log(1 - "2"); // -1
    console.log(1 * "2"); // 2
    console.log(1 / "2"); // 0.5
    console.log(1 % "2"); // 1
    console.log(1 - ""); // 1
    console.log(1 - "   "); // 1
    console.log(1 - "12abc"); // NaN
	// 其他数据类型参与
    console.log(1 + true); // 2
    console.log(1 + false);  // 1
    console.log(1 + undefined);  //NaN
    console.log(1 + null); // 1

2.比较运算符

大于
<	小于
>=	大于等于
<=	小于等于
==	相等，只判断值大小是否相等，不判断数据类型
!=	不等，与相等完全相反
===	全等，不光判断值相等，还要判断数据类型相等
!==	不全等，与全等于完全相反

1.正常情况：数字与数字比较

	console.log(7 > 8);
    console.log(7 < 8);
    console.log(7 >= 8);
    console.log(7 <= 8);
    console.log(7 == 8);
    console.log(7 != 8);
    console.log(8 === 8);
    console.log(8 !== 8);

2.非正常情况1

• 特殊值参与比较运算。

• NaN参与：不等于和不全等于结果是 true，其他的都得到 false。

• Infinity参与的运算，视情况而定

	console.log(NaN > 8);// false
    console.log(NaN < 8);// false
    console.log(NaN >= 8);// false
    console.log(NaN <= 8);// false
    console.log(NaN == 8);// false
    console.log(NaN != 8);// true
    console.log(NaN === 8);// false
    console.log(NaN !== 8);// true
    console.log(NaN > NaN);// false
    console.log(NaN < NaN);// false
    console.log(NaN >= NaN);// false
    console.log(NaN <= NaN);// false
    console.log(NaN == NaN);// false
    console.log(NaN != NaN);// true
    console.log(NaN === NaN);// false
    console.log(NaN !== NaN);// true

	console.log(Infinity > 8);// true
    console.log(Infinity < 8);// false
    console.log(Infinity >= 8);// true
    console.log(Infinity <= 8);// false
    console.log(Infinity == 8);// false
    console.log(Infinity != 8);// true
    console.log(Infinity === 8);// false
    console.log(Infinity !== 8);// true
    console.log(Infinity > Infinity);// false
    console.log(Infinity < Infinity);// false
    console.log(Infinity >= Infinity);// true
    console.log(Infinity <= Infinity);// true
    console.log(Infinity == Infinity); //true
    console.log(Infinity != Infinity);// false
    console.log(Infinity === Infinity);// true
    console.log(Infinity !== Infinity);//false

3.非正常情况2

• 其他数据类型参与比较运算（排除字符串与字符串的比较）。

• 其他数据类型也会隐式转换为数字参与比较。

“123”→123 true→1 false→0 null→0 undefined→NaN “”→0 “abc”→NaN

• null 的判断比较特殊：null 与 0 判断时，相等判断为 false，>= 和 <= 判断为 true

• null == undefined

   	console.log(1 == "1"); // true
    console.log(1 == true); // true
    console.log(0 == false); // true
    console.log(0 == ""); // true
    console.log(0 == "     "); // true
    console.log(0 == undefined); // false
    console.log(0 == null); // false
    console.log(1 > null); // true
    console.log(0 >= null); // true
    console.log(0 <= null); // true
    console.log(undefined == null); // true

4.非正常情况3

• 字符串与字符串比较。

• 不会发生隐式转换为数字，而是比较两个字符串的 Unicode 编码顺序。

• 字符编码顺序：从前往后 0-9，A-Z，a-z，前面的小于后面的。

• 比较时，不关心两个字符串的长度，从第一个字符开始比较，依次往后顺延比较，直到比较出大小，就不再往后比较

5.比较运算符比较顺序

• 从前往后比较，前面的结果与后面的进行比较。

console.log(3 > 2 > 1); // false

3.逻辑运算符

逻辑运算符常用于布尔类型值之间; 当操作数都是布尔值时，返回值也是布尔值。

&&	逻辑与运算符且
\|\|	逻辑或运算符
!	逻辑非运算符

1.正常情况

布尔类型的值参与运算，返回值为布尔值。

	// 逻辑与：都真才真，有假就假
    console.log(true && true); // true
    console.log(true && false); // false
    console.log(false && true); // false
    console.log(false && false); // false	
	// 逻辑或：有真就真，都假才假
    console.log(true || true); // true
    console.log(true || false); // true
    console.log(false || true); // true
    console.log(false || false); // false
	// 逻辑非:非真既假，非假既真
    console.log(!true); // false
    console.log(!false); // true
    console.log(!!!!!!!false); // 从最近的！开始计算，一直到最前面 true

2. 非正常情况

除了布尔类型的值之外，其他数据类型的值也可以参与逻辑运算。运算过程中需要将操作数隐式转换为布尔类型的值，参与判断计算，最终运算结果还是原来的某个位置的数据。
并不是所有逻辑运算返回结果都是布尔值，其他数据参与得到的就是数据本身
隐式转换规律
- 转为false：NaN、0、 “”空字符串、null、undefined
- 转为true：非0 非NaN数字、非空字符串
- 当它们用于非布尔值的时候，返回值就可能是非布尔值。其实这种运算非常简单，就两句话
- (逻辑与 a&&b ) 如果a能被转换为false，那么返回a；否则，返回b。
- (逻辑或 a ||b ) 如果a能被转换为true，那么返回a；否则，返回b。

    // 非正常情况，其他类型数据参与运算
    console.log(null && "123"); // null
    console.log(12 && "123"); // 123
    console.log(12 || "123"); // 12
    console.log(undefined || null); // null
   // 非运算的运算结果只能是 true 或false
    console.log(!9); // falese

逻辑运算符运算顺序

同种运算符从前往后运算。
综合运算顺序：非、与、或。

   // 非运算的运算结果只能是 true 或false
    console.log(!9); // falese

4.赋值运算符

赋值运算符必须有变量参与运算，赋值运算符会做两件事情：

第一，将变量中原始值参与对应数学运算，与右侧的数据。
第二，将运算结果再重新赋值给变量。
变量位于操作符的左侧。

=	等于
+=	加等于
-=	减等于
*=	乘等于
/=	除等于
%=	取余等于
++	递加
--	递减

	// 定义变量
    var a = 5;
    // 加等于
    a += 3;  // 等价于  a = a + 3
    console.log(a);
    // 乘等于
    a *= 6; // 等价于  a = a * 6
    console.log(a);
    // 递加
    console.log(a++); // 48
    // console.log(++a); // 49
    console.log(a);

5.一元运算符(面试容易遇到)

++ 和 -- 也叫一元运算符，只有一个操作数。
++ 或 -- 符号可以写在变量前和变量后面，位置不同可能导致程序运行结果不同。
以 ++ 为例：
a++: ++ 符号在变量之后，a++ 在参与程序过程中使用的原始没有加 1 的值，使用完后第二次用 a 变量时，a 用的就是加 1 后的新值。先参与，后自加。
++a：++ 符号在变量之前，++a 在参与过程中整体就使用 a 加 1 之后的新值，使用完后第二次用 a 变量时，a 用的也是加 1 的新值。先自加，后参与。

    var a = 10,b = 20,c = 30;
    // 计算一个综合的算式
    var num = a++ + ++b + c++ + ++a;
    console.log(num); // 73
    console.log(a); // 12
    console.log(b); // 21
    console.log(c); //31

6.运算优先级

• 运算优先级也可以叫综合运算顺序。

• 优先级从高到底

() 优先级最高
一元运算符 ++ -- !
算数运算符先* / % 后 + -
关系运算符 > >= < <=
相等运算符 == != === !==
逻辑运算符先&& 后||
赋值运算符

	// () → 一元 → 算术 → 比较 → 逻辑 → 赋值
    var a = 4;
    var num = 1 * (2 + 3) && ++a || 5 > 6 && 7 < 8 || !9;
    // num = 1 * 5 && ++a || 5 > 6 && 7 < 8 || !9
    // num = 1 * 5 && 5 || 5 > 6 && 7 < 8 || false
    // num = 5 && 5 || 5 > 6 && 7 < 8 || false
    // num = 5 && 5 || false && true || false
    // num = 5 || false || false
    // num = 5
    console.log(num);

2-12 JavaScript操作符