JavaScript Promise 심층 가이드

Promise 개념과 동작 원리

JavaScript에서 비동기 처리를 위한 핵심 메커니즘인 Promise는 콜백 지옥을 해소하고 코드의 가독성을 높이는 대표적인 패턴입니다. 미래 시점에 완료될 작업의 결과값을 담아두는 대역 객체(proxy object)로 이해할 수 있습니다.

상태 전이 규칙

Promise는 다음과 같은 엄격한 상태 머신을 따릅니다:

  • pending: 초기 상태, 아직 처리 중
  • fulfilled: 성공적으로 완료됨
  • rejected: 실패로 종료됨

pending에서 fulfilled 또는 rejected로 단 한 번만 전환되며, 이후 상태는 불변입니다.

Promise 생성과 실행 시점

const fetchUserData = new Promise(function(fulfill, deny) {
  // executor는 즉시 동기적으로 실행됨
  console.log('네트워크 요청 시작');
  
  setTimeout(() => {
    const isSuccess = Math.random() > 0.3;
    if (isSuccess) {
      fulfill({ id: 1, name: 'Kim' });
    } else {
      deny(new Error('사용자 정보 로딩 실패'));
    }
  }, 1000);
});

then 메서드와 마이크로태스크

then()는 항상 새로운 Promise를 반환하여 체이닝이 가능합니다. 콜은 마이크로태스크 큐에 등록되어 현재 실행 중인 동기 코드 이후 처리됩니다.

console.log('첫 번째');

const p = new Promise((res) => {
  console.log('두 번째');
  res();
});

p.then(() => console.log('네 번째'));
console.log('세 번째');

// 출력: 첫 번째 → 두 번째 → 세 번째 → 네 번째

then의 두 번째 인자 vs catch

권장되는 패턴은 then의 첫 번째 인자만 사용하고, 오류 처리는 catch로 분리하는 것입니다.

fetchData('/api/items')
  .then(response => response.json())
  .then(items => renderList(items))
  .catch(err => {
    console.error('처리 중 오류:', err);
    showFallbackUI();
  });

finally: 상태 불문 실행

ES2018에서 도입된 finally()는 성공/실패 여부와 무관하게 항상 실행됩니다. 로딩 스피너 해제, 리소스 정리 등에 유용합니다.

showLoadingSpinner();

fetchDashboardData()
  .then(data => updateCharts(data))
  .catch(error => logToService(error))
  .finally(() => hideLoadingSpinner());

Promise.all: 병렬 처리와 단일 실패 전파

모든 Promise가 성공해야 전체가 성공하며, 하나라도 실패하면 즉시 rejected됩니다.

const urls = ['/api/user', '/api/orders', '/api/preferences'];

const requests = urls.map(url => fetch(url));

Promise.all(requests)
  .then(([userRes, orderRes, prefRes]) => {
    return Promise.all([userRes.json(), orderRes.json(), prefRes.json()]);
  })
  .then(([user, orders, prefs]) => {
    initDashboard({ user, orders, prefs });
  })
  .catch(err => {
    // 세 요청 중 어느 하나라도 실패하면 여기로
    console.error('대시보드 초기화 실패');
  });

Promise.race: 타임아웃 패턴 구현

가장 먼저 settled(fulfilled 또는 rejected)된 결과를 채택합니다.

function fetchWithTimeout(url, ms = 5000) {
  const fetchPromise = fetch(url);
  const timeoutPromise = new Promise((_, reject) => {
    setTimeout(() => reject(new Error('요청 시간 초과')), ms);
  });
  
  return Promise.race([fetchPromise, timeoutPromise]);
}

Promise.allSettled: 개별 결과 확인

모든 Promise의 최종 상태를 개별적으로 확인할 수 있습니다. 실패한 요청이 있어도 전체가 rejected되지 않습니다.

const tasks = [
  fetch('/api/critical'),
  fetch('/api/optional-1'),
  fetch('/api/optional-2')
];

Promise.allSettled(tasks).then(outcomes => {
  outcomes.forEach((outcome, idx) => {
    if (outcome.status === 'fulfilled') {
      console.log(`작업 ${idx} 성공:`, outcome.value);
    } else {
      console.log(`작업 ${idx} 실패:`, outcome.reason);
    }
  });
});

Promise.any: 첫 성공 채택

여러 후보 중 첫 번째로 성공한 Promise의 값을 반환합니다. 모두 실패할 경우에만 rejected됩니다.

const mirrorServers = [
  'https://mirror-a.example.com/data',
  'https://mirror-b.example.com/data',
  'https://mirror-c.example.com/data'
];

Promise.any(mirrorServers.map(url => fetch(url)))
  .then(response => response.blob())
  .then(blob => displayImage(blob))
  .catch(err => {
    // AggregateError: 모든 mirror가 실패한 경우
    console.error('모든 서버 응답 없음');
  });

정적 메서드: resolve/reject

// 이미 존재하는 값을 Promise로 래핑
const cachedData = Promise.resolve(JSON.parse(localStorage.getItem('config')));

// 즉시 거부되는 Promise
const denied = Promise.reject(new Error('권한 없음'));
// 또는
throw new Error('권한 없음'); // async 함수 내에서 동등

실전 활용 사례

HTTP 클라이언트 래퍼

function httpRequest(config) {
  const { endpoint, payload, verb = 'GET', token } = config;
  
  return new Promise((fulfill, deny) => {
    const xhr = new XMLHttpRequest();
    xhr.open(verb, endpoint);
    xhr.setRequestHeader('Authorization', `Bearer ${token}`);
    xhr.setRequestHeader('Content-Type', 'application/json');
    
    xhr.onload = () => {
      if (xhr.status >= 200 && xhr.status < 300) {
        fulfill(xhr.response);
      } else {
        deny(new Error(`HTTP ${xhr.status}: ${xhr.statusText}`));
      }
    };
    
    xhr.onerror = () => deny(new Error('네트워크 요청 실패'));
    xhr.ontimeout = () => deny(new Error('응답 시간 초과'));
    
    xhr.send(payload ? JSON.stringify(payload) : null);
  });
}

이미지 프리로딩 유틸리티

function loadImageAsset(src) {
  return new Promise((fulfill, deny) => {
    const img = new Image();
    
    img.onload = () => fulfill({
      element: img,
      naturalWidth: img.naturalWidth,
      naturalHeight: img.naturalHeight
    });
    
    img.onerror = () => deny(new Error(`이미지 로딩 실패: ${src}`));
    
    img.src = src;
  });
}

// 사용
Promise.all(
  bannerImages.map(url => loadImageAsset(url))
).then(images => {
  images.forEach(({ element }) => gallery.appendChild(element));
});

모달 다이얼로그 래퍼

function createConfirmDialog(message) {
  return new Promise((fulfill, deny) => {
    const overlay = document.createElement('div');
    overlay.className = 'modal-overlay';
    
    overlay.innerHTML = `
      <div class="dialog-box">
        <p>${message}</p>
        <button id="confirm-btn">확인</button>
        <button id="cancel-btn">취소</button>
      </div>
    `;
    
    document.body.appendChild(overlay);
    
    overlay.querySelector('#confirm-btn').addEventListener('click', () => {
      document.body.removeChild(overlay);
      fulfill('confirmed');
    });
    
    overlay.querySelector('#cancel-btn').addEventListener('click', () => {
      document.body.removeChild(overlay);
      deny(new Error('user_cancelled'));
    });
  });
}

Promise 직접 구현하기

Promise A+ 스펙을 준수하는 간략한 구현입니다.

const STATE = {
  PENDING: 'PENDING',
  FULFILLED: 'FULFILLED',
  REJECTED: 'REJECTED'
};

class CustomPromise {
  constructor(executor) {
    this._state = STATE.PENDING;
    this._result = undefined;
    this._fulfillQueue = [];
    this._rejectQueue = [];
    
    const resolve = (value) => this._changeState(STATE.FULFILLED, value);
    const reject = (reason) => this._changeState(STATE.REJECTED, reason);
    
    try {
      executor(resolve, reject);
    } catch (err) {
      reject(err);
    }
  }
  
  _changeState(newState, value) {
    if (this._state !== STATE.PENDING) return;
    
    this._state = newState;
    this._result = value;
    
    const callbacks = newState === STATE.FULFILLED 
      ? this._fulfillQueue 
      : this._rejectQueue;
      
    callbacks.forEach(cb => cb(value));
  }
  
  _isThenable(obj) {
    return obj && typeof obj.then === 'function';
  }
  
  then(onFulfilled, onRejected) {
    onFulfilled = typeof onFulfilled === 'function' 
      ? onFulfilled 
      : val => val;
    onRejected = typeof onRejected === 'function' 
      ? onRejected 
      : err => { throw err; };
    
    return new CustomPromise((resolve, reject) => {
      const wrappedResolve = (value) => {
        queueMicrotask(() => {
          try {
            const outcome = onFulfilled(value);
            if (this._isThenable(outcome)) {
              outcome.then(resolve, reject);
            } else {
              resolve(outcome);
            }
          } catch (err) {
            reject(err);
          }
        });
      };
      
      const wrappedReject = (reason) => {
        queueMicrotask(() => {
          try {
            const outcome = onRejected(reason);
            if (this._isThenable(outcome)) {
              outcome.then(resolve, reject);
            } else {
              resolve(outcome);
            }
          } catch (err) {
            reject(err);
          }
        });
      };
      
      if (this._state === STATE.FULFILLED) {
        wrappedResolve(this._result);
      } else if (this._state === STATE.REJECTED) {
        wrappedReject(this._result);
      } else {
        this._fulfillQueue.push(wrappedResolve);
        this._rejectQueue.push(wrappedReject);
      }
    });
  }
  
  catch(onRejected) {
    return this.then(null, onRejected);
  }
  
  finally(callback) {
    return this.then(
      value => CustomPromise.resolve(callback()).then(() => value),
      reason => CustomPromise.resolve(callback()).then(() => { throw reason; })
    );
  }
  
  static resolve(value) {
    return new CustomPromise(res => res(value));
  }
  
  static reject(reason) {
    return new CustomPromise((_, rej) => rej(reason));
  }
}

// 검증
const demo = new CustomPromise((res) => {
  setTimeout(() => res('CustomPromise 동작 확인'), 100);
});

demo
  .then(msg => msg + '!')
  .then(console.log);

흔한 실수와 해결책

실수 1: Promise 생성자 내부에서 비동기 오류 미처리

// ❌ 문제: executor 내 throw는 catch로 전파되지 않을 수 있음
new Promise(() => {
  setTimeout(() => { throw new Error('늦은 오류'); }, 0);
});

// ✅ 해결: reject 명시 호출
new Promise((resolve, reject) => {
  setTimeout(() => reject(new Error('적절한 오류 전파')), 0);
});

실수 2: then 내부에서 중첩 Promise 미반환

// ❌ 순서 보장 안 됨
getUser(1).then(u => {
  fetchOrders(u.id).then(orders => console.log(orders));
});

// ✅ 올바른 이닝
getUser(1)
  .then(u => fetchOrders(u.id))
  .then(orders => console.log(orders));

태그: JavaScript Promise 비동기 프로그래밍 ES6 async-await

10월 30일 09:35에 게시됨