Откуда в Promise берутся resolve и reject

Откуда берутся resolve и reject в Promise

resolve и reject — это функции, которые передаются в конструктор Promise в качестве аргументов. Когда вы создаете новый Promise, вы получаете эти две функции для контроля его состояния.

Как это работает

When you create a Promise, you pass a callback function (called executor) to the constructor. This executor function automatically receives two parameters: resolve and reject.

new Promise((resolve, reject) => {
  // resolve и reject - это функции
  // Вы их вызываете, чтобы изменить состояние Promise
});

Структура Promise конструктора

const promise = new Promise((resolve, reject) => {
  // executor функция - выполняется сразу же при создании
  
  // resolve - функция для успешного завершения
  // reject - функция для отклонения (ошибка)
});

Простые примеры

Пример 1: Базовый Promise с resolve

const promise = new Promise((resolve, reject) => {
  console.log("Promise создан");
  
  // Вызываем resolve через 1 секунду
  setTimeout(() => {
    resolve("Успех!");
  }, 1000);
});

promise.then(result => {
  console.log(result); // "Успех!"
});

Пример 2: Promise с reject

const promise = new Promise((resolve, reject) => {
  const error = new Error("Что-то пошло не так");
  
  setTimeout(() => {
    reject(error);
  }, 1000);
});

promise.catch(error => {
  console.log(error.message); // "Что-то пошло не так"
});

Пример 3: Условное выполнение

const promise = new Promise((resolve, reject) => {
  const random = Math.random();
  
  if (random > 0.5) {
    resolve("Вам повезло!");
  } else {
    reject("Не повезло...");
  }
});

promise
  .then(result => console.log(result))
  .catch(error => console.log(error));

Детальный разбор: откуда они берутся

Шаг за шагом

// Шаг 1: Создаем новый Promise
const myPromise = new Promise((resolve, reject) => {
  // Шаг 2: JavaScript автоматически создает функции resolve и reject
  // и передает их в качестве аргументов функции executor
  
  // Шаг 3: Мы можем вызвать эти функции
  resolve("данные");
  // или
  reject(new Error("ошибка"));
});

Ключевой момент: resolve и reject — это внутренние функции Promise, которые JavaScript автоматически создает и передает вам.

Что делают resolve и reject

resolve(value)

const promise = new Promise((resolve, reject) => {
  // resolve меняет состояние Promise на "fulfilled"
  resolve(42);
});

promise.then(value => {
  console.log(value); // 42
});

resolve передает значение в then() обработчик.

reject(reason)

const promise = new Promise((resolve, reject) => {
  // reject меняет состояние Promise на "rejected"
  reject(new Error("Ошибка!"));
});

promise.catch(error => {
  console.log(error.message); // "Ошибка!"
});

reject передает причину ошибки в catch() обработчик.

Состояния Promise

const promise = new Promise((resolve, reject) => {
  // Состояние: "pending" (ожидание)
  // Это состояние до вызова resolve или reject
  
  setTimeout(() => {
    resolve("данные");
    // Состояние: "fulfilled" (выполнено)
  }, 1000);
});

Три состояния Promise:

1. Pending — начальное состояние, Promise ещё выполняется
2. Fulfilled — Promise выполнен успешно, вызван resolve()
3. Rejected — Promise отклонен, вызван reject()

Практический пример: fetch с Promise

function fetchUser(userId) {
  return new Promise((resolve, reject) => {
    // Симуляция API запроса
    setTimeout(() => {
      if (userId > 0) {
        resolve({
          id: userId,
          name: "Иван",
          email: "ivan@mail.com"
        });
      } else {
        reject(new Error("Неверный ID"));
      }
    }, 1000);
  });
}

// Использование
fetchUser(1)
  .then(user => console.log("Пользователь:", user))
  .catch(error => console.log("Ошибка:", error.message));

Важные правила

1. Resolve и reject вызываются только один раз

const promise = new Promise((resolve, reject) => {
  resolve("первый");
  resolve("второй"); // этот вызов будет проигнорирован
  reject(new Error("ошибка")); // и этот тоже
});

promise.then(value => {
  console.log(value); // "первый" (только первый вызов действует)
});

2. Нельзя использовать оба одновременно

const promise = new Promise((resolve, reject) => {
  if (success) {
    resolve(data); // используем resolve
  } else {
    reject(error); // или reject, но не оба
  }
});

3. Можно передать другой Promise

const promise1 = new Promise((resolve, reject) => {
  resolve(42);
});

const promise2 = new Promise((resolve, reject) => {
  resolve(promise1); // resolve может получить другой Promise
});

promise2.then(value => {
  console.log(value); // 42
});

Современный подход: async/await

// Вместо явного использования Promise:
async function getData() {
  return new Promise((resolve, reject) => {
    resolve("данные");
  });
}

// Лучше использовать async/await:
async function getData() {
  return "данные";
  // или
  throw new Error("ошибка");
}

const data = await getData();

Практический пример: обработка ошибок

function loadJSON(url) {
  return new Promise((resolve, reject) => {
    fetch(url)
      .then(response => {
        if (!response.ok) {
          reject(new Error("HTTP ошибка"));
        }
        return response.json();
      })
      .then(data => resolve(data))
      .catch(error => reject(error));
  });
}

loadJSON("https://api.example.com/data")
  .then(data => console.log("Успех:", data))
  .catch(error => console.log("Ошибка:", error.message));

Ключевые выводы

1. resolve и reject — это функции, автоматически передаваемые в executor функцию Promise
2. resolve используется для успешного завершения Promise
3. reject используется для отклонения Promise при ошибке
4. Каждый из них может быть вызван только один раз
5. Promise гарантирует, что состояние не изменится после первого вызова resolve или reject
6. В современном коде используйте async/await вместо явного создания Promise