Promises (обещания) — это один из механизмов обработки асинхронных операций в JavaScript. Они позволяют более эффективно и читаемо работать с асинхронным кодом, избегая "callback hell" (ада вложенных коллбеков). Promise представляет собой объект, который может быть в одном из трёх состояний: pending (ожидание), fulfilled (выполнено) и rejected (отклонено). Это состояние позволяет работать с результатами асинхронных операций, не блокируя поток выполнения программы.

Основные понятия

pending (ожидание): начальное состояние Promise, до того, как операция завершится.
fulfilled (выполнено): состояние, когда операция завершена успешно.
rejected (отклонено): состояние, когда операция завершена с ошибкой.

Как работает Promise?

Когда вы создаёте Promise, вы передаёте в него функцию, которая выполняет асинхронную задачу (например, запрос к серверу). Эта функция принимает два параметра — resolve и reject:

resolve(value): вызывается, если операция завершена успешно.
reject(error): вызывается, если операция завершена с ошибкой.

После выполнения асинхронной операции Promise либо переходит в состояние fulfilled, либо в состояние rejected.

Пример использования Promise

let promise = new Promise((resolve, reject) => {
  let success = true;  // Симуляция успешной операции

  if (success) {
    resolve("Operation was successful!");  // Операция выполнена успешно
  } else {
    reject("Operation failed!");  // Операция не удалась
  }
});

promise
  .then(result => {
    console.log(result);  // Обрабатываем результат успешной операции
  })
  .catch(error => {
    console.log(error);  // Обрабатываем ошибку
  });

Пояснение:

Создание Promise: Внутри конструктора Promise мы проверяем, выполнена ли операция успешно (переменная success). В зависимости от этого мы вызываем resolve() или reject().

Обработка результатов: После создания Promise можно использовать метод .then() для обработки успешного результата и метод .catch() для обработки ошибок.

Цепочки Promises

Метод .then() возвращает новый Promise, что позволяет цепочить несколько асинхронных операций, выполняя их последовательно.

let promise = new Promise((resolve, reject) => {
  resolve("Step 1 completed");
});

promise
  .then(result => {
    console.log(result);
    return "Step 2 completed";  // Передаём результат следующему then
  })
  .then(result => {
    console.log(result);
    return "Step 3 completed";
  })
  .then(result => {
    console.log(result);
  });

Пояснение:

Каждый .then() метод получает результат предыдущего шага и передает его следующему.
Мы можем легко строить цепочку асинхронных операций, упрощая обработку ошибок и результатов.

Обработка ошибок с помощью `.catch()`

Метод .catch() используется для обработки ошибок в Promise. Если какая-то из операций в цепочке завершится ошибкой, управление передастся в .catch().

let promise = new Promise((resolve, reject) => {
  let success = false;  // Симуляция ошибки
  if (success) {
    resolve("Operation was successful");
  } else {
    reject("Operation failed");
  }
});

promise
  .then(result => {
    console.log(result);
  })
  .catch(error => {
    console.log("Error: " + error);  // Обработка ошибки
  });

Асинхронные функции и `async/await`

С введением async/await в ECMAScript 2017 (ES8), работа с Promises стала ещё удобнее. async превращает функцию в асинхронную, а await используется для ожидания выполнения Promise.

async function fetchData() {
  try {
    let response = await someAsyncFunction();
    console.log(response);
  } catch (error) {
    console.log(error);
  }
}

Пояснение:

async позволяет использовать await внутри функции.
await приостанавливает выполнение функции до тех пор, пока Promise не завершится, и затем возвращает его результат.