【JS逆向】【5.JavaScript 基础语法】运算符，算术运算符，比较运算符，逻辑运算符，赋值运算符，位运算符

运算符

运算符（operator）也被称为操作符，是用于实现赋值、比较和执行算术术运算等功能的符号。
JavaScript中常用的运算符有：

• 算术运算符
• 递增和递减运算符
• 比较运算符
• 逻辑运算符
• 赋值运算符

1. 算术运算符

概念：算术运算使用的符号，用于执行两个变量或值的算术运算

运算符	描述	实例
+	加	10 + 20 = 30
-	减	10 - 20 = -10
*	乘	10 * 20 = 100
/	除	10 / 20 = 0.5
%	取余数（取模）	返回除法的余数9 % 2 = 1
**	次幂	求次方 10 ** 2 = 100

# 加法运算符
console.log(1 + 2)                 // 等于3
console.log(1 + NaN)               // NaN，只要有一个NaN就为NaN
console.log(Infinity + Infinity)     // Infinity
console.log(-Infinity + -Infinity)    // -Infinity
console.log( Infinity + -Infinity)   // NaN，正无穷和负无穷相加等NaN
console.log(100 + '100')           // 100100，字符串连接符，有字符串就不是加法
console.log('您的年龄是：' + 10 + 20)   // 您的年龄是：1020，被转换成字符串
consolelot(10 + 20 + '是您的年龄')       // 30是您的年龄，没有被转成字符串
console.log('您的年龄是：' + (10 + 20)) // 您的年龄是：30，没有被转成字符串
console.log(10 + {})             // 10[object Object]类型是string
console.log(10 + 对象)             // 10[object Object]，如果有toString()或valueOf()，则返回10+返回数的值

# 减法运算符
var a, b;
a = 2;
b = 1;
var sub = a - b;
console.log(sub);  // 1
console.log(2 - 1);  // 1
console.log(100 - 70)                //等于30
console.log(-100 - 70)                //等于-170
console.log(-100 - -70)               //-30，一般写成-100 - (-70)比较清晰
console.log(1 - 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(100 - true)             //99，true转成数值为1
console.log(100 - '')                 //100，''转成了0
console.log(100 - '70')              //30，'70'转成了数值70
console.log(100 - null)              //100，null转成了0
console.log(100 - 'Lee')              //NaN，Lee转成了NaN
console.log(100 - 对象 )             //NaN，如果有toString()或valueOf()
 则返回10-返回数的值


# 乘法运算符
console.log(100 * 70)               //7000          
console.log(100 * NaN)             //NaN，只要有一个NaN即为NaN
console.log(Infinity * Infinity)         //Infinity
console.log(-Infinity * Infinity )       //-Infinity
console.log(-Infinity * -Infinity)       //Infinity
console.log(100 * true)            //100，true转成数值为1
console.log(100 * '')                 //0，''转成了0
console.log(100 * null)             //0，null转成了0
console.log(100 * 'Lee')           //NaN，Lee转成了NaN
console.log(100 * 对象)            //NaN，如果有toString()或valueOf()
 则返回10 - 返回数的值


# 除法运算符
var a, b;
a = 2;
b = 1;
var div = a / b;
console.log(div); // 2
console.log(3 / 2); // 1.5
console.log(100 / 70)                //1.42....
console.log(100 / NaN)              //NaN
console.log(Infinity / Infinity)          //NaN
console.log(-Infinity / Infinity)        //NaN
console.log(-Infinity / -Infinity)        //NaN
console.log(100 / true)              //100，true转成1
console.log(100 / '')              //Infinity，
console.log(100 / null)            //Infinity，
console.log(100 / 'Lee')             //NaN
console.log(100 / 对象)           //NaN，如果有toString()或valueOf()，则返回10 / 返回数的值



# 取余运算符
var a, b;
a = 9;
b = 6;
var div = a % b;
console.log(div);  // 3
console.log(-3 / 2);  // -1.5
console.log(-3 % 2);  // -1
console.log(10 % 3)                   //1，余数为1            
console.log(100 % NaN)               //NaN
console.log(Infinity % Infinity)       //NaN           
console.log(-Infinity %  Infinity)       //NaN
console.log(-Infinity %  -Infinity)       //NaN
console.log(100 %  true)           //0
console.log(100 %  '')              //NaN
console.log(100 %  null)            //NaN
console.log(100 %  'Lee')          //NaN
console.log(100 %  对象)             //NaN，如果有toString()或valueOf()，则返回10 % 返回数的值

# 求次幂（次方、指数）
console.log(2 ** 3);    // 8
console.log(2 ** 0.5);  // 1.414...  √2
console.log(0.3 ** 2);  // 0.09

2. 递增和递减运算符

• 如果需要反复给数字变量添加或减去1，可以使用递增（++）和递减（ - - ）运算符来完成。
• 在 JavaScript 中，递增（++）和递减（ - - ）既可以放在变量前面，也可以放在变量后面。放在变量前面时，我们可以称为前置递增（递减）运算符，放在变量后面时，我们可以称为后置递增（递减）运算符。
• 注意：递增和递减运算符必须和变量配合使用

前置递增运算符

++num 前置递增，就是自加1，类似于 num = num + 1，但是 ++num 写起来更简单。
使用口诀：先自加，后返回值

// 前置递增运算符 ++ 写在变量的前面
var num1 = 10;
++num1;    // 类似于 num1 = num1 + 1
console.log(num1);
var num2 = 10;
console.log(++num2 + 10);   // 先加1，后返回值

后置递增运算符

num++ 后置递增，就是自加1，类似于 num = num + 1 ，但是 num++ 写起来更简单。
使用口诀：先返回原值，后自加

var num1 = 10;
num1++;    // num1 = num2 + 1     ++num1;
console.log(num1);
// 前置自增和后置自增如果单独使用，效果是一样的
// 后置自增 口诀：先返回原值，后自加1
var num2 = 10;
console.log(num2++ + 10);
console.log(num2);

前置递增和后置递增小结

• 前置递增和后置递增运算符可以简化代码的编写，让变量的值 + 1 比以前写法更简单
• 单独使用时，运行结果相同
• 与其他代码联用时，执行结果会不同
• 后置：先原值运算，后自加（先人后己）
• 前置：先自加，后运算（先己后人）
• 开发时，大多使用后置递增/减，并且代码独占一行，例如：num++; 或者 num- -;

3. 比较（关系）运算符

比较运算符用于比较两个值的大小，然后返回一个布尔值，表示是否满足指定的条件。
注意，比较运算符可以比较各种类型的值，不仅仅是数值。

符号	描述	案例	结果
>	大于	1 < 2	true
<	小于	1 > 2	false
<=	小于或等于	2 >= 2	true
>=	大于或等于	3 <= 2	false
==	相等（会转型）	6 == 6	true
===	严格相等	9 === “9”	false
!=	不相等	8!=8	false
!==	严格不相等	8!==“8”	true

这八个比较运算符分成两类：相等比较和非相等比较。两者的规则是不一样的，对于非相等的比较，算法是先看两个运算子是否都是字符串，如果是的，就按照字典顺序比较（实际上是比较 Unicode 码点）；否则，将两个运算子都转成数值，再比较数值的大小。

console.log(3 >= 5);  # false
console.log(2 <= 6);  # true
// 程序里面的等号符号是 ==
console.log(5 == 6);  # false
console.log('香蕉' == '卟NaNa');
console.log(88 == 88);  # true
// == 会默认转换数据类型，会把字符串型的数据类型转换为数字型的，只要求值相等就可以 true
console.log(88 == '88');   # true
console.log(66 != 66);  # false
// 全等 ===
console.log(22 === 22);  # true
// 全等 ===  要求两侧的值和数据类型完全一致才可以 true
 console.log(22 === '22');  # false

4. 逻辑运算符

概念：逻辑运算符是用来进行布尔值运算的运算符，其返回值也是布尔值。后面开发中经常用于多个条件的判断

符号	说明	案例
&&	“逻辑与”，简称 “与” and	true && false
!	“逻辑非”，简称 “非” not	!true

逻辑与 &&

两边都是 true才返回 true，否则返回 false

// 逻辑与 &&  and  两边都是true，结果才是true，只要有一侧是false，结果就是false
console.log(3 > 2 && 3 > 5);  # false
console.log(3 > 2 && 3 < 5);  # true

逻辑或 ||

两边都为 false 才返回 false，否则都为true

// 逻辑或 ||  or  两侧都为false时，结果才是false，只要有一侧时true，结果就是true
console.log(3 > 2 || 3 > 5);  # true
console.log(3 < 2 || 3 > 5);  # false

逻辑非 ！

逻辑非（!）也叫作取反符，用来取一个布尔值相反的值，如 true 的相反值是 false

// 逻辑非 ！ not
console.log(!true);  # false

短路运算（逻辑中断）

短路运算的原理：当有多个表达式（值）时，左边的表达式值可以确定结果时，就不再继续运算右边的表达式的值

逻辑与

• 语法： 表达式1 && 表达式2
• 如果第一个表达式的值为真，则返回表达式2
• 如果第一个表达式的值为假，则返回表达式1

// 逻辑与短路运算 如果表达式为真，则返回表达式2，如果表达式1为假，则返回表达式1
console.log(123 && 456);  # 456
console.log(123 && 456 && 789);  # 789
console.log(1 && 2 + 3 && 8 - 6);  # 2
// 如果有如果有空的或者是否定的为假的，其余是真的，0、''、null、undefined、NaN为假
console.log(0 && 456);  # 0
console.log('' && 456);  # 空值
console.log(0 && 1+2 && 345);  # 0

逻辑或

• 语法： 表达式1 || 表达式2
• 如果第一个表达式的值为真，则返回表达式1
• 如果第一个表达式的值为假，则返回表达式2

// 逻辑或短路运算 如果表达式1结果为真，则返回表达式1，如果表达式1结果为假，则返回表达式2
console.log(123 || 456);  # 123
console.log(123 || 456 || 789);  # 123
console.log(0 || 456 || 789);  # 456
// 逻辑中断会影响程序的运行结果
var num = 0;
console.log(123 || num++);
console.log(num); # 123

5. 赋值运算符

概念：用来把数据赋值给变量的运算符

符号	说明	案例
=	直接赋值	var usrName = “我爱JS”
+=、-=	加、减一个数后再赋值	var age = 10; age += 5; // 15
*=、/=、%=	乘、除、取模 后再赋值	var age = 2; age *= 5; // 10

// 赋值运算符 = 、+= 、-= 、*= 、/= 、%=
var num = 10;
num += 5;           // 相当于 num = num + 5; 此处num运算前的值是10，运算后是15
console.log(num);
num -= 3;           // 相当于 num = num - 3; 此处num运算前的值是15，运算后是12
console.log(num);
num *= 2;           // 相当于 num = num * 2; 此处num运算前的值是12，运算后是24
console.log(num);
num /= 2;           // 相当于 num = num / 2; 此处num运算前的值是24，运算后是12
console.log(num);
num %= 7;           // 相当于 num = num % 7; 此处num运算前的值是12，运算后是5
console.log(num);

6. 位运算符

按位运算符是JavaScript中的一组二进制运算符，用于对数字的二进制表示进行操作。按位运算符会将操作数转换成二进制形式，然后对它们的每一位进行比较和计算，最终得出运算结果。

位运算符有七种，分别是：位非NOT(~)、位与AND(&)、位或OR（|）、位异或XOR(^)、左移(<<)、有符号右移(>>)、无符号右移(>>>)

console.log(~25)                //-26
console.log(25 & 3)               //1
console.log(25 | 3)               //27
console.log(25 << 3)         //200
console.log(25 >> 2)              //6
console.log(25 >>> 2)            //6