Declutterfier! Saves Data!

--- a PPN by Garber Painting Akron. With Image Size Reduction included!

URL: http://github.com/javascript-tutorial/zh.javascript.info/pull/451.patch

��必须仅在创建时设置，然后不再修改。 -That's exactly the case for a coffee machine: power never changes. +这就是咖啡机的实际情况：功率永远不会改变。 -To do so, we only need to make getter, but not the setter: +要做到这一点，我们只需要设置 getter，而不是 setter： ```js run class CoffeeMachine { @@ -141,18 +141,18 @@ class CoffeeMachine { } -// create the coffee machine +// 创建咖啡机 let coffeeMachine = new CoffeeMachine(100); -alert(`Power is: ${coffeeMachine.power}W`); // Power is: 100W +alert(`Power is: ${coffeeMachine.power}W`); // 功率是100W coffeeMachine.power = 25; // Error (no setter) ``` -````smart header="Getter/setter functions" -Here we used getter/setter syntax. +````smart header="Getter/setter 功能" +这里我们使用 getter/setter 语法。 -But most of the time `get.../set...` functions are preferred, like this: +但大多数时候首选 `get.../set...` 函数，像这样： ```js class CoffeeMachine { @@ -171,26 +171,26 @@ class CoffeeMachine { new CoffeeMachine().setWaterAmount(100); ``` -That looks a bit longer, but functions are more flexible. They can accept multiple arguments (even if we don't need them right now). So, for the future, just in case we need to refactor something, functions are a safer choice. +这看起来有点长，但函数更灵活。他们可以接受多个参数（即使我们现在不需要它们）。因此，万一以后我们需要重构某些东西，函数是更安全的选择。 -Surely, there's a tradeoff. On the other hand, get/set syntax is shorter, so ultimately there's no strict rule, it's up to you to decide. +当然，这是一种权衡的选择。另一方面，get/set 语法更短，所以最终没有严格的规则，而是由你自己来决定。 ```` -```smart header="Protected fields are inherited" -If we inherit `class MegaMachine extends CoffeeMachine`, then nothing prevents us from accessing `this._waterAmount` or `this._power` from the methods of the new class. +```smart header="受保护的字段是继承的" +如果我们继承 `class MegaMachine extends CoffeeMachine`，那么无法阻止我们从新的类中的方法访问 `this._waterAmount` 或 `this._power`。 -So protected fields are naturally inheritable. Unlike private ones that we'll see below. +所以受保护的字段是自然可继承的。不像我们接下来将看到的私有字段。 ``` -## Private "#waterLimit" +## 私有的 “#waterLimit” [recent browser=none] -There's a finished JavaScript proposal, almost in the standard, that provides language-level support for private properties and methods. +在标准中几乎有个已完成的 Javascript 提案，它为私有属性和方法提供语言级支持。 -Privates should start with `#`. They are only accessible from inside the class. +私有属性和方法应该以 `#` 开头。他们只能从类的内部访问。 -For instance, here we add a private `#waterLimit` property and extract the water-checking logic into a separate method: +例如，在这里我们添加一个私有属性 `#waterLimit`，并将检查水量的逻辑提取到一个单独的方法中： ```js class CoffeeMachine { @@ -223,18 +223,18 @@ class CoffeeMachine { let coffeeMachine = new CoffeeMachine(); *!* -coffeeMachine.#checkWater(); // Error -coffeeMachine.#waterLimit = 1000; // Error +coffeeMachine.#checkWater(); // 无效 +coffeeMachine.#waterLimit = 1000; // 无效 */!* -coffeeMachine.waterAmount = 100; // Works +coffeeMachine.waterAmount = 100; // 有效 ``` -On the language level, `#` is a special sign that the field is private. We can't access it from outside or from inheriting classes. +在语言层面，`#` 是该字段为私有的特殊标志。我们无法从外部或从继承的类中访问它。 -Private fields do not conflict with public ones. We can have both private `#waterAmount` and public `waterAmount` fields at the same time. +私有字段不与公共字段发生冲突。我们可以同时拥有私有属性 `#waterAmount` 和公共属性 `waterAmount`。 -For instance, let's make `waterAmount` an accessor for `#waterAmount`: +例如，让 `waterAmount` 成为 `#waterAmount` 的访问器： ```js run class CoffeeMachine { @@ -257,9 +257,9 @@ machine.waterAmount = 100; alert(machine.#waterAmount); // Error ``` -Unlike protected ones, private fields are enforced by the language itself. That's a good thing. +与受保护的字段不同，私有字段由语言本身强制执行。这是好事。 -But if we inherit from `CoffeeMachine`, then we'll have no direct access to `#waterAmount`. We'll need to rely on `waterAmount` getter/setter: +但是如果我们继承 `CoffeeMachine`，那么我们将无法直接访问 `#waterAmount`。我们需要依赖 `waterAmount` getter / setter： ```js class MegaCoffeeMachine extends CoffeeMachine() { @@ -271,12 +271,12 @@ class MegaCoffeeMachine extends CoffeeMachine() { } ``` -In many scenarios such limitation is too severe. If we extend a `CoffeeMachine`, we may have legitimate reason to access its internals. That's why protected fields are used most of the time, even though they are not supported by the language syntax. +在许多情况下，这种限制太严重了。如果我们扩展一个 `CoffeeMachine`，我们可能有正当理由访问其内部。这就是为什么大多数时候都会使用受保护字段的原因，即使它们不受语言语法的支持。 ````warn -Private fields are special. +私有字段很特别。 -Remember, usually we can access fields by this[name]: +请记住，通常我们可以通过 this[name] 访问字段： ```js class User { @@ -288,43 +288,43 @@ class User { } ``` -With private fields that's impossible: `this['#name']` doesn't work. That's a syntax limitation to ensure privacy. +私有字段是不可能的： `this['#name']` 不起作用。这是确保私有性的语法限制。 ```` -## Summary +## 总结 -In terms of OOP, delimiting of the internal interface from the external one is called [encapsulation]("https://en.wikipedia.org/wiki/Encapsulation_(computer_programming)"). +就面向对象编程（OOP）而言，内部接口与外部接口的划分称为[封装]("https://en.wikipedia.org/wiki/Encapsulation_(computer_programming)")。 -It gives the following benefits: +它具有以下优点： -Protection for users, so that they don't shoot themselves in the feet -: Imagine, there's a team of developers using a coffee machine. It was made by the "Best CoffeeMachine" company, and works fine, but a protective cover was removed. So the internal interface is exposed. +保护用户，使他们不会误伤自己 +: 想象一下，有一群开发人员使用咖啡机。它是由 “Best CoffeeMachine” 公司制造的，工作正常，但保护盖被拿走了。因此内部接口暴露了出来。 - All developers are civilized -- they use the coffee machine as intended. But one of them, John, decided that he's the smartest one, and made some tweaks in the coffee machine internals. So the coffee machine failed two days later. + 所有的开发人员都是文明的——他们按照预期使用咖啡机。但其中一个人，约翰，被认为是最聪明的，并且决定让他在咖啡机内部做一些调整。然而咖啡机两天后就坏了。 - That's surely not John's fault, but rather the person who removed the protective cover and let John do his manipulations. + 这肯定不是约翰的错，而是那个取下保护套并让约翰执行自己操作的人。 - The same in programming. If a user of a class will change things not intended to be changed from the outside -- the consequences are unpredictable. + 编程也一样。如果一个类的使用者想要改变那些本不打算从外部改变的东西——后果是不可预测的。 -Supportable -: The situation in programming is more complex than with a real-life coffee machine, because we don't just buy it once. The code constantly undergoes development and improvement. +可支持的 +: 编程的情况比现实生活中的咖啡机更复杂，因为我们不只是购买一次。代码不断经历着发展和改进。 - **If we strictly delimit the internal interface, then the developer of the class can freely change its internal properties and methods, even without informing the users..** + **如果我们严格界定内部接口，那么类的开发人员可以自由地更改其内部属性和方法，即使没有通知用户…** - It's much easier to develop, if you know that certain methods can be renamed, their parameters can be changed, and even removed, because no external code depends on them. + 如果你知道由于没有外部代码的依赖，某些方法可以重命名，它们的参数可以改变，甚至可以删除，这样的话开发起来要容易得多。 - For users, when a new version comes out, it may be a total overhaul, but still simple to upgrade if the external interface is the same. + 对于使用者来说，当新版本出现时，它可能是全面的检修，但如果外部接口相同，则仍然很容易升级。 -Hiding complexity -: People adore to use things that are simple. At least from outside. What's inside is a different thing. +隐藏复杂性 +: 人们喜欢使用简单的东西。至少从外部来看是这样。内部的东西则是另外一回事了。 - Programmers are not an exception. + 程序员也不例外。 - **It's always convenient when implementation details are hidden, and a simple, well-documented external interface is available.** + **隐藏实施细节时总是很方便，并且提供了一个简单的，记录详细的外部接口。** -To hide internal interface we use either protected or public properties: +为了隐藏内部接口，我们使用受保护的或公共的属性： -- Protected fields start with `_`. That's a well-known convention, not enforced at the language level. Programmers should only access a field starting with `_` from its class and classes inheriting from it. -- Private fields start with `#`. JavaScript makes sure we only can access those from inside the class. +- 受保护的字段以 `_` 开头。这是一个众所周知的惯例，没有在语言层面强制执行。程序员只应该通过它的类和它继承的类中访问以 `_` 开头的字段。 +- 私有字段以 `#` 开头。JavaScript 确保我们只能访问类中的内容。 -Right now, private fields are not well-supported among browsers, but can be polyfilled. +目前，在各浏览器中不支持私有字段，但可以用 polyfill 解决。 From 6353ee155a8ce3c594fa34905d5755c0bf17d9c0 Mon Sep 17 00:00:00 2001 From: ish-kafel <1136461977@qq.com> Date: Thu, 15 Aug 2019 08:39:37 +0800 Subject: [PATCH 2/3] Update article.md MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit 同步英文版 --- .../article.md | 35 +++++++++---------- 1 file changed, 17 insertions(+), 18 deletions(-) diff --git a/1-js/09-classes/04-private-protected-properties-methods/article.md b/1-js/09-classes/04-private-protected-properties-methods/article.md index c57f6a923b..7aca962032 100644 --- a/1-js/09-classes/04-private-protected-properties-methods/article.md +++ b/1-js/09-classes/04-private-protected-properties-methods/article.md @@ -48,16 +48,16 @@ 这是个概括的介绍。 -在 JavaScript 中，有三种类型的属性和成员： +在 JavaScript 中，有两种类型的对象字段（属性和成员）： - 公共的：可从任何地方访问。它们包含外部接口。直到现在我们只使用公共属性和方法。 - 私有的：只能从类的内部访问。这些用于内部接口。 -在许多其他语言中，还存在“受保护”的字段：只能从类的内部访问和扩展它们。它们对内部接口也很有用。它们在某种意义上比私有的属性和方法更广泛，因为我们通常希望继承类来获得正确执行扩展的访问权限。 +在许多其他语言中，还存在“受保护”的字段：只能从类的内部访问和扩展它们（类似私有的，但是加上了向继承的类的访问）。它们对内部接口也很有用。它们在某种意义上比私有的属性和方法更广泛，因为我们通常希望继承类来获得正确执行扩展的访问权限。受保护的字段不是在语言级别的 Javascript 中实现的，但实际上它们非常方便，因此它们是模拟（这里求校对）的。 -在下一步中，我们将使用所有这些类型的属性在 Javascript 中制作咖啡机。咖啡机有很多细节，我们不会对它们进行全面模拟以保持简洁（尽管我们可以）。 +现在，我们将使用所有这些类型的属性在 Javascript 中制作咖啡机。咖啡机有很多细节，我们不会对它们进行全面模拟以保持简洁（尽管我们可以）。 ## 受保护的 “waterAmount” @@ -87,7 +87,7 @@ coffeeMachine.waterAmount = 200; **受保护的属性通常以下划线 `_` 作为前缀。** -这不是在语言层面强制实施的，但是有一种惯例是不应该从外部访问这些属性和方法。大多数程序员都遵循它。 +这不是在语言层面强制实施的，但是有一个在程序员之间人尽皆知的惯例是不应该从外部访问这些属性和方法。所以我们的属性将被称为 `_waterAmount` ： @@ -171,9 +171,9 @@ class CoffeeMachine { new CoffeeMachine().setWaterAmount(100); ``` -这看起来有点长，但函数更灵活。他们可以接受多个参数（即使我们现在不需要它们）。因此，万一以后我们需要重构某些东西，函数是更安全的选择。 +这看起来有点长，但函数更灵活。他们可以接受多个参数（即使我们现在不需要它们）。 -当然，这是一种权衡的选择。另一方面，get/set 语法更短，所以最终没有严格的规则，而是由你自己来决定。 +另一方面，get/set 语法更短，所以最终没有严格的规则，而是由你自己来决定。 ```` ```smart header="受保护的字段是继承的" @@ -190,9 +190,9 @@ new CoffeeMachine().setWaterAmount(100); 私有属性和方法应该以 `#` 开头。他们只能从类的内部访问。 -例如，在这里我们添加一个私有属性 `#waterLimit`，并将检查水量的逻辑提取到一个单独的方法中： +例如，这有一个私有属性 `#waterLimit`，以及检查水量的私有方法 `#checkWater`： -```js +```js run class CoffeeMachine { *!* #waterLimit = 200; @@ -223,11 +223,10 @@ class CoffeeMachine { let coffeeMachine = new CoffeeMachine(); *!* -coffeeMachine.#checkWater(); // 无效 -coffeeMachine.#waterLimit = 1000; // 无效 +// 不能从类的外部访问其私有方法 +coffeeMachine.#checkWater(); // Error +coffeeMachine.#waterLimit = 1000; // Error */!* - -coffeeMachine.waterAmount = 100; // 有效 ``` 在语言层面，`#` 是该字段为私有的特殊标志。我们无法从外部或从继承的类中访问它。 @@ -273,17 +272,17 @@ class MegaCoffeeMachine extends CoffeeMachine() { 在许多情况下，这种限制太严重了。如果我们扩展一个 `CoffeeMachine`，我们可能有正当理由访问其内部。这就是为什么大多数时候都会使用受保护字段的原因，即使它们不受语言语法的支持。 -````warn +````warn header="私有字段不能通过 this[name] 访问" 私有字段很特别。 -请记住，通常我们可以通过 this[name] 访问字段： +如我们所知，通常我们可以使用 this[name] 访问字段： ```js class User { ... sayHi() { let fieldName = "name"; - alert(`Hello, ${this[fieldName]}`); + alert(`Hello, ${*!*this[fieldName]*/!*}`); } } ``` @@ -309,11 +308,11 @@ class User { 可支持的 : 编程的情况比现实生活中的咖啡机更复杂，因为我们不只是购买一次。代码不断经历着发展和改进。 - **如果我们严格界定内部接口，那么类的开发人员可以自由地更改其内部属性和方法，即使没有通知用户…** + **如果我们严格界定内部接口，那么类的开发人员可以自由地更改其内部属性和方法，即使没有通知用户。** - 如果你知道由于没有外部代码的依赖，某些方法可以重命名，它们的参数可以改变，甚至可以删除，这样的话开发起来要容易得多。 + 如果你是这样的类的开发者，当知道由于没有外部代码的依赖，私有方法可以安全地重命名，它们的参数可以改变，甚至可以删除是很棒的事。 - 对于使用者来说，当新版本出现时，它可能是全面的检修，但如果外部接口相同，则仍然很容易升级。 + 对于使用者来说，当新版本出现时，它可能是全面的内部检查，但如果外部接口相同，则仍然很容易升级。隐藏复杂性 : 人们喜欢使用简单的东西。至少从外部来看是这样。内部的东西则是另外一回事了。 From 86eb69a5d153a3d8f1c015f268593ba45d15a67f Mon Sep 17 00:00:00 2001 From: ish-kafel <1136461977@qq.com> Date: Fri, 16 Aug 2019 12:30:50 +0800 Subject: [PATCH 3/3] =?UTF-8?q?=E4=BF=AE=E6=AD=A3=E7=BF=BB=E8=AF=91?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../article.md | 57 +++++++------------ 1 file changed, 22 insertions(+), 35 deletions(-) diff --git a/1-js/09-classes/04-private-protected-properties-methods/article.md b/1-js/09-classes/04-private-protected-properties-methods/article.md index 7aca962032..749098f4e1 100644 --- a/1-js/09-classes/04-private-protected-properties-methods/article.md +++ b/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 确保我们只能访问类中的内容。 pFad - Phonifier reborn

Pfad - The Proxy pFad © 2024 Your Company Name. All rights reserved.

Note: This service is not intended for secure transactions such as banking, social media, email, or purchasing. Use at your own risk. We assume no liability whatsoever for broken pages.

Alternative Proxies: