修正翻译

Author: ish-kafel

1-js/09-classes/04-private-protected-properties-methods/article.md

@@ -1,7 +1,7 @@
 
 # 私有的和受保护的属性和方法
 
-面向对象编程最重要的原则之一——划分出外部接口和内部接口。
+面向对象编程最重要的原则之一 —— 划分出外部接口和内部接口。
 
 在开发比 “hello world” 应用更复杂的东西时，这是“必须”的做法。
 
@@ -11,7 +11,7 @@
 
 ## 一个真实的例子
 
-例如咖啡机。从外面看很简单：一个按钮，一个显示器，几个洞……当然，结果就是——很棒的咖啡！:)
+例如咖啡机。从外面看很简单：一个按钮，一个显示器，几个洞……当然，结果就是 —— 很棒的咖啡！:)
 
 ![](coffee.jpg)
 
@@ -21,9 +21,9 @@
 
 有很多细节。但我们可以在不了解的情况下使用它。
 
-咖啡机非常可靠，不是吗？我们可以使用好几年，只有在出现问题时——进行维修。
+咖啡机非常可靠，不是吗？我们可以使用好几年，只有在出现问题时 —— 进行维修。
 
-咖啡机的可靠性和简洁性的秘诀——所有细节都经过精心调整并 *隐藏* 在内部。
+咖啡机的可靠性和简洁性的秘诀 —— 所有细节都经过精心调整并 **隐藏** 在内部。
 
 如果我们从咖啡机上取下保护盖，那么使用它将会复杂得多（要按哪里？），并且危险（会触电）。
 
@@ -35,10 +35,10 @@
 
 在面向对象的编程中，属性和方法分为两组：
 
-- *内部接口* —— 可以通过类的其他方法访问，但不能从外部访问的方法和属性。
-- *外部接口* —— 也可从类的外部访问的方法和属性。
+- **内部接口** —— 可以通过类的其他方法访问，但不能从外部访问的方法和属性。
+- **外部接口** —— 也可从类的外部访问的方法和属性。
 
-如果我们继续用咖啡机进行类比——内部隐藏的内容：锅炉管，加热元件等——是其内部的接口。
+如果我们继续用咖啡机进行类比 —— 内部隐藏的内容：锅炉管，加热元件等 —— 是其内部的接口。
 
 内部接口用于对象，它的细节相互使用。例如，锅炉管连接到加热元件。
 
@@ -48,18 +48,18 @@
 
 这是个概括的介绍。
 
-在 JavaScript 中，有两种类型的对象字段（属性和成员）：
+在 JavaScript 中，有两种类型的对象字段（属性和方法）：
 
 - 公共的：可从任何地方访问。它们包含外部接口。直到现在我们只使用公共属性和方法。
 - 私有的：只能从类的内部访问。这些用于内部接口。
 
 在许多其他语言中，还存在“受保护”的字段：只能从类的内部访问和扩展它们（类似私有的，但是加上了向继承的类的访问）。它们对内部接口也很有用。它们在某种意义上比私有的属性和方法更广泛，因为我们通常希望继承类来获得正确执行扩展的访问权限。
 
-受保护的字段不是在语言级别的 Javascript 中实现的，但实际上它们非常方便，因此它们是模拟（这里求校对）的。
+受保护的字段不是在 Javascript 语言级别上实现的，但实际上它们非常方便，因为它们是在 Javascript 中模拟的类定义语法。
 
 现在，我们将使用所有这些类型的属性在 Javascript 中制作咖啡机。咖啡机有很多细节，我们不会对它们进行全面模拟以保持简洁（尽管我们可以）。
 
-## 受保护的 “waterAmount”
+## 受保护的“waterAmount”
 
 让我们先做一个简单的咖啡机类：
 
@@ -117,9 +117,9 @@ let coffeeMachine = new CoffeeMachine(100);
 coffeeMachine.waterAmount = -10; // Error: Negative water
 ```
 
-现在访问受到控制，因此将水量设置为小于零的数失败了。
+现在访问受到控制，因此将水量设置为小于零的数将会失败。
 
-## 只读的 “power”
+## 只读的“power”
 
 对于 `power` 属性，让我们将它设为只读的。有时候一个属性必须仅在创建时设置，然后不再修改。
 
@@ -144,12 +144,12 @@ class CoffeeMachine {
 // 创建咖啡机
 let coffeeMachine = new CoffeeMachine(100);
 
-alert(`Power is: ${coffeeMachine.power}W`); // 功率是100W
+alert(`Power is: ${coffeeMachine.power}W`); // 功率是：100W
 
 coffeeMachine.power = 25; // Error (no setter)
 ```
 
-````smart header="Getter/setter 功能"
+````smart header="Getter/setter 函数"
 这里我们使用 getter/setter 语法。
 
 但大多数时候首选 `get.../set...` 函数，像这样：
@@ -182,7 +182,7 @@ new CoffeeMachine().setWaterAmount(100);
 所以受保护的字段是自然可继承的。不像我们接下来将看到的私有字段。
 ```
 
-## 私有的 “#waterLimit”
+## 私有的“#waterLimit”
 
 [recent browser=none]
 
@@ -205,19 +205,6 @@ class CoffeeMachine {
   }
 */!*
 
-  _waterAmount = 0;
-
-  set waterAmount(value) {
-*!*
-    this.#checkWater(value);
-*/!*
-    this._waterAmount = value;
-  }
-
-  get waterAmount() {
-    return this._waterAmount;
-  }
-
 }
 
 let coffeeMachine = new CoffeeMachine();
@@ -264,7 +251,7 @@ alert(machine.#waterAmount); // Error
 class MegaCoffeeMachine extends CoffeeMachine() {
   method() {
 *!*
-    alert( this.#waterAmount ); // Error: can only access from CoffeeMachine
+    alert( this.#waterAmount ); // 错误：只能从 CoffeeMachine 中访问
 */!*
   }
 }
@@ -275,7 +262,7 @@ class MegaCoffeeMachine extends CoffeeMachine() {
 ````warn header="私有字段不能通过 this[name] 访问"
 私有字段很特别。
 
-如我们所知，通常我们可以使用 this[name] 访问字段：
+如我们所知，通常我们可以使用 `this[name]` 访问字段：
 
 ```js
 class User {
@@ -297,13 +284,13 @@ class User {
 它具有以下优点：
 
 保护用户，使他们不会误伤自己
-: 想象一下，有一群开发人员使用咖啡机。它是由 “Best CoffeeMachine” 公司制造的，工作正常，但保护盖被拿走了。因此内部接口暴露了出来。
+: 想象一下，有一群开发人员使用咖啡机。它是由“Best CoffeeMachine”公司制造的，工作正常，但保护盖被拿走了。因此内部接口暴露了出来。
 
-    所有的开发人员都是文明的——他们按照预期使用咖啡机。但其中一个人，约翰，被认为是最聪明的，并且决定让他在咖啡机内部做一些调整。然而咖啡机两天后就坏了。
+    所有的开发人员都是文明的 —— 他们按照预期使用咖啡机。但其中一个人，约翰，被认为是最聪明的，并且决定让他在咖啡机内部做一些调整。然而咖啡机两天后就坏了。
 
-    这肯定不是约翰的错，而是那个取下保护套并让约翰执行自己操作的人。
+    这肯定不是约翰的错，而是那个取下保护套并让约翰执行自己操作的人的错。
 
-    编程也一样。如果一个类的使用者想要改变那些本不打算从外部改变的东西——后果是不可预测的。
+    编程也一样。如果一个类的使用者想要改变那些本不打算从外部改变的东西 —— 后果是不可预测的。
 
 可支持的
 : 编程的情况比现实生活中的咖啡机更复杂，因为我们不只是购买一次。代码不断经历着发展和改进。
@@ -321,7 +308,7 @@ class User {
 
     **隐藏实施细节时总是很方便，并且提供了一个简单的，记录详细的外部接口。**
 
-为了隐藏内部接口，我们使用受保护的或公共的属性：
+为了隐藏内部接口，我们使用受保护的或私有的属性：
 
 - 受保护的字段以 `_` 开头。这是一个众所周知的惯例，没有在语言层面强制执行。程序员只应该通过它的类和它继承的类中访问以 `_` 开头的字段。
 - 私有字段以 `#` 开头。JavaScript 确保我们只能访问类中的内容。