Text improovments

Author: nglazov

1-js/11-async/02-promise-basics/article.md

@@ -2,15 +2,15 @@
 
 Представьте, что вы известный певец, которого фанаты постоянно донимают расспросами о предстоящем сингле.
 
-Чтобы получить передышку, вы обещаете разослать его им, когда он будет опубликован. Вы даете фанатам список, в который они могут записаться, чтобы получить новости. Они могут оставить свой e-mail, чтобы когда песня выйдет сразу получить её. И даже больше, если, например, вы передумаете выпускать песню, они также получат уведомление об этом.
+Чтобы получить передышку, вы обещаете разослать им сингл, когда он будет выпущен. Вы даете фанатам список, в который они могут записаться, чтобы получать новости. Они могут оставить свой e-mail, чтобы когда песня выйдет сразу получить её. И даже больше, если, например, вы передумаете выпускать песню, они также получат уведомление об этом.
 
 Все счастливы! Вы счастливы, потому что вас больше не донимают фанаты, а фанаты - могут больше не беспокоится, что пропустят новый сингл.
 
 Это аналогия из реальной жизни для ситуаций, с которыми мы часто сталкиваемся в программировании:
 
 1. "Певец" - это "создающий" код, который делает что-то, что занимает время. Например, скачивает новый скрипт.
 2. "Фанаты" - это "потребляющий" код, который хочет получить результат "создающего" кода, когда он будет готов. Этот результат может быть необходим большому количеству функций.
-3. *Promise* (обещание) - это специальный объект в JavaScript, который связывает "создающий" и "потребляющий" коды вместе. В терминах нашей аналогии - это "список подписок". "Создающий" код может выполнятся любое необходимое ему время, чтобы получить обещанный результат, а *обещание* делает результат доступным для всего кода, который подписан на него, когда результат готов.
+3. *Promise* (обещание) - это специальный объект в JavaScript, который связывает "создающий" и "потребляющий" коды вместе. В терминах нашей аналогии - это "список подписок". "Создающий" код может выполнятся любое необходимое ему время, чтобы получить обещанный результат, а *промис* делает результат доступным для всего кода, который подписан на него, когда результат готов.
 
 Аналогия не совсем точна, потому что объект Promise в JavaScript гораздо сложнее простого списка подписок: он обладает дополнительными возможностями и ограничениями. Но для начала и она хороша.
 
@@ -22,14 +22,14 @@ let promise = new Promise(function(resolve, reject) {
 });
 ```
 
-Функция, переданная в конструкцию `new Promise` называется *исполнитель*. Когда `Promise` создан, функция-исполнитель запускается автоматически. Она содержит "создающий" код, который когда-нибудь создать результат. В терминах аналогии: *исполнитель* - это "певец".
+Функция, переданная в конструкцию `new Promise` называется *исполнитель*. Когда `Promise` создан, функция-исполнитель запускается автоматически. Она содержит "создающий" код, который когда-нибудь создаст результат. В терминах нашей аналогии: *исполнитель* - это "певец".
 
 Объект `Promise`, полученный в результате выполнения конструктора, имеет внутренние свойства:
 
-- `state` ("состояние") — вначале `pending` ("ожидание"), потом может измениться на `fulfilled` («выполнено успешно») or `rejected` ("выполнено с ошибкой"),
+- `state` ("состояние") — вначале `pending` ("ожидание"), потом может измениться на `fulfilled` ("выполнено успешно") или `rejected` ("выполнено с ошибкой"),
 - `result` ("результат") — имеет произвольное значение, по вашему выбору, изначально `undefined`.
 
-Когда исполнитель завершает выполнение, он должен вызвать одну из функций, полученных в качестве аргументов:
+Когда функция-исполнитель завершает своё выполнение, она должна вызвать одну из функций, полученных в качестве аргументов:
 
 - `resolve(value)` — сообщает, что работа выполнена успешно:
     - устанавливает в `state` значение `"fulfilled"`,
@@ -55,8 +55,8 @@ let promise = new Promise(function(resolve, reject) {
 
 Мы можем наблюдать две вещи, запустив код выше:
 
-1. Исполнитель вызывается автоматически и сразу (с помощью `new Promise`).
-2. Исполнитель получает два аргумента: `resolve` и `reject` — эти функции встроены в JavaScript, поэтому нам не нужно их создавать. Вместо этого мы должны написать функцию-исполнитель, для их вызова по готовности.
+1. Исполнитель будет вызван автоматически без задержек (с помощью `new Promise`).
+2. Исполнитель получает два аргумента: `resolve` и `reject` — это функции встроенные в JavaScript, поэтому нам не нужно их писать. Вместо этого мы должны написать функцию-исполнитель, которая вызовет одну из них по готовности.
 
 Спустя одну секунду "обработки" исполнитель вызовет `resolve("done")`, чтобы передать результат:
 
@@ -93,7 +93,7 @@ let promise = new Promise(function(resolve, reject) {
 });
 ```
 
-Идея в том, что задача выполненная исполнителем может иметь только что-то одно: результат или ошибку.
+Идея в том, что задача выполняемая исполнителем может иметь только один итог: результат или ошибку.
 
 Также, `resolve`/`reject` ожидает только один аргумент (или ни одного), а все дополнительные аргументы будут проигнорированы.
 ````
@@ -102,8 +102,8 @@ let promise = new Promise(function(resolve, reject) {
 На случай, когда что-то пойдёт неправильно, `reject` может быть вызван аргументом любого типа (как и `resolve`). Но рекомендуется использовать объект `Error` (или унаследованный от него). "Почему так?" Скоро нам станет понятно.
 ```
 
-````smart header="Мгновенный вызов `resolve`/`reject`"
-Обычно, исполнитель делает что-то асинхронное и после этого вызывает `resolve`/`reject`  через какое-то время, но это не обязательно. `resolve` или `reject` могут быть вызваны сразу, как в примере:
+````smart header="Вызов `resolve`/`reject` сразу"
+Обычно, исполнитель делает что-то асинхронное и после этого вызывает `resolve`/`reject` через какое-то время, но это не обязательно. `resolve` или `reject` могут быть вызваны сразу:
 
 ```js
 let promise = new Promise(function(resolve, reject) {
@@ -118,7 +118,7 @@ let promise = new Promise(function(resolve, reject) {
 ````
 
 ```smart header="Свойства `state` и `result` - внутренние"
-Свойства `state` и `result` - это внутренние свойства объекта `Promise` и мы не имеем к ним прямого доступа из "потребляющего" кода. Для этого следует использовать методы `.then`/`.catch`/`.finally`, про них речь пойдет дальше.
+Свойства `state` и `result` - это внутренние свойства объекта `Promise` и мы не имеем к ним прямого доступа из "потребляющего" кода. Для обработки результата следует использовать методы `.then`/`.catch`/`.finally`, про них речь пойдет дальше.
 ```
 
 ## Потребители: then, catch, finally
@@ -138,17 +138,17 @@ promise.then(
 );
 ```
 
-Первый аргумент метода `.then` - функция, которая
+Первый аргумент метода `.then` - функция, которая:
 
-1. выполняется, когда `Promise` переходит в состояние `fulfilled`
+1. выполняется, когда `Promise` переходит в состояние `fulfilled`, и
 2. получает результат.
 
 Второй аргумент `.then`  - функция, которая:
 
-1. выполняется, когда `Promise` переходит в состояние `rejected`
+1. выполняется, когда `Promise` переходит в состояние `rejected`, и
 2. получает ошибку.
 
-Например, ниже реакции на успешно завершенный промис:
+Например, ниже реакции на успешно выполненный промис:
 
 ```js run
 let promise = new Promise(function(resolve, reject) {
@@ -209,11 +209,11 @@ promise.catch(alert); // выведет "Error: Whoops!" спустя одну 
 */!*
 ```
 
-Вызов `.catch(f)` - это сокращенный вариант `.then(null, f)`, внутри они полностью аналогичны.
+Вызов `.catch(f)` - это сокращенный вариант `.then(null, f)`, внутри они полностью одинаковые.
 
 ### Метод finally (в конце)
 
-По аналогии с блоком `finally` из обычного `try {...} catch {...}`, в `promise`, также есть метод `finally`
+По аналогии с блоком `finally` из обычного `try {...} catch {...}`, в `promise`, также есть метод `finally`.
 
 Вызов `.finally(f)` это тоже самое, что передать в `.then(f, f)`, в том смысле, что "потребляющий" код выполниться в любом случае, когда промис станет решённым: успешно или с ошибкой.
 
@@ -232,9 +232,9 @@ new Promise((resolve, reject) => {
   .then(result => show result, err => show error)
 ```
 
-Это не совсем псевдоним, как можно подумать. Существует несколько важных отличий:
+Это не совсем псевдоним, как можно было подумать. Существует несколько важных отличий:
 
-1. Обработчик, вызываемый из `finally` не имеет аргументов. Мы не знаем, как в `finally` был завершён `Promise`. И это нормально, потому что обычно, наша задача - выполнить "главные" завершающие процедуры.
+1. Обработчик, вызываемый из `finally` не имеет аргументов. В `finally` мы не знаем, как  был завершён `Promise`. И это нормально, потому что обычно, наша задача - выполнить "основные" завершающие процедуры.
 2. `Finally` пропустит результат или ошибку к следующим обработчикам.
 
     Например, здесь результат проходит через `finally` к `then`:
@@ -263,15 +263,15 @@ new Promise((resolve, reject) => {
 3. Последнее, но не менее значимое, у метода `.finally(f)` более удобный синтаксис, чем у`.then(f, f)`: не надо дублировать функции.
 
 ````smart header="На завершенных промисах обработчики запускаются сразу"
-Если `promise` в состоянии ожидания, обработчики в `.then/catch/finally` будут ждать окончания. Однако, если `promise` уже решён, тогда они выполнятся сразу:
+Если промис в состоянии ожидания, обработчики в `.then/catch/finally` будут ждать его окончания. Однако, если `promise` уже решён, тогда обработчики выполнятся сразу:
 
 ```js run
 // мгновенный перевод `promise` в состояние решён
 let promise = new Promise(resolve => resolve("done!"));
 
 promise.then(alert); // done! (выведется сразу)
 ```
-Хорошо то, что обработчик `.then` гарантированно запустится независимо от того, установится `Promise` мгновенно, или через какое-то время.
+Хорошо то, что обработчик `.then` гарантированно будет запущен независимо от того, был ли `Promise` выполнен мгновенно, или находится в состоянии ожидания.
 ````
 
 Теперь, рассмотрим несколько практических примеров того, как `Promise` может облегчить нам написание асинхронного кода.
@@ -296,7 +296,7 @@ function loadScript(src, callback) {
 
 Теперь перепишем её используя `Promise`.
 
-Новой функции `loadScript` не требуется аргумент callback. Вместо этого она будет создавать и возвращать объект `Promise`, который будет переходить в состояние решён, когда загрузка закончится. Внешний код может добавлять обработчики (функции-подписчиков) используя для этого метод `.then`:
+Новой функции `loadScript` будет не нужен аргумент callback. Вместо этого она будет создавать и возвращать объект `Promise`, который будет переходить в состояние решён, когда загрузка закончится. Внешний код может добавлять обработчики (функции-подписчиков) используя для этого метод `.then`:
 
 ```js run
 function loadScript(src) {