JavaScript运算符

定义

---

运算符:也称操作符，是一种符号。通过运算符可以对一个或多个值进行运算，并获取运算结果
表达式:由数字，运算符，变量的组合，表达式最终都有一个运算结果，我们称之为表达式的返回值

---

分类

---

• 算数运算符
• 自增/自减 运算符
• 一元运算符
• 逻辑运算符
• 赋值运算符
• 比较运算符
• 三元运算符

---

算数运算符

---

用于执行两个变量或值的算数运算

运算符	描述
+	加，字符串拼接
-	减
*	除
%	模（取余）

例子：

假设用户输入345，怎么分别得到3、4、5这三个数呢？

答案：

得到3的方法：345 除以100，得到3.45然后取整，得到3。即：parseInt(345/100)

得到4的方法：345 除以100，余数是45，除以10，得到4.5，取整。即：parseInt(345 % 100 / 10)

得到5的方法：345 除以10，余数就是5。即：345 % 10

运算规则

• 先算乘除，后算加减
• 小括号，影响计算顺序
• 百分号，取余，只关心余数

浮点数运算的精度问题

浮点数值的最高精度是 17 位小数，但在进行算术计算时，会丢失精度，导致计算不够准确，因此，不要直接判断两个浮点数是否相等。

---

自增/自减运算符

---

自增

自增分为两种： ++后置 和 ++前置

• 一个变量自增以后，原变量的值会立即自增1。也就是说，无论是 a++ 还是++a，都会立即使原变量的值自增1。
• a++这个表达式的值等于原变量的值（a自增前的值）。你可以这样理解：先把 a 的值赋值给表达式，然后 a 再自增
• ++a这个表达式的值等于新值 （a自增后的值）。 你可以这样理解：a 先自增，然后再把自增后的值赋值给表达式

自减

同上

开发时大多数使用后置自增/自减

let n1 = 10;
let n2 = 20;

let result1 = n1++;

console.log(n1); // 11
console.log(result1); // 10

result = ++n1;
console.log(n1); //12
console.log(result); //12

let result2 = n2--;
console.log(n2); // 19
console.log(result2); // 20

result2 = --n2;
console.log(n2); // 18
console.log(result2); // 18

---

一元运算符

---

一元运算符，只需要一个操作数。

typeof

typeof就是典型的一元运算符

let a = 'abc'
console.log(typeof a)//string

正号

• 正号不会被数字产生任何影响。比如说2和+2是一样的
• 我们可以对一个其他的数据类型使用+，将其转换为number

var a = true;
a = +a;   // 注意这行代码的一元运算符操作
console.log('a：' + a);
console.log(typeof a);

console.log('-----------------');

var b = '18';
b = +b;   // 注意这行代码的一元运算符操作
console.log('b：' + b);
console.log(typeof b);

负号

同上
负号可以对数字进行取反

---

逻辑运算符

---

• && 与：两个都为真，结果才为真
• || 或：只要有一个是真，结果就是真
• ! 非：对一个布尔值进行取反

能参与逻辑运算的，都是布尔值

连比写法：

const a = prompt('请输入您的年龄');

if (a >= 18 && a < 65) {
	alert('可以上班');
} else {
	alert('准备退休');
}
//x 上面的a>=18 && a<= 65千万别想当然地写成 18<= a <= 65，没有这种语法

非布尔值的与或运算

实际开发中，我们经常用这种代码进行容错处理或兜底处理

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

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

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

那么，返回结果是哪个原值呢？

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

• 如果第一个值为false，则执行第一条语句，并直接返回第一个值；不会再往后执行
• 如果第一个值为true，则继续执行第二条语句，并返回第二个值（如果所有的值都为true，则返回的是最后一个值）

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

• 如果第一个值为true，则执行第一条语句，并直接返回第一个值；不会再往后执行。
• 如果第一个值为false，则继续执行第二条语句，并返回第二个值（（如果所有的值都为false，则返回的是最后一个值）。

实际开发中，我们经常是这样来做「容错处理」的：

当前端成功调用一个接口后，返回的数据为 result 对象。这个时候，我们用变量 a 来接收 result 里的图片资源。通常的写法是这样的：

if (result.resultCode == 0) {
	var a = result && result.data && result.data.imgUrl || 'https://p9-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/948a45588da74367b1fd173261743f8c~tplv-k3u1fbpfcp-zoom-1.image';
}

上方代码的意思是，获取返回结果中的result.data.imgUrl这个图片资源；如果返回结果中没有 result.data.imgUrl 这个字段，就用 http://img.smyhvae.com/20160401_01.jpg 作为兜底图片。这种写法，在实际开发中经常用到。

非布尔值的 ! 运算

非布尔值进行与或运算时，会先将其转换为布尔值，然后再运算，但返回结果时布尔值

let a = 10;
a = !a

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

短路运算的妙用

下方举例中的写法技巧，在实际开发中，经常用到。这种写法，是一种很好的「容错、容灾、降级」方案，需要多看几遍。

JS中的&&属于短路的与：

• 如果第一个值为false，则不会执行后面的内容。

• 如果第一个值为 true，则继续执行第二条语句，并返回第二个值。

举例：

const a1 = 'qianguyihao';
//第一个值为true，会继续执行后面的内容
a1 && alert('看 a1 出不出来'); // 可以弹出 alert 框

const a2 = undefined;
//第一个值为false，不会继续执行后面的内容
a2 && alert('看 a2 出不出来'); // 不会弹出 alert 框

JS中的||属于短路的或：

• 如果第一个值为true，则不会执行后面的内容。

• 如果第一个值为 false，则继续执行第二条语句，并返回第二个值。

举例：

const result; // 请求接口时，后台返回的内容
let errorMsg = ''; // 前端的文案提示

if (result && result.retCode != 0) {
	// 接口返回异常码时
	errorMsg = result.msg || '活动太火爆，请稍后再试'; // 文案提示信息，优先用 接口返回的msg字段，其次用 '活动太火爆，请稍后再试' 这个文案兜底。
}

if (!result) {
	// 接口挂掉时
	errorMsg = '网络异常，请稍后再试';
}

---

赋值运算符

---

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

• = 直接赋值。比如 let a = 5

• +=。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

---

比较运算符

---

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

比较运算符有很多种，比如：

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

非数值的比较

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

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

//console.log(10 > null); //true

//任何值和NaN做任何比较都是false

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

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

比较字符编码时，是一位一位进行比较。如果两位一样，则比较下一位

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

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

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

• 任何值和NaN做比较都是false

==符号的强调

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

• == 这个符号，还可以验证字符串是否相同

console.log("我爱你中国" == "我爱你中国")

• == 这个符号并不严谨，会做隐式转换，将不同的数据类型，转为相同类型进行比较（大部分情况下，都是转换为数字）

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

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

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

• NaN不和任何值相等，包括他本身

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

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

===全等符号的强调

全等在比较时，不会做类型转换。如果要保证绝对等于（完全等于），我们就要用三个等号===

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

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

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

---

三元运算符

---

三元运算符也叫条件运算符

语法：条件表达式 ? 语句1 : 语句2

执行的流程： 三元运算符在执行的时候，首先对条件表达式进行求值：

• 如果该值为true，则执行语句1，并返回执行结果
• 如果该值为false，则执行语句2，并返回执行结果

如果条件的表达式的求值结果是一个非布尔值，会将其转换为布尔值然后再运算

运算符的优先级

---

如下（从高到低）

• .、[]、new

• ()

• ++、--

• !、~、+（单目）、-（单目）、typeof、void、delete

• %、*、/

• +（双目）、-（双目）

• <<、>>、>>>

• 关系运算符：<、<=、>、>=

• ==、!==、===、!==

• &

• ^

• |

• &&

• ||

• ?:

• =、+=、-=、*=、/=、%=、<<=、>>=、>>>=、&=、^=、|=

• ,

逻辑与 && 比逻辑或 || 的优先级更高
你在实际写代码的时候，如果不清楚哪个优先级更高，可以把括号运用上

---

Unicode编码

---

这一段中，我们来讲引申的内容：Unicode编码的使用

• 在字符串中可以使用转义字符输入Unicode编码。

\u四位编码

console.log("\u2600");  // 这里的 2600 采用的是16进制
console.log("\u2602");  // 这里的 2602 采用的是16进制。

• 我们还可以在 HTML 网页中使用Unicode编码

&#四位编码;
<!-- 我们知道，Unicode编码采用的是16进制，但是，这里的编码需要使用10进制。-->
<h1 style="font-size: 100px;">&#9860;</h1>

---