Зачем нужен Promise?

Зачем нужен Promise в JavaScript и Node.js

Promise — это один из самых важных паттернов в современном JavaScript, особенно в Node.js backend-разработке. Это фундаментальная концепция, без понимания которой невозможно писать качественный асинхронный код.

Проблема: Callback Hell (Pyramid of Doom)

До появления Promises код с асинхронными операциями выглядел так:

// Плохо: Callback Hell
fs.readFile('user.json', (err, data) => {
  if (err) {
    console.error('Error reading user.json:', err);
    return;
  }
  
  const user = JSON.parse(data);
  
  db.query('SELECT * FROM orders WHERE user_id = ?', [user.id], (err, orders) => {
    if (err) {
      console.error('Error fetching orders:', err);
      return;
    }
    
    sendEmail(user.email, orders, (err, result) => {
      if (err) {
        console.error('Error sending email:', err);
        return;
      }
      
      console.log('Email sent successfully');
      // Обработка результата
    });
  });
});

Проблемы:

• Невыразительный код — сложно читать и понимать
• Дублирование обработки ошибок — каждый callback проверяет ошибку
• Сложно отследить выполнение — непонятно, в каком порядке выполняются операции
• Трудно тестировать — вложенные callbacks сложно мокировать

Что такое Promise

Promise — это объект, который представляет результат асинхронной операции. Он может находиться в трех состояниях:

1. Pending (ожидание) — операция еще не завершена
2. Fulfilled (выполнено) — операция завершилась успешно, есть значение
3. Rejected (отклонено) — операция завершилась с ошибкой

// Создание Promise
const promise = new Promise((resolve, reject) => {
  setTimeout(() => {
    resolve('Success!'); // Переход в fulfilled
  }, 1000);
});

// Работа с результатом
promise
  .then(result => console.log(result)) // Если fulfilled
  .catch(error => console.error(error)); // Если rejected

Преимущества Promise

1. Цепочки операций (Chaining)

Вместо вложенности callback можно использовать цепочку .then():

// С Promise
fs.promises.readFile('user.json')
  .then(data => {
    const user = JSON.parse(data);
    return db.query('SELECT * FROM orders WHERE user_id = ?', [user.id]);
  })
  .then(orders => {
    return sendEmail(user.email, orders);
  })
  .then(result => {
    console.log('Email sent successfully');
  })
  .catch(error => {
    console.error('Something went wrong:', error);
  });

2. Единая обработка ошибок

Одного .catch() в конце цепочки достаточно для всей цепочки операций.

3. Параллельное выполнение

// Promise.all — выполнить все параллельно
Promise.all([
  fetchUser(userId),
  fetchOrders(userId),
  fetchPayments(userId)
])
.then(([user, orders, payments]) => {
  console.log('All data loaded:', { user, orders, payments });
})
.catch(error => {
  console.error('One of the requests failed:', error);
});

// Promise.race — получить результат первого завершившегося
Promise.race([
  fetch('https://server1.com/data'),
  fetch('https://server2.com/data'),
  fetch('https://server3.com/data')
])
.then(response => response.json())
.catch(error => console.error('All servers failed'));

Async/Await — синтаксический сахар над Promise

Async/Await делает код еще более читаемым, скрывая Promise под капотом:

// С async/await
async function processUser(userId) {
  try {
    // Выглядит как синхронный код, но работает асинхронно
    const userData = await fs.promises.readFile('user.json');
    const user = JSON.parse(userData);
    
    const orders = await db.query(
      'SELECT * FROM orders WHERE user_id = ?',
      [user.id]
    );
    
    const result = await sendEmail(user.email, orders);
    
    console.log('Email sent:', result);
    return result;
  } catch (error) {
    // Единая обработка всех ошибок
    console.error('Error processing user:', error);
    throw error; // Re-throw если нужно
  }
}

// Использование
processUser(123)
  .then(result => console.log('Success'))
  .catch(error => console.error('Failed'));

Практические примеры в Node.js Backend

Пример 1: Работа с базой данных

class UserRepository {
  // С Promise
  findById(id) {
    return new Promise((resolve, reject) => {
      db.query('SELECT * FROM users WHERE id = ?', [id], (err, results) => {
        if (err) reject(err);
        else resolve(results[0]);
      });
    });
  }
  
  // Или использовать promisify
  async findByIdAsync(id) {
    try {
      const result = await db.promise().query(
        'SELECT * FROM users WHERE id = ?',
        [id]
      );
      return result[0][0];
    } catch (error) {
      throw new DatabaseError('Failed to fetch user', error);
    }
  }
}

Пример 2: HTTP запросы

const axios = require('axios');

async function fetchUserData(userId) {
  try {
    // Параллельно выполняем несколько запросов
    const [userResponse, ordersResponse, reviewsResponse] = await Promise.all([
      axios.get(`/api/users/${userId}`),
      axios.get(`/api/orders?user_id=${userId}`),
      axios.get(`/api/reviews?user_id=${userId}`)
    ]);
    
    return {
      user: userResponse.data,
      orders: ordersResponse.data,
      reviews: reviewsResponse.data
    };
  } catch (error) {
    if (error.response?.status === 404) {
      throw new NotFoundError('User not found');
    }
    throw error;
  }
}

// Использование в Express
app.get('/api/users/:id/full', async (req, res, next) => {
  try {
    const data = await fetchUserData(req.params.id);
    res.json(data);
  } catch (error) {
    next(error); // Передаем в error middleware
  }
});

Пример 3: Обработка больших потоков данных

async function processLargeDataset(dataset) {
  const batchSize = 100;
  const results = [];
  
  // Обработка батчами для эффективности
  for (let i = 0; i < dataset.length; i += batchSize) {
    const batch = dataset.slice(i, i + batchSize);
    
    // Параллельная обработка всех элементов в батче
    const batchResults = await Promise.all(
      batch.map(item => processItem(item))
    );
    
    results.push(...batchResults);
  }
  
  return results;
}

Promise vs Callback

Promise в контексте Node.js Backend

В современном Node.js backend-разработке:

1. Все асинхронные операции возвращают Promise или работают с async/await
2. Middleware обрабатывают Promise и отлавливают ошибки
3. Тесты используют Promise для ожидания асинхронных операций

// Express middleware с Promise
const asyncHandler = (fn) => (req, res, next) => {
  Promise.resolve(fn(req, res, next)).catch(next);
};

app.get('/users/:id', asyncHandler(async (req, res) => {
  const user = await User.findById(req.params.id);
  res.json(user);
}));

Заключение

Promise — это не просто удобство, это фундамент асинхронного программирования в JavaScript и Node.js. Без понимания Promise невозможно:

• Писать чистый и читаемый код
• Правильно обрабатывать ошибки
• Управлять асинхронными потоками
• Масштабировать backend-приложения

Это знание критично для любого Node.js разработчика, от junior до senior уровня.