diff --git a/1-js/01-getting-started/1-intro/article.md b/1-js/01-getting-started/1-intro/article.md
index c40a43443f..319d40aabe 100644
--- a/1-js/01-getting-started/1-intro/article.md
+++ b/1-js/01-getting-started/1-intro/article.md
@@ -24,11 +24,11 @@ JavaScript 在刚诞生的时候，它的名字叫 "LiveScript"。但是因为
 
 不同的引擎有不同的“代号”，例如：
 
-- [V8](https://en.wikipedia.org/wiki/V8_(JavaScript_engine)) —— Chrome 和 Opera 中的 JavaScript 引擎。
+- [V8](https://en.wikipedia.org/wiki/V8_(JavaScript_engine)) —— Chrome、Opera 和 Edge 中的 JavaScript 引擎。
 - [SpiderMonkey](https://en.wikipedia.org/wiki/SpiderMonkey) —— Firefox 中的 JavaScript 引擎。
-- ……还有其他一些代号，像 "Chakra" 用于 IE，"ChakraCore" 用于 Microsoft Edge，"Nitro" 和 "SquirrelFish" 用于 Safari，等等。
+- ……还有其他一些代号，像 "Chakra" 用于 IE，"JavaScriptCore"、"Nitro" 和 "SquirrelFish" 用于 Safari，等等。
 
-上面这些术语很容易记住，因为它们经常出现在开发者的文章中。我们也会用到这些术语。例如，如果“V8 支持某个功能”，那么我们可以认为这个功能大概能在 Chrome 和 Opera 中正常运行。
+上面这些术语很容易记住，因为它们经常出现在开发者的文章中。我们也会用到这些术语。例如，如果“V8 支持某个功能”，那么我们可以认为这个功能大概能在 Chrome、Opera 和 Edge 中正常运行。
 
 ```smart header="引擎是如何工作的？"
 
@@ -110,7 +110,8 @@ JavaScript 是将这三件事结合在一起的唯一的浏览器技术。
 - [TypeScript](http://www.typescriptlang.org/) 专注于添加“严格的数据类型”以简化开发，以更好地支持复杂系统的开发。由微软开发。
 - [Flow](http://flow.org/) 也添加了数据类型，但是以一种不同的方式。由 Facebook 开发。
 - [Dart](https://www.dartlang.org/) 是一门独立的语言。它拥有自己的引擎，该引擎可以在非浏览器环境中运行（例如手机应用），它也可以被编译成 JavaScript。由 Google 开发。
-- [Brython](https://brython.info/) 是一个 Python 的 JavaScript 编译器，可以在不使用 JavaScript 的情况下，以纯 Python 编写应用程序。
+- [Brython](https://brython.info/) 是一个 Python 到 JavaScript 的转译器，让我们可以在不使用 JavaScript 的情况下，以纯 Python 编写应用程序。
+- [Kotlin](https://kotlinlang.org/docs/reference/js-overview.html) 是一个现代、简洁且安全的编程语言，编写出的应用程序可以在浏览器和 Node 环境中运行。
 
 这样的语言还有很多。当然，即使我们在使用此类编译语言，我们也需要了解 JavaScript。因为了解 JavaScript 才能让我们真正明白我们在做什么。
 
diff --git a/1-js/01-getting-started/2-manuals-specifications/article.md b/1-js/01-getting-started/2-manuals-specifications/article.md
index 2c3bfc6e95..8d04a3fb46 100644
--- a/1-js/01-getting-started/2-manuals-specifications/article.md
+++ b/1-js/01-getting-started/2-manuals-specifications/article.md
@@ -17,16 +17,11 @@
 
 ## 手册
 
-- **MDN（Mozilla）JavaScript 索引** 是一个带有用例和其他信息的手册。它是一个获取关于个别语言函数、方法等深入信息的很好的来源。
+- **MDN（Mozilla）JavaScript 索引** 是一个带有用例和其他信息的主要的手册。它是一个获取关于个别语言函数、方法等深入信息的很好的信息来源。
 
     你可以在 <https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference> 阅读它。
 
-    虽然，利用互联网搜索通常是最好的选择。只需在查询时输入“MDN [关键字]”，例如 <https://google.com/search?q=MDN+parseInt> 搜索 `parseInt` 函数。
-
-
-- **MSDN** —— 一本微软的手册，它包含大量的信息，包括 JavaScript（在里面经常被写成 JScript）。如果有人需要关于 Internet Explorer 的规范细节，最好去看：<http://msdn.microsoft.com/>。
-
-    当然，我们还可以在使用互联网搜索中使用如 "RegExp MSDN" 或 "RegExp MSDN jscript" 这样的词条。
+虽然，利用互联网搜索通常是最好的选择。只需在查询时输入“MDN [关键字]”，例如 <https://google.com/search?q=MDN+parseInt> 搜索 `parseInt` 函数。
 
 ## 兼容性表
 
diff --git a/1-js/01-getting-started/3-code-editors/article.md b/1-js/01-getting-started/3-code-editors/article.md
index a41c5790ea..de5c1038e6 100644
--- a/1-js/01-getting-started/3-code-editors/article.md
+++ b/1-js/01-getting-started/3-code-editors/article.md
@@ -32,7 +32,6 @@ IDE 加载项目（通常包含很多文件），并且允许在不同文件之
 下面是一些值得你关注的“轻量编辑器”：
 
 - [Atom](https://atom.io/)（跨平台，免费）。
-- [Visual Studio Code](https://code.visualstudio.com/)（跨平台，免费）。
 - [Sublime Text](http://www.sublimetext.com)（跨平台，共享软件）。
 - [Notepad++](https://notepad-plus-plus.org/)（Windows，免费）。
 - [Vim](http://www.vim.org/) 和 [Emacs](https://www.gnu.org/software/emacs/) 也很棒，如果你知道怎么使用它们的话。
diff --git a/1-js/02-first-steps/01-hello-world/article.md b/1-js/02-first-steps/01-hello-world/article.md
index ca2f840cab..0fbf41feec 100644
--- a/1-js/02-first-steps/01-hello-world/article.md
+++ b/1-js/02-first-steps/01-hello-world/article.md
@@ -9,7 +9,7 @@
 
 ## “script” 标签
 
-JavaScript 程序可以在 `<script>` 标签的帮助下插入到 HTML 文档的任何地方。
+我们几乎可以使用 `<script>` 标签将 JavaScript 程序插入到 HTML 文档的任何位置。
 
 比如：
 
diff --git a/1-js/02-first-steps/02-structure/article.md b/1-js/02-first-steps/02-structure/article.md
index d7074fb1a0..cc22474412 100644
--- a/1-js/02-first-steps/02-structure/article.md
+++ b/1-js/02-first-steps/02-structure/article.md
@@ -56,39 +56,36 @@ alert(3 +
 如果你好奇地想知道一个这种错误的具体例子，那你可以看看下面这段代码：
 
 ```js run
-[1, 2].forEach(alert)
+alert("Hello");
+
+[1, 2].forEach(alert);
 ```
 
-你不需要考虑方括号 `[]` 和 `forEach` 的含义，现在它们并不重要，之后我们会学习它们。让我们先记住这段代码的运行结果：先显示 `1`，然后显示 `2`。
+你不需要考虑方括号 `[]` 和 `forEach` 的含义，现在它们并不重要，之后我们会学习它们。让我们先记住这段代码的运行结果：先显示 `Hello`，然后显示 `1`，然后 `2`。
 
-现在我们在代码前面插入一个 `alert` 语句，并且不加分号：
+现在，让我们删除 `alert` 语句后的分号：
 
 ```js run no-beautify
-alert("There will be an error")
+alert("Hello")
 
-[1, 2].forEach(alert)
+[1, 2].forEach(alert);
 ```
 
-现在，如果我们运行代码，只有第一个 `alert` 语句的内容被显示了出来，随后我们收到了一个错误！
-
-但是，如果我们在第一个 `alert` 语句末尾加上一个分号，就工作正常了：
-```js run
-alert("All fine now");
-
-[1, 2].forEach(alert)
-```
+与上面的代码相比只有一个字符的区别：第一行末尾的分号不见了。
 
-现在，我们能得到 "All fine now"，然后是 `1` 和 `2`。
+如果我们运行这段代码，只有第一个 `Hello` 会被显示出来（并且有一个报错，你可能需要打开控制台才能看到它）。并且不会再有数字被显示出来。
 
-无分号的变体（variant）会出现报错，是因为 JavaScript 并不会在方括号 `[...]` 前添加一个隐式的分号。
+这是因为，JavaScript 引擎并没有假设在方括号 `[...]` 前有一个分号。因此，最后一个示例中的代码被视为了单个语句。
 
-所以，因为没有自动插入分号，第一个例子中的代码被视为了一条简单的语句，我们从引擎看到的是这样的：
+对于引擎来说，它是这样的：
 
 ```js run no-beautify
-alert("There will be an error")[1, 2].forEach(alert)
+alert("Hello")[1, 2].forEach(alert);
 ```
 
-但它应该是两条语句，而不是一条。这种情况下的合并是不对的，所以才会造成错误。诸如此类，还有很多。
+看起来很奇怪，对吧？在这种情况下，这样将两行代码合并到一起是不对的。我们需要在 `alert` 后面加一个分号，代码才能正常运行。
+
+这也可能发生在其他情况下。
 ````
 
 即使语句被换行符分隔了，我们依然建议在它们之间加分号。这个规则被社区广泛采用。我们再次强调一下 —— 大部分时候可以省略分号，但是最好不要省略分号，尤其对新手来说。
diff --git a/1-js/02-first-steps/04-variables/article.md b/1-js/02-first-steps/04-variables/article.md
index 5736b0bd51..acd022c497 100644
--- a/1-js/02-first-steps/04-variables/article.md
+++ b/1-js/02-first-steps/04-variables/article.md
@@ -24,7 +24,7 @@ let message;
 let message;
 
 *!*
-message = 'Hello'; // 保存字符串
+message = 'Hello'; // 将字符串 'Hello' 保存在名为 message 的变量中
 */!*
 ```
 
diff --git a/1-js/02-first-steps/05-types/article.md b/1-js/02-first-steps/05-types/article.md
index 7870ca3ab5..d49243d63d 100644
--- a/1-js/02-first-steps/05-types/article.md
+++ b/1-js/02-first-steps/05-types/article.md
@@ -64,7 +64,7 @@ n = 12.345;
 
 我们将在 <info:number> 一节中学习数字的更多细节。
 
-## BigInt 类型
+## BigInt 类型 [#bigint-type]
 
 在 JavaScript 中，"number" 类型无法表示大于 <code>(2<sup>53</sup>-1)</code>（即 `9007199254740991`），或小于 <code>-(2<sup>53</sup>-1)</code> 的整数。这是其内部表示形式导致的技术限制。
 
diff --git a/1-js/02-first-steps/08-operators/3-primitive-conversions-questions/solution.md b/1-js/02-first-steps/08-operators/3-primitive-conversions-questions/solution.md
index 26153bcdd2..8854f14583 100644
--- a/1-js/02-first-steps/08-operators/3-primitive-conversions-questions/solution.md
+++ b/1-js/02-first-steps/08-operators/3-primitive-conversions-questions/solution.md
@@ -9,7 +9,6 @@ true + false = 1
 "$" + 4 + 5 = "$45"
 "4" - 2 = 2
 "4px" - 2 = NaN
-7 / 0 = Infinity
 "  -9  " + 5 = "  -9  5" // (3)
 "  -9  " - 5 = -14 // (4)
 null + 1 = 1 // (5)
diff --git a/1-js/02-first-steps/08-operators/3-primitive-conversions-questions/task.md b/1-js/02-first-steps/08-operators/3-primitive-conversions-questions/task.md
index 3bd73f0d8d..01f3c1ad95 100644
--- a/1-js/02-first-steps/08-operators/3-primitive-conversions-questions/task.md
+++ b/1-js/02-first-steps/08-operators/3-primitive-conversions-questions/task.md
@@ -16,7 +16,6 @@ true + false
 "$" + 4 + 5
 "4" - 2
 "4px" - 2
-7 / 0
 "  -9  " + 5
 "  -9  " - 5
 null + 1
diff --git a/1-js/02-first-steps/08-operators/article.md b/1-js/02-first-steps/08-operators/article.md
index 249e64c8aa..49983c8128 100644
--- a/1-js/02-first-steps/08-operators/article.md
+++ b/1-js/02-first-steps/08-operators/article.md
@@ -56,17 +56,21 @@ alert( 8 % 3 ); // 2，8 除以 3 的余数
 
 ### 求幂 **
 
-求幂运算 `a ** b` 是 `a` 乘以自身 `b` 次。
+求幂运算 `a ** b` 将 `a` 提升至 `a` 的 `b` 次幂。
+
+在数学中我们将其表示为 a<sup>b</sup>。
 
 例如：
 
 ```js run
-alert( 2 ** 2 ); // 4  (2 * 2，自乘 2 次)
-alert( 2 ** 3 ); // 8  (2 * 2 * 2，自乘 3 次)
-alert( 2 ** 4 ); // 16 (2 * 2 * 2 * 2，自乘 4 次)
+alert( 2 ** 2 ); // 2² = 4
+alert( 2 ** 3 ); // 2³ = 8
+alert( 2 ** 4 ); // 2⁴ = 16
 ```
 
-在数学上，求幂的定义也适用于非整数。例如，平方根是以 `1/2` 为单位的求幂：
+就像在数学计算中一样，幂运算也适用于非整数。
+
+例如，平方根是指数为 ½ 的幂运算：
 
 ```js run
 alert( 4 ** (1/2) ); // 2（1/2 次方与平方根相同)
@@ -104,7 +108,13 @@ alert( 2 + '1' ); // "21"
 alert(2 + 2 + '1' ); // "41"，不是 "221"
 ```
 
-在这里，运算符是按顺序工作。第一个 `+` 将两个数字相加，所以返回 `4`，然后下一个 `+` 将字符串 `1` 加入其中，所以就是 `4 + '1' = 41`。
+在这里，运算符是按顺序工作。第一个 `+` 将两个数字相加，所以返回 `4`，然后下一个 `+` 将字符串 `1` 加入其中，所以就是 `4 + '1' = '41'`。
+
+```js run
+alert('1' + 2 + 2); // "122"，不是 "14"
+```
+
+这里，第一个操作数是一个字符串，所以编译器将其他两个操作数也视为了字符串。`2` 被与 `'1'` 连接到了一起，也就是像 `'1' + 2 = "12"` 然后 `"12" + 2 = "122"` 这样。
 
 二元 `+` 是唯一一个以这种方式支持字符串的运算符。其他算术运算符只对数字起作用，并且总是将其运算元转换为数字。
 
@@ -214,7 +224,7 @@ alert( x ); // 5
 
 `=` 是一个运算符，而不是一个有着“魔法”作用的语言结构。
 
-在 JavaScript 中，大多数运算符都会返回一个值。这对于 `+` 和 `-` 来说是显而易见的，但对于 `=` 来说也是如此。
+在 JavaScript 中，所有运算符都会返回一个值。这对于 `+` 和 `-` 来说是显而易见的，但对于 `=` 来说也是如此。
 
 语句 `x = value` 将值 `value` 写入 `x` **然后返回 x**。
 
diff --git a/1-js/02-first-steps/09-comparison/article.md b/1-js/02-first-steps/09-comparison/article.md
index 1ddd2fd2ca..9a4948c4aa 100644
--- a/1-js/02-first-steps/09-comparison/article.md
+++ b/1-js/02-first-steps/09-comparison/article.md
@@ -7,7 +7,7 @@
 - 大于 / 小于：<code>a &gt; b</code>，<code>a &lt; b</code>。
 - 大于等于 / 小于等于：<code>a &gt;= b</code>，<code>a &lt;= b</code>。
 - 检查两个值的相等：`a == b`，请注意双等号 `==` 表示相等性检查，而单等号 `a = b` 表示赋值。
-- 检查两个值不相等。不相等在数学中的符号是 <code>&ne;</code>，但在 JavaScript 中写成 <code>a != b</code>。
+- 检查两个值不相等：不相等在数学中的符号是 <code>&ne;</code>，但在 JavaScript 中写成 <code>a != b</code>。
 
 在本文中，我们将进一步了解不同类型的比较，JavaScript 是如何进行比较的，包括一些重要的特殊性。
 
diff --git a/1-js/02-first-steps/10-ifelse/2-check-standard/task.md b/1-js/02-first-steps/10-ifelse/2-check-standard/task.md
index 0ca4d36046..c96a189b2b 100644
--- a/1-js/02-first-steps/10-ifelse/2-check-standard/task.md
+++ b/1-js/02-first-steps/10-ifelse/2-check-standard/task.md
@@ -4,11 +4,10 @@ importance: 2
 
 # JavaScript 的名字
 
-使用 `if..else` 结构，实现提问 "What is the "official" name of JavaScript?" 的代码
+使用 `if..else` 结构，实现提问 “JavaScript 的“官方”名称是什么？”的代码
 
-如果访问者输入了 "ECMAScript"，输出就提示 "Right!"，否则 — 输出："Didn't know? ECMAScript!"
+如果访问者输入了 "ECMAScript"，输出就提示 "Right!"，否则 — 输出：“你不知道？ECMAScript！”
 
 ![](ifelse_task2.svg)
 
 [demo src="ifelse_task2"]
-
diff --git a/1-js/02-first-steps/11-logical-operators/article.md b/1-js/02-first-steps/11-logical-operators/article.md
index 4449958a96..0f1ffd3dc3 100644
--- a/1-js/02-first-steps/11-logical-operators/article.md
+++ b/1-js/02-first-steps/11-logical-operators/article.md
@@ -1,6 +1,6 @@
 # 逻辑运算符
 
-JavaScript 中有三个逻辑运算符：`||`（或），`&&`（与），`!`（非）。
+JavaScript 中有四个逻辑运算符：`||`（或），`&&`（与），`!`（非），`??`（空值合并运算符）。本文我们先介绍前三个，在下一篇文章中再详细介绍 `??` 运算符。
 
 虽然它们被称为“逻辑”运算符，但这些运算符却可以被应用于任意类型的值，而不仅仅是布尔值。它们的结果也同样可以是任意类型。
 
@@ -64,7 +64,7 @@ if (hour < 10 || hour > 18 || isWeekend) {
 }
 ```
 
-## 或运算寻找第一个真值
+## 或运算寻找第一个真值 [#or-finds-the-first-truthy-value]
 
 上文提到的逻辑处理多少有些传统了。下面让我们看看 JavaScript 的“附加”特性。
 
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
index 2cdd808ed7..9da1752825 100644
--- a/1-js/02-first-steps/12-nullish-coalescing-operator/article.md
+++ b/1-js/02-first-steps/12-nullish-coalescing-operator/article.md
@@ -2,15 +2,14 @@
 
 [recent browser="new"]
 
-在本文中，我们将值既不是 `null` 也不是 `undefined` 的表达式称为“已定义的（defined）”。
-
 空值合并运算符（nullish coalescing operator）的写法为两个问号 `??`。
 
+由于它对待 `null` 和 `undefined` 的方式类似，所以在本文中我们将使用一个特殊的术语对其进行表示。我们将值既不是 `null` 也不是 `undefined` 的表达式称为“已定义的（defined）”。
+
 `a ?? b` 的结果是：
 - 如果 `a` 是已定义的，则结果为 `a`，
 - 如果 `a` 不是已定义的，则结果为 `b`。
 
-
 换句话说，如果第一个参数不是 `null/undefined`，则 `??` 返回第一个参数。否则，返回第二个参数。
 
 空值合并运算符并不是什么全新的东西。它只是一种获得两者中的第一个“已定义的”值的不错的语法。
@@ -21,22 +20,24 @@
 result = (a !== null && a !== undefined) ? a : b;
 ```
 
+现在你应该清楚了 `??` 的作用。让我们来看看它的使用场景吧。
+
 通常 `??` 的使用场景是，为可能是未定义的变量提供一个默认值。
 
-例如，在这里，如果 `user` 是未定义的，我们则显示 `Anonymous`：
+例如，在这里，如果 `user` 是已定义的则显示 `user`，否则显示 `匿名`：
 
 ```js run
 let user;
 
-alert(user ?? "Anonymous"); // Anonymous
+alert(user ?? "匿名"); // 匿名（user 未定义）
 ```
 
-当然，如果 `user` 的值为除 `null/undefined` 外的任意值，那么我们看到的将是它：
+在下面这个例子中，我们将一个名字赋值给了 `user`：
 
 ```js run
 let user = "John";
 
-alert(user ?? "Anonymous"); // John
+alert(user ?? "匿名"); // John（user 已定义）
 ```
 
 我们还可以使用 `??` 序列从一系列的值中选择出第一个非 `null/undefined` 的值。
@@ -75,7 +76,7 @@ alert(firstName || lastName || nickName || "Anonymous"); // Supercoder
 */!*
 ```
 
-或 `||` 运算符自 JavaScript 诞生就存在，因此开发者长期将其用于这种目的。
+纵观 JavaScript 发展史，或 `||` 运算符先于 `??` 出现。它自 JavaScript 诞生就存在了，因此开发者长期将其用于这种目的。
 
 另一方面，空值合并运算符 `??` 是最近才被添加到 JavaScript 中的，它的出现是因为人们对 `||` 不太满意。
 
@@ -96,16 +97,18 @@ alert(height || 100); // 100
 alert(height ?? 100); // 0
 ```
 
-- `height || 100` 首先会检查 `height` 是否为一个假值，发现它确实是。
-    - 所以，结果为第二个参数，`100`。
+- `height || 100` 首先会检查 `height` 是否为一个假值，它是 `0`，确实是假值。
+    - 所以，`||` 运算的结果为第二个参数，`100`。
 - `height ?? 100` 首先会检查 `height` 是否为 `null/undefined`，发现它不是。
     - 所以，结果为 `height` 的原始值，`0`。
 
-如果高度 `0` 为有效值，则不应将其替换为默认值，所以 `??` 能够得出正确的结果。
+实际上，高度 `0` 通常是一个有效值，它不应该被替换为默认值。所以 `??` 运算得到的是正确的结果。
 
 ## 优先级
 
-`??` 运算符的优先级相当低：在 [MDN table](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Operator_Precedence#Table) 中为 `5`。因此，`??` 在 `=` 和 `?` 之前计算，但在大多数其他运算符（例如，`+` 和 `*`）之后计算。
+`??` 运算符的优先级与 `||` 差不多，只是稍微低一点。`??` 运算符的优先级为 `5`，`||` 为 `6` ，详见：[MDN table](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Operator_Precedence#Table) 。
+
+这意味着，就像 `||` 一样，空值合并运算符在 `=` 和 `?` 运算前计算，但在大多数其他运算（例如 `+` 和 `*`）之后计算。
 
 因此，如果我们需要在还有其他运算符的表达式中使用 `??` 进行取值，需要考虑加括号：
 
@@ -139,7 +142,7 @@ let area = height ?? (100 * width) ?? 50;
 let x = 1 && 2 ?? 3; // Syntax error
 ```
 
-这个限制无疑是值得商榷的，但它被添加到语言规范中是为了避免人们从 `||` 切换到 `??` 时的编程错误。
+这个限制无疑是值得商榷的，它被添加到语言规范中是为了避免人们从 `||` 切换到 `??` 时的编程错误。
 
 可以明确地使用括号来解决这个问题：
 
diff --git a/1-js/02-first-steps/13-while-for/article.md b/1-js/02-first-steps/13-while-for/article.md
index b5212c3dbc..4feecd6a25 100644
--- a/1-js/02-first-steps/13-while-for/article.md
+++ b/1-js/02-first-steps/13-while-for/article.md
@@ -106,7 +106,7 @@ for (let i = 0; i < 3; i++) { // 结果为 0、1、2
 
 | 语句段 |             |                                                                            |
 | ----- | ----------- |----------------------------------------------------------------------------|
-| begin | `i = 0`     | 进入循环时执行一次。                                     |
+| begin | `let i = 0`     | 进入循环时执行一次。                                     |
 | condition | `i < 3` | 在每次循环迭代之前检查，如果为 false，停止循环。          |
 | body（循环体） | `alert(i)` | 条件为真时，重复运行。                        |
 | step | `i++`        | 在每次循环体迭代后执行。 |
@@ -363,12 +363,23 @@ for (let i = 0; i < 3; i++) { ... }
 
 例如，这样做是不可能的：
 ```js
-break label;  // 无法跳转到这个标签
+break label;  // 跳转至下面的 label 处（无效）
 
 label: for (...)
 ```
 
-只有在循环内部才能调用 `break/continue`，并且标签必须位于指令上方的某个位置。 
+`break` 指令必须在代码块内。从技术上讲，任何被标记的代码块都有效，例如：
+```js
+label: {
+  // ...
+  break label; // 有效
+  // ...
+}
+```
+
+……尽管 99.9% 的情况下 `break` 都被用在循环内，就像在上面那些例子中我们看到的那样。
+
+`continue` 只有在循环内部才可行。
 ````
 
 ## 总结
diff --git a/1-js/02-first-steps/14-switch/article.md b/1-js/02-first-steps/14-switch/article.md
index 1ece615784..7c39b7fe10 100644
--- a/1-js/02-first-steps/14-switch/article.md
+++ b/1-js/02-first-steps/14-switch/article.md
@@ -47,7 +47,7 @@ switch (a) {
     break;
 */!*
   case 5:
-    alert( 'Too large' );
+    alert( 'Too big' );
     break;
   default:
     alert( "I don't know such values" );
diff --git a/1-js/02-first-steps/15-function-basics/article.md b/1-js/02-first-steps/15-function-basics/article.md
index a0c95041d0..ec5783112d 100644
--- a/1-js/02-first-steps/15-function-basics/article.md
+++ b/1-js/02-first-steps/15-function-basics/article.md
@@ -20,10 +20,10 @@ function showMessage() {
 }
 ```
 
-`function` 关键字首先出现，然后是 **函数名**，然后是括号之间的 **参数** 列表（用逗号分隔，在上述示例中为空），最后是花括号之间的代码（即“函数体”）。
+`function` 关键字首先出现，然后是 **函数名**，然后是括号之间的 **参数** 列表（用逗号分隔，在上述示例中为空，我们将在接下来的示例中看到），最后是花括号之间的代码（即“函数体”）。
 
 ```js
-function name(parameters) {
+function name(parameter1, parameter2, ... parameterN) {
   ...body...
 }
 ```
@@ -137,7 +137,7 @@ alert( userName ); // *!*John*/!*，未被更改，函数没有访问外部变
 
 ## 参数
 
-我们可以使用参数（也称“函数参数”）来将任意数据传递给函数。
+我们可以通过参数将任意数据传递给函数。
 
 在如下示例中，函数有两个参数：`from` 和 `text`。
 
@@ -146,17 +146,14 @@ function showMessage(*!*from, text*/!*) { // 参数：from 和 text
   alert(from + ': ' + text);
 }
 
-*!*
-showMessage('Ann', 'Hello!'); // Ann: Hello! (*)
-showMessage('Ann', "What's up?"); // Ann: What's up? (**)
-*/!*
+*!*showMessage('Ann', 'Hello!');*/!* // Ann: Hello! (*)
+*!*showMessage('Ann', "What's up?");*/!* // Ann: What's up? (**)
 ```
 
 当函数在 `(*)` 和 `(**)` 行中被调用时，给定值被复制到了局部变量 `from` 和 `text`。然后函数使用它们进行计算。
 
 这里还有一个例子：我们有一个变量 `from`，并将它传递给函数。请注意：函数会修改 `from`，但在函数外部看不到更改，因为函数修改的是复制的变量值副本：
 
-
 ```js run
 function showMessage(from, text) {
 
@@ -175,19 +172,31 @@ showMessage(from, "Hello"); // *Ann*: Hello
 alert( from ); // Ann
 ```
 
+当一个值被作为函数参数（parameter）传递时，它也被称为 **参数（argument）**。
+
+换一种方式，我们把这些术语搞清楚：
+
+- 参数（parameter）是函数声明中括号内列出的变量（它是函数声明时的术语）。
+- 参数（argument）是调用函数时传递给函数的值（它是函数调用时的术语）。
+
+我们声明函数时列出它们的参数（parameters），然后调用它们传递参数（arguments）。
+
+在上面的例子中，我们可以说：“函数 `showMessage` 被声明，并且带有两个参数（parameters），随后它被调用，两个参数（arguments）分别为 `from` 和 `"Hello"`”。
+
+
 ## 默认值
 
-如果未提供参数，那么其默认值则是 `undefined`。
+如果一个函数被调用，但有参数（argument）未被提供，那么相应的值就会变成 `undefined`。
 
-例如，之前提到的函数 `showMessage(from, text)` 可以只使用一个参数调用：
+例如，之前提到的函数 `showMessage(from, text)` 可以只使用一个参数（argument）调用：
 
 ```js
 showMessage("Ann");
 ```
 
-那不是错误，这样调用将输出 `"*Ann*: undefined"`。这里没有参数 `text`，所以程序假定 `text === undefined`。
+那不是错误，这样调用将输出 `"*Ann*: undefined"`。因为参数 `text` 的值未被传递，所以变成了 `undefined`。
 
-如果我们想在本示例中设定“默认”的 `text`，那么我们可以在 `=` 之后指定它：
+我们可以使用 `=` 为函数声明中的参数指定所谓的“默认”（如果对应参数的值未被传递则使用）值：
 
 ```js run
 function showMessage(from, *!*text = "no text given"*/!*) {
@@ -211,19 +220,23 @@ function showMessage(from, text = anotherFunction()) {
 ```smart header="默认参数的计算"
 在 JavaScript 中，每次函数在没带个别参数的情况下被调用，默认参数会被计算出来。
 
-在上面的例子中，每次 `showMessage()` 不带 `text` 参数被调用时，`anotherFunction()` 就会被调用。
+在上面的例子中，如果传递了参数 `text`，那么 `anotherFunction()` 就不会被调用。
+
+如果没传递参数 `text`，那么 `anotherFunction()` 就会被调用。
 ```
 
 ### 后备的默认参数
 
-有些时候，将参数默认值的设置放在函数执行（相较更后期）而不是函数声明的时候，也能行得通。
+有些时候，将参数默认值的设置放在函数执行（相较更后期）而不是函数声明时，也行得通。
 
-为了判断参数是否被省略掉，我们可以拿它跟 `undefined` 做比较：
+我们可以通过将参数与 `undefined` 进行比较，来检查该参数是否在函数执行期间被传递进来：
 
 ```js run
 function showMessage(text) {
+  // ...
+
 *!*
-  if (text === undefined) {
+  if (text === undefined) { // 如果参数未被传递进来
     text = 'empty message';
   }
 */!*
@@ -237,18 +250,18 @@ showMessage(); // empty message
 ……或者我们可以使用 `||` 运算符：
 
 ```js
-// 如果 "text" 参数被省略或者被传入空字符串，则赋值为 'empty'
 function showMessage(text) {
+  // 如果 text 为 undefined 或者为假值，那么将其赋值为 'empty'
   text = text || 'empty';
   ...
 }
 ```
 
-现代 JavaScript 引擎支持 [空值合并运算符](info:nullish-coalescing-operator) `??`，当可能遇到其他假值时它更有优势，如 `0` 会被视为正常值不被合并：
+现代 JavaScript 引擎支持 [空值合并运算符](info:nullish-coalescing-operator) `??`，它在大多数假值（例如 `0`）应该被视为“正常值”时更具优势：
 
 ```js run
-// 如果没有传入 "count" 参数，则显示 "unknown"
 function showCount(count) {
+  // 如果 count 为 undefined 或 null，则提示 "unknown"
   alert(count ?? "unknown");
 }
 
diff --git a/1-js/02-first-steps/17-arrow-functions-basics/1-rewrite-arrow/solution.md b/1-js/02-first-steps/17-arrow-functions-basics/1-rewrite-arrow/solution.md
index 58500a60e3..8ac5cb63c5 100644
--- a/1-js/02-first-steps/17-arrow-functions-basics/1-rewrite-arrow/solution.md
+++ b/1-js/02-first-steps/17-arrow-functions-basics/1-rewrite-arrow/solution.md
@@ -1,7 +1,7 @@
 
 ```js run
 function ask(question, yes, no) {
-  if (confirm(question)) yes()
+  if (confirm(question)) yes();
   else no();
 }
 
diff --git a/1-js/02-first-steps/17-arrow-functions-basics/1-rewrite-arrow/task.md b/1-js/02-first-steps/17-arrow-functions-basics/1-rewrite-arrow/task.md
index c12c5d8b5d..98be891a31 100644
--- a/1-js/02-first-steps/17-arrow-functions-basics/1-rewrite-arrow/task.md
+++ b/1-js/02-first-steps/17-arrow-functions-basics/1-rewrite-arrow/task.md
@@ -5,7 +5,7 @@
 
 ```js run
 function ask(question, yes, no) {
-  if (confirm(question)) yes()
+  if (confirm(question)) yes();
   else no();
 }
 
diff --git a/1-js/02-first-steps/17-arrow-functions-basics/article.md b/1-js/02-first-steps/17-arrow-functions-basics/article.md
index 96250ad581..cd5fefc00f 100644
--- a/1-js/02-first-steps/17-arrow-functions-basics/article.md
+++ b/1-js/02-first-steps/17-arrow-functions-basics/article.md
@@ -5,7 +5,7 @@
 它被称为“箭头函数”，因为它看起来像这样：
 
 ```js
-let func = (arg1, arg2, ...argN) => expression
+let func = (arg1, arg2, ..., argN) => expression
 ```
 
 ……这里创建了一个函数 `func`，它接受参数 `arg1..argN`，然后使用参数对右侧的 `expression` 求值并返回其结果。
@@ -13,7 +13,7 @@ let func = (arg1, arg2, ...argN) => expression
 换句话说，它是下面这段代码的更短的版本：
 
 ```js
-let func = function(arg1, arg2, ...argN) {
+let func = function(arg1, arg2, ..., argN) {
   return expression;
 };
 ```
diff --git a/1-js/02-first-steps/18-javascript-specials/article.md b/1-js/02-first-steps/18-javascript-specials/article.md
index c46c18467b..ed567d0670 100644
--- a/1-js/02-first-steps/18-javascript-specials/article.md
+++ b/1-js/02-first-steps/18-javascript-specials/article.md
@@ -273,7 +273,7 @@ switch (age) {
     ```
 
 
-- 函数可能具有局部变量：在函数内部声明的变量。这类变量只在函数内部可见。
+- 函数可能具有局部变量：在函数内部声明的变量，或在其参数列表中。这类变量只在函数内部可见。
 - 参数可以有默认值：`function sum(a = 1, b = 2) {...}`。
 - 函数总是返回一些东西。如果没有 `return` 语句，那么返回的结果是 `undefined`。
 
diff --git a/1-js/03-code-quality/01-debugging-chrome/article.md b/1-js/03-code-quality/01-debugging-chrome/article.md
index e9e7c5bab9..ec5c44661c 100644
--- a/1-js/03-code-quality/01-debugging-chrome/article.md
+++ b/1-js/03-code-quality/01-debugging-chrome/article.md
@@ -1,4 +1,4 @@
-# 在 Chrome 中调试
+# 在浏览器中调试
 
 在编写更复杂的代码前，让我们先来聊聊调试吧。
 
diff --git a/1-js/03-code-quality/02-coding-style/article.md b/1-js/03-code-quality/02-coding-style/article.md
index 37e6f1abd5..af98957eeb 100644
--- a/1-js/03-code-quality/02-coding-style/article.md
+++ b/1-js/03-code-quality/02-coding-style/article.md
@@ -301,11 +301,11 @@ function pow(x, n) {
 
 下面是一些最出名的代码检查工具：
 
-- [JSLint](http://www.jslint.com/) — 第一批检查器之一。
-- [JSHint](http://www.jshint.com/) — 比 JSLint 多了更多设置。
-- [ESLint](http://eslint.org/) — 应该是最新的一个。
+- [JSLint](https://www.jslint.com/) — 第一批检查器之一。
+- [JSHint](https://www.jshint.com/) — 比 JSLint 多了更多设置。
+- [ESLint](https://eslint.org/) — 应该是最新的一个。
 
-它们都能够做好代码检查。我使用的是 [ESLint](http://eslint.org/)。
+它们都能够做好代码检查。我使用的是 [ESLint](https://eslint.org/)。
 
 大多数检查器都可以与编辑器集成在一起：只需在编辑器中启用插件并配置代码风格即可。
 
@@ -335,7 +335,7 @@ function pow(x, n) {
 
 这里的 `"extends"` 指令表示我们是基于 "eslint:recommended" 的设置项而进行设置的。之后，我们制定我们自己的规则。
 
-你也可以从网上下载风格规则集并进行扩展。有关安装的更多详细信息，请参见 <http://eslint.org/docs/user-guide/getting-started>。
+你也可以从网上下载风格规则集并进行扩展。有关安装的更多详细信息，请参见 <https://eslint.org/docs/user-guide/getting-started>。
 
 此外，某些 IDE 有内建的检查器，这非常方便，但是不像 ESLint 那样可自定义。
 
diff --git a/1-js/03-code-quality/02-coding-style/code-style.svg b/1-js/03-code-quality/02-coding-style/code-style.svg
index 03d9760e38..9c517b5923 100644
--- a/1-js/03-code-quality/02-coding-style/code-style.svg
+++ b/1-js/03-code-quality/02-coding-style/code-style.svg
@@ -1,75 +1 @@
-<svg width="715px" height="528px" viewBox="0 0 715 528" version="1.1" xmlns="http://www.w3.org/2000/svg">
-  <defs>
-    <style>
-      @import url(https://fonts.googleapis.com/css?family=Open+Sans:bold|Noto+Sans+SC:bold|Consolas:bold);
-    </style>
-  </defs>
-  <g stroke="none" stroke-width="1" fill="none" fill-rule="evenodd">
-    <g>
-      <rect fill="#FFFFFF" x="0" y="0" width="715" height="528"></rect>
-      <rect x="240" y="146" width="416" height="336" fill="#F5F2F0"></rect>
-      <text font-family="Consolas-Bold, Consolas" font-size="14" font-weight="bold" y="163.8">
-        <tspan x="244.7" fill="#0076AC">function </tspan><tspan fill="#000">pow</tspan><tspan fill="#999">(</tspan><tspan fill="#000">x</tspan><tspan fill="#999">, </tspan><tspan fill="#000">n</tspan><tspan fill="#999">) {</tspan>
-        <tspan x="260.1" dy="17" fill="#0076AC">let </tspan><tspan fill="#000">result </tspan><tspan fill="#A77F57">= </tspan><tspan fill="#9b1855">1</tspan><tspan fill="#999">;</tspan>
-        <tspan x="260.1" dy="34" fill="#0076AC">for </tspan><tspan fill="#999">(</tspan><tspan fill="#0076AC">let </tspan><tspan fill="#000">i </tspan><tspan fill="#A77F57">= </tspan><tspan fill="#9b1855">0</tspan><tspan fill="#999">; </tspan><tspan fill="#000">i </tspan><tspan fill="#A77F57">&lt; </tspan><tspan fill="#000">n</tspan><tspan fill="#999">; </tspan><tspan fill="#000">i</tspan><tspan fill="#A77F57">++</tspan><tspan fill="#999">) {</tspan>
-        <tspan x="275.5" dy="17" fill="#000">result </tspan><tspan fill="#A77F57">*= </tspan><tspan fill="#000">x</tspan><tspan fill="#999">;</tspan>
-        <tspan x="260.1" dy="17" fill="#999">}</tspan>
-        <tspan x="260.1" dy="34" fill="#0076AC">return </tspan><tspan fill="#000">result</tspan><tspan fill="#999">;</tspan>
-        <tspan x="244.7" dy="17" fill="#999">}</tspan>
-        <tspan x="244.7" dy="34" fill="#0076AC">let </tspan><tspan fill="#000">x </tspan><tspan fill="#A77F57">= </tspan><tspan fill="#000">prompt</tspan><tspan fill="#999">(</tspan><tspan fill="#649A00">"x?"</tspan><tspan fill="#999">, </tspan><tspan fill="#649A00">""</tspan><tspan fill="#999">);</tspan>
-        <tspan x="244.7" dy="17" fill="#0076AC">let </tspan><tspan fill="#000">n </tspan><tspan fill="#A77F57">= </tspan><tspan fill="#000">prompt</tspan><tspan fill="#999">(</tspan><tspan fill="#649A00">"n?"</tspan><tspan fill="#999">, </tspan><tspan fill="#649A00">""</tspan><tspan fill="#999">);</tspan>
-        <tspan x="244.7" dy="34" fill="#0076AC">if </tspan><tspan fill="#999">(</tspan><tspan fill="#000">n </tspan><tspan fill="#A77F57">&lt; </tspan><tspan fill="#9b1855">0</tspan><tspan fill="#999">) {</tspan>
-        <tspan x="260.1" dy="17" fill="#000">alert</tspan><tspan fill="#999">(</tspan><tspan fill="#649A00">`Power </tspan><tspan fill="#999">${</tspan><tspan fill="#000">n</tspan><tspan fill="#999">} </tspan><tspan fill="#649A00">is not supported,</tspan>
-        <tspan x="275.5" dy="17" fill="#649A00">please enter an integer number, greater than 0`</tspan><tspan fill="#999">);</tspan>
-        <tspan x="244.7" dy="17" fill="#999">} </tspan><tspan fill="#0076AC">else </tspan><tspan fill="#999">{</tspan>
-        <tspan x="260.1" dy="17" fill="#000">alert</tspan><tspan fill="#999">( </tspan><tspan fill="#000">pow</tspan><tspan fill="#999">(</tspan><tspan fill="#000">x</tspan><tspan fill="#999">, </tspan><tspan fill="#000">n</tspan><tspan fill="#999">) );</tspan>
-        <tspan x="244.7" dy="17" fill="#999">} </tspan>
-      </text>
-      <g fill="#EE6B47">
-        <text font-family="OpenSans-Regular, Open Sans" font-size="12" font-weight="normal">
-          <tspan x="249.069336" y="186">2</tspan>
-        </text>
-        <text font-family="Microsoft YaHei, Noto Sans SC" font-size="14" font-weight="bold">
-          <tspan x="13.543457" y="84">函数名与圆括号之间和圆括号与参数之间没有空格</tspan>
-          <tspan x="60" y="180">行首缩进两个空格</tspan>
-          <tspan x="67.0517578" y="233">后面有一个空格</tspan>
-          <tspan x="508.036133" y="455">} else { 不空行</tspan>
-          <tspan x="265" y="501">嵌套调用两边各一个空格</tspan>
-          <tspan x="63" y="365">逻辑块之间空一行</tspan>
-          <tspan x="515.240723" y="350">一行不要太长</tspan>
-          <tspan x="609" y="233">强制使用分号</tspan>
-          <tspan x="560.253418" y="155">运算符两边有空格</tspan>
-          <tspan x="464.23291" y="89">花括号在同一行，前面有空格</tspan>
-          <tspan x="440" y="292">参数之间有一个空格</tspan>
-          <tspan x="314" y="28">参数之间有一个空格</tspan>
-        </text>
-        <text font-family="OpenSans-Bold, OpenSans" font-size="14" font-weight="bold">
-          <tspan x="70" y="214">for/if/while…</tspan>
-        </text>
-        <g stroke="#EE6B47" stroke-width="2" stroke-linecap="square">
-          <path d="m250.5,355.5 v16"></path>
-          <path d="m247.5,360.5 3,-5"></path>
-          <path d="m250.5,372.5 3,-5"></path>
-          <path d="m250.5,355.5 3,5"></path>
-          <path d="m247.5,367.5 3,5"></path>
-          <path d="m259,180.5 v9.5"></path>
-          <path d="m245,180.5 v9.5"></path>
-          <path d="m245,190.5 h14"></path>
-        </g>
-        <path d="m324.89,141.3 -46.81,-46.8 1.42,-1.42 46.8,46.81 4.2,-4.24 5,14.85 -14.85,-4.95z"></path>
-        <path d="m224,178.5 h-46.5 v-2 H224 v-6 l14,7 -14,7z"></path>
-        <path d="m224,211.5 h-46.5 v-2 H224 v-6 l14,7 -14,7z"></path>
-        <path d="m430.01,436.33 67.1,8.8 -0.26,1.98 -67.1,-8.8 -0.78,5.94 -12.97,-8.76 14.79,-5.1z"></path>
-        <path d="m319.7,466.64 16.7,16.34 -1.4,1.43 -16.7,-16.34 -4.2,4.28 -5.1,-14.79 14.9,4.8z"></path>
-        <path d="m218,362.5 h-39.56 v-2 h39.56 v-6 l14,7 -14,7z"></path>
-        <path d="m464.74,384.12 79.28,-29.9 0.7,1.87 -79.28,29.9 2.1,5.6 L452,390 462.62,378.5Z"></path>
-        <path d="m409,227.5 h192 v2 h-192 v6 l-14,-7 14,-7z"></path>
-        <path d="m423.98,197.6 161.29,-34.29 0.4,1.96 -161.28,34.29 1.24,5.87 -15.14,-3.93 12.23,-9.76z"></path>
-        <path d="m421.26,147.17 106.22,-49.5 0.84,1.8 -106.2,49.5 2.53,5.44 L409,154 l9.73,-12.26z"></path>
-        <path d="M362.5,132 V36 h2 v96 h6 l-7,14 -7,-14z"></path>
-        <path d="m409.73,313 25.2,-27.43 1.47,1.36 -25.2,27.42 4.42,4.06 -14.62,5.58 4.3,-15.05z"></path>
-        <path d="m373.98,467.8 -23.67,18.1 -1.22,-1.6 23.68,-18.1 -3.65,-4.76 15.38,-2.94 -6.87,14.06z"></path>
-      </g>
-    </g>
-  </g>
-</svg>
+<svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" width="715" height="528" viewBox="0 0 715 528"><defs><style>@import url(https://fonts.googleapis.com/css?family=Open+Sans:bold,italic,bolditalic%7CPT+Mono);@font-face{font-family:&apos;PT Mono&apos;;font-weight:700;font-style:normal;src:local(&apos;PT MonoBold&apos;),url(/font/PTMonoBold.woff2) format(&apos;woff2&apos;),url(/font/PTMonoBold.woff) format(&apos;woff&apos;),url(/font/PTMonoBold.ttf) format(&apos;truetype&apos;)}</style></defs><g id="combined" fill="none" fill-rule="evenodd" stroke="none" stroke-width="1"><g id="code-style.svg"><path fill="#FFF" d="M0 0h715v528H0z"/><image id="Bitmap" width="395" height="340" x="239" y="143" xlink:href="data:image/png;base64,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"/><path id="Line-17" stroke="#EE6B47" stroke-linecap="square" stroke-width="2" d="M250.5 355.5v16"/><path id="Line-18" stroke="#EE6B47" stroke-linecap="square" stroke-width="2" d="M247.5 360.5l3-5"/><path id="Line-10" stroke="#EE6B47" stroke-linecap="square" stroke-width="2" d="M250.5 372.5l3-5"/><path id="Line-11" stroke="#EE6B47" stroke-linecap="square" stroke-width="2" d="M253.5 360.5l-3-5"/><path id="Line-12" stroke="#EE6B47" stroke-linecap="square" stroke-width="2" d="M250.5 372.5l-3-5"/><text id="2" fill="#EE6B47" font-family="OpenSans-Regular, Open Sans" font-size="12" font-weight="normal"><tspan x="249.069" y="186">2</tspan></text><path id="Line-19" stroke="#EE6B47" stroke-linecap="square" stroke-width="2" d="M259 190v-9.5"/><path id="Line-5" stroke="#EE6B47" stroke-linecap="square" stroke-width="2" d="M245 190v-9.5"/><path id="Line-20" stroke="#EE6B47" stroke-linecap="square" stroke-width="2" d="M245 190.5h14"/><text id="No-space-between-the" fill="#EE6B47" font-family="OpenSans-Bold, Open Sans" font-size="14" font-weight="bold"> <tspan x="13.543" y="84">函数名与圆括号之间以及圆括号与参数之间没有空格</tspan></text><path id="Line" fill="#EE6B47" fill-rule="nonzero" d="M279.5 93.086l.707.707 46.1 46.1 4.243-4.242 4.95 14.849-14.85-4.95 4.243-4.243-46.1-46.1-.707-.707 1.414-1.414z"/><text id="Indentation-2-spaces" fill="#EE6B47" font-family="OpenSans-Bold, Open Sans" font-size="14" font-weight="bold"><tspan x="90" y="182">缩进两个空格</tspan></text><path id="Line-4" fill="#EE6B47" fill-rule="nonzero" d="M224 170.5l14 7-14 7v-6h-46.5v-2H224v-6z"/><text id="A-space-" fill="#EE6B47" font-family="OpenSans-Bold, Open Sans" font-size="14" font-weight="bold"><tspan x="33" y="233">一个空格</tspan> <tspan x="33" y="214">在 for/if/while… 后面</tspan></text><path id="Line-6" fill="#EE6B47" fill-rule="nonzero" d="M224 203.5l14 7-14 7v-6h-46.5v-2H224v-6z"/><text id="}-else-{-without-a-l" fill="#EE6B47" font-family="OpenSans-Bold, Open Sans" font-size="14" font-weight="bold"><tspan x="508.036" y="455">} else { 不空行</tspan></text><path id="Line-14" fill="#EE6B47" fill-rule="nonzero" d="M430.792 430.381l-.781 5.949 66.12 8.679.99.13-.26 1.983-.991-.13-66.12-8.679-.78 5.95L416 435.5l14.792-5.119z"/><text id="Spaces-around-a-nest" fill="#EE6B47" font-family="OpenSans-Bold, Open Sans" font-size="14" font-weight="bold"><tspan x="266" y="501">嵌套调用两边各一个空格</tspan></text><path id="Line-15" fill="#EE6B47" fill-rule="nonzero" d="M309 457.565l14.903 4.786-4.196 4.289 15.992 15.645.715.7-1.398 1.43-.715-.7-15.993-15.645-4.195 4.29L309 457.564z"/><text id="An-empty-line" fill="#EE6B47" font-family="OpenSans-Bold, Open Sans" font-size="14" font-weight="bold"><tspan x="55" y="366">逻辑块之间空一行</tspan></text><path id="Line-7" fill="#EE6B47" fill-rule="nonzero" d="M218 354.5l14 7-14 7v-6h-39.558v-2H218v-6z"/><text id="Lines-are-not-very-l" fill="#EE6B47" font-family="OpenSans-Bold, Open Sans" font-size="14" font-weight="bold"><tspan x="515.241" y="350">一行不要太长</tspan></text><path id="Line-13" fill="#EE6B47" fill-rule="nonzero" d="M544.024 354.211l.706 1.872-.935.353-78.344 29.557 2.119 5.614L452 390l10.628-11.491 2.117 5.613 78.344-29.558.935-.353z"/><text id="A-semicolon-;" fill="#EE6B47" font-family="OpenSans-Bold, Open Sans" font-size="14" font-weight="bold"><tspan x="609" y="233">强制使用分号 ;</tspan></text><path id="Line-8" fill="#EE6B47" fill-rule="nonzero" d="M409 221.5v6h192v2H409v6l-14-7 14-7z"/><text id="Spaces-around-operat" fill="#EE6B47" font-family="OpenSans-Bold, Open Sans" font-size="14" font-weight="bold"><tspan x="560.253" y="155">运算符两边有空格</tspan></text><path id="Line-16" fill="#EE6B47" fill-rule="nonzero" d="M585.27 163.314l.416 1.956-.978.208-160.307 34.088 1.249 5.869-15.15-3.935 12.238-9.759 1.247 5.868 160.307-34.087.978-.208z"/><text id="Curly-brace-{-on-the" fill="#EE6B47" font-family="OpenSans-Bold, Open Sans" font-size="14" font-weight="bold"><tspan x="464.233" y="89">花括号 { 在同一行，前面有空格</tspan></text><path id="Line-3" fill="#EE6B47" fill-rule="nonzero" d="M527.484 97.671l.845 1.813-.907.422-105.311 49.086 2.536 5.438L409 154l9.732-12.26 2.535 5.439 105.31-49.085.907-.423z"/><path id="Line-2" fill="#EE6B47" fill-rule="nonzero" d="M364.5 36v96h6l-7 14-7-14h6V36h2z"/><text id="A-space-between-argu" fill="#EE6B47" font-family="OpenSans-Bold, Open Sans" font-size="14" font-weight="bold"><tspan x="443" y="280">参数之间有一个空格</tspan></text><path id="Line-9" fill="#EE6B47" fill-rule="nonzero" d="M434.94 285.587l1.473 1.353-.677.737-24.528 26.69 4.419 4.06L401 324l4.318-15.045 4.418 4.059 24.528-26.69.676-.737z"/><text id="A-space-between-para" fill="#EE6B47" font-family="OpenSans-Bold, Open Sans" font-size="14" font-weight="bold"><tspan x="299" y="20">参数之间有一个空格</tspan></text><path id="Line" fill="#EE6B47" fill-rule="nonzero" d="M384.5 458.5l-6.869 14.065-3.645-4.767-22.879 17.496-.794.608-1.215-1.589.795-.607 22.878-17.497-3.644-4.765L384.5 458.5z"/></g></g></svg>
\ No newline at end of file
diff --git a/1-js/03-code-quality/05-testing-mocha/article.md b/1-js/03-code-quality/05-testing-mocha/article.md
index 2811361a3f..d306d23a60 100644
--- a/1-js/03-code-quality/05-testing-mocha/article.md
+++ b/1-js/03-code-quality/05-testing-mocha/article.md
@@ -2,7 +2,7 @@
 
 自动化测试将被用于进一步的任务中，并且还将被广泛应用在实际项目中。
 
-## 为什么我们需要测试？
+## 我们为什么需要测试？
 
 当我们在写一个函数时，我们通常可以想象出它应该做什么：哪些参数会给出哪些结果。
 
diff --git a/1-js/03-code-quality/06-polyfills/article.md b/1-js/03-code-quality/06-polyfills/article.md
index 4822861c70..c995272fc9 100644
--- a/1-js/03-code-quality/06-polyfills/article.md
+++ b/1-js/03-code-quality/06-polyfills/article.md
@@ -1,5 +1,5 @@
 
-# Polyfill
+# Polyfill 和转译器
 
 JavaScript 语言在稳步发展。也会定期出现一些对语言的新提议，它们会被分析讨论，如果认为有价值，就会被加入到 <https://tc39.github.io/ecma262/> 的列表中，然后被加到 [规范](http://www.ecma-international.org/publications/standards/Ecma-262.htm) 中。
 
@@ -9,46 +9,83 @@ JavaScript 引擎背后的团队关于首先要实现什么有着他们自己想
 
 查看语言特性的当前支持状态的一个很好的页面是 <https://kangax.github.io/compat-table/es6/>（它很大，我们现在还有很多东西要学）。
 
-## Babel
+作为程序员，我们希望使用最新的特性。好东西越多越好！
 
-当我们使用语言的一些现代特性时，一些引擎可能无法支持这样的代码。正如上所述，并不是所有功能在任何地方都有实现。
+另一方面，如何让我们现代的代码在还不支持最新特性的旧引擎上工作？
 
-这就是 Babel 来拯救的东西。
+有两个工作可以做到这一点：
 
-[Babel](https://babeljs.io) 是一个 [transpiler](https://en.wikipedia.org/wiki/Source-to-source_compiler)。它将现代的 JavaScript 代码转化为以前的标准形式。
+1. 转译器（Transpilers）。
+2. 垫片（Polyfills）。
 
-实际上，Babel 包含了两部分：
+通过本文，我们一起了解它们的工作原理以及它们在 Web 开发中的位置。
 
-1. 第一，用于重写代码的 transpiler 程序。开发者在自己的电脑上运行它。它以之前的语言标准对代码进行重写。然后将代码传到面向用户的网站。像 [webpack](http://webpack.github.io/) 这样的现代项目构建系统，提供了在每次代码改变时自动运行 transpiler 的方法，因此很容易集成在开发过程中。
+## 转译器（Transpilers）
 
-2. 第二，polyfill。
+[转译器](https://en.wikipedia.org/wiki/Source-to-source_compiler) 是一种可以将源码转译成另一种源码的特殊的软件。它可以解析（“阅读和理解”）现代代码，并使用旧的语法结构对其进行重写，进而使其也可以在旧的引擎中工作。
 
-    新的语言特性可能不仅包括语法结构，还包括新的内建函数。
-    Transpiler 会重写代码，将语法结构转换为旧的结构。但是对于新的内建函数，需要我们去实现。JavaScript 是一个高度动态化的语言。脚本可以添加/修改任何函数，从而使它们的行为符合现代标准。
+例如，在 ES2020 之前没有“空值合并运算符” `??`。所以，如果访问者使用过时了的浏览器访问我们的网页，那么该浏览器可能就不明白 `height = height ?? 100` 这段代码的含义。
 
-    更新/添加新函数的脚本称为 “polyfill”。它“填补”了缺口，并添加了缺少的实现。
-    
-    两个有意思的 polyfills 是：
-    - [core js](https://github.com/zloirock/core-js) 支持很多，允许只包含需要的功能。
-    - [polyfill.io](http://polyfill.io) 根据功能和用户的浏览器，为脚本提供 polyfill 的服务。
+转译器会分析我们的代码，并将 `height ?? 100` 重写为 `(height !== undefined && height !== null) ? height : 100`。
 
-所以，如果我们要使用现代语言功能，transpiler 和 polyfill 是必要的。
+```js
+// 在运行转译器之前
+height = height ?? 100;
 
-## 教程中的案例
+// 在运行转译器之后
+height = (height !== undefined && height !== null) ? height : 100;
+```
 
+现在，重写了的代码适用于更旧版本的 JavaScript 引擎。
 
-````online
-大多数例子都是可运行的，例如：
+通常，开发者会在自己的计算机上运行转译器，然后将转译后的代码部署到服务器。
 
-```js run
-alert('Press the "Play" button in the upper-right corner to run');
-```
+说到名字，[Babel](https://babeljs.io) 是最著名的转译器之一。
+
+现代项目构建系统，例如 [webpack](http://webpack.github.io/)，提供了在每次代码更改时自动运行转译器的方法，因此很容易将代码转译集成到开发过程中。
+
+## 垫片（Polyfills）
+
+新的语言特性可能不仅包括语法结构和运算符，还可能包括内建函数。
+
+例如，`Math.trunc(n)` 是一个“截断”数字小数部分的函数，例如 `Math.trunc(1.23)` 返回 `1`。
+
+在一些（非常过时的）JavaScript 引擎中没有 `Math.trunc` 函数，所以这样的代码会执行失败。
+
+由于我们谈论的是新函数，而不是语法更改，因此无需在此处转译任何内容。我们只需要声明缺失的函数。
+
+更新/添加新函数的脚本被称为“polyfill”。它“填补”了空白并添加了缺失的实现。
 
-只有在你的浏览器支持它时才会工作的现代 JS 例子。
-````
+对于这种特殊情况，`Math.trunc` 的 polyfill 是一个实现它的脚本，如下所示：
 
-```offline
-当你正在阅读离线版本时，在 PDF 中，示例是不可运行的。在 EPUB 格式中，部分例子可以运行。
+```js
+if (!Math.trunc) { // 如果没有这个函数
+  // 实现它
+  Math.trunc = function(number) {
+    // Math.ceil 和 Math.floor 甚至存在于上古年代的 JavaScript 引擎中
+    // 在本教程的后续章节中会讲到它们
+    return number < 0 ? Math.ceil(number) : Math.floor(number);
+  };
+}
 ```
 
-Google Chrome 通常是对新语言特性支持更新最快的，在没有任何 transpiler 的情况下，也能很好地运行前沿的演示，当然其他的现代浏览器也挺好。
+JavaScript 是一种高度动态的语言，脚本可以添加/修改任何函数，甚至包括内建函数。
+
+两个有趣的 polyfill 库：
+- [core js](https://github.com/zloirock/core-js) 支持了很多特性，允许只包含需要的特性。
+- [polyfill.io](http://polyfill.io) 提供带有 polyfill 的脚本的服务，具体取决于特性和用户的浏览器。
+
+
+## 总结
+
+在本章中，我们希望激励你学习现代甚至“前沿”的语言特性，即使 JavaScript 引擎还没有很好地支持它们。
+
+只是不要忘记使用转译器（如果使用现代语法或运算符）和 polyfill（添加可能缺少的特性）。它们将确保代码能正常工作。
+
+例如，以后熟悉了 JavaScript，你就可以搭建一个基于 [webpack](http://webpack.github.io/) 和 [babel-loader](https://github.com/babel/babel-loader) 插件的代码构建系统。
+
+展示对各种特征的当前支持情况的工具：
+- <https://kangax.github.io/compat-table/es6/> —— 对于原生 JavaScript。
+- <https://caniuse.com/> —— 对于浏览器相关的函数。
+
+P.S. 谷歌的 Chrome 浏览器通常是对最新的语言特性的支持情况最好的浏览器，如果教程的示例运行失败，请尝试使用 Chrome 浏览器。不过，教程中的大多数示例都适用于任意的现代浏览器。
diff --git a/1-js/04-object-basics/01-object/article.md b/1-js/04-object-basics/01-object/article.md
index 1148ad0b04..4088f80f71 100644
--- a/1-js/04-object-basics/01-object/article.md
+++ b/1-js/04-object-basics/01-object/article.md
@@ -92,30 +92,6 @@ let user = {
 ```
 这叫做尾随（trailing）或悬挂（hanging）逗号。这样便于我们添加、删除和移动属性，因为所有的行都是相似的。
 
-````smart header="使用 const 声明的对象是可以被修改的"
-请注意：用 `const` 声明的对象 **能** 被修改。
-
-例如：
-
-```js run
-const user = {
-  name: "John"
-};
-
-*!*
-user.name = "Pete"; // (*)
-*/!*
-
-alert(user.name); // Pete
-```
-
-`(*)` 行似乎会触发一个错误，但实际并没有。`const` 声明仅固定了 `user` 的值，而不是值（该对象）里面的内容。
-
-仅当我们尝试将 `user=...` 作为一个整体进行赋值时，`const` 会抛出错误。
-
-有另一种将对象属性变为常量的方式，我们将在后面的 <info:property-descriptors> 一章中学习它。
-````
-
 ## 方括号
 
 对于多词属性，点操作就不能用了：
diff --git a/1-js/04-object-basics/02-object-copy/article.md b/1-js/04-object-basics/02-object-copy/article.md
index 47649a4750..c9a1e71fed 100644
--- a/1-js/04-object-basics/02-object-copy/article.md
+++ b/1-js/04-object-basics/02-object-copy/article.md
@@ -2,7 +2,7 @@
 
 与原始类型相比，对象的根本区别之一是对象是“通过引用”被存储和复制的，与原始类型值相反：字符串，数字，布尔值等 —— 始终是以“整体值”的形式被复制的。
 
-如果我们稍微看一下复制值时发生了什么，就很容易理解了。
+如果我们深入了解复制值时会发生什么，就很容易理解了。
 
 让我们从原始类型开始，例如一个字符串。
 
@@ -21,7 +21,7 @@ let phrase = message;
 
 但是，对象不是这样的。
 
-**赋值了对象的变量存储的不是对象本身，而是该对象“在内存中的地址”，换句话说就是对该对象的“引用”。**
+**赋值了对象的变量存储的不是对象本身，而是该对象“在内存中的地址” —— 换句话说就是对该对象的“引用”。**
 
 让我们看一个这样的变量的例子：
 
@@ -37,13 +37,13 @@ let user = {
 
 该对象被存储在内存中的某个位置（在图片的右侧），而变量 `user`（在左侧）保存的是对其的“引用”。
 
-我们可以将对象变量（例如 `user`）想象成一张带有地址的纸。
+我们可以将一个对象变量（例如 `user`）想象成一张写有对象的地址的纸。
 
-当我们对对象执行操作时，例如获取一个属性 `user.name`，JavaScript 引擎将对该地址进行搜索，并在实际对象上执行操作。
+当我们对对象执行操作时，例如获取一个属性 `user.name`，JavaScript 引擎会查看该地址中的内容，并在实际对象上执行操作。
 
 现在，这就是为什么它很重要。
 
-**当一个对象变量被复制 —— 引用则被复制，而该对象并没有被复制。**
+**当一个对象变量被复制 —— 引用被复制，而该对象自身并没有被复制。**
 
 例如：
 
@@ -57,7 +57,7 @@ let admin = user; // 复制引用
 
 ![](variable-copy-reference.svg)
 
-正如你所看到的，这里仍然只有一个对象，现在有两个引用它的变量。
+正如你所看到的，这里仍然只有一个对象，但现在有两个引用它的变量。
 
 我们可以通过其中任意一个变量来访问该对象并修改它的内容：
 
@@ -73,8 +73,7 @@ admin.name = 'Pete'; // 通过 "admin" 引用来修改
 alert(*!*user.name*/!*); // 'Pete'，修改能通过 "user" 引用看到
 ```
 
-
-这就像我们有个带两把钥匙的柜子，并使用其中一把钥匙（`admin`）来打开它。那么，我们如果之后用另外一把钥匙（`user`），则也能看到更改。
+这就像我们有一个带有两把钥匙的柜子，使用其中一把钥匙（`admin`）打开柜子并更改了里面的东西。那么，如果我们稍后用另一把钥匙（`user`），我们仍然可以打开同一个柜子并且可以访问更改的内容。
 
 ## 通过引用来比较
 
@@ -99,15 +98,15 @@ let b = {}; // 两个独立的对象
 alert( a == b ); // false
 ```
 
-对于类似 `obj1 > obj2` 的比较，或者跟一个原始类型值的比较 `obj == 5`，对象都会被转换为原始值。我们很快就会学到对象是如何转换的，但是说实话，很少需要进行这样的比较，通常是在编程错误的时候才会出现这种情况。
+对于类似 `obj1 > obj2` 的比较，或者跟一个原始类型值的比较 `obj == 5`，对象都会被转换为原始值。我们很快就会学到对象是如何转换的，但是说实话，很少需要进行这样的比较 —— 通常是在编程错误的时候才会出现这种情况。
 
-## 克隆与合并，Object.assign
+## 克隆与合并，Object.assign [#cloning-and-merging-object-assign]
 
 那么，拷贝一个对象变量会又创建一个对相同对象的引用。
 
 但是，如果我们想要复制一个对象，那该怎么做呢？创建一个独立的拷贝，克隆？
 
-这也是可行的，但稍微有点困难，因为 JavaScript 没有提供对此操作的内建的方法。实际上，也很少需要这样做。通过引用进行拷贝在大多数情况下已经很好了。
+这也是可行的，但稍微有点困难，因为 JavaScript 没有提供对此操作的内建的方法。但很少需要这样做 —— 通过引用进行拷贝在大多数情况下已经满足了。
 
 但是，如果我们真的想要这样做，那么就需要创建一个新对象，并通过遍历现有属性的结构，在原始类型值的层面，将其复制到新对象，以复制已有对象的结构。
 
@@ -134,7 +133,7 @@ clone.name = "Pete"; // 改变了其中的数据
 alert( user.name ); // 原来的对象中的 name 属性依然是 John
 ```
 
-我们也可以使用 [Object.assign](mdn:js/Object/assign) 方法来达成同样的效果。
+我们也可以使用 [Object.assign](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/assign) 方法来达成同样的效果。
 
 语法是：
 
@@ -187,6 +186,8 @@ let clone = Object.assign({}, user);
 
 它将 `user` 中的所有属性拷贝到了一个空对象中，并返回这个新的对象。
 
+还有其他克隆对象的方法，例如使用 [spread 语法](info:rest-parameters-spread) `clone = {...user}`，在后面的章节中我们会讲到。
+
 ## 深层克隆
 
 到现在为止，我们都假设 `user` 的所有属性均为原始类型。但属性可以是对其他对象的引用。那应该怎样处理它们呢？
@@ -226,9 +227,33 @@ user.sizes.width++;       // 通过其中一个改变属性值
 alert(clone.sizes.width); // 51，能从另外一个看到变更的结果
 ```
 
-为了解决此问题，我们应该使用会检查每个 `user[key]` 的值的克隆循环，如果值是一个对象，那么也要复制它的结构。这就叫“深拷贝”。
+为了解决这个问题，我们应该使用一个拷贝循环来检查 `user[key]` 的每个值，如果它是一个对象，那么也复制它的结构。这就是所谓的“深拷贝”。
+
+我们可以使用递归来实现它。或者为了不重复造轮子，采用现有的实现，例如 [lodash](https://lodash.com) 库的 [_.cloneDeep(obj)](https://lodash.com/docs#cloneDeep)。
+
+````smart header="使用 const 声明的对象也是可以被修改的"
+通过引用对对象进行存储的一个重要的副作用是声明为 `const` 的对象 **可以** 被修改。
+
+例如：
+
+```js run
+const user = {
+  name: "John"
+};
+
+*!*
+user.name = "Pete"; // (*)
+*/!*
+
+alert(user.name); // Pete
+```
+
+看起来 `(*)` 行的代码会触发一个错误，但实际并没有。`user` 的值是一个常量，它必须始终引用同一个对象，但该对象的属性可以被自由修改。
+
+换句话说，只有当我们尝试将 `user=...` 作为一个整体进行赋值时，`const user` 才会报错。
 
-我们可以用递归来实现。或者不自己造轮子，使用现成的实现，例如 JavaScript 库 [lodash](https://lodash.com) 中的 [_.cloneDeep(obj)](https://lodash.com/docs#cloneDeep)。
+也就是说，如果我们真的需要创建常量对象属性，也是可以的，但使用的是完全不同的方法。我们将在 <info:property-descriptors> 一章中学习它。
+````
 
 ## 总结
 
diff --git a/1-js/04-object-basics/03-garbage-collection/article.md b/1-js/04-object-basics/03-garbage-collection/article.md
index a07400a076..9f7fea5c39 100644
--- a/1-js/04-object-basics/03-garbage-collection/article.md
+++ b/1-js/04-object-basics/03-garbage-collection/article.md
@@ -14,8 +14,8 @@ JavaScript 中主要的内存管理概念是 **可达性**。
 
     比方说：
 
-    - 当前函数的局部变量和参数。
-    - 嵌套调用时，当前调用链上所有函数的变量与参数。
+    - 当前执行的函数，它的局部变量和参数。
+    - 当前嵌套调用链上的其他函数、它们的局部变量和参数。
     - 全局变量。
     - （还有一些内部的）
 
diff --git a/1-js/04-object-basics/04-object-methods/7-calculator/_js.view/test.js b/1-js/04-object-basics/04-object-methods/7-calculator/_js.view/test.js
index 1f71eda4c6..e6000ec2ea 100644
--- a/1-js/04-object-basics/04-object-methods/7-calculator/_js.view/test.js
+++ b/1-js/04-object-basics/04-object-methods/7-calculator/_js.view/test.js
@@ -16,6 +16,11 @@ describe("calculator", function() {
       prompt.restore();
     });
 
+    it('the read get two values and saves them as object properties', function () {
+      assert.equal(calculator.a, 2);
+      assert.equal(calculator.b, 3);
+    });
+
     it("the sum is 5", function() {
       assert.equal(calculator.sum(), 5);
     });
diff --git a/1-js/04-object-basics/04-object-methods/8-chain-calls/solution.md b/1-js/04-object-basics/04-object-methods/8-chain-calls/solution.md
index 1cc235b517..7b05531e10 100644
--- a/1-js/04-object-basics/04-object-methods/8-chain-calls/solution.md
+++ b/1-js/04-object-basics/04-object-methods/8-chain-calls/solution.md
@@ -21,7 +21,7 @@ let ladder = {
     return this;
 */!*
   }
-}
+};
 
 ladder.up().up().down().up().down().showStep(); // 1
 ```
diff --git a/1-js/04-object-basics/04-object-methods/article.md b/1-js/04-object-basics/04-object-methods/article.md
index e190dc2ce2..8a99d3100c 100644
--- a/1-js/04-object-basics/04-object-methods/article.md
+++ b/1-js/04-object-basics/04-object-methods/article.md
@@ -81,7 +81,7 @@ user = {
 // 方法简写看起来更好，对吧？
 let user = {
 *!*
-  sayHi() { // 与 "sayHi: function()" 一样
+  sayHi() { // 与 "sayHi: function(){...}" 一样
 */!*
     alert("Hello");
   }
diff --git a/1-js/04-object-basics/06-constructor-new/1-two-functions-one-object/task.md b/1-js/04-object-basics/06-constructor-new/1-two-functions-one-object/task.md
index e40ac0c58d..b2ff3eca5e 100644
--- a/1-js/04-object-basics/06-constructor-new/1-two-functions-one-object/task.md
+++ b/1-js/04-object-basics/06-constructor-new/1-two-functions-one-object/task.md
@@ -4,7 +4,7 @@ importance: 2
 
 # 两个函数 — 一个对象
 
-是否可以创建像 `new A()==new B()` 这样的函数 `A` 和 `B`？
+是否可以创建像 `new A() == new B()` 这样的函数 `A` 和 `B`？
 
 ```js no-beautify
 function A() { ... }
diff --git a/1-js/04-object-basics/06-constructor-new/2-calculator-constructor/_js.view/test.js b/1-js/04-object-basics/06-constructor-new/2-calculator-constructor/_js.view/test.js
index 036053927c..3c8a0cc753 100644
--- a/1-js/04-object-basics/06-constructor-new/2-calculator-constructor/_js.view/test.js
+++ b/1-js/04-object-basics/06-constructor-new/2-calculator-constructor/_js.view/test.js
@@ -11,6 +11,11 @@ describe("calculator", function() {
     calculator.read();
   });
 
+  it("the read method asks for two values using prompt and remembers them in object properties", function() {
+    assert.equal(calculator.a, 2);
+    assert.equal(calculator.b, 3);
+  });
+
   it("when 2 and 3 are entered, the sum is 5", function() {
     assert.equal(calculator.sum(), 5);
   });
diff --git a/1-js/04-object-basics/06-constructor-new/article.md b/1-js/04-object-basics/06-constructor-new/article.md
index c84707cb39..8c931bf5ac 100644
--- a/1-js/04-object-basics/06-constructor-new/article.md
+++ b/1-js/04-object-basics/06-constructor-new/article.md
@@ -70,6 +70,7 @@ let user = {
 如果我们有许多行用于创建单个复杂对象的代码，我们可以将它们封装在一个立即调用的构造函数中，像这样：
 
 ```js
+// 创建一个函数并立即使用 new 调用它
 let user = new function() {
   this.name = "John";
   this.isAdmin = false;
@@ -91,7 +92,7 @@ let user = new function() {
 
 在一个函数内部，我们可以使用 `new.target` 属性来检查它是否被使用 `new` 进行调用了。
 
-对于常规调用，它为空，对于使用 `new` 的调用，则等于该函数：
+对于常规调用，它为 undefined，对于使用 `new` 的调用，则等于该函数：
 
 ```js run
 function User() {
diff --git a/1-js/04-object-basics/07-optional-chaining/article.md b/1-js/04-object-basics/07-optional-chaining/article.md
index 941efd4ec4..471127a3ad 100644
--- a/1-js/04-object-basics/07-optional-chaining/article.md
+++ b/1-js/04-object-basics/07-optional-chaining/article.md
@@ -74,7 +74,7 @@ alert( user.address && user.address.street && user.address.street.name ); // und
 
 ## 可选链
 
-如果可选链 `?.` 前面的部分是 `undefined` 或者 `null`，它会停止运算并返回该部分。
+如果可选链 `?.` 前面的值为 `undefined` 或者 `null`，它会停止运算并返回 `undefined`。
 
 **为了简明起见，在本文接下来的内容中，我们会说如果一个属性既不是 `null` 也不是 `undefined`，那么它就“存在”。**
 
@@ -103,7 +103,7 @@ alert( user?.address.street ); // undefined
 
 请注意：`?.` 语法使其前面的值成为可选值，但不会对其后面的起作用。
 
-例如，在 `user?.address.street.name` 中，`?.` 允许 `user` 为 `null/undefined`，但仅此而已。更深层次的属性是通过常规方式访问的。如果我们希望它们中的一些也是可选的，那么我们需要使用更多的 `?.` 来替换 `.`。
+例如，在 `user?.address.street.name` 中，`?.` 允许 `user` 为 `null/undefined`（在这种情况下会返回 `undefined`）也不会报错，但这仅对于 `user`。更深层次的属性是通过常规方式访问的。如果我们希望它们中的一些也是可选的，那么我们需要使用更多的 `?.` 来替换 `.`。
 
 ```warn header="不要过度使用可选链"
 我们应该只将 `?.` 使用在一些东西可以不存在的地方。
@@ -166,25 +166,23 @@ userGuest.admin?.(); // 啥都没有（没有这样的方法）
 */!*
 ```
 
-在这两行代码中，我们首先使用点符号（`userAdmin.admin`）来获取 `admin` 属性，因为用户对象一定存在，因此可以安全地读取它。
+在这两行代码中，我们首先使用点符号（`userAdmin.admin`）来获取 `admin` 属性，因为我们假定对象 `userAdmain` 存在，因此可以安全地读取它。
 
-然后 `?.()` 会检查它左边的部分：如果 `admin` 函数存在，那么就调用运行它（对于 `userAdmin`）。否则（对于 `userGuest`）运算停止，没有错误。
+然后 `?.()` 会检查它左边的部分：如果 `admin` 函数存在，那么就调用运行它（对于 `userAdmin`）。否则（对于 `userGuest`）运算停止，没有报错。
 
 如果我们想使用方括号 `[]` 而不是点符号 `.` 来访问属性，语法 `?.[]` 也可以使用。跟前面的例子类似，它允许从一个可能不存在的对象上安全地读取属性。
 
 ```js run
+let key = "firstName";
+
 let user1 = {
   firstName: "John"
 };
 
-let user2 = null; // 假设，我们不能授权此用户
-
-let key = "firstName";
+let user2 = null;
 
 alert( user1?.[key] ); // John
 alert( user2?.[key] ); // undefined
-
-alert( user1?.[key]?.something?.not?.existing); // undefined
 ```
 
 此外，我们还可以将 `?.` 跟 `delete` 一起使用：
diff --git a/1-js/04-object-basics/08-symbol/article.md b/1-js/04-object-basics/08-symbol/article.md
index bdef21cf56..65ca6a326c 100644
--- a/1-js/04-object-basics/08-symbol/article.md
+++ b/1-js/04-object-basics/08-symbol/article.md
@@ -109,7 +109,7 @@ user[id] = "Their id value";
 
 ……但如果我们处于同样的目的，使用字符串 `"id"` 而不是用 symbol，那么 **就会** 出现冲突：
 
-```js run
+```js
 let user = { name: "John" };
 
 // 我们的脚本使用了 "id" 属性。
diff --git a/figures.sketch b/figures.sketch
index 6ce5e03c08..aa3ecfcab2 100644
Binary files a/figures.sketch and b/figures.sketch differ