fixes and suggestions

Author: mykhaliuk

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

@@ -5,7 +5,7 @@ importance: 5
 # Задерживающий декоратор
 
 Создайте декоратор `delay(f, ms)`, который задерживает каждый вызов `f` на` ms` миллисекунд.
-For instance:
+Например:
 
 ```js
 function f(x) {

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

@@ -5,7 +5,7 @@ importance: 5
 # Антидребезговый (debounce) декоратор
 
 Результатом декоратора `debounce(f, ms)` должна быть обёртка, которая передает вызов `f` не более одного раза в `ms` миллисекунд.
-Другими словами, когда мы вызываем `debounce`, это гарантирует, что все остальные вызовы будут игнорироваться в течении `ms`.
+Другими словами, когда мы вызываем `debounce`, это гарантирует, что все остальные вызовы будут игнорироваться в течение `ms`.
 
 Например:
 

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

@@ -16,7 +16,7 @@ describe("throttle(f, 1000)", function() {
     assert.equal(log, "1");
   });
 
-  it("далее вызовы игнорируются до истечения 1000 мс от полседнего вызова", function() {
+  it("далее вызовы игнорируются до истечения 1000 мс от последнего вызова", function() {
     f1000(2); // (задержка - менее 1000 мс с момента последнего вызов)
     f1000(3); // (задержка - менее 1000 мс с момента последнего вызов)
     // запланирован вызов спустя f(3) 1000 мс

1-js/06-advanced-functions/09-call-apply-decorators/article.md

@@ -110,7 +110,7 @@ alert( worker.slow(2) ); // Ой! Ошибка: не удается прочит
 
 Ошибка возникает в строке `(*)`. Функция пытается получить доступ к `this.someMethod` и завершается с ошибкой. Видите почему?
 
-Причина в том, что в строке `(**)` декоратор вызывает оригинальную функцию как `func(x)`, а в этом случае функция получает `this = undefined`.
+Причина в том, что в строке `(**)` декоратор вызывает оригинальную функцию как `func(x)`, а в этом случае функция получает `this=undefined`.
 
 Мы бы наблюдали похожий симптом, если бы попытались запустить:
 
@@ -142,7 +142,7 @@ func.call(obj, 1, 2, 3)
 
 Они оба вызывают `func` с аргументами `1`, `2` и `3`. Единственное отличие состоит в том, что `func.call` также устанавливает `this` в `obj`.
 
-Например, в приведенном ниже коде мы вызываем `sayHi` в контексте различных объектов: `sayHi.call(user)` запускает `sayHi`, передавая `this = user`, а следующая строка устанавливает `this = admin`:
+Например, в приведенном ниже коде мы вызываем `sayHi` в контексте различных объектов: `sayHi.call(user)` запускает `sayHi`, передавая `this=user`, а следующая строка устанавливает `this=admin`:
 
 ```js run
 function sayHi() {
@@ -153,8 +153,8 @@ let user = { name: "John" };
 let admin = { name: "Admin" };
 
 // используем 'call' для передачи различных объектов как 'this'
-sayHi.call( user ); // this = John
-sayHi.call( admin ); // this = Admin
+sayHi.call( user ); // this=John
+sayHi.call( admin ); // this=Admin
 ```
 
 Здесь мы используем `call` для вызова `say` с заданным контекстом и аргументом 'phrase':
@@ -204,22 +204,22 @@ function cachingDecorator(func) {
 worker.slow = cachingDecorator(worker.slow); // теперь сделаем её кеширующей
 
 alert( worker.slow(2) ); // работает
-alert( worker.slow(2) ); // работает, не вызывая первоначальную функцию (кэшируется)
+alert( worker.slow(2) ); // работает, не вызывая первоначальную функцию (кешируется)
 ```
 
 Теперь всё в порядке.
 
 Чтобы всё было понятно, давайте посмотрим глубже, как передается `this`:
 
 1. После *декорации* `worker.slow` становится обёрткой `function (x) { ... }`.
-2. Так что при выполнении `worker.slow(2)` обёртка получает `2` в качестве аргумента, и `this = worker` (это объект перед точкой).
+2. Так что при выполнении `worker.slow(2)` обёртка получает `2` в качестве аргумента, и `this=worker` (это объект перед точкой).
 3. Внутри обёртки, если результат еще не кэширован, `func.call(this, x)` передает текущий `this` (`= worker`) и текущий аргумент (`= 2`) в оригинальную функцию.
 
 ## Использование нескольких аргументов с "func.apply"
 
 Теперь давайте сделаем `cachingDecorator` еще более универсальным. До сих пор он работал только с функциями с одним аргументом.
 
-Как же кэшировать метод с несколькими аргументами `worker.slow`?
+Как же кешировать метод с несколькими аргументами `worker.slow`?
 
 ```js
 let worker = {
@@ -234,7 +234,7 @@ worker.slow = cacheingDecorator(worker.slow);
 
 Здесь у нас есть две задачи для решения.
 
-Во-первых, - как использовать оба аргумента `min` и `max` для ключа в коллекции `cache`? Ранее для одного аргумента `x` мы могли просто сохранить результат `cache.set (x, result)` и вызвать `cache.get (x)` чтобы получить его. Но теперь нам нужно запомнить результат для *комбинации аргументов* `(min,max)`. Нативный `Map` принимает только одно значение как ключ.
+Во-первых, - как использовать оба аргумента `min` и `max` для ключа в коллекции `cache`? Ранее для одного аргумента `x` мы могли просто сохранить результат `cache.set(x, result)` и вызвать `cache.get(x)` чтобы получить его. Но теперь нам нужно запомнить результат для *комбинации аргументов* `(min,max)`. Нативный `Map` принимает только одно значение как ключ.
 
 Есть много возможных решений:
 
@@ -255,7 +255,7 @@ worker.slow = cacheingDecorator(worker.slow);
 func.apply(context, args)
 ```
 
-Он выполняет `func`, устанавливая`this = context`, и использует массивоподобный объект `args` в качестве списка аргументов.
+Он выполняет `func`, устанавливая`this=context`, и использует массивоподобный объект `args` в качестве списка аргументов.
 
 Например, эти два вызова почти одинаковые:
 
@@ -264,9 +264,9 @@ func(1, 2, 3);
 func.apply(context, [1, 2, 3])
 ```
 
-Оба запускают `func`, передавая аргументы `1,2,3`. Но `apply` также устанавливает `this = context`.
+Оба запускают `func`, передавая аргументы `1,2,3`. Но `apply` также устанавливает `this=context`.
 
-Например, здесь `say` вызывается с `this = user` и `messageData` в качестве списка аргументов:
+Например, здесь `say` вызывается с `this=user` и `messageData` в качестве списка аргументов:
 
 ```js run
 function say(time, phrase) {
@@ -279,7 +279,7 @@ let messageData = ['10:00', 'Hello']; // становится time и phrase
 
 *!*
 // this принимает значение user, messageData передаётся как список аргументов (time, phrase)
-say.apply(user, messageData); // [10:00] John: Hello (this = user)
+say.apply(user, messageData); // [10:00] John: Hello (this=user)
 */!*
 ```
 
@@ -301,7 +301,7 @@ func.apply(context, args);   // тот же эффект
 - Оператор расширения `...` позволяет передавать *итеративный* объект `args` в виде списка в `call`.
 - В свою очередь `Apply` принимает только *массивоподобный* объект `args`.
 
-Итак, эти вызовы дополняют друг друга. Там, где мы ожидаем итеративность, работает `call`, где мы ожидаем массивоподобный объект, работает` apply`.
+Итак, эти вызовы дополняют друг друга. Там, где мы ожидаем итеративность, работает `call`, где мы ожидаем массивоподобный объект, работает `apply`.
 
 И если `args` является итеративным и похожим на реальный массив, то технически мы могли бы использовать любой из них, но `apply`, вероятно, будет быстрее, потому что это одна операция. Большинство движков JavaScript внутренне оптимизируют его лучше, чем пара `call + spread`.
 
@@ -360,7 +360,7 @@ alert( "Again " + worker.slow(3, 5) ); // аналогично (из кеша)
 
 Есть два изменения:
 
-- В строке `(*)` вызываем `hash` для создания одного ключа из `arguments`. Здесь мы используем простую функцию "объединения", которая превращает аргументы `(3, 5)` в ключ `" 3,5 "`. В более сложных случаях могут потребоваться другие функции хеширования 
+- В строке `(*)` вызываем `hash` для создания одного ключа из `arguments`. Здесь мы используем простую функцию "объединения", которая превращает аргументы `(3, 5)` в ключ `" 3,5 "`. В более сложных случаях могут потребоваться другие функции хеширования.
 - Затем `(**)` используем `func.apply` для передачи как контекста, так и всех аргументов, полученных обёрткой (независимо от их количества), в исходную функцию.
 
 
@@ -427,9 +427,9 @@ hash(1, 2);
 6. ...выполнять до тех пор, пока `this.length` элементов не будет склеено.
 7. Вернуть `result`.
 
-Таким образом, технически он принимает `this` и объединяет `this[0]`, `this[1]`... и т.д. вместе. Он намеренно написан так, что допускает любое подобное массиву `this` (не случайно, многие методы следуют этой практике). Вот почему он также работает с `this = arguments`.
+Таким образом, технически он принимает `this` и объединяет `this[0]`, `this[1]`... и т.д. вместе. Он намеренно написан так, что допускает любое подобное массиву `this` (не случайно, многие методы следуют этой практике). Вот почему он также работает с `this=arguments`.
 
-## Резюме
+## Итого
 
 *Декоратор* - это обертка вокруг функции, которая изменяет поведение последней. Основная работа по-прежнему выполняется функцией.
 
@@ -450,7 +450,7 @@ let wrapper = function(original, arguments) {
 }
 ```
 
-Мы также рассмотрели пример *заимствования метода*, когда мы вызываем метод у объекта в контексте другого объекта. Весьма распространено заимствовать методы массива и применять их к аргументам. Альтернативным способом является использование объекта рест-параметров `...args`, который является реальным массивом.
+Мы также рассмотрели пример *заимствования метода*, когда мы вызываем метод у объекта в контексте другого объекта. Весьма распространено заимствовать методы массива и применять их к аргументам. В качестве альтернативы можно использовать объект с остаточными параметрами `...args`, который является реальным массивом.
 
 
 В реальной практике очень много декораторов. Проверьте, насколько хорошо вы их освоили, решая задачи этой главы.