corrections article

Author: mykhaliuk

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

@@ -43,9 +43,9 @@ alert( slow(2) ); // slow(2) кешируем
 alert( "Again: " + slow(2) ); // возвращаем кеш
 ```
 
-В коде выше `cachingDecorator` - *декоратор*: это специальная функция, которая принимает другую функцию и изменяет ее поведение.
+В коде выше `cachingDecorator` -- это *декоратор*, специальная функция, которая принимает другую функцию и изменяет её поведение.
 
-Идея состоит в том, что мы можем вызвать `cachingDecorator` с любой функцией, в результате чего мы получим кеширующую обертку. Это здорово, т.к. у нас может быть множество функций, использующих такой функционал, и все, что нам нужно сделать - это применить к ним `cachingDecorator`.
+Идея состоит в том, что мы можем вызвать `cachingDecorator` с любой функцией, в результате чего мы получим кеширующую обёртку. Это здорово, т.к. у нас может быть множество функций, использующих такой функционал, и все, что нам нужно сделать - это применить к ним `cachingDecorator`.
 
 Отделяя кеширующий код от основного кода, мы также сохраняем чистоту и простоту последнего.
 
@@ -55,7 +55,7 @@ alert( "Again: " + slow(2) ); // возвращаем кеш
 
 ![](decorator-makecaching-wrapper.png)
 
-Как мы видим обертка возвращает результат выполнения `func(x)` "как есть". Из внешнего кода обернутая функция `slow` по-прежнему делает то же самое. Обертка всего добавляет к её поведению аспект кэширования.
+Как мы видим обертка возвращает результат выполнения `func(x)` "как есть". Из внешнего кода обернутая функция `slow` по-прежнему делает то же самое. Обертка всего добавляет к её поведению аспект кеширования.
 
 Подводя итог, можно выделить несколько преимуществ использования отдельной `cachingDecorator` вместо изменения кода самой `slow`:
 
@@ -68,7 +68,7 @@ alert( "Again: " + slow(2) ); // возвращаем кеш
 
 Упомянутый выше кеширующий декоратор не подходит для работы с методами объектов.
 
-Например, в приведенном ниже коде `worker.slow()` перестает работать после применения декоратора:
+Например, в приведённом ниже коде `worker.slow()` перестает работать после применения декоратора:
 
 ```js run
 // зделаем worker.slow кеширующим
@@ -110,7 +110,7 @@ alert( worker.slow(2) ); // Ой! Ошибка: не удается прочит
 
 Ошибка возникает в строке `(*)`. Функция пытается получить доступ к `this.someMethod` и завершается с ошибкой. Видите почему?
 
-Причина в том, что в строке `(**)` декоратор вызывает оригинальную функцию как `func(x)`, а в этом случае функция получает `this=undefined`.
+Причина в том, что в строке `(**)` декоратор вызывает оригинальную функцию как `func(x)`, а в этом случае функция получает `this = undefined`.
 
 Мы бы наблюдали похожий симптом, если бы попытались запустить:
 
@@ -119,7 +119,7 @@ let func = worker.slow;
 func(2);
 ```
 
-Т.е. декоратор передает вызов оригинальному методу, но без контекста. Следовательно - ошибка.
+Т.е. декоратор передаёт вызов оригинальному методу, но без контекста. Следовательно -- ошибка.
 
 Давайте это исправим.
 
@@ -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,11 +153,11 @@ 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':
+Здесь мы используем `call` для вызова `say` с заданным контекстом и фразой:
 
 
 ```js run
@@ -172,7 +172,7 @@ say.call( user, "Hello" ); // John: Hello
 ```
 
 
-В нашем случае мы можем использовать `call` в обертке для передачи контекста в исходную функцию:
+В нашем случае мы можем использовать `call` в обёртке для передачи контекста в исходную функцию:
 
 
 ```js run
@@ -209,11 +209,11 @@ alert( worker.slow(2) ); // работает, не вызывая первона
 
 Теперь всё в порядке.
 
-Чтобы всё было понятно, давайте посмотрим глубже, как передается `this`:
+Чтобы всё было понятно, давайте посмотрим глубже, как передаётся `this`:
 
 1. После *декорации* `worker.slow` становится обёрткой `function (x) { ... }`.
 2. Так что при выполнении `worker.slow(2)` обёртка получает `2` в качестве аргумента, и `this=worker` (это объект перед точкой).
-3. Внутри обёртки, если результат еще не кэширован, `func.call(this, x)` передает текущий `this` (`= worker`) и текущий аргумент (`= 2`) в оригинальную функцию.
+3. Внутри обёртки, если результат еще не кеширован, `func.call(this, x)` передаёт текущий `this` (`=worker`) и текущий аргумент (`=2`) в оригинальную функцию.
 
 ## Использование нескольких аргументов с "func.apply"
 
@@ -229,7 +229,7 @@ let worker = {
 };
 
 // should remember same-argument calls
-worker.slow = cacheingDecorator(worker.slow);
+worker.slow = cachingDecorator(worker.slow);
 ```
 
 Здесь у нас есть две задачи для решения.
@@ -313,7 +313,7 @@ let wrapper = function() {
 };
 ```
 
-Это называется *переадресация вызова*. Обертка передает все, что получает: контекст 'this' и аргументы для 'anotherFunction' и возвращает её результат.
+Это называется *переадресация вызова*. Обертка передаёт все, что получает: контекст `this` и аргументы для `anotherFunction` и возвращает её результат.
 
 Когда внешний код вызывает такую 'обёртку', он неотличим от вызова исходной функции.
 
@@ -412,7 +412,7 @@ hash(1, 2);
 
 Этот трюк называется *заимствование метода*.
 
-Мы берем (заимствуем) метод join из обычного массива `[] .join`. И используем `[] .join.call`, чтобы выполнить его в контексте `arguments`.
+Мы берем (заимствуем) метод join из обычного массива `[].join`. И используем `[].join.call`, чтобы выполнить его в контексте `arguments`.
 
 Почему это работает?
 
@@ -421,8 +421,8 @@ hash(1, 2);
 
 1. Пускай первым аргументом будет `glue` или, в случае отсутствия аргументов, им будет запятая `","`
 2. Пускай `result` будет пустой строкой `""`.
-3. Добавить `this [0]` к `result`.
-4. Добавить `this [1]` к `glue`.
+3. Добавить `this[0]` к `result`.
+4. Добавить `this[1]` к `glue`.
 5. Добавить `this[2]` к `glue`.
 6. ...выполнять до тех пор, пока `this.length` элементов не будет склеено.
 7. Вернуть `result`.