Node.js의 프로미스(Promise) 사용법

1. 프로미스란

프로미스(Promise)는 비동기 작업의 최종 완료 또는 실패를 나타내는 객체입니다. ES6(ECMAScript 2015)에서 도입되었으며, 콜백 지옥을 해결하고 비동기 코드를 더 읽기 쉽게 만들어줍니다. 프로미스는 pending(대기), fulfilled(이행), rejected(거부) 세 가지 상태를 가집니다.

2. 프로미스의 기본 구조

2.1 프로미스 생성

const myPromise = new Promise((resolve, reject) => {
  // 비동기 작업 수행
  const success = true;

  if (success) {
    resolve('작업 성공'); // 성공 시 resolve 호출
  } else {
    reject(new Error('작업 실패')); // 실패 시 reject 호출
  }
});

2.2 프로미스 사용

myPromise
  .then(result => {
    console.log('성공:', result);
  })
  .catch(error => {
    console.error('실패:', error.message);
  })
  .finally(() => {
    console.log('작업 완료 (성공/실패 무관)');
  });

3. 프로미스 활용 예시

3.1 비동기 함수를 프로미스로 감싸기

function delay(ms) {
  return new Promise(resolve => {
    setTimeout(resolve, ms);
  });
}

// 사용
delay(2000).then(() => {
  console.log('2초 후 실행');
});

3.2 HTTP 요청 예시

const https = require('https');

function fetchData(url) {
  return new Promise((resolve, reject) => {
    https.get(url, (res) => {
      let data = '';

      res.on('data', chunk => {
        data += chunk;
      });

      res.on('end', () => {
        try {
          resolve(JSON.parse(data));
        } catch (err) {
          reject(err);
        }
      });
    }).on('error', reject);
  });
}

// 사용
fetchData('https://api.example.com/data')
  .then(data => console.log(data))
  .catch(err => console.error(err));

3.3 파일 시스템 작업

const fs = require('fs').promises;

// Node.js fs 모듈의 promises API 사용
async function readConfig() {
  const data = await fs.readFile('config.json', 'utf8');
  return JSON.parse(data);
}

4. 프로미스 체이닝

여러 비동기 작업을 순차적으로 연결할 수 있습니다.

function getUser(userId) {
  return new Promise(resolve => {
    setTimeout(() => resolve({ id: userId, name: '홍길동' }), 100);
  });
}

function getOrders(userId) {
  return new Promise(resolve => {
    setTimeout(() => resolve([{ id: 1, product: '노트북' }]), 100);
  });
}

function getOrderDetails(orderId) {
  return new Promise(resolve => {
    setTimeout(() => resolve({ orderId, price: 1500000 }), 100);
  });
}

// 프로미스 체이닝
getUser(1)
  .then(user => {
    console.log('사용자:', user.name);
    return getOrders(user.id);
  })
  .then(orders => {
    console.log('주문 수:', orders.length);
    return getOrderDetails(orders[0].id);
  })
  .then(details => {
    console.log('주문 금액:', details.price);
  })
  .catch(err => {
    console.error('에러 발생:', err.message);
  });

반응형

5. 프로미스 정적 메서드

5.1 Promise.all

모든 프로미스가 완료될 때까지 기다립니다. 하나라도 실패하면 전체가 실패합니다.

const promise1 = fetch('/api/users');
const promise2 = fetch('/api/products');
const promise3 = fetch('/api/orders');

Promise.all([promise1, promise2, promise3])
  .then(([users, products, orders]) => {
    console.log('모든 데이터 로드 완료');
  })
  .catch(err => {
    console.error('하나 이상 실패:', err);
  });

5.2 Promise.allSettled

모든 프로미스의 결과를 기다립니다. 실패해도 다른 결과를 받을 수 있습니다.

Promise.allSettled([promise1, promise2, promise3])
  .then(results => {
    results.forEach((result, index) => {
      if (result.status === 'fulfilled') {
        console.log(`${index}: 성공 -`, result.value);
      } else {
        console.log(`${index}: 실패 -`, result.reason);
      }
    });
  });

5.3 Promise.race

가장 먼저 완료되는 프로미스의 결과를 반환합니다.

const timeout = new Promise((_, reject) => {
  setTimeout(() => reject(new Error('타임아웃')), 5000);
});

const fetchData = fetch('/api/data');

Promise.race([fetchData, timeout])
  .then(data => console.log('데이터:', data))
  .catch(err => console.error('실패:', err.message));

5.4 Promise.any

가장 먼저 성공하는 프로미스의 결과를 반환합니다. 모두 실패해야 실패합니다.

const servers = [
  fetch('https://server1.com/api'),
  fetch('https://server2.com/api'),
  fetch('https://server3.com/api')
];

Promise.any(servers)
  .then(response => console.log('가장 빠른 응답:', response))
  .catch(err => console.error('모든 서버 실패'));

6. 에러 처리

function riskyOperation() {
  return new Promise((resolve, reject) => {
    const random = Math.random();
    if (random > 0.5) {
      resolve('성공');
    } else {
      reject(new Error('실패'));
    }
  });
}

// catch로 에러 처리
riskyOperation()
  .then(result => console.log(result))
  .catch(err => console.error('에러:', err.message))
  .finally(() => console.log('작업 종료'));

// then의 두 번째 인자로 에러 처리
riskyOperation()
  .then(
    result => console.log(result),
    err => console.error('에러:', err.message)
  );

결론

프로미스는 콜백의 단점을 보완한 비동기 처리 패턴으로, then/catch/finally를 통해 결과를 처리합니다. Promise.all, Promise.race 등의 정적 메서드로 여러 비동기 작업을 효율적으로 관리할 수 있습니다. 프로미스 체이닝을 통해 순차적인 비동기 작업을 가독성 있게 작성할 수 있으며, async/await와 함께 사용하면 더욱 직관적인 코드가 됩니다.