Какой будет ответ, если вызвать Promise.Resolve, а потом Promise.Reject?

Ответ на вопрос о последовательных вызовах Promise.Resolve и Promise.Reject

Краткий ответ

Если вызвать Promise.resolve(), а потом Promise.reject(), то мы получим два отдельных промиса, а не один цепочный результат. Первый промис успешно выполнится (fulfilled), второй - отклонится (rejected). Они не связаны друг с другом, если не объединены в цепочку с помощью .then() и .catch().

Детальное объяснение

В JavaScript Promise.resolve() и Promise.reject() - это статические методы конструктора Promise, которые возвращают новые промисы с разными состояниями:

// Создаем успешный промис
const resolvedPromise = Promise.resolve('Успех!');

// Создаем отклоненный промис
const rejectedPromise = Promise.reject('Ошибка!');

// Эти промисы независимы друг от друга

Что произойдет при последовательном вызове:

// Пример 1: Независимые вызовы
Promise.resolve('Первый успех')
  .then(result => console.log('Resolved:', result)); // Выполнится

Promise.reject('Первая ошибка')
  .catch(error => console.log('Rejected:', error)); // Выполнится

// Оба обработчика сработают независимо

Ключевые особенности:

• Promise.resolve(value) создает промис, который сразу переходит в состояние fulfilled с переданным значением
• Promise.reject(reason) создает промис, который сразу переходит в состояние rejected с причиной отклонения
• Эти вызовы не отменяют и не влияют друг на друга, если не объединены в цепочку

Правильная цепочка промисов

Если вы хотите создать последовательность, где отклонение прерывает выполнение, нужно использовать цепочку:

// Пример 2: Цепочка с обработкой ошибок
Promise.resolve('Начало')
  .then(result => {
    console.log('Шаг 1:', result);
    return Promise.reject('Искусственная ошибка');
  })
  .then(result => {
    // Этот блок НЕ выполнится из-за ошибки выше
    console.log('Шаг 2:', result);
  })
  .catch(error => {
    // Этот блок выполнится для обработки ошибки
    console.log('Поймана ошибка:', error);
  });

// Вывод:
// Шаг 1: Начало
// Поймана ошибка: Искусственная ошибка

Практический пример с асинхронными операциями

// Пример 3: Реальный сценарий
function fetchUserData(userId) {
  // Сначала проверяем валидность ID
  if (!userId) {
    return Promise.reject('Неверный ID пользователя');
  }
  
  // Затем делаем асинхронный запрос
  return Promise.resolve({ id: userId, name: 'Иван Иванов' })
    .then(user => {
      // Дополнительная обработка
      user.lastLogin = new Date();
      return user;
    });
}

// Использование
fetchUserData(123)
  .then(user => console.log('Данные:', user))
  .catch(error => console.error('Ошибка:', error));

fetchUserData(null)
  .then(user => console.log('Данные:', user)) // Не выполнится
  .catch(error => console.error('Ошибка:', error)); // Выполнится

Важные нюансы

1. Состояния промисов:

   • pending - ожидание
   • fulfilled - успешно выполнено
   • rejected - отклонено с ошибкой

2. Обработка ошибок:

   // Неправильно - ошибка не будет поймана
   Promise.resolve()
     .then(() => Promise.reject('Ошибка'));
   
   // Правильно - с обработкой
   Promise.resolve()
     .then(() => Promise.reject('Ошибка'))
     .catch(error => console.error(error));
   

3. Использование async/await:

   async function example() {
     try {
       const result1 = await Promise.resolve('Успех');
       console.log(result1);
       
       // Следующая строка вызовет исключение
       const result2 = await Promise.reject('Ошибка');
     } catch (error) {
       console.log('Поймано в catch:', error);
     }
   }
   
   example();
   

Вывод

Вызов Promise.resolve() и Promise.reject() создает два независимых промиса с разными состояниями. Для создания последовательной логики с обработкой ошибок необходимо:

• Объединять промисы в цепочку с помощью .then() и .catch()
• Использовать async/await с блоком try-catch
• Помнить, что каждый вызов Promise.reject() требует отдельной обработки ошибок, иначе может возникнуть необработанное исключение

Это фундаментальное поведение промисов в JavaScript, которое обеспечивает гибкость в управлении асинхронными операциями и обработке ошибок.