Update article.md

Author: keslo

1-js/06-advanced-functions/08-settimeout-setinterval/article.md

@@ -75,7 +75,7 @@ setTimeout(() => alert('Привет'), 1000);
 // не правильно!
 setTimeout(sayHi(), 1000);
 ```
-Это не работает, потому что `setTimeout` ожидает ссылку на функцию. Здесь `sayHi()` запускает выполнение функции и *результат выполнения* отправляется в `setTimeout`. В нашем случае результатом выполнения `sayHi()` является `undefined` (так как функция ничего не возвращает), поэтому и нечего планировать.
+Это не работает, потому что `setTimeout` ожидает ссылку на функцию. Здесь `sayHi()` запускает выполнение функции и *результат выполнения* отправляется в `setTimeout`. В нашем случае результатом выполнения `sayHi()` является `undefined` (так как функция ничего не возвращает), поэтому ничего не планируется.
 ````
 
 ### Отмена через clearTimeout
@@ -99,7 +99,7 @@ clearTimeout(timerId);
 alert(timerId); // тот же идентификатор (не принимает значение null после отмены)
 ```
 
-Как мы видим, в результате вывода `alert` в браузере идентификатором таймера является число. В других средах это может быть что-то еще. Например, Node.js возвращает объект таймера с дополнительными методами.
+Как мы видим из вывода `alert`, в браузере идентификатором таймера является число. В других средах это может быть что-то еще. Например, Node.js возвращает объект таймера с дополнительными методами.
 
 Повторюсь, что нет единой спецификации на эти методы, поэтому такое поведение является нормальным.
 
@@ -115,7 +115,7 @@ let timerId = setInterval(func|code, [delay], [arg1], [arg2], ...)
 
 Все аргументы имеют такое же значение. Но отличие этого метода от `setTimeout` в том, что функция запускается не один раз, а периодически через указанный интервал времени.
 
-Чтобы остановить дальнейшее выполнение функции необходимо вызвать `clearInterval(timerId)`.
+Чтобы остановить дальнейшее выполнение функции, необходимо вызвать `clearInterval(timerId)`.
 
 Следующий пример выводит сообщение каждые 2 секунды. Через 5 секунд вывод прекращается:
 
@@ -154,7 +154,7 @@ let timerId = setTimeout(function tick() {
 
 Метод `setTimeout` выше планирует следующий вызов прямо после окончания текущего `(*)`.
 
-Рекурсивный `setTimeout` более гибкий метод, чем `setInterval`. Таким образом, следующий вызов может быть задан по-разному, в зависимости от результатов текущего.
+Рекурсивный `setTimeout` - более гибкий метод, чем `setInterval`. С его помощью, последующий вызов может быть задан по-разному, в зависимости от результатов предыдущего.
 
 Например, необходимо написать сервис, который отправляет запрос для получения данных на сервер каждые 5 секунд, но если сервер перегружен, то необходимо увеличить интервал запросов до 10, 20, 40 секунд...
 Вот псевдокод:
@@ -175,9 +175,9 @@ let timerId = setTimeout(function request() {
 ```
 
 
-И если мы постоянно получаем ресурсоемкие задачи, то можем измерить время, затраченное на выполнение, и спланировать следующий вызов раньше или позже.
+А если функции, которые мы планируем, ресурсоёмкие и требуют времени, то можем измерить время, затраченное на выполнение, и спланировать следующий вызов раньше или позже.
 
-**Рекурсивный `setTimeout` гарантирует задержку между извлечениями, `setInterval` -- нет.**
+**Рекурсивный `setTimeout` гарантирует задержку между выполнениями, `setInterval` -- нет.**
 
 Сравним два фрагмента кода. Первый использует `setInterval`:
 
@@ -232,14 +232,14 @@ setTimeout(function() {...}, 100);
 
 Для `setInterval` функция остается в памяти до тех, пока не будет вызван `clearInterval`.
 
-Это побочный эффект. Функция ссылается на внешнее лексическое окружение, поэтому пока она существует, внешние переменные существуют тоже. Они могут занимать больше памяти, чем сама функция. Поэтому если нет больше необходимости планирования вызова функции, то лучше отменить его, даже если он не очень большой.
+Есть и побочный эффект. Функция ссылается на внешнее лексическое окружение, поэтому пока она существует, внешние переменные существуют тоже. Они могут занимать больше памяти, чем сама функция. Поэтому, если нет регулярный вызов функции больше не нужен, то лучше отменить его, даже если функция очень маленькая.
 ````
 
 ## setTimeout(...,0)
 
 Особый вариант использования: `setTimeout(func, 0)` или просто `setTimeout(func)`.
 
-Это планирование вызова `func` настолько быстро, насколько это возможно. Но планировщик будет вызывать функцию только после завершения выполнения текущего кода.
+Это планирует вызов `func` настолько быстро, насколько это возможно. Но планировщик будет вызывать функцию только после завершения выполнения текущего кода.
 
 Так вызов функции будет запланирован сразу после выполнения текущего кода. Другими словами, *асинхронно*.
 
@@ -277,7 +277,7 @@ function count() {
     i++;
   }
 
-  alert("Выполнено в " + (Date.now() - start) + ' мс');
+  alert("Выполнено за " + (Date.now() - start) + ' мс');
 }
 
 count();
@@ -300,7 +300,7 @@ function count() {
   } while (i % 1e6 != 0);
 
   if (i == 1e9) {
-    alert("Выполнено в " + (Date.now() - start) + ' мс');
+    alert("Выполнено за " + (Date.now() - start) + ' мс');
   } else {
     setTimeout(count); // планируем новый вызов (**)
   }
@@ -353,7 +353,7 @@ function count() {
 count();
 ```
 
-Теперь когда запускаем `count()` и узнаем, что нам будет нужен ещё `count()`, мы планируем это сразу перед выполнением задачи.
+Теперь когда в процессе рабоыт `count()` мы видим, что нам будет нужен ещё вызов `count()`, мы планируем это сразу перед выполнением задачи.
 
 Если запустите этот код, то легко заметите, что он занимает существенно меньше времени.
 
@@ -379,14 +379,16 @@ setTimeout(function run() {
 
 Первый таймер запускается сразу (как и указано в спецификации) и затем задержка вступает в игру и мы видим `9, 15, 20, 24...`.
 
-Это ограничение существует давно и многие скрипты полагаются на него, поэтому оно существует по историческим причинам. 
+Это ограничение существует давно, многие скрипты полагаются на него, поэтому оно сохраняется по историческим причинам.
 
-Этого ограничения в серверном JavaScript не существует и там есть другие способы планирования немедленной асинхронной работы. Например, [process.nextTick](https://nodejs.org/api/process.html) и [setImmediate](https://nodejs.org/api/timers.html) для Node.js. Так что это ограничение относится только к браузерам.
+Этого ограничения нет в серверном JavaScript. Там есть и другие способы планирования асинхронных задач. Например, [process.nextTick](https://nodejs.org/api/process.html) и [setImmediate](https://nodejs.org/api/timers.html) для Node.js. Так что это ограничение относится только к браузерам.
 ````
 
 ### Даем возможность отрисовки браузеру
 
-Другим преимуществом для браузерных скриптов является возможность показа процесса загрузки или чего-либо ещё пользователю. Это связано с тем, что браузер обычно выполняет все «перерисовки» после завершения скрипта.
+Другим преимуществом разбития тяжёлых задач на части является возможность показать процесс выполнения в браузере.
+
+Обычно браузер отрисовывает изменения после завершения выполнения текущего кода. Так что если функция меняет много элементов -- всё это мы увидим, когда текущий код будет завершён.
 
 Поэтому, если мы делаем одну огромную функцию, то даже если она что-то меняет, изменения не отразятся в документе до ее завершения.
 
@@ -401,7 +403,7 @@ setTimeout(function run() {
     for (let j = 0; j < 1e6; j++) {
       i++;
       // вставляем текущее значение i в <div>
-      // (об innerHTML поговорим в отдельной главе, но его смысл должен быть понятен)
+      // (об innerHTML поговорим в соответствующей главе, здесь мы просто вставляем номер в элемент)
       progress.innerHTML = i;
     }
   }
@@ -438,20 +440,20 @@ setTimeout(function run() {
 </script>
 ```
 
-Теперь в `<div>` показано изменение `i`.
+Теперь `<div>` показывает увеличивающиеся значения `i`.
 
 ## Итого
 
 - Методы `setInterval(func, delay, ...args)` и `setTimeout(func, delay, ...args)` позволяют выполнять `func` регулярно или только один раз после задержки `delay`, заданной в мс.
 - Для отмены выполнения необходимо вызвать `clearInterval/clearTimeout` со значением, которое возвращают методы `setInterval/setTimeout`.
 - Вложенный вызов `setTimeout` является более гибкой альтернативой `setInterval`. Также он может гарантировать минимальное время *между* выполнениями.
-- Планирование с нулевой задержкой `setTimeout(...,0)` используется для вызовов, которые должны быть исполнены "как можно скорее, после завершения исполнения текущего кода".
+- Планирование с нулевой задержкой `setTimeout(func,0)` или, что тоже самое, `setTimeout(func)`, используется для вызовов, которые должны быть исполнены "как можно скорее, после завершения исполнения текущего кода".
 
 Некоторые случаи использования `setTimeout(...,0)`:
 - разделить ресурсоемкие задачи на части, чтобы скрипт не "зависал",
-- позволить браузеру сделать что-то еще, пока идет процесс (отрисовка статуса загрузки).
+- позволить браузеру сделать что-то еще, пока идет процесс (рисовать полоску прогресса).
 
-Обратите внимание, что все методы планирования не дают *гарантию* точности задержки. Поэтому не стоит полагаться на это в запланированном коде.
+Обратим внимание, что все методы планирования *не гарантируют* точную задержку. Не стоит полагаться на это в коде.
 
 Например, таймер в браузере может замедляться по многим причинам:
 - Перегружен процессор.