fixes

Author: mykhaliuk

1-js/06-advanced-functions/06-function-object/5-sum-many-brackets/task.md

@@ -14,4 +14,4 @@ sum(6)(-1)(-2)(-3) == 0
 sum(0)(1)(2)(3)(4)(5) == 15
 ```
 
-P.S. Hint: you may need to setup custom object to primitive conversion for your function.
+P.S. Hint: you may need to setup custom object to primitive conversion for your function.

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

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

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

@@ -6,7 +6,7 @@ importance: 5
 
 Создайте "тормозящий" декоратор `throttle(f, ms)` - который возвращает обёртку, передавая вызов в `f` не более одного раза в `ms` миллисекунд. Те вызовы, которые попадают в период "торможения", игнорируются.
 
-**Вариант с `debounce` - если проигнорированный вызов является последним во время "задержки", то он выполняется в конце.**
+**Отличие от `debounce` - если проигнорированный вызов является последним во время "задержки", то он выполняется в конце.**
 
 Давайте рассмотрим реальное приложение, чтобы лучше понять это требование и выяснить, откуда оно взято.
 

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

@@ -64,7 +64,7 @@ alert( "Again: " + slow(2) ); // возвращаем кеш
 - При необходимости мы можем объединить несколько декораторов (речь о них пойдет позже).
 
 
-## Применение "func.call" к контексту.
+## Применение "func.call" для передачи контекста.
 
 Упомянутый выше кеширующий декоратор не подходит для работы с методами объектов.
 
@@ -212,10 +212,10 @@ 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"
+## Переходим к нескольким аргументам с "func.apply"
 
 Теперь давайте сделаем `cachingDecorator` еще более универсальным. До сих пор он работал только с функциями с одним аргументом.
 
@@ -224,7 +224,7 @@ alert( worker.slow(2) ); // работает, не вызывая первона
 ```js
 let worker = {
   slow(min, max) {
-    return min + max; // страшно тяжелая задача для процессора
+    return min + max; // здесь может быть тяжёлая задача
   }
 };
 
@@ -234,11 +234,11 @@ worker.slow = cachingDecorator(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` принимает только одно значение как ключ.
 
 Есть много возможных решений:
 
-1. Реализовать новую (или использовать стороннюю) структуру данных типа коллекции, которая которая более универсальна и поддерживает множественные ключи.
+1. Реализовать новую (или использовать стороннюю) структуру данных для коллекции, которая которая более универсальна чем встроенный `Map`, и поддерживает множественные ключи.
 2. Использовать вложенные коллекции: `cache.set(min)` будет `Map` которая хранит пару `(max, result)`. Тогда получить `result` мы можем вызвав `cache.get(min).get(max)`.
 3. Соединить два значения в одно. В нашем конкретном случае мы можем просто использовать строку `"min,max"` как ключ к `Map`. Для гибкости, мы можем позволить передавать *функцию кеширования* в декоратор, которая знает, как сделать одно значение из многих.
 
@@ -255,7 +255,7 @@ worker.slow = cachingDecorator(worker.slow);
 func.apply(context, args)
 ```
 
-Он выполняет `func`, устанавливая`this=context`, и использует массивоподобный объект `args` в качестве списка аргументов.
+Он выполняет `func`, устанавливая`this=context`, и принимая в качестве списка аргументов объект-псевдомассив `args`.
 
 Например, эти два вызова почти одинаковые:
 
@@ -283,8 +283,8 @@ say.apply(user, messageData); // [10:00] John: Hello (this=user)
 */!*
 ```
 
-Единственная разница в синтаксисе между `call` и `apply` состоит в том, что `call` ожидает список аргументов, в то время как `apply` принимает массивоподобный объект.
-Мы уже знаем оператор  расширения `...` из главы <info: rest-parameters-spread-operator>, который может передавать массив (или любой итеративный объект) в виде списка аргументов. Поэтому, если мы используем его с `call`, мы можем достичь почти того же, что и `apply`.
+Единственная разница в синтаксисе между `call` и `apply` состоит в том, что `call` ожидает список аргументов, в то время как `apply` принимает объект-псевдомассив.
+Мы уже знаем оператор  расширения `...` из главы <info: rest-parameters-spread-operator>, который может передавать массив (или любой перебираемый объект) в виде списка аргументов. Поэтому, если мы используем его с `call`, мы можем достичь почти того же, что и `apply`.
 Эти два вызова почти эквивалентны:
 
 ```js
@@ -298,12 +298,12 @@ func.apply(context, args);   // тот же эффект
 
 Если мы посмотрим более внимательно, то между такими использованиями `call` и` apply` есть небольшая разница.
 
-- Оператор расширения `...` позволяет передавать *итеративный* объект `args` в виде списка в `call`.
-- В свою очередь `Apply` принимает только *массивоподобный* объект `args`.
+- Оператор расширения `...` позволяет передавать *перебираемый* объект `args` в виде списка в `call`.
+- В свою очередь `Apply` принимает только *объект-псевдомассив* `args`.
 
-Итак, эти вызовы дополняют друг друга. Там, где мы ожидаем итеративность, работает `call`, где мы ожидаем массивоподобный объект, работает `apply`.
+Итак, эти вызовы дополняют друг друга. Там, где мы ожидаем итеративность, работает `call`, где мы ожидаем объект-псевдомассив, работает `apply`.
 
-И если `args` является итеративным и похожим на реальный массив, то технически мы могли бы использовать любой из них, но `apply`, вероятно, будет быстрее, потому что это одна операция. Большинство движков JavaScript внутренне оптимизируют его лучше, чем пара `call + spread`.
+И если `args` является перебираемый и похожим на реальный массив, то технически мы могли бы использовать любой из них, но `apply`, вероятно, будет быстрее, потому что это одна операция. Большинство движков JavaScript внутренне оптимизируют его лучше, чем пара `call + spread`.
 
 Одним из наиболее важных применений `apply` является передача вызова другой функции, например так:
 
@@ -384,7 +384,7 @@ function hash(args) {
 }
 ```
 
-...К сожалению, это не сработает. Потому что мы вызываем `hash(arguments)`а объект `arguments`  является итеративным и массивоподобным, но не реальным массивом.
+...К сожалению, это не сработает. Потому что мы вызываем `hash(arguments)`а объект `arguments` является перебираемым и объектом-псевдомассивом, но не реальным массивом.
 
 Таким образом, вызов `join` для него потерпит неудачу, что мы и можем видеть ниже:
 
@@ -416,7 +416,7 @@ hash(1, 2);
 
 Почему это работает?
 
-Это связано с тем, что внутренний алгоритм нативного метода arr.join(glue) очень прост.
+Это связано с тем, что внутренний алгоритм встроенного метода arr.join(glue) очень прост.
 Взято из спецификации практически "как есть":
 
 1. Пускай первым аргументом будет `glue` или, в случае отсутствия аргументов, им будет запятая `","`
@@ -440,7 +440,7 @@ hash(1, 2);
 Для реализации `cachingDecorator` мы изучили методы:
 
 - [func.call(context, arg1, arg2...)](mdn:js/Function/call) -- вызывает `func` с данным контекстом и аргументами.
-- [func.apply(context, args)](mdn:js/Function/apply) -- вызывает `func` передавая `context` как `this` и массивоподобный `args` как список аргументов.
+- [func.apply(context, args)](mdn:js/Function/apply) -- вызывает `func` передавая `context` как `this` и объект-псевдомассив `args` как список аргументов.
 
 В основном *переадресация вызова* выполняется с помощью `apply`: