# 常用运算符

# 算数运算符

常见的算数运算符有以下几种：

# 算数运算符的运算规则

（1）先算乘除、后算加减。

（2）小括号：能够影响计算顺序，且可以嵌套。没有中括号、没有大括号，只有小括号。

（3）百分号：取余。只关心余数。

# 算数运算符的注意事项

（1）当对非 Number 类型的值进行运算（包括+、-、*、/）时，会将这些值转换为 Number 然后再运算。（注：字符串 + Number、字符串 + 字符串是特例，稍后再讲）

比如：

result1 = true + 1; // 2 = 1+ 1

result2 = true + false; // 1 = 1+ 0

result3 = 1 + null; // 1 = 1+ 0

result4 = 100 - "1"; // 99

（2）任何值和 NaN 做运算的结果都是 NaN。

（3）任何的值和字符串做加法运算，都会先转换为字符串，然后再做拼串操作。

比如：

result1 = 1 + 2 + "3"; // 33

result2 = "1" + 2 + 3; // 123

我们可以利用这一特点，来将一个任意的数据类型转换为 String：我们只需要为任意的数据类型 + 一个 "" 即可将其转换为 String。这是一种隐式的类型转换，由浏览器自动完成，实际上它也是调用 String()函数。也就是说，c = c + "" 等价于 c = String(c)。

（4）任何值做-、*、/运算时都会自动转换为 Number。

我们可以利用这一特点，为一个值-0、*1、/1来将其转换为 Number。原理和 Number()函数一样，使用起来更加简单。

# 赋值运算符

可以将符号右侧的值赋值给符号左侧的变量。

举例：

• +=。a += 5 等价于 a = a + 5

• -=。a -= 5 等价于 a = a - 5

• *=。a _= 5 等价于 a = a _ 5

• /=。a /= 5 等价于 a = a / 5

• %=。a %= 5 等价于 a = a % 5

# 自增和自减

# 自增 ++

自增分成两种：a++和++a。

（1）对于一个变量自增以后，原变量的值会立即自增 1。也就是说，无论是 a++ 还是++a，都会立即使原变量的值自增 1。

（2）我们要注意的是：a是变量，而a++和++a是表达式。

那这两种自增，有啥区别呢？区别是：a++ 和 ++a的值不同：（也就是说，表达式的值不同）

• a++的值等于原变量的值（a 自增前的值）

• ++a的值等于新值 （a 自增后的值）

# 自减 --

原理同上。

var n1 = 10;
var n2 = 20;

var n = n1++; //n1 = 11  n1++ = 10

console.log("n=" + n); // 10
console.log("n1=" + n1); //11

n = ++n1; //n1 = 12  ++n1 =12
console.log("n=" + n); //12
console.log("n1=" + n1); //12

n = n2--; // n2=19 n2--=20
console.log("n=" + n); //20
console.log("n2=" + n2); //19

n = --n2; //n2=18 --n2 = 18
console.log("n=" + n); //18
console.log("n2=" + n2); //18

# 比较运算符

通过比较运算符可以比较两个值之间的大小关系，如果关系成立它会返回 true，如果关系不成立则返回 false。

关系运算符有很多种，比如：

>	大于号
<	小于号
>= 	大于或等于
<=  小于或等于
== 	等于
=== 全等于
!=	不等于
!== 不全等于

关系运算符，得到的结果都是布尔值：要么是 true，要么是 false。

举例如下：

var result = 5 > 10; // false

# 非数值的比较

（1）对于非数值进行比较时，会将其转换为数字然后再比较。

举例如下：

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

console.log(10 > null); //true
console.log(10 < undefined); // false
//任何值和NaN做任何比较都是false

console.log(10 <= "hello"); //false
console.log(true > false); //true

（2）特殊情况：如果符号两侧的值都是字符串时，不会将其转换为数字进行比较。比较两个字符串时，比较的是字符串的Unicode 编码。【非常重要，这里是个大坑】

比较字符编码时，是一位一位进行比较。如果两位一样，则比较下一位，所以借用它可以来对英文进行排序。

PS：所以说，当你尝试去比较"123"和"56"这两个字符串时，你会发现，字符串"56"竟然比字符串"123"要大。也就是说，下面这样代码的打印结果，其实是 true:（这个我们一定要注意，在日常开发中，很容易忽视）

// 比较两个字符串时，比较的是字符串的字符编码，所以可能会得到不可预期的结果
console.log("56" > "123"); // true

因此：当我们在比较两个字符串型的数字时，一定一定要先转型，比如 parseInt()。

（3）任何值和 NaN 做任何比较都是 false。

# ==符号的强调

注意==这个符号，它是判断是否等于，而不是赋值。

（1）==这个符号，还可以验证字符串是否相同。例如：

	console.log("我爱你中国" == "我爱你中国");		//输出结果为true

（2）==这个符号并不严谨，会将不同类型的东西，转为相同类型进行比较（大部分情况下，都是转换为数字）。例如：

console.log("6" == 6); // 打印结果：true。这里的字符串"6"会先转换为数字6，然后再进行比较
console.log(true == "1"); // 打印结果：true

console.log(null == 0); // 打印结果：true

（3）undefined 衍生自 null，所以这两个值做相等判断时，会返回 true。

console.log(undefined == null); //打印结果：true。

（4）NaN 不和任何值相等，包括他本身。

console.log(NaN == NaN); //false

问题：那如果我想判断 b 的值是否为 NaN，该怎么办呢？

答案：可以通过 isNaN()函数来判断一个值是否是 NaN。举例：

console.log(isNaN(b)); //false

如上方代码所示，如果 b 为 NaN，则返回 true；否则返回 false。

# ===全等符号的强调

如果要保证完全等于，我们就要用三个等号===。全等不会做类型转换。例如：

console.log("6" === 6); //false
console.log(6 === 6); //true

上述内容分析出：

• ==两个等号，不严谨，"6"和 6 是 true。

• ===三个等号，严谨，"6"和 6 是 false。

另外还有：==的反面是!=，===的反面是!==。。例如：

console.log(3 != 8); //true
console.log(3 != "3"); //false，因为3=="3"是true，所以反过来就是false。
console.log(3 !== "3"); //true，应为3==="3"是false，所以反过来是true。

# 逻辑运算符

# 逻辑运算符

逻辑运算符有三个：

• && 与（且）：两个都为真，结果才为真。

• || 或：只要有一个是真，结果就是真。

• ! 非：对一个布尔值进行取反。

连比的写法：

来看看逻辑运算符连比的写法。

举例 1：

console.log(3 < 2 && 2 < 4);

输出结果为 false。

举例 2：（判断一个人的年龄是否在 18~60 岁之间）

var a = prompt("请输入您的年龄");
alert(a >= 18 && a <= 65);

PS：上面的这个a>=18 && a<= 65千万别想当然的写成18<= a <= 65，没有这种语法。

# 注意事项

（1）JS 中的&&属于短路的与，如果第一个值为 false，则不会看第二个值。举例：

//第一个值为true，会检查第二个值
true && alert("看我出不出来！！"); // 可以弹出 alert 框

//第一个值为false，不会检查第二个值
false && alert("看我出不出来！！"); // 不会弹出 alert 框

（2）JS 中的||属于短路的或，如果第一个值为 true，则不会看第二个值。举例：

（3）如果对非布尔值进行逻辑运算，则会先将其转换为布尔值，然后再操作。举例：

var a = 10;
a = !a;

console.log(a); // false
console.log(typeof a); // boolean

上面的例子，我们可以看到，对非布尔值进行!操作之后，返回结果为布尔值。

# 非布尔值的与或运算【重要】

之所以重要，是因为在实际开发中，我们经常用这种代码做容错处理。

非布尔值进行与或运算时，会先将其转换为布尔值，然后再运算，但返回结果是原值。比如说：

var result = 5 && 6; // 运算过程：true && true;
console.log("result：" + result); // 打印结果：6（也就是说最后面的那个值。）

上方代码可以看到，虽然运算过程为布尔值的运算，但返回结果是原值。

那么，返回结果是哪个原值呢？我们来看一下。

与运算的返回结果：（以两个非布尔值的运算为例）

• 如果第一个值为 true，则必然返回第二个值（所以说，如果所有的值都为 true，则返回的是最后一个值）

• 如果第一个值为 false，则直接返回第一个值

或运算的返回结果：（以两个非布尔值的运算为例）

• 如果第一个值为 true，则直接返回第一个值

• 如果第一个值为 false，则返回第二个值