Используется ли Promise только для асинхронных операций во внешней среде

Promise: не только для асинхронных операций

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

Promise для синхронного кода

Promise можно использовать для синхронных операций. Код внутри Promise.resolve() выполняется сразу:

// Promise для синхронной операции
const syncPromise = Promise.resolve(42);

syncPromise.then(value => {
  console.log("Value:", value); // Value: 42
});

console.log("Executed first"); // Это выполнится раньше!

// Результат:
// Executed first
// Value: 42

Почему это полезно? Потому что вы получаете единый интерфейс для работы с данными, независимо от того, доступны ли они синхронно или асинхронно:

// Функция может возвращать данные синхронно или асинхронно
function getData(useAsync) {
  if (useAsync) {
    return fetch("/api/data").then(r => r.json());
  } else {
    return Promise.resolve({ name: "John", age: 30 });
  }
}

// Код всегда одинаков
getData(false).then(data => {
  console.log(data);
});

Promise для управления потоком выполнения

Проблема: вам нужно выполнить несколько задач в определённом порядке, но не все они асинхронные.

// Promise решает эту проблему
function processData() {
  return Promise.resolve()
    .then(() => {
      console.log("Step 1: Load config");
      return config;
    })
    .then(cfg => {
      console.log("Step 2: Validate", cfg);
      return validateConfig(cfg);
    })
    .then(validCfg => {
      console.log("Step 3: Fetch data");
      return fetch("/api/data");
    })
    .then(res => res.json())
    .then(data => {
      console.log("Step 4: Process", data);
      return processData(data);
    })
    .catch(error => {
      console.error("Error:", error);
    });
}

Promise для задержек и таймаутов

Promise часто используется для создания таймаутов:

// Удобный способ создать задержку
function delay(ms) {
  return new Promise(resolve => setTimeout(resolve, ms));
}

async function retryWithDelay() {
  let attempts = 0;
  while (attempts < 3) {
    try {
      return await fetch("/api/flaky-endpoint");
    } catch (error) {
      attempts++;
      if (attempts < 3) {
        await delay(1000); // Подождать 1 секунду перед повтором
      }
    }
  }
  throw new Error("Failed after 3 attempts");
}

Promise как инструмент композиции

Promise.all() — выполнить несколько операций параллельно (синхронные или асинхронные):

// Все операции синхронные
const results = await Promise.all([
  Promise.resolve(1),
  Promise.resolve(2),
  Promise.resolve(3)
]);

console.log(results); // [1, 2, 3]

// Смешанные синхронные и асинхронные
const mixed = await Promise.all([
  fetch("/api/users").then(r => r.json()), // асинхронная
  Promise.resolve(loadLocalData()),        // синхронная
  calculateTotal()                         // синхронная
]);

Promise.race() — подождать первого результата:

// Таймаут для fetch
function fetchWithTimeout(url, timeout = 5000) {
  return Promise.race([
    fetch(url),
    new Promise((_, reject) =>
      setTimeout(() => reject(new Error("Timeout")), timeout)
    )
  ]);
}

fetchWithTimeout("/api/data", 3000);

Promise для обработки ошибок

Promise и .catch() — единый механизм обработки ошибок:

// Обработка синхронных и асинхронных ошибок одинаково
function safeOperation() {
  return Promise.resolve()
    .then(() => {
      // Может быть синхронная ошибка
      if (!config.isValid) {
        throw new Error("Invalid config");
      }
      return config;
    })
    .then(cfg => {
      // Может быть асинхронная ошибка
      return fetch("/api/validate", { body: JSON.stringify(cfg) });
    })
    .catch(error => {
      // Обрабатывает обе ошибки одинаково
      console.error("Operation failed:", error);
      return null;
    });
}

Promise для модулей и инициализации

Lazy initialization с Promise:

// Модуль инициализируется при первом использовании
let database = null;
let initPromise = null;

function initDatabase() {
  if (initPromise) return initPromise;
  
  initPromise = Promise.resolve()
    .then(() => console.log("Connecting..."))
    .then(() => connectToDB())
    .then(conn => {
      database = conn;
      console.log("Connected");
      return database;
    });
  
  return initPromise;
}

async function query(sql) {
  const db = await initDatabase();
  return db.run(sql);
}

Promise vs Callback Hell

Callback Hell — если не использовать Promise:

// Кошмар читаемости
loadConfig((err1, config) => {
  if (err1) handleError(err1);
  else {
    validateConfig(config, (err2, valid) => {
      if (err2) handleError(err2);
      else {
        fetchData((err3, data) => {
          if (err3) handleError(err3);
          else {
            processData(data, (err4, result) => {
              if (err4) handleError(err4);
              else console.log("Done:", result);
            });
          }
        });
      }
    });
  }
});

// С Promise — читаемо и просто
Promise.resolve()
  .then(() => loadConfig())
  .then(config => validateConfig(config))
  .then(() => fetchData())
  .then(data => processData(data))
  .catch(handleError);

Выводы

Promise используется для:

• Асинхронных операций (API, файлы) — это основное применение
• Синхронного кода — для единого интерфейса
• Управления потоком выполнения — последовательные операции
• Обработки ошибок — единый механизм для всех типов ошибок
• Композиции операций — Promise.all, Promise.race
• Таймаутов и задержек — удобный синтаксис
• Инициализации — lazy loading модулей

Promise — это универсальный инструмент для управления асинхронным и синхронным кодом в JavaScript. Это не только про API запросы!