update: 运算符

04-JavaScript基础/10-运算符.md

@@ -182,9 +182,9 @@ var result2 = true + NaN; // NaN
 
 那这两种自增，有啥区别呢？区别是：`a++` 和 `++a`的值不同：（也就是说，表达式的值不同）
 
--   `a++`这个表达式的值等于原变量的值（a 自增前的值）。你可以这样理解：先把 a 的值赋值给表达式，然后 a 再自增。
+-   `a++`这个表达式的值等于原变量的值（a 自增前的值）。可以这样理解：先把 a 的值赋值给表达式，然后 a 再自增。
 
--   `++a`这个表达式的值等于新值 （a 自增后的值）。 你可以这样理解：a 先自增，然后再把自增后的值赋值给表达式。
+-   `++a`这个表达式的值等于新值 （a 自增后的值）。 可以这样理解：a 先自增，然后把自增后的值赋值给表达式。
 
 ### 自减 `-- `
 
@@ -218,29 +218,30 @@ console.log(result2); // 18
 
 ### 隐式类型转换
 
-自增和自减的执行过程：
+自增和自减时，a的执行过程：
 
-（1）先调用`Number(参数)`函数；
+（1）先调用`Number(a)`函数；
 
-（2）然后将`Number(参数)`的返回结果进行 加 1 操作。
+（2）然后将`Number(a)`的返回结果进行 加 1 操作，得到的结果赋值给 a。
 
 举例 1：
 
 ```javascript
-var a = '666';
+let a = '666'; // 这里不能用 const 定义，否则报错。
 a++;
 
-console.log(typeof a); // 打印结果： number
 console.log(a); // 打印结果：667
+console.log(typeof a); // 打印结果： number
 ```
 
 举例2：
 
 ```javascript
-var a = 'abc';
+let a = 'abc';
 a++;
-console.log(typeof a); // 打印结果：number
+
 console.log(a); // 打印结果：NaN。因为 Number('abc')的结果为 NaN，再自增后，结果依然是 NaN
+console.log(typeof a); // 打印结果：number
 ```
 
 ## 一元运算符
@@ -265,15 +266,15 @@ typeof 这个运算符的返回结果就是变量的类型。那返回结果的
 
 **返回结果**：
 
-| typeof 的代码写法 | 返回结果  |
-| :---------------- | :-------: |
-| typeof 数字       |  number   |
-| typeof 字符串     |  string   |
-| typeof 布尔型     |  boolean  |
-| typeof 对象       |  object   |
-| typeof 方法       | function  |
-| typeof null       |  object   |
-| typeof undefined  | undefined |
+| typeof 的语法                | 返回结果  |
+| :--------------------------- | :-------: |
+| typeof 数字（含 typeof NaN） |  number   |
+| typeof 字符串                |  string   |
+| typeof 布尔型                |  boolean  |
+| typeof 对象                  |  object   |
+| typeof 方法                  | function  |
+| typeof null                  |  object   |
+| typeof undefined             | undefined |
 
 备注 1：为啥 `typeof null`的返回值也是 object 呢？因为 null 代表的是**空对象**。
 
@@ -306,9 +307,11 @@ console.log({} instanceof Array); // 打印结果：false
 
 > 注意，这里说的是正号/负号，不是加号/减号。
 
+（1）不会改变原数值。
+
 （1）正号不会对数字产生任何影响。比如说，`2`和`+2`是一样的。
 
-（2）我们可以对一个其他的数据类型使用`+`，来将其转换为 number【重要的小技巧】。比如：
+（2）我们可以对其他的数据类型使用`+`，来将其转换为 number【重要的小技巧】。比如：
 
 ```javascript
 var a = true;
@@ -340,33 +343,30 @@ number
 
 ### 隐式类型转换——正号/负号
 
-任何值做`+a`、`-a`运算时， 内部调用的是 Number() 函数。不会改变原数值。
-
+任何值做`+a`、`-a`运算时， 内部调用的是 Number() 函数。
 
 **举例**：
 
 ```javascript
-var a = '666';
-var b = +a; // 对 a 进行一元运算，b是运算结果
+const a = '666';
+const b = +a; // 对 a 进行一元运算，b是运算结果
 
 console.log(typeof a); // 打印结果：string。说明 a 的数据类型保持不变。
-console.log(a); // 打印结果：666
+console.log(a); // 打印结果："666"。不会改变原数值。
 
 console.log(typeof b); // 打印结果：number。说明 b 的数据类型发生了变化。
 console.log(b); // 打印结果：666
 ```
 
-
-
 ## 逻辑运算符
 
 逻辑运算符有三个：
 
--   `&&` 与（且）：两个都为真，结果才为真。
+-   `&&`： 与（且）。两个都为真，结果才为真。
 
--   `||` 或：只要有一个是真，结果就是真。
+-   `||` ：或。只要有一个是真，结果就是真。
 
--   `!` 非：对一个布尔值进行取反。
+-   `!` ：非。对一个布尔值进行取反。
 
 注意：能参与逻辑运算的，都是布尔值。
 
@@ -404,7 +404,7 @@ PS：上面的`a>=18 && a<= 65`千万别想当然地写成` 18<= a <= 65`，没
 
 ```javascript
 var result = 5 && 6; // 运算过程：true && true;
-console.log('result：' + result); // 打印结果：6（也就是说最后面的那个值。）
+console.log('result：' + result); // 打印结果：6（也就是最后面的那个值）
 ```
 
 上方代码可以看到，虽然运算过程为布尔值的运算，但返回结果是原值。
@@ -413,13 +413,13 @@ console.log('result：' + result); // 打印结果：6（也就是说最后面
 
 **与运算**的返回结果：（以多个非布尔值的运算为例）
 
--   如果第一个值为 false，则执行第一条语句，并直接返回第一个值；不会再往后执行。
+-   如果第一个值为 false，则只执行第一条语句，并直接返回第一个值；不会再往后执行。
 
 -   如果第一个值为 true，则继续执行第二条语句，并返回第二个值（如果所有的值都为 true，则返回的是最后一个值）。
 
 **或运算**的返回结果：（以多个非布尔值的运算为例）
 
--   如果第一个值为 true，则执行第一条语句，并直接返回第一个值；不会再往后执行。
+-   如果第一个值为 true，则只执行第一条语句，并直接返回第一个值；不会再往后执行。
 
 -   如果第一个值为 false，则继续执行第二条语句，并返回第二个值（（如果所有的值都为 false，则返回的是最后一个值）。
 
@@ -496,25 +496,40 @@ if (!result) {
 
 ## 赋值运算符
 
-赋值：将符号右侧的值赋给符号左侧的变量。
+赋值：将等号右侧的值赋给符号左侧的变量。
 
 ### 赋值运算符包括哪些
 
 -   `=` 直接赋值。比如 `var a = 5`。意思是，把 5 这个值，往 a 里面存一份。简称：把 5 赋值给 a。
 
--   `+=`。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 _ = 5 等价于 a = a _ 5
+-   `/=`：比如 a /= 5 等价于 a = a / 5。
+
+-   `%=`：比如 a %= 5 等价于 a = a % 5。
+
+### 注意事项
+
+（1）算数运算符的优先级高于赋值运算符。举例：
+
+```js
+const result = 1 + 2; // 先计算 1 + 2，再把计算结果赋值给 result。因为算数运算符的优先级高于赋值运算符。
+```
+
+（2）赋值运算符的结合性是右结合性（从右至左的顺序计算）。举例：
+
+```js
+const a1, a2;
+a1 = a2 = 3; // 先将 3 复制给 a2，再将 a2 的值赋值给 a1
+```
 
--   `/=`。a /= 5 等价于 a = a / 5
 
--   `%=`。a %= 5 等价于 a = a % 5
 
-### 赋值运算符的注意事项
 
-todo