FIX: 将装饰者统一修改为装饰器

leviding · leviding · commit 6b7313bd8021 · 2020-11-17T21:25:17.000+08:00
diff --git a/1-js/06-advanced-functions/09-call-apply-decorators/01-spy-decorator/task.md b/1-js/06-advanced-functions/09-call-apply-decorators/01-spy-decorator/task.md
@@ -2,9 +2,9 @@ importance: 5
 
 ---
 
-# 间谍装饰者
+# 间谍装饰器
 
-创建一个装饰者 `spy(func)`，它应该返回一个包装器，该包装器将所有对函数的调用保存在其 `calls` 属性中。 
+创建一个装饰器 `spy(func)`，它应该返回一个包装器，该包装器将所有对函数的调用保存在其 `calls` 属性中。 
 
 每个调用都保存为一个参数数组。
 
@@ -27,4 +27,4 @@ for (let args of work.calls) {
 }
 ```
 
-P.S. 该装饰者有时对于单元测试很有用。它的高级形式是 [Sinon.JS](http://sinonjs.org/) 库中的 `sinon.spy`。
+P.S. 该装饰器有时对于单元测试很有用。它的高级形式是 [Sinon.JS](http://sinonjs.org/) 库中的 `sinon.spy`。
diff --git a/1-js/06-advanced-functions/09-call-apply-decorators/02-delay/task.md b/1-js/06-advanced-functions/09-call-apply-decorators/02-delay/task.md
@@ -2,9 +2,9 @@ importance: 5
 
 ---
 
-# 延时装饰者
+# 延时装饰器
 
-创建一个装饰者 `delay(f, ms)`，该装饰者将 `f` 的每次调用延时 `ms` 毫秒。
+创建一个装饰器 `delay(f, ms)`，该装饰器将 `f` 的每次调用延时 `ms` 毫秒。
 
 例如：
 
diff --git a/1-js/06-advanced-functions/09-call-apply-decorators/04-throttle/task.md b/1-js/06-advanced-functions/09-call-apply-decorators/04-throttle/task.md
@@ -2,9 +2,9 @@ importance: 5
 
 ---
 
-# 节流装饰者
+# 节流装饰器
 
-创建一个“节流”装饰者 `throttle(f, ms)` —— 返回一个包装器。
+创建一个“节流”装饰器 `throttle(f, ms)` —— 返回一个包装器。
 
 当被多次调用时，它会在每 `ms` 毫秒最多将调用传递给 `f` 一次。
 
@@ -24,7 +24,7 @@ importance: 5
 
 ……但是更新函数 `update()` 太重了，无法在每个微小移动上都执行。高于每 100ms 更新一次的更新频次也没有意义。
 
-因此，我们将其包装到装饰者中：使用 `throttle(update, 100)` 作为在每次鼠标移动时运行的函数，而不是原始的 `update()`。装饰者会被频繁地调用，但是最多每 100ms 将调用转发给 `update()` 一次。
+因此，我们将其包装到装饰器中：使用 `throttle(update, 100)` 作为在每次鼠标移动时运行的函数，而不是原始的 `update()`。装饰器会被频繁地调用，但是最多每 100ms 将调用转发给 `update()` 一次。
 
 在视觉上，它看起来像这样：
 
diff --git a/1-js/06-advanced-functions/09-call-apply-decorators/article.md b/1-js/06-advanced-functions/09-call-apply-decorators/article.md
@@ -1,4 +1,4 @@
-# 装饰者模式和转发，call/apply
+# 装饰器模式和转发，call/apply
 
 JavaScript 在处理函数时提供了非凡的灵活性。它们可以被传递，用作对象，现在我们将看到如何在它们之间 **转发（forward）** 调用并 **装饰（decorate）** 它们。
 
@@ -43,7 +43,7 @@ alert( slow(2) ); // slow(2) 被缓存下来了
 alert( "Again: " + slow(2) ); // 和前面一行结果相同
 ```
 
-在上面的代码中，`cachingDecorator` 是一个 **装饰者（decorator）**：一个特殊的函数，它接受另一个函数并改变它的行为。
+在上面的代码中，`cachingDecorator` 是一个 **装饰器（decorator）**：一个特殊的函数，它接受另一个函数并改变它的行为。
 
 其思想是，我们可以为任何函数调用 `cachingDecorator`，它将返回缓存包装器。这很棒啊，因为我们有很多函数可以使用这样的特性，而我们需要做的就是将 `cachingDecorator` 应用于它们。
 
@@ -59,11 +59,11 @@ alert( "Again: " + slow(2) ); // 和前面一行结果相同
 
 - `cachingDecorator` 是可重用的。我们可以将它应用于另一个函数。
 - 缓存逻辑是独立的，它没有增加 `slow` 本身的复杂性（如果有的话）。
-- 如果需要，我们可以组合多个装饰者（其他装饰者将遵循同样的逻辑）。
+- 如果需要，我们可以组合多个装饰器（其他装饰器将遵循同样的逻辑）。
 
 ## 使用 "func.call" 设定上下文
 
-上面提到的缓存装饰者不适用于对象方法。
+上面提到的缓存装饰器不适用于对象方法。
 
 例如，在下面的代码中，`worker.slow()` 在装饰后停止工作：
 
@@ -232,7 +232,7 @@ worker.slow = cachingDecorator(worker.slow);
 
 1. 实现一个新的（或使用第三方的）类似 map 的更通用并且允许多个键的数据结构。
 2. 使用嵌套 map：`cache.set(min)` 将是一个存储（键值）对 `(max, result)` 的 `Map`。所以我们可以使用 `cache.get(min).get(max)` 来获取 `result`。
-3. 将两个值合并为一个。为了灵活性，我们可以允许为装饰者提供一个“哈希函数”，该函数知道如何将多个值合并为一个值。
+3. 将两个值合并为一个。为了灵活性，我们可以允许为装饰器提供一个“哈希函数”，该函数知道如何将多个值合并为一个值。
 
 对于许多实际应用，第三种方式就足够了，所以我们就用这个吧。
 
@@ -392,21 +392,21 @@ hash(1, 2);
 
 因此，从技术上讲，它需要 `this` 并将 `this[0]`，`this[1]` ……等 join 在一起。它的编写方式是故意允许任何类数组的 `this` 的（不是巧合，很多方法都遵循这种做法）。这就是为什么它也可以和 `this=arguments` 一起使用。
 
-## 装饰者和函数属性
+## 装饰器和函数属性
 
-通常，用装饰的函数替换一个函数或一个方法是安全的，除了一件小东西。如果原始函数有属性，例如 `func.calledCount` 或其他，则装饰后的函数将不再提供这些属性。因为这是装饰者。因此，如果有人使用它们，那么就需要小心。
+通常，用装饰的函数替换一个函数或一个方法是安全的，除了一件小东西。如果原始函数有属性，例如 `func.calledCount` 或其他，则装饰后的函数将不再提供这些属性。因为这是装饰器。因此，如果有人使用它们，那么就需要小心。
 
 例如，在上面的示例中，如果 `slow` 函数具有任何属性，而 `cachingDecorator(slow)` 则是一个没有这些属性的包装器。
 
-一些包装器可能会提供自己的属性。例如，装饰者会计算一个函数被调用了多少次以及花费了多少时间，并通过包装器属性公开（expose）这些信息。
+一些包装器可能会提供自己的属性。例如，装饰器会计算一个函数被调用了多少次以及花费了多少时间，并通过包装器属性公开（expose）这些信息。
 
-存在一种创建装饰者的方法，该装饰者可保留对函数属性的访问权限，但这需要使用特殊的 `Proxy` 对象来包装函数。我们将在后面的 <info:proxy#proxy-apply> 中学习它。
+存在一种创建装饰器的方法，该装饰器可保留对函数属性的访问权限，但这需要使用特殊的 `Proxy` 对象来包装函数。我们将在后面的 <info:proxy#proxy-apply> 中学习它。
 
 ## 总结
 
-**装饰者** 是一个围绕改变函数行为的包装器。主要工作仍由该函数来完成。
+**装饰器** 是一个围绕改变函数行为的包装器。主要工作仍由该函数来完成。
 
-装饰者可以被看作是可以添加到函数的 "features" 或 "aspects"。我们可以添加一个或添加多个。而这一切都无需更改其代码！
+装饰器可以被看作是可以添加到函数的 "features" 或 "aspects"。我们可以添加一个或添加多个。而这一切都无需更改其代码！
 
 为了实现 `cachingDecorator`，我们研究了以下方法：
 
@@ -423,4 +423,4 @@ let wrapper = function() {
 
 我们也可以看到一个 **方法借用（method borrowing）** 的例子，就是我们从一个对象中获取一个方法，并在另一个对象的上下文中“调用”它。采用数组方法并将它们应用于参数 `arguments` 是很常见的。另一种方法是使用 Rest 参数对象，该对象是一个真正的数组。
 
-在 JavaScript 领域里有很多装饰者（decorators）。通过解决本章的任务，来检查你掌握它们的程度吧。
+在 JavaScript 领域里有很多装饰器（decorators）。通过解决本章的任务，来检查你掌握它们的程度吧。
diff --git a/1-js/06-advanced-functions/12-arrow-functions/article.md b/1-js/06-advanced-functions/12-arrow-functions/article.md
@@ -80,7 +80,7 @@ group.showList();
 
 箭头函数也没有 `arguments` 变量。
 
-当我们需要使用当前的 `this` 和 `arguments` 转发一个调用时，这对装饰者（decorators）来说非常有用。
+当我们需要使用当前的 `this` 和 `arguments` 转发一个调用时，这对装饰器（decorators）来说非常有用。
 
 例如，`defer(f, ms)` 获得了一个函数，并返回一个包装器，该包装器将调用延迟 `ms` 毫秒：
 
diff --git a/1-js/08-prototypes/03-native-prototypes/2-defer-to-prototype-extended/solution.md b/1-js/08-prototypes/03-native-prototypes/2-defer-to-prototype-extended/solution.md
@@ -16,7 +16,7 @@ function f(a, b) {
 f.defer(1000)(1, 2); // 1 秒后显示 3
 ```
 
-请注意：我们在 `f.apply` 中使用 `this` 以使装饰者适用于对象方法。
+请注意：我们在 `f.apply` 中使用 `this` 以使装饰器适用于对象方法。
 
 因此，如果将包装器函数作为对象方法调用，那么 `this` 将会被传递给原始方法 `f`。
 
diff --git a/1-js/08-prototypes/03-native-prototypes/2-defer-to-prototype-extended/task.md b/1-js/08-prototypes/03-native-prototypes/2-defer-to-prototype-extended/task.md
@@ -2,7 +2,7 @@ importance: 4
 
 ---
 
-# 将装饰者 "defer()" 添加到函数
+# 将装饰器 "defer()" 添加到函数
 
 在所有函数的原型中添加 `defer(ms)` 方法，该方法返回一个包装器，将函数调用延迟 `ms` 毫秒。
 
