👾 smth

Author: Rnbsov

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

@@ -1,3 +1,4 @@
+
 # Промисы
 
 Представьте, что вы известный певец, которого фанаты постоянно донимают расспросами о предстоящем сингле.
@@ -210,7 +211,7 @@ promise.catch(alert); // выведет "Error: Ошибка!" спустя од
 
 Вызов `.catch(f)` - это сокращённый, "укороченный" вариант  `.then(null, f)`.
 
-### finally
+## Очистка: finally
 
 По аналогии с блоком `finally` из обычного `try {...} catch {...}`, у промисов также есть метод `finally`.
 
@@ -234,32 +235,46 @@ new Promise((resolve, reject) => {
 Но это не совсем псевдоним `then(f,f)`, как можно было подумать. Существует несколько важных отличий:
 
 1. Обработчик, вызываемый из `finally`, не имеет аргументов. В `finally` мы не знаем, как был завершён промис. И это нормально, потому что обычно наша задача - выполнить "общие" завершающие процедуры.
+
+    Пожалуйста, взгляните на приведенный выше пример: как вы можете видеть, обработчик `finally` не имеет аргументов, а результат promise обрабатывается в следующем обработчике.
+
 2. Обработчик `finally` "пропускает" результат или ошибку дальше, к последующим обработчикам.
 
     Например, здесь результат проходит через `finally` к `then`:
+    
     ```js run
     new Promise((resolve, reject) => {
       setTimeout(() => resolve("result"), 2000)
     })
-      .finally(() => alert("Промис завершён"))
-      .then(result => alert(result)); // <-- .then обработает результат
+      .finally(() => alert("Промис завершён")) // срабатывает первым
+      .then(result => alert(result)); // <-- .then показывает "значение"
     ```
-
+    
+    Как вы можете видеть, значение возвращаемое первым промисом, передается через `finally` к следующему `then`.
+    
+    Это очень удобно, потому что `finally` не предназначен для обработки результата промиса. Как уже было сказано, это место для проведения общей очистки, независимо от того, каков был результат.
+    
     А здесь ошибка из промиса проходит через `finally` к `catch`:
 
     ```js run
     new Promise((resolve, reject) => {
       throw new Error("error");
     })
-      .finally(() => alert("Промис завершён"))
-      .catch(err => alert(err));  // <-- .catch обработает объект ошибки
+      .finally(() => alert("Промис завершён")) // срабатывает первым
+      .catch(err => alert(err));  // <-- .catch показывает ошибку
     ```  
 
-    Это очень удобно, потому что `finally` не предназначен для обработки результата промиса. Так что он просто пропускает его через себя дальше.
+3. Обработчик `finally` также не должен ничего возвращать. Если это так, то возвращаемое значение молча игнорируется.
+
+    Единственным исключением из этого правила является случай, когда обработчик `finally` выдает ошибку. Затем эта ошибка передается следующему обработчику вместо любого предыдущего результата.
+    
+Подведем итог:
 
-    Мы более подробно поговорим о создании цепочек промисов и передаче результатов между обработчиками в следующей главе.
+- Обработчик `finally` не получает результат предыдущего обработчика (у него нет аргументов). Вместо этого этот результат передается следующему подходящему обработчику.
+- Если обработчик `finally` возвращает что-то, это игнорируется.
+- Когда `finally` выдает ошибку, выполнение переходит к ближайшему обработчику ошибок.
 
-3. Последнее, но не менее значимое: вызов `.finally(f)` удобнее, чем `.then(f, f)` - не надо дублировать функции f.
+Эти функции полезны и заставляют все работать правильно, если мы используем `finally` так, как предполагается: для общих процедур очистки.
 
 ````smart header="На завершённых промисах обработчики запускаются сразу"
 Если промис в состоянии ожидания, обработчики в `.then/catch/finally` будут ждать его. Однако, если промис уже завершён, то обработчики выполнятся сразу: