From 52298f5b093987d3ec0a74816312a5b506eaf8c7 Mon Sep 17 00:00:00 2001
From: LeviDing <imdingxuewen@gmail.com>
Date: Sun, 5 Apr 2020 12:16:47 +0800
Subject: [PATCH 1/9] Update article.md

---
 1-js/02-first-steps/01-hello-world/article.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

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 c004bcb2af..05963169ed 100644
--- a/1-js/02-first-steps/01-hello-world/article.md
+++ b/1-js/02-first-steps/01-hello-world/article.md
@@ -46,7 +46,7 @@ JavaScript 程序可以在 `<script>` 标签的帮助下插入到 HTML 文档的
 `<script>` 标签有一些现在很少用到的特性（attribute），但是我们可以在老代码中找到它们：
 
 `type` 特性：<code>&lt;script <u>type</u>=...&gt;</code>
-: 在老的 HTML4 标准中，要求 script 标签有 `type` 特性。通常是 `type="text/javascript"`。这样的特性声明现在已经不再需要。而且，现代 HTML 标准已经完全改变了此特性的含义。现在，它可以用于 JavaScript 模块。但这是一个高级话题：我们将在本教程的另一部分中探讨 JavaScript 模块。
+: 在老的 HTML4 标准中，要求 script 标签有 `type` 特性。通常是 `type="text/javascript"`。这样的特性声明现在已经不再需要。而且，现代 HTML 标准已经完全改变了此特性的含义。现在，它可以用于 JavaScript 模块。但这是一个高级话题，我们将在本教程的另一部分中探讨 JavaScript 模块。
 
 `language` 特性：<code>&lt;script <u>language</u>=...&gt;</code>
 : 这个特性是为了显示脚本使用的语言。这个特性现在已经没有任何意义，因为语言默认就是 JavaScript。不再需要使用它了。

From dc2dcab0ea4dc7aede6555ac62988c22fe1f91da Mon Sep 17 00:00:00 2001
From: LeviDing <imdingxuewen@gmail.com>
Date: Sun, 5 Apr 2020 12:19:19 +0800
Subject: [PATCH 2/9] Update article.md

---
 1-js/02-first-steps/13-switch/article.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/1-js/02-first-steps/13-switch/article.md b/1-js/02-first-steps/13-switch/article.md
index 0bda78de8d..1ece615784 100644
--- a/1-js/02-first-steps/13-switch/article.md
+++ b/1-js/02-first-steps/13-switch/article.md
@@ -117,7 +117,7 @@ switch (+a) {
 比如，如果我们想让 `case 3` 和 `case 5` 执行同样的代码：
 
 ```js run no-beautify
-let a = 2 + 2;
+let a = 3;
 
 switch (a) {
   case 4:

From 8cd114bc8b235309746915fc64c226945f1956a2 Mon Sep 17 00:00:00 2001
From: LeviDing <imdingxuewen@gmail.com>
Date: Sun, 5 Apr 2020 12:25:08 +0800
Subject: [PATCH 3/9] Update article.md

---
 1-js/05-data-types/02-number/article.md | 11 +++++------
 1 file changed, 5 insertions(+), 6 deletions(-)

diff --git a/1-js/05-data-types/02-number/article.md b/1-js/05-data-types/02-number/article.md
index 0f145b81fa..2a43e8cefd 100644
--- a/1-js/05-data-types/02-number/article.md
+++ b/1-js/05-data-types/02-number/article.md
@@ -56,7 +56,7 @@ let ms = 1e-6; // six zeroes to the left from 1
 
 ### 十六进制，二进制和八进制数字
 
-[十六进制](https://en.wikipedia.org/wiki/Hexadecimal)数字在 JavaScript 中被广泛用于表示颜色，编码字符以及其他许多事物。所以很自然地，写一个更简短的方法：`0x` 然后是数字。
+[十六进制](https://en.wikipedia.org/wiki/Hexadecimal) 数字在 JavaScript 中被广泛用于表示颜色，编码字符以及其他许多事物。所以很自然地，写一个更简短的方法：`0x` 然后是数字。
 
 例如：
 
@@ -279,7 +279,6 @@ JavaScript 在这种事件中不会触发错误。它尽最大努力使数字符
 ```
 
 
-
 ## 测试：isFinite 和 isNaN
 
 还记得这两个特殊的数值吗？
@@ -325,7 +324,7 @@ alert( isFinite(num) );
 
 ```smart header="与 Object.is 进行比较"
 
-有一种特殊的内置方法 [Object.is](mdn:js/Object/is)，它可以比较 `===` 等值，但对于两种边缘情况更可靠： 
+有一种特殊的内置方法 [`Object.is`](mdn:js/Object/is)，它可以比较 `===` 等值，但对于两种边缘情况更可靠： 
 
 1. 它适用于 `NaN`： `Object.is（NaN，NaN）=== true`，这是件好事。
 2. 值 `0` 和 `-0` 是不同的：`Object.is（0，-0）=== false`，它不是很重要，但这些值在技术上是不同的。
@@ -407,7 +406,7 @@ JavaScript 有一个内置的 [Math](https://developer.mozilla.org/en/docs/Web/J
     alert( Math.pow(2, 10) ); // 2 的 10 次幂 = 1024
     ```
 
-这里有 `Math` 对象中的更多函数和常量，包括三角函数，你可以在这里找到它 [docs for the Math](https://developer.mozilla.org/en/docs/Web/JavaScript/Reference/Global_Objects/Math)。
+这里有 `Math` 对象中的更多函数和常量，包括三角函数，你可以在 [Math 函数文档](https://developer.mozilla.org/en/docs/Web/JavaScript/Reference/Global_Objects/Math) 中找到这些内容。
 
 ## 总结
 
@@ -428,9 +427,9 @@ JavaScript 有一个内置的 [Math](https://developer.mozilla.org/en/docs/Web/J
 
 分数：
 
-- 使用 `Math.floor`、`Math.ceil`、`Math.trunc`、`Math.round` 或 `num.toFixed(precision)` 截取。
+- 使用 `Math.floor`，`Math.ceil`，`Math.trunc`，`Math.round` 或 `num.toFixed(precision)` 截取。
 - 请记住，使用分数时会损失精度。
 
 更多的数学函数：
 
-- 需要时请参阅 [Math](https://developer.mozilla.org/en/docs/Web/JavaScript/Reference/Global_Objects/Math) 对象,虽然这个文档非常小,但是它可以满足基础的要求。
+- 需要时请参阅 [Math](https://developer.mozilla.org/en/docs/Web/JavaScript/Reference/Global_Objects/Math) 对象，虽然这个文档非常小，但是它可以满足基础的要求。

From c9c7ab746c5c1f35c3af02dcab5990e604ca258b Mon Sep 17 00:00:00 2001
From: LeviDing <imdingxuewen@gmail.com>
Date: Sun, 5 Apr 2020 12:31:17 +0800
Subject: [PATCH 4/9] Update article.md

---
 .../02-rest-parameters-spread/article.md      | 45 +++++++++++++++++++
 1 file changed, 45 insertions(+)

diff --git a/1-js/06-advanced-functions/02-rest-parameters-spread/article.md b/1-js/06-advanced-functions/02-rest-parameters-spread/article.md
index 9738b61bf6..2e90415585 100644
--- a/1-js/06-advanced-functions/02-rest-parameters-spread/article.md
+++ b/1-js/06-advanced-functions/02-rest-parameters-spread/article.md
@@ -225,6 +225,51 @@ alert( Array.from(str) ); // H,e,l,l,o
 因此，对于将一些“东西”转换为数组的任务，`Array.from` 往往更通用。
 
 
+## Get a new copy of an object/array
+
+Remember when we talked about `Object.assign()` [in the past](https://javascript.info/object#cloning-and-merging-object-assign)?
+
+It is possible to do the same thing with the spread operator!
+
+```js run
+let arr = [1, 2, 3];
+let arrCopy = [...arr]; // spread the array into a list of parameters
+                        // then put the result into a new array
+
+// do the arrays have the same contents?
+alert(JSON.stringify(arr) === JSON.stringify(arrCopy)); // true
+
+// are the arrays equal?
+alert(arr === arrCopy); // false (not same reference)
+
+// modifying our initial array does not modify the copy:
+arr.push(4);
+alert(arr); // 1, 2, 3, 4
+alert(arrCopy); // 1, 2, 3
+```
+
+Note that it is possible to do the same thing to make a copy of an object:
+
+```js run
+let obj = { a: 1, b: 2, c: 3 };
+let objCopy = { ...obj }; // spread the object into a list of parameters
+                          // then return the result in a new object
+
+// do the objects have the same contents?
+alert(JSON.stringify(obj) === JSON.stringify(objCopy)); // true
+
+// are the objects equal?
+alert(obj === objCopy); // false (not same reference)
+
+// modifying our initial object does not modify the copy:
+obj.d = 4;
+alert(JSON.stringify(obj)); // {"a":1,"b":2,"c":3,"d":4}
+alert(JSON.stringify(objCopy)); // {"a":1,"b":2,"c":3}
+```
+
+This way of copying an object is much shorter than `let objCopy = Object.assign({}, obj);` or for an array `let arrCopy = Object.assign([], arr);` so we prefer to use it whenever we can.
+
+
 ## 总结
 
 当我们在代码中看到 `"..."` 时，它要么是 rest 参数，要么就是 spread 语法。

From 32ecb58f7ac53ad53771cad8f4cddda3d9ed0408 Mon Sep 17 00:00:00 2001
From: LeviDing <imdingxuewen@gmail.com>
Date: Sun, 5 Apr 2020 14:52:20 +0800
Subject: [PATCH 5/9] Update article.md

---
 1-js/06-advanced-functions/03-closure/article.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/1-js/06-advanced-functions/03-closure/article.md b/1-js/06-advanced-functions/03-closure/article.md
index 92a2153ea4..2c8bea6d41 100644
--- a/1-js/06-advanced-functions/03-closure/article.md
+++ b/1-js/06-advanced-functions/03-closure/article.md
@@ -182,7 +182,7 @@ alert( counter() ); // 2
 右侧的矩形演示了执行过程中全局词法环境的变化：
 
 1. 当脚本开始运行，词法环境预先填充了所有声明的变量。
-    - 最初，它们处于“未初始化（Uninitialized）”状态。这是一种特殊的内部状态，这意味着引擎知道变量，但是不允许在 `let` 之前使用它。几乎就像变量不存在一样。
+    - 最初，它们处于“未初始化（Uninitialized）”状态。这是一种特殊的内部状态，这意味着引擎知道变量，但是在用 `let` 声明前，不能引用它。几乎就像变量不存在一样。
 2. 然后 `let phrase` 定义出现了。它尚未被赋值，因此它的值为 `undefined`。从这一刻起，我们就可以使用变量了。
 3. `phrase` 被赋予了一个值。
 4. `phrase` 的值被修改。

From 69d5a4a5d0332f555d9a48521e0d40d2a1e158dc Mon Sep 17 00:00:00 2001
From: LeviDing <imdingxuewen@gmail.com>
Date: Sun, 5 Apr 2020 14:55:22 +0800
Subject: [PATCH 6/9] Update article.md

---
 1-js/99-js-misc/03-currying-partials/article.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/1-js/99-js-misc/03-currying-partials/article.md b/1-js/99-js-misc/03-currying-partials/article.md
index 31b85035b2..b0f13de293 100644
--- a/1-js/99-js-misc/03-currying-partials/article.md
+++ b/1-js/99-js-misc/03-currying-partials/article.md
@@ -39,7 +39,7 @@ alert( curriedSum(1)(2) ); // 3
 正如你所看到的，实现非常简单：只有两个包装器（wrapper）。
 
 - `curry(func)` 的结果就是一个包装器 `function(a)`。
-- 当它被像 `sum(1)` 这样调用时，它的参数会被保存在词法环境中，然后返回一个新的包装器 `function(b)`。
+- 当它被像 `curriedSum(1)` 这样调用时，它的参数会被保存在词法环境中，然后返回一个新的包装器 `function(b)`。
 - 然后这个包装器被以 `2` 为参数调用，并且，它将该调用传递给原始的 `sum` 函数。
 
 柯里化更高级的实现，例如 lodash 库的 [_.curry](https://lodash.com/docs#curry)，会返回一个包装器，该包装器允许函数被正常调用或者以偏函数（partial）的方式调用：

From a54b5780f064cff30d861bb5c73501e33cde4e54 Mon Sep 17 00:00:00 2001
From: LeviDing <imdingxuewen@gmail.com>
Date: Sun, 5 Apr 2020 15:05:14 +0800
Subject: [PATCH 7/9] Update article.md

---
 1-js/09-classes/01-class/article.md | 91 +++++++++++++++++++++++++++--
 1 file changed, 87 insertions(+), 4 deletions(-)

diff --git a/1-js/09-classes/01-class/article.md b/1-js/09-classes/01-class/article.md
index b13941a8f9..f6d0f56d50 100644
--- a/1-js/09-classes/01-class/article.md
+++ b/1-js/09-classes/01-class/article.md
@@ -298,13 +298,17 @@ class User {
 new User().sayHi();
 ```
 
-## Class 属性
+## Class 字段
 
 ```warn header="旧的浏览器可能需要 polyfill"
-类级别的属性是最近才添加到语言中的。
+类字段（field）是最近才添加到语言中的。
 ```
 
-在上面的例子中，`User` 只有方法。现在我们为其添加一个属性：
+Previously, classes only had methods.
+
+"Class fields" is a syntax that allows to add any properties.
+
+For instance, let's add `name` property to `class User`:
 
 ```js run
 class User {
@@ -323,7 +327,86 @@ alert(User.prototype.sayHi); // 被放在 User.prototype 中
 alert(User.prototype.name); // undefined，没有被放在 User.prototype 中
 ```
 
-`name` 属性没有被放在 `User.prototype` 中。相反，它是在调用构造器之前通过 `new` 分创建的，它是对象自身的属性。
+The important thing about class fields is that they are set on individual objects, not `User.prototype`.
+
+Technically, they are processed after the constructor has done it's job.
+
+### Making bound methods with class fields
+
+As demonstrated in the chapter <info:bind> functions in JavaScript have a dynamic `this`. It depends on the context of the call.
+
+So if an object method is passed around and called in another context, `this` won't be a reference to its object any more.
+
+For instance, this code will show `undefined`:
+
+```js run
+class Button {
+  constructor(value) {
+    this.value = value;
+  }
+
+  click() {
+    alert(this.value);
+  }
+}
+
+let button = new Button("hello");
+
+*!*
+setTimeout(button.click, 1000); // undefined
+*/!*
+```
+
+The problem is called "losing `this`".
+
+There are two approaches to fixing it, as discussed in the chapter <info:bind>:
+
+1. Pass a wrapper-function, such as `setTimeout(() => button.click(), 1000)`.
+2. Bind the method to object, e.g. in the constructor:
+
+```js run
+class Button {
+  constructor(value) {
+    this.value = value;
+*!*
+    this.click = this.click.bind(this);
+*/!*
+  }
+
+  click() {
+    alert(this.value);
+  }
+}
+
+let button = new Button("hello");
+
+*!*
+setTimeout(button.click, 1000); // hello
+*/!*
+```
+
+Class fields provide a more elegant syntax for the latter solution:
+
+```js run
+class Button {
+  constructor(value) {
+    this.value = value;
+  }
+*!*
+  click = () => {
+    alert(this.value);
+  }
+*/!*
+}
+
+let button = new Button("hello");
+
+setTimeout(button.click, 1000); // hello
+```
+
+The class field `click = () => {...}` creates an independent function on each `Button` object, with `this` bound to the object. Then we can pass `button.click` around anywhere, and it will be called with the right `this`.
+
+That's especially useful in browser environment, when we need to setup a method as an event listener.
 
 ## 总结
 

From b0c308fd8b5f68e59222da1933aed636af60e7fc Mon Sep 17 00:00:00 2001
From: LeviDing <imdingxuewen@gmail.com>
Date: Sun, 5 Apr 2020 15:30:59 +0800
Subject: [PATCH 8/9] Update article.md

---
 .../02-rest-parameters-spread/article.md      | 32 +++++++++----------
 1 file changed, 16 insertions(+), 16 deletions(-)

diff --git a/1-js/06-advanced-functions/02-rest-parameters-spread/article.md b/1-js/06-advanced-functions/02-rest-parameters-spread/article.md
index 2e90415585..31c4b14852 100644
--- a/1-js/06-advanced-functions/02-rest-parameters-spread/article.md
+++ b/1-js/06-advanced-functions/02-rest-parameters-spread/article.md
@@ -225,49 +225,49 @@ alert( Array.from(str) ); // H,e,l,l,o
 因此，对于将一些“东西”转换为数组的任务，`Array.from` 往往更通用。
 
 
-## Get a new copy of an object/array
+## 获取一个 object/array 的副本
 
-Remember when we talked about `Object.assign()` [in the past](https://javascript.info/object#cloning-and-merging-object-assign)?
+还记得我们 [之前讲过的](https://zh.javascript.info/object#fu-zhi-he-he-bing-objectassign) `Object.assign()` 吗？
 
-It is possible to do the same thing with the spread operator!
+使用 spread 操作符也可以做同样的事情。
 
 ```js run
 let arr = [1, 2, 3];
-let arrCopy = [...arr]; // spread the array into a list of parameters
-                        // then put the result into a new array
+let arrCopy = [...arr]; // 将数组 spread 到参数列表中
+                        // 然后将结果放到一个新数组
 
-// do the arrays have the same contents?
+// 两个数组中的内容相同吗？
 alert(JSON.stringify(arr) === JSON.stringify(arrCopy)); // true
 
-// are the arrays equal?
-alert(arr === arrCopy); // false (not same reference)
+// 两个数组相等吗？
+alert(arr === arrCopy); // false（它们的引用是不同的）
 
-// modifying our initial array does not modify the copy:
+// 修改我们初始的数组不会修改副本：
 arr.push(4);
 alert(arr); // 1, 2, 3, 4
 alert(arrCopy); // 1, 2, 3
 ```
 
-Note that it is possible to do the same thing to make a copy of an object:
+并且，也可以通过相同的方式来复制一个对象：
 
 ```js run
 let obj = { a: 1, b: 2, c: 3 };
-let objCopy = { ...obj }; // spread the object into a list of parameters
-                          // then return the result in a new object
+let objCopy = { ...obj }; // 将对象 spread 到参数列表中
+                          // 然后将结果返回到一个新对象
 
-// do the objects have the same contents?
+// 两个对象中的内容相同吗？
 alert(JSON.stringify(obj) === JSON.stringify(objCopy)); // true
 
-// are the objects equal?
+// 两个对象相等吗？
 alert(obj === objCopy); // false (not same reference)
 
-// modifying our initial object does not modify the copy:
+// 修改我们初始的对象不会修改副本：
 obj.d = 4;
 alert(JSON.stringify(obj)); // {"a":1,"b":2,"c":3,"d":4}
 alert(JSON.stringify(objCopy)); // {"a":1,"b":2,"c":3}
 ```
 
-This way of copying an object is much shorter than `let objCopy = Object.assign({}, obj);` or for an array `let arrCopy = Object.assign([], arr);` so we prefer to use it whenever we can.
+这种方式比使用 `let arrCopy = Object.assign([], arr);` 来复制数组，或使用 `let objCopy = Object.assign({}, obj);` 来复制对象写起来要短得多。因此，只要情况允许，我们更喜欢使用它。
 
 
 ## 总结

From 268c150b9a45b8a13e26a8ddbe59fd82d6159926 Mon Sep 17 00:00:00 2001
From: LeviDing <imdingxuewen@gmail.com>
Date: Sun, 5 Apr 2020 16:05:42 +0800
Subject: [PATCH 9/9] Update article.md

---
 1-js/09-classes/01-class/article.md | 32 ++++++++++++++---------------
 1 file changed, 16 insertions(+), 16 deletions(-)

diff --git a/1-js/09-classes/01-class/article.md b/1-js/09-classes/01-class/article.md
index f6d0f56d50..145b069147 100644
--- a/1-js/09-classes/01-class/article.md
+++ b/1-js/09-classes/01-class/article.md
@@ -304,11 +304,11 @@ new User().sayHi();
 类字段（field）是最近才添加到语言中的。
 ```
 
-Previously, classes only had methods.
+之前，类仅具有方法。
 
-"Class fields" is a syntax that allows to add any properties.
+“类字段”是一种允许添加任何属性的语法。
 
-For instance, let's add `name` property to `class User`:
+例如，让我们在 `class User` 中添加一个 `name` 属性：
 
 ```js run
 class User {
@@ -327,17 +327,17 @@ alert(User.prototype.sayHi); // 被放在 User.prototype 中
 alert(User.prototype.name); // undefined，没有被放在 User.prototype 中
 ```
 
-The important thing about class fields is that they are set on individual objects, not `User.prototype`.
+关于类字段的重要一点是，它们设置在单个对象上的，而不是设置在 `User.prototype` 上的。
 
-Technically, they are processed after the constructor has done it's job.
+从技术上讲，它们是在 constructor 完成工作后被处理的。
 
-### Making bound methods with class fields
+### 使用类字段制作绑定方法
 
-As demonstrated in the chapter <info:bind> functions in JavaScript have a dynamic `this`. It depends on the context of the call.
+正如 <info:bind> 一章中所讲的，JavaScript 中的函数具有动态的 `this`。它取决于调用上下文。
 
-So if an object method is passed around and called in another context, `this` won't be a reference to its object any more.
+因此，如果一个对象方法被传递到某处，或者在另一个上下文中被调用，则 `this` 将不再是对其对象的引用。
 
-For instance, this code will show `undefined`:
+例如，此代码将显示 `undefined`：
 
 ```js run
 class Button {
@@ -357,12 +357,12 @@ setTimeout(button.click, 1000); // undefined
 */!*
 ```
 
-The problem is called "losing `this`".
+这个问题被称为“丢失 `this`”。
 
-There are two approaches to fixing it, as discussed in the chapter <info:bind>:
+我们在 <info:bind> 一章中讲过，有两种可以修复它的方式：
 
-1. Pass a wrapper-function, such as `setTimeout(() => button.click(), 1000)`.
-2. Bind the method to object, e.g. in the constructor:
+1. 传递一个包装函数，例如 `setTimeout(() => button.click(), 1000)`。
+2. 将方法绑定到对象，例如在 constructor 中：
 
 ```js run
 class Button {
@@ -385,7 +385,7 @@ setTimeout(button.click, 1000); // hello
 */!*
 ```
 
-Class fields provide a more elegant syntax for the latter solution:
+类字段为后一种解决方案提供了更优雅的语法：
 
 ```js run
 class Button {
@@ -404,9 +404,9 @@ let button = new Button("hello");
 setTimeout(button.click, 1000); // hello
 ```
 
-The class field `click = () => {...}` creates an independent function on each `Button` object, with `this` bound to the object. Then we can pass `button.click` around anywhere, and it will be called with the right `this`.
+类字段 `click = () => {...}` 在每个 `Button` 对象上创建一个独立的函数，并将 `this` 绑定到该对象上。然后，我们可以将 `button.click` 传递到任何地方，并且它会被以正确的 `this` 进行调用。
 
-That's especially useful in browser environment, when we need to setup a method as an event listener.
+这在浏览器环境中，当我们需要将一个方法设置为事件监听器时尤其有用。
 
 ## 总结