From 7c39a1cc57d19b248318f57625b8bb2c46352818 Mon Sep 17 00:00:00 2001 From: zomb-676 Date: Tue, 4 Aug 2020 06:47:39 +0800 Subject: [PATCH 01/38] translate some missing contents --- 1-js/09-classes/01-class/article.md | 16 +++--- .../02-class-inheritance/article.md | 50 +++++++++---------- 2 files changed, 33 insertions(+), 33 deletions(-) diff --git a/1-js/09-classes/01-class/article.md b/1-js/09-classes/01-class/article.md index 020ac18418..0857c9393b 100644 --- a/1-js/09-classes/01-class/article.md +++ b/1-js/09-classes/01-class/article.md @@ -267,11 +267,11 @@ alert(user.name); // John user = new User(""); // Name is too short. ``` -Technically, such class declaration works by creating getters and setters in `User.prototype`. +从技术上来讲，这样的类声明可以通过在 `User.prototype`中创建getters和setters奏效. -## Computed names [...] +## 计算属性名称 [...] -Here's an example with a computed method name using brackets `[...]`: +这里有一个使用括号的计算方法名称示例 `[...]`: ```js run class User { @@ -287,7 +287,7 @@ class User { new User().sayHi(); ``` -Such features are easy to remember, as they resemble that of literal objects. +这种特性容易记忆，因为他们与字面量对象相似. ## Class 字段 @@ -315,9 +315,9 @@ class User { new User().sayHi(); // Hello, John! ``` -So, we just write " = " in the declaration, and that's it. +这样，我们就只要在表达式中书写" = " ，就这样。 -The important difference of class fields is that they are set on individual objects, not `User.prototype`: +类属性的重要不同之处在于他们在单个对象中被设置，而不是`User.prototype`: ```js run class User { @@ -331,7 +331,7 @@ alert(user.name); // John alert(User.prototype.name); // undefined ``` -We can also assign values using more complex expressions and function calls: +我们也可以在赋值时使用更加复杂的表达式和函数调用: ```js run class User { @@ -397,7 +397,7 @@ let button = new Button("hello"); setTimeout(button.click, 1000); // hello ``` -The class field `click = () => {...}` is created on a per-object basis, there's a separate function for each `Button` object, with `this` inside it referencing that object. We can pass `button.click` around anywhere, and the value of `this` will always be correct. +类属性`click = () => {...}`是基于每一个对象被创建的，在这儿对于每一个 `Button`对象都有一个独立的方法，在内部有一个`this`指向那个对象。我们可以在任何地方传递`button.click`，并且`this`的值总是正确的。 在浏览器环境中，它对于进行事件监听尤为有用。 diff --git a/1-js/09-classes/02-class-inheritance/article.md b/1-js/09-classes/02-class-inheritance/article.md index c7f1f63112..53939f4eff 100644 --- a/1-js/09-classes/02-class-inheritance/article.md +++ b/1-js/09-classes/02-class-inheritance/article.md @@ -282,19 +282,19 @@ alert(rabbit.earLength); // 10 -### Overriding class fields: a tricky note +### 重写类属性: 一个棘手的提示 ```warn header="Advanced note" -This note assumes you have a certain experience with classes, maybe in other programming languages. +这个提示假设你或许在其他编程语言中有一定的关于类的经验。 -It provides better insight into the language and also explains the behavior that might be a source of bugs (but not very often). +这里提供了一个更好的视角来理解这门语言并且解释了它的行为为什么可能会是一种bug的来源(但是不是非常频繁) -If you find it difficult to understand, just go on, continue reading, then return to it some time later. +如果你发现这难以理解,什么都别管,继续往下阅读,之后再回到这里。 ``` -We can override not only methods, but also class fields. +我们可以重写的不仅是方法,还有类属性。 -Although, there's a tricky behavior when we access an overridden field in parent constructor, quite different from most other programming languages. +不过,这儿有一个棘手的行为当我们访问在父类构造器中被重写的一个属性时,这与绝大多数其他编程语言截然不同。 Consider this example: @@ -317,19 +317,19 @@ new Rabbit(); // animal */!* ``` -Here, class `Rabbit` extends `Animal` and overrides `name` field with its own value. +在这,`Rabbit`继承自 `Animal`并且用它自己的值重写了 `name`属性, -There's no own constructor in `Rabbit`, so `Animal` constructor is called. +因为`Rabbit`中没用自己的构造器,所以 `Animal`的构造器被调用了。 -What's interesting is that in both cases: `new Animal()` and `new Rabbit()`, the `alert` in the line `(*)` shows `animal`. +有趣的是在两种情况下 `new Animal()` 和 `new Rabbit()`,在 `(*)`的`alert`都显示了 `animal`。 -**In other words, parent constructor always uses its own field value, not the overridden one.** +**换句话说， 父类构造器总是使用它自己属性的值，而不是被重写的那一个。** -What's odd about it? +古怪的是什么呢? -If it's not clear yet, please compare with methods. +如果这还不清楚，那么请用方法来比较。 -Here's the same code, but instead of `this.name` field we call `this.showName()` method: +这里是相同的代码,但是我们调用`this.showName()`方法而不是`this.name`属性: ```js run class Animal { @@ -354,27 +354,27 @@ new Rabbit(); // rabbit */!* ``` -Please note: now the output is different. +请注意,这时的输出是不同的。 -And that's what we naturally expect. When the parent constructor is called in the derived class, it uses the overridden method. +这才是我们本来所期待的. 当父类构造器在被派生的类中调用时，它会使用被重写的方法。 -...But for class fields it's not so. As said, the parent constructor always uses the parent field. +...但是对于类属性,并非如此。 正如前文所述,父类构造器总是使用父类的属性。 -Why is there the difference? +那这里为什么会有区别呢? -Well, the reason is in the field initialization order. The class field is initialized: -- Before constructor for the base class (that doesn't extend anything), -- Imediately after `super()` for the derived class. +实际上,原因在于属性加载的顺序。类属性是如下加载的: +- 在基类被构造前加载(不继承任何类的那种)。 +- 对于被派生类,在调用 `super()`后立刻加载。 -In our case, `Rabbit` is the derived class. There's no `constructor()` in it. As said previously, that's the same as if there was an empty constructor with only `super(...args)`. +在我们这种情况下, `Rabbit`是被派生类,这里面没有 `constructor()`。正如先前所说,如果这里面只有一个空的构造器,里面只有`super(...args)`,那么这是相同的。 -So, `new Rabbit()` calls `super()`, thus executing the parent constructor, and (per the rule for derived classes) only after that its class fields are initialized. At the time of the parent constructor execution, there are no `Rabbit` class fields yet, that's why `Animal` fields are used. +所以, `new Rabbit()`调用了 `super()`因此它执行了父类构造器,并且(根据类的派生规则)只有在此之后,他的类属性才被加载。在父类构造器被执行的时候,这是还没用类属性`Rabbit`,这就是为什么`Animal`属性被使用了。 -This subtle difference between fields and methods is specific to JavaScript +这属性和方法之间微妙的区别只特定于JavaScript。 -Luckily, this behavior only reveals itself if an overridden field is used in the parent constructor. Then it may be difficult to understand what's going on, so we're explaining it here. +幸运的是,这种行为仅在一个被重写的属性被父类构造器使用时显示出来。接下来它会发生什么就很难理解了,所以我们在这里解释它。 -If it becomes a problem, one can fix it by using methods or getters/setters instead of fields. +如果它成为了一个问题,我们可以通过使用方法或者getter/setter而不是属性来修复它。 ## 深入：内部探究和 [[HomeObject]] From dbb082b711be40edb9df9bf8191296edd23e22ec Mon Sep 17 00:00:00 2001 From: zomb_676 Date: Fri, 4 Sep 2020 21:43:04 +0800 Subject: [PATCH 02/38] Update 1-js/09-classes/01-class/article.md Co-authored-by: Martin --- 1-js/09-classes/01-class/article.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/1-js/09-classes/01-class/article.md b/1-js/09-classes/01-class/article.md index 0857c9393b..374a185899 100644 --- a/1-js/09-classes/01-class/article.md +++ b/1-js/09-classes/01-class/article.md @@ -267,7 +267,7 @@ alert(user.name); // John user = new User(""); // Name is too short. ``` -从技术上来讲，这样的类声明可以通过在 `User.prototype`中创建getters和setters奏效. +从技术上来讲，这样的类声明可以通过在 `User.prototype` 中创建 getters 和 setters 奏效。 ## 计算属性名称 [...] From ab7bf5340533a0a1be855b2217d140ee09e91eb2 Mon Sep 17 00:00:00 2001 From: zomb_676 Date: Fri, 4 Sep 2020 21:43:34 +0800 Subject: [PATCH 03/38] Update 1-js/09-classes/01-class/article.md Co-authored-by: Martin --- 1-js/09-classes/01-class/article.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/1-js/09-classes/01-class/article.md b/1-js/09-classes/01-class/article.md index 374a185899..da5be92eb8 100644 --- a/1-js/09-classes/01-class/article.md +++ b/1-js/09-classes/01-class/article.md @@ -287,7 +287,7 @@ class User { new User().sayHi(); ``` -这种特性容易记忆，因为他们与字面量对象相似. +这种特性容易记忆，因为他们与字面量对象相似。 ## Class 字段 From 32594f00a911883a46a5d59a40b14c94d4029ed3 Mon Sep 17 00:00:00 2001 From: zomb_676 Date: Fri, 4 Sep 2020 21:43:54 +0800 Subject: [PATCH 04/38] Update 1-js/09-classes/01-class/article.md Co-authored-by: Martin --- 1-js/09-classes/01-class/article.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/1-js/09-classes/01-class/article.md b/1-js/09-classes/01-class/article.md index da5be92eb8..a123a56211 100644 --- a/1-js/09-classes/01-class/article.md +++ b/1-js/09-classes/01-class/article.md @@ -317,7 +317,7 @@ new User().sayHi(); // Hello, John! 这样，我们就只要在表达式中书写" = " ，就这样。 -类属性的重要不同之处在于他们在单个对象中被设置，而不是`User.prototype`: +类字段的重要不同之处在于，他们会在每个独立对象中被设好，而不是设在了 `User.prototype`： ```js run class User { From 85c04a7ba28addd129f58e9cbaff0fe1523daea0 Mon Sep 17 00:00:00 2001 From: zomb_676 Date: Fri, 4 Sep 2020 21:52:00 +0800 Subject: [PATCH 05/38] Update 1-js/09-classes/01-class/article.md Co-authored-by: Martin --- 1-js/09-classes/01-class/article.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/1-js/09-classes/01-class/article.md b/1-js/09-classes/01-class/article.md index a123a56211..efe1c73795 100644 --- a/1-js/09-classes/01-class/article.md +++ b/1-js/09-classes/01-class/article.md @@ -271,7 +271,7 @@ user = new User(""); // Name is too short. ## 计算属性名称 [...] -这里有一个使用括号的计算方法名称示例 `[...]`: +这里有一个使用中括号 `[...]` 的计算方法名称示例： ```js run class User { From 47f13bb669fc868b90733b2530c624bbaef139cc Mon Sep 17 00:00:00 2001 From: zomb_676 Date: Fri, 4 Sep 2020 21:52:35 +0800 Subject: [PATCH 06/38] Update 1-js/09-classes/01-class/article.md Co-authored-by: Martin --- 1-js/09-classes/01-class/article.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/1-js/09-classes/01-class/article.md b/1-js/09-classes/01-class/article.md index efe1c73795..2ae18f15d0 100644 --- a/1-js/09-classes/01-class/article.md +++ b/1-js/09-classes/01-class/article.md @@ -315,7 +315,7 @@ class User { new User().sayHi(); // Hello, John! ``` -这样，我们就只要在表达式中书写" = " ，就这样。 +所以，我们就只需在表达式中书写 " = " ，就这样。 类字段的重要不同之处在于，他们会在每个独立对象中被设好，而不是设在了 `User.prototype`： From fcadffc67c014de1890414683036ad4fa7d1df00 Mon Sep 17 00:00:00 2001 From: zomb_676 Date: Fri, 4 Sep 2020 21:52:49 +0800 Subject: [PATCH 07/38] Update 1-js/09-classes/01-class/article.md Co-authored-by: Martin --- 1-js/09-classes/01-class/article.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/1-js/09-classes/01-class/article.md b/1-js/09-classes/01-class/article.md index 2ae18f15d0..6eee662e4b 100644 --- a/1-js/09-classes/01-class/article.md +++ b/1-js/09-classes/01-class/article.md @@ -331,7 +331,7 @@ alert(user.name); // John alert(User.prototype.name); // undefined ``` -我们也可以在赋值时使用更加复杂的表达式和函数调用: +我们也可以在赋值时使用更加复杂的表达式和函数调用： ```js run class User { From 3ff9d5818a4b40e1b612a895c2d3bfd4cfcb2f2e Mon Sep 17 00:00:00 2001 From: zomb_676 Date: Fri, 4 Sep 2020 21:53:05 +0800 Subject: [PATCH 08/38] Update 1-js/09-classes/02-class-inheritance/article.md Co-authored-by: Martin --- 1-js/09-classes/02-class-inheritance/article.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/1-js/09-classes/02-class-inheritance/article.md b/1-js/09-classes/02-class-inheritance/article.md index 53939f4eff..1c0312717a 100644 --- a/1-js/09-classes/02-class-inheritance/article.md +++ b/1-js/09-classes/02-class-inheritance/article.md @@ -285,7 +285,7 @@ alert(rabbit.earLength); // 10 ### 重写类属性: 一个棘手的提示 ```warn header="Advanced note" -这个提示假设你或许在其他编程语言中有一定的关于类的经验。 +这个注意要点假设你或许在其他编程语言中有一定的关于类的经验。 这里提供了一个更好的视角来理解这门语言并且解释了它的行为为什么可能会是一种bug的来源(但是不是非常频繁) From 91ff5bc7aaeeba351edb9790301a79cb65ca664e Mon Sep 17 00:00:00 2001 From: zomb_676 Date: Fri, 4 Sep 2020 21:53:12 +0800 Subject: [PATCH 09/38] Update 1-js/09-classes/02-class-inheritance/article.md Co-authored-by: Martin --- 1-js/09-classes/02-class-inheritance/article.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/1-js/09-classes/02-class-inheritance/article.md b/1-js/09-classes/02-class-inheritance/article.md index 1c0312717a..05fa2f8ec6 100644 --- a/1-js/09-classes/02-class-inheritance/article.md +++ b/1-js/09-classes/02-class-inheritance/article.md @@ -368,7 +368,7 @@ new Rabbit(); // rabbit 在我们这种情况下, `Rabbit`是被派生类,这里面没有 `constructor()`。正如先前所说,如果这里面只有一个空的构造器,里面只有`super(...args)`,那么这是相同的。 -所以, `new Rabbit()`调用了 `super()`因此它执行了父类构造器,并且(根据类的派生规则)只有在此之后,他的类属性才被加载。在父类构造器被执行的时候,这是还没用类属性`Rabbit`,这就是为什么`Animal`属性被使用了。 +所以，`new Rabbit()` 调用了 `super()`，因此它执行了父类构造器，并且（根据派生类规则）只有在此之后，它的类字段才被初始化。在父类构造器被执行的时候，`Rabbit` 还没有自己的类字段，这就是为什么`Animal` 类字段被使用了。 这属性和方法之间微妙的区别只特定于JavaScript。 From 7b54ee5d7287cd707975c53a6eed0223413ffdce Mon Sep 17 00:00:00 2001 From: zomb_676 Date: Fri, 4 Sep 2020 21:53:20 +0800 Subject: [PATCH 10/38] Update 1-js/09-classes/02-class-inheritance/article.md Co-authored-by: Martin --- 1-js/09-classes/02-class-inheritance/article.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/1-js/09-classes/02-class-inheritance/article.md b/1-js/09-classes/02-class-inheritance/article.md index 05fa2f8ec6..0bc35be535 100644 --- a/1-js/09-classes/02-class-inheritance/article.md +++ b/1-js/09-classes/02-class-inheritance/article.md @@ -370,7 +370,7 @@ new Rabbit(); // rabbit 所以，`new Rabbit()` 调用了 `super()`，因此它执行了父类构造器，并且（根据派生类规则）只有在此之后，它的类字段才被初始化。在父类构造器被执行的时候，`Rabbit` 还没有自己的类字段，这就是为什么`Animal` 类字段被使用了。 -这属性和方法之间微妙的区别只特定于JavaScript。 +这种字段与方法之间微妙的区别只特定于 JavaScript。 幸运的是,这种行为仅在一个被重写的属性被父类构造器使用时显示出来。接下来它会发生什么就很难理解了,所以我们在这里解释它。 From 8f8d654ffdcafa8762bc566b704f06d85ec180ec Mon Sep 17 00:00:00 2001 From: zomb_676 Date: Fri, 4 Sep 2020 21:53:31 +0800 Subject: [PATCH 11/38] Update 1-js/09-classes/01-class/article.md Co-authored-by: Martin --- 1-js/09-classes/01-class/article.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/1-js/09-classes/01-class/article.md b/1-js/09-classes/01-class/article.md index 6eee662e4b..3e486445b7 100644 --- a/1-js/09-classes/01-class/article.md +++ b/1-js/09-classes/01-class/article.md @@ -397,7 +397,7 @@ let button = new Button("hello"); setTimeout(button.click, 1000); // hello ``` -类属性`click = () => {...}`是基于每一个对象被创建的，在这儿对于每一个 `Button`对象都有一个独立的方法，在内部有一个`this`指向那个对象。我们可以在任何地方传递`button.click`，并且`this`的值总是正确的。 +类字段 `click = () => {...}`是基于每一个对象被创建的，在这里对于每一个 `Button` 对象都有一个独立的方法，在内部有一个`this`指向此对象。我们可以在任何地方传递`button.click`，并且`this`的值总是正确的。 在浏览器环境中，它对于进行事件监听尤为有用。 From 4de22de0f782106adb976b7ff62c847b64191fe6 Mon Sep 17 00:00:00 2001 From: zomb_676 Date: Fri, 4 Sep 2020 21:53:54 +0800 Subject: [PATCH 12/38] Update 1-js/09-classes/02-class-inheritance/article.md Co-authored-by: Martin --- 1-js/09-classes/02-class-inheritance/article.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/1-js/09-classes/02-class-inheritance/article.md b/1-js/09-classes/02-class-inheritance/article.md index 0bc35be535..953db5be29 100644 --- a/1-js/09-classes/02-class-inheritance/article.md +++ b/1-js/09-classes/02-class-inheritance/article.md @@ -282,7 +282,7 @@ alert(rabbit.earLength); // 10 -### 重写类属性: 一个棘手的提示 +### 重写类字段: 一个棘手的注意要点 ```warn header="Advanced note" 这个注意要点假设你或许在其他编程语言中有一定的关于类的经验。 From da84065d9efe4fd6c664b3f06312a58351057e6b Mon Sep 17 00:00:00 2001 From: zomb_676 Date: Fri, 4 Sep 2020 21:54:09 +0800 Subject: [PATCH 13/38] Update 1-js/09-classes/02-class-inheritance/article.md Co-authored-by: Martin --- 1-js/09-classes/02-class-inheritance/article.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/1-js/09-classes/02-class-inheritance/article.md b/1-js/09-classes/02-class-inheritance/article.md index 953db5be29..a3e0c7d817 100644 --- a/1-js/09-classes/02-class-inheritance/article.md +++ b/1-js/09-classes/02-class-inheritance/article.md @@ -287,7 +287,7 @@ alert(rabbit.earLength); // 10 ```warn header="Advanced note" 这个注意要点假设你或许在其他编程语言中有一定的关于类的经验。 -这里提供了一个更好的视角来理解这门语言并且解释了它的行为为什么可能会是一种bug的来源(但是不是非常频繁) +这里提供了一个更好的视角来窥探这门语言并且解释了它的行为为什么可能会是 bugs 的来源(但是不是非常频繁)。 如果你发现这难以理解,什么都别管,继续往下阅读,之后再回到这里。 ``` From efbd6cbf5374658e3b913a8d7fdf4ef16a7abff2 Mon Sep 17 00:00:00 2001 From: zomb_676 Date: Fri, 4 Sep 2020 21:54:21 +0800 Subject: [PATCH 14/38] Update 1-js/09-classes/02-class-inheritance/article.md Co-authored-by: Martin --- 1-js/09-classes/02-class-inheritance/article.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/1-js/09-classes/02-class-inheritance/article.md b/1-js/09-classes/02-class-inheritance/article.md index a3e0c7d817..0807af4918 100644 --- a/1-js/09-classes/02-class-inheritance/article.md +++ b/1-js/09-classes/02-class-inheritance/article.md @@ -284,7 +284,7 @@ alert(rabbit.earLength); // 10 ### 重写类字段: 一个棘手的注意要点 -```warn header="Advanced note" +```warn header="高级的注意要点" 这个注意要点假设你或许在其他编程语言中有一定的关于类的经验。 这里提供了一个更好的视角来窥探这门语言并且解释了它的行为为什么可能会是 bugs 的来源(但是不是非常频繁)。 From a74b0a881f0380689061d3f4a5c3ab8d950eac8b Mon Sep 17 00:00:00 2001 From: zomb_676 Date: Fri, 4 Sep 2020 21:54:34 +0800 Subject: [PATCH 15/38] Update 1-js/09-classes/02-class-inheritance/article.md Co-authored-by: Martin --- 1-js/09-classes/02-class-inheritance/article.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/1-js/09-classes/02-class-inheritance/article.md b/1-js/09-classes/02-class-inheritance/article.md index 0807af4918..24f82aa248 100644 --- a/1-js/09-classes/02-class-inheritance/article.md +++ b/1-js/09-classes/02-class-inheritance/article.md @@ -289,7 +289,7 @@ alert(rabbit.earLength); // 10 这里提供了一个更好的视角来窥探这门语言并且解释了它的行为为什么可能会是 bugs 的来源(但是不是非常频繁)。 -如果你发现这难以理解,什么都别管,继续往下阅读,之后再回到这里。 +如果你发现这难以理解，什么都别管，继续往下阅读，之后再回到这里。 ``` 我们可以重写的不仅是方法,还有类属性。 From b8f6e3dceae09181a86904a3a384d5e0c6339ddc Mon Sep 17 00:00:00 2001 From: zomb_676 Date: Fri, 4 Sep 2020 21:54:49 +0800 Subject: [PATCH 16/38] Update 1-js/09-classes/02-class-inheritance/article.md Co-authored-by: Martin --- 1-js/09-classes/02-class-inheritance/article.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/1-js/09-classes/02-class-inheritance/article.md b/1-js/09-classes/02-class-inheritance/article.md index 24f82aa248..6e5b24316d 100644 --- a/1-js/09-classes/02-class-inheritance/article.md +++ b/1-js/09-classes/02-class-inheritance/article.md @@ -292,7 +292,7 @@ alert(rabbit.earLength); // 10 如果你发现这难以理解，什么都别管，继续往下阅读，之后再回到这里。 ``` -我们可以重写的不仅是方法,还有类属性。 +我们可以重写的不仅是方法，还有类字段。 不过,这儿有一个棘手的行为当我们访问在父类构造器中被重写的一个属性时,这与绝大多数其他编程语言截然不同。 From 85580fdafdbfe2d10987db9d4262511ee1d412bc Mon Sep 17 00:00:00 2001 From: zomb_676 Date: Fri, 4 Sep 2020 21:55:02 +0800 Subject: [PATCH 17/38] Update 1-js/09-classes/02-class-inheritance/article.md Co-authored-by: Martin --- 1-js/09-classes/02-class-inheritance/article.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/1-js/09-classes/02-class-inheritance/article.md b/1-js/09-classes/02-class-inheritance/article.md index 6e5b24316d..7e8c262ad1 100644 --- a/1-js/09-classes/02-class-inheritance/article.md +++ b/1-js/09-classes/02-class-inheritance/article.md @@ -296,7 +296,7 @@ alert(rabbit.earLength); // 10 不过,这儿有一个棘手的行为当我们访问在父类构造器中被重写的一个属性时,这与绝大多数其他编程语言截然不同。 -Consider this example: +请思考此示例： ```js run class Animal { From a7e21a9d0865b7af8acc4cfebdd9c42b28ac4b0a Mon Sep 17 00:00:00 2001 From: zomb_676 Date: Fri, 4 Sep 2020 21:55:14 +0800 Subject: [PATCH 18/38] Update 1-js/09-classes/02-class-inheritance/article.md Co-authored-by: Martin --- 1-js/09-classes/02-class-inheritance/article.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/1-js/09-classes/02-class-inheritance/article.md b/1-js/09-classes/02-class-inheritance/article.md index 7e8c262ad1..871354e0d8 100644 --- a/1-js/09-classes/02-class-inheritance/article.md +++ b/1-js/09-classes/02-class-inheritance/article.md @@ -294,7 +294,7 @@ alert(rabbit.earLength); // 10 我们可以重写的不仅是方法，还有类字段。 -不过,这儿有一个棘手的行为当我们访问在父类构造器中被重写的一个属性时,这与绝大多数其他编程语言截然不同。 +不过，当我们访问在父类构造器中一个被重写的字段时，这里会有一个诡异的行为，这与绝大多数其他编程语言很不一样。 请思考此示例： From 46f5652024898baba228b8ac0fe0db5b2b7d82bc Mon Sep 17 00:00:00 2001 From: zomb_676 Date: Fri, 4 Sep 2020 21:55:29 +0800 Subject: [PATCH 19/38] Update 1-js/09-classes/02-class-inheritance/article.md Co-authored-by: Martin --- 1-js/09-classes/02-class-inheritance/article.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/1-js/09-classes/02-class-inheritance/article.md b/1-js/09-classes/02-class-inheritance/article.md index 871354e0d8..43255642be 100644 --- a/1-js/09-classes/02-class-inheritance/article.md +++ b/1-js/09-classes/02-class-inheritance/article.md @@ -317,7 +317,7 @@ new Rabbit(); // animal */!* ``` -在这,`Rabbit`继承自 `Animal`并且用它自己的值重写了 `name`属性, +这里，`Rabbit` 继承自 `Animal` 并且用它自己的值重写了 `name` 字段。 因为`Rabbit`中没用自己的构造器,所以 `Animal`的构造器被调用了。 From e89f6b8b6ee24629ab3cf468ff59c411456e4a52 Mon Sep 17 00:00:00 2001 From: zomb_676 Date: Fri, 4 Sep 2020 21:55:43 +0800 Subject: [PATCH 20/38] Update 1-js/09-classes/02-class-inheritance/article.md Co-authored-by: Martin --- 1-js/09-classes/02-class-inheritance/article.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/1-js/09-classes/02-class-inheritance/article.md b/1-js/09-classes/02-class-inheritance/article.md index 43255642be..07c0a4f427 100644 --- a/1-js/09-classes/02-class-inheritance/article.md +++ b/1-js/09-classes/02-class-inheritance/article.md @@ -319,7 +319,7 @@ new Rabbit(); // animal 这里，`Rabbit` 继承自 `Animal` 并且用它自己的值重写了 `name` 字段。 -因为`Rabbit`中没用自己的构造器,所以 `Animal`的构造器被调用了。 +因为 `Rabbit` 中没用自己的构造器，所以 `Animal` 的构造器被调用了。 有趣的是在两种情况下 `new Animal()` 和 `new Rabbit()`,在 `(*)`的`alert`都显示了 `animal`。 From 92bf1da5d976845e7af2d28310f9934b21a3aea9 Mon Sep 17 00:00:00 2001 From: zomb_676 Date: Fri, 4 Sep 2020 21:55:57 +0800 Subject: [PATCH 21/38] Update 1-js/09-classes/02-class-inheritance/article.md Co-authored-by: Martin --- 1-js/09-classes/02-class-inheritance/article.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/1-js/09-classes/02-class-inheritance/article.md b/1-js/09-classes/02-class-inheritance/article.md index 07c0a4f427..f02445cdeb 100644 --- a/1-js/09-classes/02-class-inheritance/article.md +++ b/1-js/09-classes/02-class-inheritance/article.md @@ -321,7 +321,7 @@ new Rabbit(); // animal 因为 `Rabbit` 中没用自己的构造器，所以 `Animal` 的构造器被调用了。 -有趣的是在两种情况下 `new Animal()` 和 `new Rabbit()`,在 `(*)`的`alert`都显示了 `animal`。 +有趣的是在两种情况下 `new Animal()` 和 `new Rabbit()`，在 `(*)` 的 `alert` 都打印了 `animal`。 **换句话说， 父类构造器总是使用它自己属性的值，而不是被重写的那一个。** From 18f2d6f5a86e001b7d7736118cf02c8444195454 Mon Sep 17 00:00:00 2001 From: zomb_676 Date: Fri, 4 Sep 2020 21:56:07 +0800 Subject: [PATCH 22/38] Update 1-js/09-classes/02-class-inheritance/article.md Co-authored-by: Martin --- 1-js/09-classes/02-class-inheritance/article.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/1-js/09-classes/02-class-inheritance/article.md b/1-js/09-classes/02-class-inheritance/article.md index f02445cdeb..b6d9be4578 100644 --- a/1-js/09-classes/02-class-inheritance/article.md +++ b/1-js/09-classes/02-class-inheritance/article.md @@ -323,7 +323,7 @@ new Rabbit(); // animal 有趣的是在两种情况下 `new Animal()` 和 `new Rabbit()`，在 `(*)` 的 `alert` 都打印了 `animal`。 -**换句话说， 父类构造器总是使用它自己属性的值，而不是被重写的那一个。** +**换句话说， 父类构造器总是会使用它自己字段的值，而不是被重写的那一个。** 古怪的是什么呢? From f7383d33f3a69cdbc23dc7e80656a88c82932377 Mon Sep 17 00:00:00 2001 From: zomb_676 Date: Fri, 4 Sep 2020 21:56:23 +0800 Subject: [PATCH 23/38] Update 1-js/09-classes/02-class-inheritance/article.md Co-authored-by: Martin --- 1-js/09-classes/02-class-inheritance/article.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/1-js/09-classes/02-class-inheritance/article.md b/1-js/09-classes/02-class-inheritance/article.md index b6d9be4578..f17a20333e 100644 --- a/1-js/09-classes/02-class-inheritance/article.md +++ b/1-js/09-classes/02-class-inheritance/article.md @@ -325,7 +325,7 @@ new Rabbit(); // animal **换句话说， 父类构造器总是会使用它自己字段的值，而不是被重写的那一个。** -古怪的是什么呢? +古怪的是什么呢？ 如果这还不清楚，那么请用方法来比较。 From 9bcc31bd01bd0505cfd6cfc40c1dfc2ff4857a98 Mon Sep 17 00:00:00 2001 From: zomb_676 Date: Fri, 4 Sep 2020 21:56:36 +0800 Subject: [PATCH 24/38] Update 1-js/09-classes/02-class-inheritance/article.md Co-authored-by: Martin --- 1-js/09-classes/02-class-inheritance/article.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/1-js/09-classes/02-class-inheritance/article.md b/1-js/09-classes/02-class-inheritance/article.md index f17a20333e..9c75cc32c7 100644 --- a/1-js/09-classes/02-class-inheritance/article.md +++ b/1-js/09-classes/02-class-inheritance/article.md @@ -327,7 +327,7 @@ new Rabbit(); // animal 古怪的是什么呢？ -如果这还不清楚，那么请用方法来比较。 +如果这还不清楚，那么让我们用方法来比较。 这里是相同的代码,但是我们调用`this.showName()`方法而不是`this.name`属性: From 37b32fcb035339c8d39d02e02c8c0b5cb31317d8 Mon Sep 17 00:00:00 2001 From: zomb_676 Date: Fri, 4 Sep 2020 21:56:54 +0800 Subject: [PATCH 25/38] Update 1-js/09-classes/02-class-inheritance/article.md Co-authored-by: Martin --- 1-js/09-classes/02-class-inheritance/article.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/1-js/09-classes/02-class-inheritance/article.md b/1-js/09-classes/02-class-inheritance/article.md index 9c75cc32c7..c962aaeb4d 100644 --- a/1-js/09-classes/02-class-inheritance/article.md +++ b/1-js/09-classes/02-class-inheritance/article.md @@ -358,7 +358,7 @@ new Rabbit(); // rabbit 这才是我们本来所期待的. 当父类构造器在被派生的类中调用时，它会使用被重写的方法。 -...但是对于类属性,并非如此。 正如前文所述,父类构造器总是使用父类的属性。 +……但是对于类字段，并非如此。正如前文所述，父类构造器总是使用父类的字段。 那这里为什么会有区别呢? From 2f9889b44811a15fe89d900d1359a7525ba0dd36 Mon Sep 17 00:00:00 2001 From: zomb_676 Date: Fri, 4 Sep 2020 21:57:06 +0800 Subject: [PATCH 26/38] Update 1-js/09-classes/02-class-inheritance/article.md Co-authored-by: Martin --- 1-js/09-classes/02-class-inheritance/article.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/1-js/09-classes/02-class-inheritance/article.md b/1-js/09-classes/02-class-inheritance/article.md index c962aaeb4d..f7325b1d55 100644 --- a/1-js/09-classes/02-class-inheritance/article.md +++ b/1-js/09-classes/02-class-inheritance/article.md @@ -329,7 +329,7 @@ new Rabbit(); // animal 如果这还不清楚，那么让我们用方法来比较。 -这里是相同的代码,但是我们调用`this.showName()`方法而不是`this.name`属性: +这里是相同的代码，但是我们调用 `this.showName()` 方法而不是 `this.name` 字段： ```js run class Animal { From 2056e60f4d3c9903e133abffdafd40b21197a15e Mon Sep 17 00:00:00 2001 From: zomb_676 Date: Fri, 4 Sep 2020 21:57:20 +0800 Subject: [PATCH 27/38] Update 1-js/09-classes/02-class-inheritance/article.md Co-authored-by: Martin --- 1-js/09-classes/02-class-inheritance/article.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/1-js/09-classes/02-class-inheritance/article.md b/1-js/09-classes/02-class-inheritance/article.md index f7325b1d55..b361d15406 100644 --- a/1-js/09-classes/02-class-inheritance/article.md +++ b/1-js/09-classes/02-class-inheritance/article.md @@ -354,7 +354,7 @@ new Rabbit(); // rabbit */!* ``` -请注意,这时的输出是不同的。 +请注意，这时的输出是不同的。 这才是我们本来所期待的. 当父类构造器在被派生的类中调用时，它会使用被重写的方法。 From 88d307c80d17b7eabf533fd8723d76a089e784a7 Mon Sep 17 00:00:00 2001 From: zomb_676 Date: Fri, 4 Sep 2020 21:57:36 +0800 Subject: [PATCH 28/38] Update 1-js/09-classes/02-class-inheritance/article.md Co-authored-by: Martin --- 1-js/09-classes/02-class-inheritance/article.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/1-js/09-classes/02-class-inheritance/article.md b/1-js/09-classes/02-class-inheritance/article.md index b361d15406..c59e028081 100644 --- a/1-js/09-classes/02-class-inheritance/article.md +++ b/1-js/09-classes/02-class-inheritance/article.md @@ -356,7 +356,7 @@ new Rabbit(); // rabbit 请注意，这时的输出是不同的。 -这才是我们本来所期待的. 当父类构造器在被派生的类中调用时，它会使用被重写的方法。 +这才是我们本来所期待的结果。当父类构造器在被派生的类中被调用时，它会使用被重写的方法。 ……但是对于类字段，并非如此。正如前文所述，父类构造器总是使用父类的字段。 From 8bff11fd87543ac4a00d5119496ecbf8178c3699 Mon Sep 17 00:00:00 2001 From: zomb_676 Date: Fri, 4 Sep 2020 21:57:54 +0800 Subject: [PATCH 29/38] Update 1-js/09-classes/02-class-inheritance/article.md Co-authored-by: Martin --- 1-js/09-classes/02-class-inheritance/article.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/1-js/09-classes/02-class-inheritance/article.md b/1-js/09-classes/02-class-inheritance/article.md index c59e028081..b4c1d33fdf 100644 --- a/1-js/09-classes/02-class-inheritance/article.md +++ b/1-js/09-classes/02-class-inheritance/article.md @@ -360,7 +360,7 @@ new Rabbit(); // rabbit ……但是对于类字段，并非如此。正如前文所述，父类构造器总是使用父类的字段。 -那这里为什么会有区别呢? +那这里为什么会有区别呢？ 实际上,原因在于属性加载的顺序。类属性是如下加载的: - 在基类被构造前加载(不继承任何类的那种)。 From b4b22a967716f8d032d8e62f556f36a7686e2723 Mon Sep 17 00:00:00 2001 From: zomb_676 Date: Fri, 4 Sep 2020 21:58:15 +0800 Subject: [PATCH 30/38] Update 1-js/09-classes/02-class-inheritance/article.md Co-authored-by: Martin --- 1-js/09-classes/02-class-inheritance/article.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/1-js/09-classes/02-class-inheritance/article.md b/1-js/09-classes/02-class-inheritance/article.md index b4c1d33fdf..9c8dac8427 100644 --- a/1-js/09-classes/02-class-inheritance/article.md +++ b/1-js/09-classes/02-class-inheritance/article.md @@ -362,7 +362,7 @@ new Rabbit(); // rabbit 那这里为什么会有区别呢？ -实际上,原因在于属性加载的顺序。类属性是如下加载的: +实际上，原因在于字段初始化的顺序。类字段是这样初始化的： - 在基类被构造前加载(不继承任何类的那种)。 - 对于被派生类,在调用 `super()`后立刻加载。 From 68bad14e29d13490c0ae0309a96114e2876c627b Mon Sep 17 00:00:00 2001 From: zomb_676 Date: Fri, 4 Sep 2020 21:58:29 +0800 Subject: [PATCH 31/38] Update 1-js/09-classes/02-class-inheritance/article.md Co-authored-by: Martin --- 1-js/09-classes/02-class-inheritance/article.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/1-js/09-classes/02-class-inheritance/article.md b/1-js/09-classes/02-class-inheritance/article.md index 9c8dac8427..647f2ddc46 100644 --- a/1-js/09-classes/02-class-inheritance/article.md +++ b/1-js/09-classes/02-class-inheritance/article.md @@ -364,7 +364,7 @@ new Rabbit(); // rabbit 实际上，原因在于字段初始化的顺序。类字段是这样初始化的： - 在基类被构造前加载(不继承任何类的那种)。 -- 对于被派生类,在调用 `super()`后立刻加载。 +- 对于派生类，在调用 `super()` 后立刻初始化。 在我们这种情况下, `Rabbit`是被派生类,这里面没有 `constructor()`。正如先前所说,如果这里面只有一个空的构造器,里面只有`super(...args)`,那么这是相同的。 From b1c343734124294aa09129384bc50a442c018c4e Mon Sep 17 00:00:00 2001 From: zomb_676 Date: Fri, 4 Sep 2020 21:58:51 +0800 Subject: [PATCH 32/38] Update 1-js/09-classes/02-class-inheritance/article.md Co-authored-by: Martin --- 1-js/09-classes/02-class-inheritance/article.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/1-js/09-classes/02-class-inheritance/article.md b/1-js/09-classes/02-class-inheritance/article.md index 647f2ddc46..b2aa13f117 100644 --- a/1-js/09-classes/02-class-inheritance/article.md +++ b/1-js/09-classes/02-class-inheritance/article.md @@ -363,7 +363,7 @@ new Rabbit(); // rabbit 那这里为什么会有区别呢？ 实际上，原因在于字段初始化的顺序。类字段是这样初始化的： -- 在基类被构造前加载(不继承任何类的那种)。 +- 在基类（不继承任何类的那种）被构造前初始化。 - 对于派生类，在调用 `super()` 后立刻初始化。 在我们这种情况下, `Rabbit`是被派生类,这里面没有 `constructor()`。正如先前所说,如果这里面只有一个空的构造器,里面只有`super(...args)`,那么这是相同的。 From 420f9c091777f05ced2c04fbf7c8cd0d6a36e0ff Mon Sep 17 00:00:00 2001 From: zomb_676 Date: Fri, 4 Sep 2020 21:59:11 +0800 Subject: [PATCH 33/38] Update 1-js/09-classes/02-class-inheritance/article.md Co-authored-by: Martin --- 1-js/09-classes/02-class-inheritance/article.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/1-js/09-classes/02-class-inheritance/article.md b/1-js/09-classes/02-class-inheritance/article.md index b2aa13f117..2665008491 100644 --- a/1-js/09-classes/02-class-inheritance/article.md +++ b/1-js/09-classes/02-class-inheritance/article.md @@ -366,7 +366,7 @@ new Rabbit(); // rabbit - 在基类（不继承任何类的那种）被构造前初始化。 - 对于派生类，在调用 `super()` 后立刻初始化。 -在我们这种情况下, `Rabbit`是被派生类,这里面没有 `constructor()`。正如先前所说,如果这里面只有一个空的构造器,里面只有`super(...args)`,那么这是相同的。 +在例子中，`Rabbit` 是派生类，里面没有 `constructor()`。正如先前所说，这相当于一个里面只有`super(...args)`的空构造器。 所以，`new Rabbit()` 调用了 `super()`，因此它执行了父类构造器，并且（根据派生类规则）只有在此之后，它的类字段才被初始化。在父类构造器被执行的时候，`Rabbit` 还没有自己的类字段，这就是为什么`Animal` 类字段被使用了。 From 26e70c7498e40c1a82c81cdd0de0bcd4213e0965 Mon Sep 17 00:00:00 2001 From: zomb_676 Date: Wed, 9 Sep 2020 13:38:37 +0800 Subject: [PATCH 34/38] Update 1-js/09-classes/02-class-inheritance/article.md Co-authored-by: Martin --- 1-js/09-classes/02-class-inheritance/article.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/1-js/09-classes/02-class-inheritance/article.md b/1-js/09-classes/02-class-inheritance/article.md index 2665008491..f8456c1753 100644 --- a/1-js/09-classes/02-class-inheritance/article.md +++ b/1-js/09-classes/02-class-inheritance/article.md @@ -372,7 +372,7 @@ new Rabbit(); // rabbit 这种字段与方法之间微妙的区别只特定于 JavaScript。 -幸运的是,这种行为仅在一个被重写的属性被父类构造器使用时显示出来。接下来它会发生什么就很难理解了,所以我们在这里解释它。 +幸运的是，这种行为仅在一个被重写的字段被父类构造器使用时显现出来。接下来它会发生什么可能就很难理解了，所以我们要在这里对此行为进行解释。 如果它成为了一个问题,我们可以通过使用方法或者getter/setter而不是属性来修复它。 From e492f3d1b7f3c05e56f3c5838bda5903c5ddb3c5 Mon Sep 17 00:00:00 2001 From: zomb_676 Date: Wed, 9 Sep 2020 13:38:51 +0800 Subject: [PATCH 35/38] Update 1-js/09-classes/02-class-inheritance/article.md Co-authored-by: Martin --- 1-js/09-classes/02-class-inheritance/article.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/1-js/09-classes/02-class-inheritance/article.md b/1-js/09-classes/02-class-inheritance/article.md index f8456c1753..79e1634c09 100644 --- a/1-js/09-classes/02-class-inheritance/article.md +++ b/1-js/09-classes/02-class-inheritance/article.md @@ -374,7 +374,7 @@ new Rabbit(); // rabbit 幸运的是，这种行为仅在一个被重写的字段被父类构造器使用时显现出来。接下来它会发生什么可能就很难理解了，所以我们要在这里对此行为进行解释。 -如果它成为了一个问题,我们可以通过使用方法或者getter/setter而不是属性来修复它。 +如果出问题了，我们可以通过使用方法或者 getter/setter 而不是类字段来修复。 ## 深入：内部探究和 [[HomeObject]] From dd29184994b27bcb4fa2e34309967a6acc870e4f Mon Sep 17 00:00:00 2001 From: LeviDing Date: Tue, 22 Sep 2020 15:23:13 +0800 Subject: [PATCH 36/38] Improve: translation --- 1-js/09-classes/01-class/article.md | 12 ++++++------ 1 file changed, 6 insertions(+), 6 deletions(-) diff --git a/1-js/09-classes/01-class/article.md b/1-js/09-classes/01-class/article.md index 3e486445b7..50623a102b 100644 --- a/1-js/09-classes/01-class/article.md +++ b/1-js/09-classes/01-class/article.md @@ -267,7 +267,7 @@ alert(user.name); // John user = new User(""); // Name is too short. ``` -从技术上来讲，这样的类声明可以通过在 `User.prototype` 中创建 getters 和 setters 奏效。 +从技术上来讲，这样的类声明可以通过在 `User.prototype` 中创建 getters 和 setters 来实现。 ## 计算属性名称 [...] @@ -287,7 +287,7 @@ class User { new User().sayHi(); ``` -这种特性容易记忆，因为他们与字面量对象相似。 +这种特性很容易记住，因为它们和对象字面量类似。 ## Class 字段 @@ -315,9 +315,9 @@ class User { new User().sayHi(); // Hello, John! ``` -所以，我们就只需在表达式中书写 " = " ，就这样。 +所以，我们就只需在表达式中写 " = "，就这样。 -类字段的重要不同之处在于，他们会在每个独立对象中被设好，而不是设在了 `User.prototype`： +类字段重要的不同之处在于，它们会在每个独立对象中被设好，而不是设在 `User.prototype`： ```js run class User { @@ -331,7 +331,7 @@ alert(user.name); // John alert(User.prototype.name); // undefined ``` -我们也可以在赋值时使用更加复杂的表达式和函数调用： +我们也可以在赋值时使用更复杂的表达式和函数调用： ```js run class User { @@ -397,7 +397,7 @@ let button = new Button("hello"); setTimeout(button.click, 1000); // hello ``` -类字段 `click = () => {...}`是基于每一个对象被创建的，在这里对于每一个 `Button` 对象都有一个独立的方法，在内部有一个`this`指向此对象。我们可以在任何地方传递`button.click`，并且`this`的值总是正确的。 +类字段 `click = () => {...}` 是基于每一个对象被创建的，在这里对于每一个 `Button` 对象都有一个独立的方法，在内部都有一个指向此对象的 `this`。我们可以把 `button.click` 传递到任何地方，而且 `this` 的值总是正确的。 在浏览器环境中，它对于进行事件监听尤为有用。 From 8b0abdef2abea3123df44df99cebc44144e07901 Mon Sep 17 00:00:00 2001 From: LeviDing Date: Tue, 22 Sep 2020 16:42:45 +0800 Subject: [PATCH 37/38] Improve: translation --- .../02-class-inheritance/article.md | 44 +++++++++---------- 1 file changed, 22 insertions(+), 22 deletions(-) diff --git a/1-js/09-classes/02-class-inheritance/article.md b/1-js/09-classes/02-class-inheritance/article.md index 79e1634c09..d866a9892a 100644 --- a/1-js/09-classes/02-class-inheritance/article.md +++ b/1-js/09-classes/02-class-inheritance/article.md @@ -284,17 +284,17 @@ alert(rabbit.earLength); // 10 ### 重写类字段: 一个棘手的注意要点 -```warn header="高级的注意要点" -这个注意要点假设你或许在其他编程语言中有一定的关于类的经验。 +```warn header="高阶要点" +这个要点假设你对类已经有了一定的经验，或许是在其他编程语言中。 -这里提供了一个更好的视角来窥探这门语言并且解释了它的行为为什么可能会是 bugs 的来源(但是不是非常频繁)。 +这里提供了一个更好的视角来窥探这门语言，且解释了它的行为为什么可能会是 bugs 的来源(但不是非常频繁)。 -如果你发现这难以理解，什么都别管，继续往下阅读，之后再回到这里。 +如果你发现这难以理解，什么都别管，继续往下阅读，之后有机会再回来看。 ``` -我们可以重写的不仅是方法，还有类字段。 +我们不仅可以重写方法，还可以重写类字段。 -不过，当我们访问在父类构造器中一个被重写的字段时，这里会有一个诡异的行为，这与绝大多数其他编程语言很不一样。 +不过，当我们访问在父类构造器中的一个被重写的字段时，这里会有一个诡异的行为，这与绝大多数其他编程语言都很不一样。 请思考此示例： @@ -317,28 +317,28 @@ new Rabbit(); // animal */!* ``` -这里，`Rabbit` 继承自 `Animal` 并且用它自己的值重写了 `name` 字段。 +这里，`Rabbit` 继承自 `Animal`，并且用它自己的值重写了 `name` 字段。 -因为 `Rabbit` 中没用自己的构造器，所以 `Animal` 的构造器被调用了。 +因为 `Rabbit` 中没有自己的构造器，所以 `Animal` 的构造器被调用了。 -有趣的是在两种情况下 `new Animal()` 和 `new Rabbit()`，在 `(*)` 的 `alert` 都打印了 `animal`。 +有趣的是在这两种情况下：`new Animal()` 和 `new Rabbit()`，在 `(*)` 行的 `alert` 都打印了 `animal`。 **换句话说， 父类构造器总是会使用它自己字段的值，而不是被重写的那一个。** 古怪的是什么呢？ -如果这还不清楚，那么让我们用方法来比较。 +如果这还不清楚，那么让我们用方法来进行比较。 这里是相同的代码，但是我们调用 `this.showName()` 方法而不是 `this.name` 字段： ```js run class Animal { - showName() { // instead of this.name = 'animal' + showName() { // 而不是 this.name = 'animal' alert('animal'); } constructor() { - this.showName(); // instead of alert(this.name); + this.showName(); // 而不是 alert(this.name); } } @@ -354,27 +354,27 @@ new Rabbit(); // rabbit */!* ``` -请注意，这时的输出是不同的。 +请注意：这时的输出是不同的。 -这才是我们本来所期待的结果。当父类构造器在被派生的类中被调用时，它会使用被重写的方法。 +这才是我们本来所期待的结果。当父类构造器在派生的类中被调用时，它会使用被重写的方法。 -……但是对于类字段，并非如此。正如前文所述，父类构造器总是使用父类的字段。 +……但对于类字段并非如此。正如前文所述，父类构造器总是使用父类的字段。 -那这里为什么会有区别呢？ +这里为什么会有这样的区别呢？ 实际上，原因在于字段初始化的顺序。类字段是这样初始化的： -- 在基类（不继承任何类的那种）被构造前初始化。 -- 对于派生类，在调用 `super()` 后立刻初始化。 +- 在基类（还未继承任何东西的那种）被构造前初始化。 +- 对于派生类，在 `super()` 后立刻初始化。 -在例子中，`Rabbit` 是派生类，里面没有 `constructor()`。正如先前所说，这相当于一个里面只有`super(...args)`的空构造器。 +在我们的例子中，`Rabbit` 是派生类，里面没有 `constructor()`。正如先前所说，这相当于一个里面只有 `super(...args)` 的空构造器。 -所以，`new Rabbit()` 调用了 `super()`，因此它执行了父类构造器，并且（根据派生类规则）只有在此之后，它的类字段才被初始化。在父类构造器被执行的时候，`Rabbit` 还没有自己的类字段，这就是为什么`Animal` 类字段被使用了。 +所以，`new Rabbit()` 调用了 `super()`，因此它执行了父类构造器，并且（根据派生类规则）只有在此之后，它的类字段才被初始化。在父类构造器被执行的时候，`Rabbit` 还没有自己的类字段，这就是为什么 `Animal` 类字段被使用了。 这种字段与方法之间微妙的区别只特定于 JavaScript。 -幸运的是，这种行为仅在一个被重写的字段被父类构造器使用时显现出来。接下来它会发生什么可能就很难理解了，所以我们要在这里对此行为进行解释。 +幸运的是，这种行为仅在一个被重写的字段被父类构造器使用时才会显现出来。接下来它会发生的东西可能就比较难理解了，所以我们要在这里对此行为进行解释。 -如果出问题了，我们可以通过使用方法或者 getter/setter 而不是类字段来修复。 +如果出问题了，我们可以通过使用方法或者 getter/setter 来替代类字段，以修复这个问题。 ## 深入：内部探究和 [[HomeObject]] From 562215b05f5a4c67110d3a7ccacf85cb24e351a4 Mon Sep 17 00:00:00 2001 From: LeviDing Date: Tue, 22 Sep 2020 16:43:53 +0800 Subject: [PATCH 38/38] Update article.md --- 1-js/09-classes/02-class-inheritance/article.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/1-js/09-classes/02-class-inheritance/article.md b/1-js/09-classes/02-class-inheritance/article.md index d866a9892a..f1f266b3af 100644 --- a/1-js/09-classes/02-class-inheritance/article.md +++ b/1-js/09-classes/02-class-inheritance/article.md @@ -374,7 +374,7 @@ new Rabbit(); // rabbit 幸运的是，这种行为仅在一个被重写的字段被父类构造器使用时才会显现出来。接下来它会发生的东西可能就比较难理解了，所以我们要在这里对此行为进行解释。 -如果出问题了，我们可以通过使用方法或者 getter/setter 来替代类字段，以修复这个问题。 +如果出问题了，我们可以通过使用方法或者 getter/setter 替代类字段，来修复这个问题。 ## 深入：内部探究和 [[HomeObject]]