re:re:actable
Урок 182 минуты чтения

Callback hell и как его избежать

На этой странице
Кратко

Callback hell («пирамида судьбы») — глубокая вложенность колбэков, когда каждая асинхронная операция зависит от результата предыдущей. Код плохо читается, ошибки приходится обрабатывать на каждом уровне, а логику трудно менять. Решения: именованные функции, промисы с цепочками then, async/await и комбинаторы Promise.all.

Вопрос

Что такое callback hell? Почему это проблема и как ее избежать?

Как выглядит

getUser(userId, (error, user) => {
  if (error) return handle(error);
  getOrders(user.id, (error, orders) => {
    if (error) return handle(error);
    getOrderDetails(orders[0].id, (error, details) => {
      if (error) return handle(error);
      calculateDelivery(details, (error, delivery) => {
        if (error) return handle(error);
        render(user, details, delivery);
      });
    });
  });
});

Проблемы:

  • код растет вправо и читается снизу вверх;
  • обработка ошибок дублируется на каждом уровне;
  • сложно добавить шаг, отменить операцию или выполнить шаги параллельно;
  • переменные внешних уровней легко перепутать.

Способ 1: именованные функции

function onDelivery(error, delivery) { /* ... */ }
function onDetails(error, details) {
  if (error) return handle(error);
  calculateDelivery(details, onDelivery);
}

Вложенность уходит, но поток выполнения разбросан по файлу.

Способ 2: промисы

getUser(userId)
  .then((user) => getOrders(user.id))
  .then((orders) => getOrderDetails(orders[0].id))
  .then((details) => calculateDelivery(details))
  .then(render)
  .catch(handle); // одна обработка ошибок на всю цепочку

Каждый then возвращает новый промис, поэтому цепочка плоская.

Способ 3: async/await

async function showOrder(userId) {
  try {
    const user = await getUser(userId);
    const orders = await getOrders(user.id);
    const details = await getOrderDetails(orders[0].id);
    const delivery = await calculateDelivery(details);
    render(user, details, delivery);
  } catch (error) {
    handle(error);
  }
}

Асинхронный код читается как синхронный, ошибки ловит обычный try...catch.

Способ 4: параллельные операции

Если шаги не зависят друг от друга, не ждите их последовательно:

const [profile, notifications, cart] = await Promise.all([
  getProfile(userId),
  getNotifications(userId),
  getCart(userId),
]);

Промисификация старых API

function readFilePromise(path) {
  return new Promise((resolve, reject) => {
    fs.readFile(path, "utf8", (error, data) => (error ? reject(error) : resolve(data)));
  });
}
 
// или в Node.js
import { promisify } from "node:util";
const readFileAsync = promisify(fs.readFile);
// или сразу node:fs/promises

Что важно помнить

  • async/await тоже может превратиться в «await hell», если последовательно ждать независимые операции — используйте Promise.all.
  • Глубокая вложенность может возникать и без асинхронности — помогают ранние return и вынос функций.
  • События (клики, WebSocket) остаются на колбэках — это нормально, проблема именно в цепочках зависимых операций.
  • Для сложных потоков событий используют RxJS или state machines.

Мини-шпаргалка

  • Callback hell — пирамида вложенных колбэков.
  • Проблемы: читаемость, дублирование ошибок, сложность изменений.
  • Решения: именованные функции → промисы → async/await.
  • Независимые операции — Promise.all.
  • Старые callback-API — promisify.

Документация

MDN: Использование промисов, learn.javascript.ru: Введение в колбэки, callbackhell.com.

Дочитали до конца?
Отметьте урок — прогресс сохранится в браузере.

Поиск

Поиск по урокам