fixes

Author: iliakan

1-js/05-data-types/09-keys-values-entries/article.md

@@ -82,7 +82,7 @@ for (let value of Object.values(user)) {
 Например, у нас есть объект с ценами, и мы хотели бы их удвоить:
 
 ```js run
-let users = {
+let prices = {
   banana: 1,
   orange: 2,
   meat: 4,

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

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

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

@@ -238,84 +238,13 @@ worker.slow = cachingDecorator(worker.slow);
 
 1. Реализовать новую (или использовать стороннюю) структуру данных для коллекции, которая которая более универсальна чем встроенный `Map`, и поддерживает множественные ключи.
 2. Использовать вложенные коллекции: `cache.set(min)` будет `Map` которая хранит пару `(max, result)`. Тогда получить `result` мы можем вызвав `cache.get(min).get(max)`.
-3. Соединить два значения в одно. В нашем конкретном случае мы можем просто использовать строку `"min,max"` как ключ к `Map`. Для гибкости, мы можем позволить передавать *функцию кеширования* в декоратор, которая знает, как сделать одно значение из многих.
-
+3. Соединить два значения в одно. В нашем конкретном случае мы можем просто использовать строку `"min,max"` как ключ к `Map`. Для гибкости, мы можем позволить передавать *хеширующую функцию* в декоратор, которая знает, как сделать одно значение из многих.
 
 Для многих практических применений третий вариант достаточно хорош, поэтому мы будем придерживаться его.
 
-Вторая задача, которую нужно решить, - как передать множество аргументов в `func`? Пока что обёртка `function (x)` принимает один аргумент, и `func.call (this, x)` передаёт его.
-
-Здесь мы можем использовать другой встроенный метод [func.apply](mdn:js/Function/apply).
-
-Синтаксис:
-
-```js
-func.apply(context, args)
-```
-
-Он выполняет `func`, устанавливая`this=context`, и принимая в качестве списка аргументов объект-псевдомассив `args`.
-
-Например, эти два вызова почти одинаковые:
-
-```js
-func(1, 2, 3);
-func.apply(context, [1, 2, 3])
-```
-
-Оба запускают `func`, передавая аргументы `1,2,3`. Но `apply` также устанавливает `this=context`.
-
-Например, здесь `say` вызывается с `this=user` и `messageData` в качестве списка аргументов:
-
-```js run
-function say(time, phrase) {
-  alert(`[${time}] ${this.name}: ${phrase}`);
-}
-
-let user = { name: "John" };
-
-let messageData = ['10:00', 'Hello']; // становится time и phrase
-
-*!*
-// this принимает значение user, messageData передаётся как список аргументов (time, phrase)
-say.apply(user, messageData); // [10:00] John: Hello (this=user)
-*/!*
-```
-
-Единственная разница в синтаксисе между `call` и `apply` состоит в том, что `call` ожидает список аргументов, в то время как `apply` принимает псевдомассив.
-Мы уже знаем оператор  расширения `...` из главы <info: rest-parameters-spread-operator>, который может передавать массив (или любой перебираемый объект) в виде списка аргументов. Поэтому, если мы используем его с `call`, мы можем достичь почти того же, что и `apply`.
-Эти два вызова почти эквивалентны:
-
-```js
-let args = [1, 2, 3];
-
-*!*
-func.call(context, ...args); // передаёт массив как список с оператором расширения
-func.apply(context, args);   // тот же эффект
-*/!*
-```
-
-Если мы посмотрим более внимательно, то между такими использованиями `call` и` apply` есть небольшая разница.
-
-- Оператор расширения `...` позволяет передавать *перебираемый* объект `args` в виде списка в `call`.
-- В свою очередь `Apply` принимает только *псевдомассив* `args`.
-
-Итак, эти вызовы дополняют друг друга. Там, где мы ожидаем итеративность, работает `call`, где мы ожидаем псевдомассив, работает `apply`.
-
-И если `args` является перебираемый и похожим на реальный массив, то технически мы могли бы использовать любой из них, но `apply`, вероятно, будет быстрее, потому что это одна операция. Большинство движков JavaScript внутренне оптимизируют его лучше, чем пара `call + spread`.
-
-Одним из наиболее важных применений `apply` является передача вызова другой функции, например так:
-
-```js
-let wrapper = function() {
-  return anotherFunction.apply(this, arguments);
-};
-```
-
-Это называется *переадресация вызова*. Обёртка передаёт все, что получает: контекст `this` и аргументы для `anotherFunction` и возвращает её результат.
+Также нам понадобится заменить `func.call(this, x)` на `func.call(this, ...arguments)`, чтобы передавать все аргументы обёрнутой функции, а не только первый.
 
-Когда внешний код вызывает такую 'обёртку', он неотличим от вызова исходной функции.
-
-Теперь давайте заправим все это в более мощный `cachingDecorator`:
+Вот более мощный `cachingDecorator`:
 
 ```js run
 let worker = {
@@ -354,13 +283,52 @@ alert( worker.slow(3, 5) ); // работает
 alert( "Again " + worker.slow(3, 5) ); // аналогично (из кеша)
 ```
 
-Теперь обёртка оперирует любым количеством аргументов.
+Теперь он работает с любым количеством аргументов.
 
 Есть два изменения:
 
 - В строке `(*)` вызываем `hash` для создания одного ключа из `arguments`. Здесь мы используем простую функцию "объединения", которая превращает аргументы `(3, 5)` в ключ `" 3,5 "`. В более сложных случаях могут потребоваться другие функции хеширования.
-- Затем `(**)` используем `func.apply` для передачи как контекста, так и всех аргументов, полученных обёрткой (независимо от их количества), в исходную функцию.
+- Затем `(**)` используем `func.call(this, ...arguments)` для передачи как контекста, так и всех аргументов, полученных обёрткой (независимо от их количества), в исходную функцию.
+
+Вместо `func.call(this, ...arguments)` мы могли бы написать `func.apply(this, arguments)`.
+
+Синтаксис встроенного метода  [func.apply](mdn:js/Function/apply):
+
+```js
+func.apply(context, args)
+```
+
+Он выполняет `func`, устанавливая `this=context` и принимая в качестве списка аргументов псевдомассив `args`.
+
+Единственная разница в синтаксисе между `call` и `apply` состоит в том, что `call` ожидает список аргументов, в то время как `apply` принимает псевдомассив.
+
+Эти два вызова почти эквивалентны:
+
+```js
+func.call(context, ...args); // передаёт массив как список с оператором расширения
+func.apply(context, args);   // тот же эффект
+```
+
+Есть только одна небольшая разница:
+
+- Оператор расширения `...` позволяет передавать *перебираемый* объект `args` в виде списка в `call`.
+- А `apply` принимает только *псевдомассив* `args`.
+
+Так что эти вызовы дополняют друг друга. Для перебираемых объектов сработает `call`, а где мы ожидаем псевдомассив - `apply`.
+
+А если у нас объект, который и то и другое, например, реальный массив, то технически мы можем бы использовать любой, но `apply`, вероятно, будет быстрее, потому что большинство движков JavaScript внутренне оптимизируют его лучше.
+
+Передача всех аргументов вместе с контекстом другой функции называется "перенаправлением вызова" (call forwarding).
+
+Простейший вид такого перенаправления:
+
+```js
+let wrapper = function() {
+  return func.apply(this, arguments);
+};
+```
 
+При вызове `wrapper` из внешнего кода его не отличить от вызова исходной функции.
 
 ## Заимствование метода [#method-borrowing]
 
@@ -414,7 +382,7 @@ hash(1, 2);
 
 Почему это работает?
 
-Это связано с тем, что внутренний алгоритм встроенного метода arr.join(glue) очень прост.
+Это связано с тем, что внутренний алгоритм встроенного метода `arr.join(glue)` очень прост.
 Взято из спецификации практически "как есть":
 
 1. Пускай первым аргументом будет `glue` или, в случае отсутствия аргументов, им будет запятая `","`

1-js/06-advanced-functions/10-bind/article.md

@@ -5,13 +5,13 @@ libs:
 
 # Привязка контекста к функции
 
-При использовании `setTimeout` с методами объекта (или при передаче методов объекта) возникает известная проблема: "потеря `this`".
+При передаче методов объекта в качестве колбэков, например для `setTimeout`, возникает известная проблема - потеря `this`.
 
-Внезапно, `this` просто перестает работать правильно. Такая ситуация типична для новичков, но также случается и с опытными разработчиками.
+В этой главе мы посмотрим, как можно её решать.
 
 ## Потеря "this"
 
-Мы уже знаем, что в JavaScript легко потерять `this`: когда метод передается где-то отдельно от объекта - `this` теряется.
+Мы уже видели примеры потери `this`. Как только метод передается отдельно от объекта - `this` теряется.
 
 Вот как это может произойти с `setTimeout`:
 
@@ -37,7 +37,7 @@ let f = user.sayHi;
 setTimeout(f, 1000); // контекст user потеряли
 ```
 
-Метод `setTimeout` в браузере имеет особенность: он устанавливает `this=window` для вызова функции (в Node.js `this` становится объектом таймера, но здесь это не имеет значения). Таким образом, для `this.firstName` он пытается получить `window.firstName`, которого не существует. В других подобных случаях, как мы увидим, обычно `this` просто становится `undefined`.
+Метод `setTimeout` в браузере имеет особенность: он устанавливает `this=window` для вызова функции (в Node.js `this` становится объектом таймера, но здесь это не имеет значения). Таким образом, для `this.firstName` он пытается получить `window.firstName`, которого не существует. В других подобных случаях обычно `this` просто становится `undefined`.
 
 Задача довольно типичная - мы хотим передать метод объекта куда-то ещё (в этом конкретном случае - в планировщик), где он будет вызван. Как бы сделать так, чтобы он вызывался в правильном контексте?