feat: update translation

leviding · leviding · commit 61a149220eee · 2022-02-12T20:51:27.000+08:00
diff --git a/1-js/02-first-steps/05-types/article.md b/1-js/02-first-steps/05-types/article.md
@@ -46,13 +46,15 @@ n = 12.345;
     alert( "not a number" / 2 ); // NaN，这样的除法是错误的
     ```
 
-    `NaN` 是粘性的。任何对 `NaN` 的进一步操作都会返回 `NaN`：
+    `NaN` 是粘性的。任何对 `NaN` 的进一步数学运算都会返回 `NaN`：
 
     ```js run
-    alert( "not a number" / 2 + 5 ); // NaN
+    alert( NaN + 1 ); // NaN
+    alert( 3 * NaN ); // NaN
+    alert( "not a number" / 2 - 1 ); // NaN
     ```
 
-    所以，如果在数学表达式中有一个 `NaN`，会被传播到最终结果。
+    所以，如果在数学表达式中有一个 `NaN`，会被传播到最终结果（只有一个例外：`NaN ** 0` 结果为 `1`）。
 
 ```smart header="数学运算是安全的"
 在 JavaScript 中做数学运算是安全的。我们可以做任何事：除以 0，将非数字字符串视为数字，等等。
@@ -213,13 +215,6 @@ alert(age); // "undefined"
 
 `typeof` 运算符返回参数的类型。当我们想要分别处理不同类型值的时候，或者想快速进行数据类型检验时，非常有用。
 
-它支持两种语法形式：
-
-1. 作为运算符：`typeof x`。
-2. 函数形式：`typeof(x)`。
-
-换言之，有括号和没有括号，得到的结果是一样的。
-
 对 `typeof x` 的调用会以字符串的形式返回数据类型：
 
 ```js
@@ -251,9 +246,19 @@ typeof alert // "function"  (3)
 最后三行可能需要额外的说明：
 
 1. `Math` 是一个提供数学运算的内建 `object`。我们会在 <info:number> 一节中学习它。此处仅作为一个 `object` 的示例。
-2. `typeof null` 的结果是 `"object"`。这是官方承认的 `typeof` 的行为上的错误，这个问题来自于 JavaScript 语言的早期，并为了兼容性而保留了下来。`null` 绝对不是一个 `object`。`null` 有自己的类型，它是一个特殊值。
+2. `typeof null` 的结果为 `"object"`。这是官方承认的 `typeof` 的错误，这个问题来自于 JavaScript 语言的早期阶段，并为了兼容性而保留了下来。`null` 绝对不是一个 `object`。`null` 有自己的类型，它是一个特殊值。`typeof` 的行为在这里是错误的。
 3. `typeof alert` 的结果是 `"function"`，因为 `alert` 在 JavaScript 语言中是一个函数。我们会在下一章学习函数，那时我们会了解到，在 JavaScript 语言中没有一个特别的 "function" 类型。函数隶属于 `object` 类型。但是 `typeof` 会对函数区分对待，并返回 `"function"`。这也是来自于 JavaScript 语言早期的问题。从技术上讲，这种行为是不正确的，但在实际编程中却非常方便。
 
+```smart header="`typeof(x)` 语法"
+你可能还会遇到另一种语法：`typeof(x)`。它与 `typeof x` 相同。
+
+简单点说：`typeof` 是一个操作符，不是一个函数。这里的括号不是 `typeof` 的一部分。它是数学运算分组的括号。
+
+通常，这样的括号里包含的是一个数学表达式，例如 `(2 + 2)`，但这里它只包含一个参数 `(x)`。从语法上讲，它们允许在 `typeof` 运算符和其参数之间不打空格，有些人喜欢这样的风格。
+
+有些人更喜欢用 `typeof(x)`，尽管 `typeof x` 语法更为常见。
+```
+
 ## 总结
 
 JavaScript 中有八种基本的数据类型（译注：前七种为基本数据类型，也称为原始类型，而 `object` 为复杂数据类型）。
@@ -269,7 +274,7 @@ JavaScript 中有八种基本的数据类型（译注：前七种为基本数据
 
 我们可以通过 `typeof` 运算符查看存储在变量中的数据类型。
 
-- 两种形式：`typeof x` 或者 `typeof(x)`。
+- 通常用作 `typeof x`，但 `typeof(x)` 也可行。
 - 以字符串的形式返回类型名称，例如 `"string"`。
 - `typeof null` 会返回 `"object"` —— 这是 JavaScript 编程语言的一个错误，实际上它并不是一个 `object`。
 
diff --git a/1-js/02-first-steps/08-operators/article.md b/1-js/02-first-steps/08-operators/article.md
@@ -195,18 +195,18 @@ alert( +apples + +oranges ); // 5
 | 优先级 | 名称 | 符号 |
 |------------|------|------|
 | ... | ... | ... |
-| 17 | 一元加号 | `+` |
-| 17 | 一元负号 | `-` |
-| 16 | 求幂 | `**` |
-| 15 | 乘号 | `*` |
-| 15 | 除号 | `/` |
+| 16 | 一元加号 | `+` |
+| 16 | 一元负号 | `-` |
+| 15 | 求幂 | `**` |
+| 14 | 乘号 | `*` |
+| 14 | 除号 | `/` |
 | 13 | 加号 | `+` |
 | 13 | 减号 | `-` |
 | ... | ... | ... |
 | 3 | 赋值符 | `=` |
 | ... | ... | ... |
 
-我们可以看到，“一元加号运算符”的优先级是 `17`，高于“二元加号运算符”的优先级 `13`。这也是为什么表达式 `"+apples + +oranges"` 中的一元加号先生效，然后才是二元加法。
+我们可以看到，“一元加号运算符”的优先级是 `16`，高于“二元加号运算符”的优先级 `13`。这也是为什么表达式 `"+apples + +oranges"` 中的一元加号先生效，然后才是二元加法。
 
 ## 赋值运算符
 
diff --git a/1-js/02-first-steps/12-nullish-coalescing-operator/article.md b/1-js/02-first-steps/12-nullish-coalescing-operator/article.md
@@ -106,7 +106,7 @@ alert(height ?? 100); // 0
 
 ## 优先级
 
-`??` 运算符的优先级与 `||` 差不多，只是稍微低一点。`??` 运算符的优先级为 `5`，`||` 为 `6` ，详见：[MDN table](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Operator_Precedence#Table) 。
+`??` 运算符的优先级与 `||` 相同，它们的的优先级都为 `4`，详见：[MDN](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Operator_Precedence#Table)。
 
 这意味着，就像 `||` 一样，空值合并运算符在 `=` 和 `?` 运算前计算，但在大多数其他运算（例如 `+` 和 `*`）之后计算。
 
diff --git a/1-js/02-first-steps/16-function-expressions/article.md b/1-js/02-first-steps/16-function-expressions/article.md
@@ -12,19 +12,31 @@ function sayHi() {
 
 另一种创建函数的语法称为 **函数表达式**。
 
-通常会写成这样：
+它允许我们在任何表达式的中间创建一个新函数。
+
+例如：
 
 ```js
 let sayHi = function() {
   alert( "Hello" );
 };
 ```
 
-在这里，函数被创建并像其他赋值一样，被明确地分配给了一个变量。不管函数是被怎样定义的，都只是一个存储在变量 `sayHi` 中的值。
+在这里我们可以看到变量 `sayHi` 得到了一个值，新函数 `function() { alert("Hello"); }`。
+
+由于函数创建发生在赋值表达式的上下文中（在 `=` 的右侧），因此这是一个 **函数表达式**。
+
+请注意，`function` 关键字后面没有函数名。函数表达式允许省略函数名。
+
+这里我们立即将它赋值给变量，所以上面的两个代码示例的含义是一样的：“创建一个函数并将其放入变量 `sayHi` 中”。
 
-上面这两段示例代码的意思是一样的：“创建一个函数，并把它存进变量 `sayHi`”。
+在更多更高阶的情况下，稍后我们会遇到，可以创建一个函数并立即调用，或者安排稍后执行，而不是存储在任何地方，因此保持匿名。
 
-我们还可以用 `alert` 打印这个变量值：
+## 函数是一个值
+
+重申一次：无论函数是如何创建的，函数都是一个值。上面的两个示例都在 `sayHi` 变量中存储了一个函数。
+
+我们还可以用 `alert` 打印这个变量的值：
 
 ```js run
 function sayHi() {
@@ -63,10 +75,10 @@ sayHi(); // Hello    //     这里也能运行（为什么不行呢）
 2. `(2)` 行将 `sayHi` 复制到了变量 `func`。请注意：`sayHi` 后面没有括号。如果有括号，`func = sayHi()` 会把 `sayHi()` 的调用结果写进`func`，而不是 `sayHi` **函数** 本身。
 3. 现在函数可以通过 `sayHi()` 和 `func()` 两种方式进行调用。
 
-注意，我们也可以在第一行中使用函数表达式来声明 `sayHi`：
+我们也可以在第一行中使用函数表达式来声明 `sayHi`：
 
 ```js
-let sayHi = function() {
+let sayHi = function() { // (1) 创建
   alert( "Hello" );
 };
 
@@ -90,9 +102,9 @@ let sayHi = function() {
 }*!*;*/!*
 ```
 
-答案很简单：
-- 在代码块的结尾不需要加分号 `;`，像 `if { ... }`，`for {  }`，`function f { }` 等语法结构后面都不用加。
-- 函数表达式是在语句内部的：`let sayHi = ...;`，作为一个值。它不是代码块而是一个赋值语句。不管值是什么，都建议在语句末尾添加分号 `;`。所以这里的分号与函数表达式本身没有任何关系，它只是用于终止语句。
+答案很简单：这里函数表达式是在赋值语句 `let sayHi = ...;` 中以 `function(…) {…}` 的形式创建的。建议在语句末尾加上分号 `;`，它不是函数语法的一部分。
+
+分号用于更简单的赋值，例如 `let sayHi = 5;`，它也用于函数赋值。
 ````
 
 ## 回调函数
