fixes

Author: mykhaliuk

1-js/06-advanced-functions/09-call-apply-decorators/01-spy-decorator/task.md

@@ -1,10 +1,10 @@
-важность: 5
+importance: 5
 
 ---
 
-# Декоратор шпион
+# Декоратор-шпион
 
-Создайте декоратор `spy(func)`, который должен возвращать обёртку, которая сохраняет все вызовы функции в своем свойстве `Call`.
+Создайте декоратор `spy(func)`, который должен возвращать обёртку, которая сохраняет все вызовы функции в своем свойстве `calls`.
 
 Каждый вызов должен сохраняться как массив аргументов.
 
@@ -27,4 +27,4 @@ for (let args of work.calls) {
 }
 ```
 
-P.S.: Этот декоратор иногда полезен для юнит-тестирования. Его расширенная форма - `sinon.spy` содержится в библиотеке [Sinon.JS] (http://sinonjs.org/).
+P.S.: Этот декоратор иногда полезен для юнит-тестирования. Его расширенная форма - `sinon.spy` содержится в библиотеке [Sinon.JS](http://sinonjs.org/).

1-js/06-advanced-functions/09-call-apply-decorators/02-delay/solution.md

@@ -14,11 +14,11 @@ let f1000 = delay(alert, 1000);
 f1000("test"); // показывает "test" после 1000 мс
 ```
 
-Обратите внимание, как здесь используется функция-стрелка. Как мы знаем, функция-стрелока не имеет собственных `this` и `arguments`, поэтому `f.apply(this, arguments)` берет `this` и `arguments` из обёртки.
+Обратите внимание, как здесь используется функция-стрелка. Как мы знаем, функция-стрелка не имеет собственных `this` и `arguments`, поэтому `f.apply(this, arguments)` берет `this` и `arguments` из обёртки.
 
-Если мы передадим обычную функцию, `setTimeout` вызовет ее без аргументов и `this = window` (при условии, что код выполняется в браузере).
+Если мы передадим обычную функцию, `setTimeout` вызовет ее без аргументов и с `this = window` (при условии, что код выполняется в браузере).
 
-Мы все еще можем передать правильное `this`, используя промежуточную переменную, но это немного громоздко:
+Мы все еще можем передать правильный `this`, используя промежуточную переменную, но это немного громоздко:
 
 ```js
 function delay(f, ms) {

1-js/06-advanced-functions/09-call-apply-decorators/02-delay/task.md

@@ -1,4 +1,4 @@
-важность: 5
+importance: 5
 
 ---
 
@@ -20,6 +20,6 @@ f1000("test"); // показывает "test" после 1000 мс
 f1500("test"); // показывает "test" после 1500 мс
 ```
 
-Другими словами, `delay (f, ms)` возвращает вариант `f` с "задержкой на `ms` мс".
+Другими словами, `delay(f, ms)` возвращает вариант `f` с "задержкой на `ms` мс".
 
 В приведенном выше коде `f` - функция с одним аргументом, но ваше решение должно передавать все аргументы и контекст `this`.

1-js/06-advanced-functions/09-call-apply-decorators/03-debounce/_js.view/test.js

@@ -7,7 +7,7 @@ describe("debounce", function() {
     this.clock.restore();
   });
 
-  it("вызывает функцию максимум один раз в мс", function() {
+  it("вызывает функцию один раз в 'ms' мс", function() {
     let log = '';
 
     function f(a) {

1-js/06-advanced-functions/09-call-apply-decorators/03-debounce/solution.md

@@ -20,8 +20,8 @@ function debounce(f, ms) {
 - `isCooldown = false` -- готова к выполнению.
 - `isCooldown = true` -- ожидание окончания тайм-аута.
 
-В первом вызове `isCoolDown` является ложным, поэтому вызов продолжается, и состояние изменяется на `true`.
+В первом вызове `isCoolDown = false`, поэтому вызов продолжается, и состояние изменяется на `true`.
 
-Пока `isCoolDown` имеет значение true, все остальные вызовы игнорируются.
+Пока `isCoolDown` имеет значение `true`, все остальные вызовы игнорируются.
 
-Затем `setTimeout` устанавливает в него значение `false` после заданной задержки.
+Затем `setTimeout` устанавливает его в `false` после заданной задержки.

1-js/06-advanced-functions/09-call-apply-decorators/03-debounce/task.md

@@ -1,11 +1,11 @@
-важность: 5
+importance: 5
 
 ---
 
-# Отклоняющий декоратор
+# Антидребезговый (debounce) декоратор
 
 Результатом декоратора `debounce(f, ms)` должна быть обёртка, которая передает вызов `f` не более одного раза в `ms` миллисекунд.
-Другими словами, когда мы вызываем «отклоненную» функцию, это гарантирует, что все остальные вызовы будут игнорироваться в течении `ms`.
+Другими словами, когда мы вызываем `debounce`, это гарантирует, что все остальные вызовы будут игнорироваться в течении `ms`.
 
 Например:
 
@@ -15,9 +15,9 @@ let f = debounce(alert, 1000);
 f(1); // выполняется немедленно
 f(2); // проигнорирован
 
-setTimeout( () => f(3), 100); // проигнорирован ( прошло только 100 мс )
-setTimeout( () => f(4), 1100); // выполняется
-setTimeout( () => f(5), 1500); // проигнорирован ( прошло только 100 мс от последнего вызова)
+setTimeout(() => f(3), 100); // проигнорирован (прошло только 100 мс)
+setTimeout(() => f(4), 1100); // выполняется
+setTimeout(() => f(5), 1500); // проигнорирован (прошло только 100 мс от последнего вызова)
 ```
 
-На практике `debounce` полезен для функций, которые извлекают/обновляют что-то и мы знаем, что ничего нового нельзя сделать за такой короткий период времени, поэтому лучше не тратить ресурсы.
+На практике `debounce` полезен для функций, которые получают/обновляют данные, и мы знаем, что повторный вызов в течение короткого промежутка времени не даст ничего нового. Так что лучше не тратить на него ресурсы.

1-js/06-advanced-functions/09-call-apply-decorators/04-throttle/_js.view/solution.js

@@ -22,7 +22,7 @@ function throttle(func, ms) {
     setTimeout(function() {
       isThrottled = false;
       if (savedArgs) {
-        // если были вызовы, последний savedThis/savedArgs
+        // если были вызовы, savedThis/savedArgs хранят последний из них
         // рекурсивный вызов запускает функцию и снова устанавливает время задержки
         wrapper.apply(savedThis, savedArgs);
         savedArgs = savedThis = null;

1-js/06-advanced-functions/09-call-apply-decorators/04-throttle/_js.view/test.js

@@ -21,7 +21,7 @@ describe("throttle(f, 1000)", function() {
     f1000(3); // (задержка - менее 1000 мс с момента последнего вызов)
     // запланирован вызов спустя f(3) 1000 мс
 
-    assert.equal(log, "1"); //  происходит 1-й вызов
+    assert.equal(log, "1"); // прямо сейчас только 1-й вызов завершен
 
     this.clock.tick(1000); // через 1000 мс...
     assert.equal(log, "13"); // log==13, произошел вызов f1000(3)

1-js/06-advanced-functions/09-call-apply-decorators/04-throttle/solution.md

@@ -33,7 +33,7 @@ function throttle(func, ms) {
 Вызов `throttle(func, ms)` возвращает `wrapper`.
 
 1. Во время первого вызова обёртка просто вызывает `func` и устанавливает состояние задержки (`isThrottled = true`).
-2. В этом состоянии все вызовы, запоминаются в `saveArgs / saveThis`. Обратите внимание, что контекст и аргументы одинаково важны и должны быть запомнены. Они нам нужны для того, чтобы воспроизвести вызов.
+2. В этом состоянии все вызовы запоминаются в `saveArgs / saveThis`. Обратите внимание, что контекст и аргументы одинаково важны и должны быть запомнены. Они нам нужны для того, чтобы воспроизвести вызов позднее.
 3. ... Затем по прошествии `ms` миллисекунд срабатывает `setTimeout`. Состояние задержки сбрасывается (`isThrottled = false`). И если мы проигнорировали вызовы, то «обёртка» выполняется с последними запомненными аргументами и контекстом.
 
 На третьем шаге выполняется не `func`, а `wrapper`, потому что нам нужно не только выполнить `func`, но и еще раз установить состояние задержки и таймаут для его сброса.

1-js/06-advanced-functions/09-call-apply-decorators/04-throttle/task.md

@@ -1,24 +1,24 @@
-важность: 5
+importance: 5
 
 ---
 
-# Задерживающий декоратор
+# Тормозящий (throttling) декоратор
 
-Создайте "задерживающий" декоратор `throttle(f, ms)` - который возвращает обёртку, передавая вызов в `f` не более одного раза в `ms` миллисекунд. Те вызовы, которые попадают в период "задержки", игнорируются.
+Создайте "тормозящий" декоратор `throttle(f, ms)` - который возвращает обёртку, передавая вызов в `f` не более одного раза в `ms` миллисекунд. Те вызовы, которые попадают в период "торможения", игнорируются.
 
 **Вариант с `debounce` - если проигнорированный вызов является последним во время "задержки", то он выполняется в конце.**
 
 Давайте рассмотрим реальное приложение, чтобы лучше понять это требование и выяснить, откуда оно взято.
 
 **Например, мы хотим отслеживать движения указателя.**
 
-В браузере мы можем объявить функцию, которая будет запускаться при каждом микродвижении указателя и получать его местоположение при каждом его перемещении. Во время активного использования мыши эта функция запускается очень часто, это может происходить около 100 раз в секунду (каждые 10 мс).
+В браузере мы можем объявить функцию, которая будет запускаться при каждом движении указателя и получать его местоположение. Во время активного использования мыши эта функция запускается очень часто, это может происходить около 100 раз в секунду (каждые 10 мс).
 
 **Отслеживающая функция должна обновлять некоторую информацию на веб-странице.**
 
 Функция обновления `update()` слишком ресурсоёмкая, чтобы делать это при каждом микродвижении. Также нет смысла делать это чаще, чем один раз в 100 мс.
 
-Поэтому мы объявим `throttle(update, 100)` как функцию, которая будет запускаться при каждом перемещении указателя вместо оригинальной `update()`. Декоратор будет вызываться часто, но `update()` будет вызываться максимум раз в 100 мс.
+Поэтому мы обернем вызов в декоратор: будем использовать throttle(update, 100) как функцию, которая будет запускаться при каждом перемещении указателя вместо оригинальной update(). Декоратор будет вызываться часто, но `update()` будет вызываться максимум раз в 100 мс.
 
 Визуально это будет выглядеть вот так: