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));