Что попадает в результат другого Promise при множественных вызовах?

Работа с результатом Promise при множественных вызовах

Когда речь идёт о множественных вызовах одного и того же Promise, важно понимать, что Promise в JavaScript — это объект, представляющий будущее завершение (или ошибку) асинхронной операции. Ключевая особенность: Promise не является функцией-вычислителем, а лишь контейнером для результата.

Основной принцип: "Мемоизация" результата

Promise запоминает своё состояние и результат после первого разрешения (resolve) или отклонения (reject). Это означает:

const myPromise = new Promise((resolve) => {
  console.log('Создаётся Promise');
  setTimeout(() => resolve('Результат'), 1000);
});

// Множественные вызовы then
myPromise.then(result => console.log('Первый вызов:', result));
myPromise.then(result => console.log('Второй вызов:', result));
myPromise.then(result => console.log('Третий вызов:', result));

// В консоли будет:
// "Создаётся Promise" (один раз!)
// Через 1 секунду:
// "Первый вызов: Результат"
// "Второй вызов: Результат"
// "Третий вызов: Результат"

Ключевые аспекты поведения

1. Единоразовое вычисление:

   • Функция-исполнитель (executor) (resolve, reject) => {...} вызывается сразу при создании Promise
   • Она выполняется только один раз, независимо от количества подписок

2. Неизменяемость результата:

   const promise = new Promise(resolve => {
     resolve(Math.random());
   });
   
   promise.then(value => console.log(value)); // 0.123456
   promise.then(value => console.log(value)); // 0.123456 (то же значение!)
   promise.then(value => console.log(value)); // 0.123456 (то же значение!)
   

   • Random вычисляется один раз, результат фиксируется

3. Состояния Promise:

   • pending — ожидание (до первого разрешения)
   • fulfilled — успешно завершён (после resolve)
   • rejected — завершён с ошибкой (после reject)
   • Переход между состояниями необратим

Практические последствия

Для успешного завершения:

const successfulPromise = Promise.resolve('Данные');

// Все обработчики получат одинаковый результат
successfulPromise.then(data => console.log(data)); // "Данные"
successfulPromise.then(data => console.log(data)); // "Данные"

Для ошибок:

const failedPromise = Promise.reject(new Error('Ошибка'));

// Все обработчики ошибок получат одну и ту же ошибку
failedPromise.catch(err => console.log(err.message)); // "Ошибка"
failedPromise.catch(err => console.log(err.message)); // "Ошибка"

Отличие от обычных функций

// Обычная функция — вычисляет каждый раз
function getData() {
  return Math.random();
}
console.log(getData(), getData(), getData()); // Все разные значения

// Promise — вычисляет один раз
const promiseData = Promise.resolve(Math.random());
promiseData.then(v => console.log(v, v, v)); // Все одинаковые значения

Особые случаи и нюансы

1. Поздние подписчики:

   const promise = new Promise(resolve => {
     setTimeout(() => resolve('Готово'), 1000);
   });
   
   // Подписка ДО завершения
   promise.then(result => console.log('До:', result));
   
   setTimeout(() => {
     // Подписка ПОСЛЕ завершения (через 2 секунды)
     promise.then(result => console.log('После:', result)); // Сработает сразу!
   }, 2000);
   

   • Если Promise уже завершён, then/catch выполняются немедленно

2. Цепочки Promise:

   const basePromise = Promise.resolve(10);
   
   const chain1 = basePromise.then(x => x * 2); // 20
   const chain2 = basePromise.then(x => x + 5); // 15
   
   // chain1 и chain2 — РАЗНЫЕ Promise, но оба основаны на одном результате
   

3. Повторное использование vs Создание нового:

   // ПЛОХО: создаёт новый Promise каждый раз
   function fetchData() {
     return fetch('/api/data'); // Новый запрос при каждом вызове
   }
   
   // ХОРОШО: переиспользует существующий результат
   let cachedPromise;
   function getCachedData() {
     if (!cachedPromise) {
       cachedPromise = fetch('/api/data');
     }
     return cachedPromise;
   }
   

Выводы и рекомендации

1. Promise идеально подходит для кэширования асинхронных результатов
2. Один Promise — один результат, что обеспечивает консистентность данных
3. Не стоит путать повторное использование Promise с созданием новых
4. Для повторных вычислений нужно создавать новые экземпляры Promise
5. Шаблон "одиночка" (Singleton) для асинхронных операций естественно ложится на Promise

Это поведение делает Promise мощным инструментом для управления асинхронными операциями, особенно в сценариях, где требуется согласованность данных и избегание повторных вычислений.