Какие знаешь статусы пребывания Promise кроме pending?

Какие знаешь статусы пребывания Promise кроме pending?

Promise в JavaScript имеет три статуса (состояния): pending, fulfilled (resolved) и rejected. После создания Promise может находиться в одном из этих состояний, и переход между ними работает по чётким правилам.

Три статуса Promise

1. Pending (ожидание)

Это начальное состояние Promise. Асинхронная операция ещё не завершилась:

const promise = new Promise((resolve, reject) => {
  // Здесь промис находится в состоянии pending
  console.log('Promise создан, статус: pending');
});

console.log(promise); // Promise { <pending> }

2. Fulfilled (выполнено, resolved)

Промис перешёл в это состояние, когда асинхронная операция успешно завершилась. Вызывается функция resolve():

const promise = new Promise((resolve, reject) => {
  setTimeout(() => {
    resolve('Успех!'); // Переход в fulfilled
  }, 1000);
});

promise.then(value => {
  console.log('Статус: fulfilled');
  console.log('Значение:', value); // 'Успех!'
});

3. Rejected (отклонено)

Промис перешёл в это состояние, если произошла ошибка. Вызывается функция reject():

const promise = new Promise((resolve, reject) => {
  setTimeout(() => {
    reject('Ошибка загрузки!'); // Переход в rejected
  }, 1000);
});

promise.catch(error => {
  console.log('Статус: rejected');
  console.log('Ошибка:', error); // 'Ошибка загрузки!'
});

Переходы между статусами

Один раз перейдя из pending, Promise больше не изменит свой статус:

const promise = new Promise((resolve, reject) => {
  resolve('Первый');
  resolve('Второй'); // Игнорируется, уже выполнен
  reject('Ошибка');  // Игнорируется, уже выполнен
});

promise.then(value => {
  console.log(value); // 'Первый' (только первое значение)
});

Это называется immutability (неизменяемость) — статус и значение Promise не могут изменяться после первого перехода.

Практические примеры

Успешное выполнение:

function fetchUser(id) {
  return new Promise((resolve, reject) => {
    setTimeout(() => {
      // Переход в fulfilled
      resolve({
        id: id,
        name: 'John',
        email: 'john@example.com'
      });
    }, 1000);
  });
}

fetchUser(1)
  .then(user => {
    console.log('Статус: fulfilled');
    console.log('Пользователь:', user);
  });

Ошибка:

function fetchData() {
  return new Promise((resolve, reject) => {
    setTimeout(() => {
      // Переход в rejected
      reject(new Error('Network error'));
    }, 1000);
  });
}

fetchData()
  .then(data => {
    console.log('Успех:', data);
  })
  .catch(error => {
    console.log('Статус: rejected');
    console.log('Ошибка:', error.message); // 'Network error'
  });

Проверка статуса Promise

Особенность JavaScript — нет способа напрямую узнать статус Promise. Нужно использовать методы .then(), .catch(), .finally():

const promise = new Promise((resolve) => {
  setTimeout(() => resolve('Done'), 1000);
});

// Нельзя сделать так:
// console.log(promise.status); // undefined

// Нужно использовать:
promise.then(() => {
  console.log('Выполнен (fulfilled)');
});

promise.catch(() => {
  console.log('Ошибка (rejected)');
});

promise.finally(() => {
  console.log('Завершён (независимо от статуса)');
});

Методы обработки статусов

then() — обработка fulfilled и rejected:

promise.then(
  value => {
    // Вызывается если статус fulfilled
    console.log('Успех:', value);
  },
  error => {
    // Вызывается если статус rejected
    console.log('Ошибка:', error);
  }
);

catch() — обработка только rejected:

promise.catch(error => {
  // Вызывается только если статус rejected
  console.log('Ошибка:', error);
});

finally() — выполняется в любом случае:

promise.finally(() => {
  // Выполнится независимо от статуса
  console.log('Операция завершена');
});

Promise Chaining

При цепочке .then() каждое выполнение создаёт новый Promise:

fetch('/api/user/1')
  .then(response => response.json())  // fulfilled → fulfilled (новый Promise)
  .then(user => user.posts)           // fulfilled → fulfilled (новый Promise)
  .catch(error => console.error(error)); // rejected (если был на любом этапе)

Promise.all() — все должны быть fulfilled

const promises = [
  Promise.resolve('A'),
  Promise.resolve('B'),
  Promise.resolve('C')
];

Promise.all(promises)
  .then(values => {
    console.log('Все выполнены:', values); // ['A', 'B', 'C']
  })
  .catch(error => {
    console.log('Хотя бы один rejected:', error);
  });

Если хотя бы один Promise rejected, весь Promise.all переходит в rejected.

Promise.allSettled() — ждёт все независимо

const promises = [
  Promise.resolve('Успех'),
  Promise.reject('Ошибка'),
  Promise.resolve('Ещё успех')
];

Promise.allSettled(promises)
  .then(results => {
    console.log(results);
    // [
    //   { status: 'fulfilled', value: 'Успех' },
    //   { status: 'rejected', reason: 'Ошибка' },
    //   { status: 'fulfilled', value: 'Ещё успех' }
    // ]
  });

Promise.race() — первый завершённый побеждает

const promises = [
  new Promise(r => setTimeout(() => r('Первый'), 1000)),
  new Promise(r => setTimeout(() => r('Второй'), 500))
];

Promise.race(promises)
  .then(winner => {
    console.log('Победитель:', winner); // 'Второй' (быстрее)
  });

Диаграмма переходов

        pending (начальное состояние)
            ↓
       ┌────┴────┐
       ↓         ↓
  fulfilled   rejected
   (resolve)  (reject)
     ↓           ↓
    ↓→ НЕИЗМЕННО ←↓

Async/Await с статусами Promise

async function handlePromise() {
  try {
    const result = await promise; // Ждёт fulfilled
    console.log('Статус: fulfilled, значение:', result);
  } catch (error) {
    console.log('Статус: rejected, ошибка:', error); // Перехватывает rejected
  }
}

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

function loadUserData(userId) {
  return new Promise((resolve, reject) => {
    fetch(`/api/users/${userId}`)
      .then(response => {
        if (!response.ok) {
          throw new Error('HTTP Error'); // Переход в rejected
        }
        return response.json();
      })
      .then(data => {
        resolve(data); // Переход в fulfilled
      })
      .catch(error => {
        reject(error); // Переход в rejected
      });
  });
}

// Использование
loadUserData(1)
  .then(user => {
    console.log('Данные получены (fulfilled):', user);
  })
  .catch(error => {
    console.log('Ошибка при загрузке (rejected):', error);
  })
  .finally(() => {
    console.log('Загрузка завершена');
  });

Вывод

Помимо pending, Promise имеет два других статуса:

1. Fulfilled (resolved) — асинхронная операция успешно завершилась, вызвана resolve()
2. Rejected — произошла ошибка, вызвана reject()

Ключные моменты:

• Promise может быть только в одном из трёх состояний
• Переход из pending необратим
• Обработка разных статусов: .then(), .catch(), .finally()
• Статусы используются для управления асинхронным кодом в JavaScript