
ํ ๋ฒ์ ์ ๋ฆฌํ๋ ์๋ฐ์คํฌ๋ฆฝํธ ๋น๋๊ธฐ ์ฝ๋ ์์ฑ๋ฒ
ํ ๋ฒ์ ์ ๋ฆฌํ๋ ์๋ฐ์คํฌ๋ฆฝํธ ๋น๋๊ธฐ ์ฝ๋ ์์ฑ๋ฒ ๊ด๋ จ
์ง๋ ๊ธ โํ ๋ฒ์ ์ดํดํ๋ ์๋ฐ์คํฌ๋ฆฝํธ ๋น๋๊ธฐ ํ๋ก๊ทธ๋๋ฐโ์์ ์๋ฐ์คํฌ๋ฆฝํธ์ ๋น๋๊ธฐ ์ฒ๋ฆฌ ๊ฐ๋
์ ์ดํด๋ณด์์ต๋๋ค. ์๋ฐ์คํฌ๋ฆฝํธ๋ ์ฑ๊ธ ์ค๋ ๋ ์ธ์ด์ด๊ธฐ ๋๋ฌธ์, ๋๊ธฐ์ ์ผ๋ก ์คํ๋๋ ์ฝ๋๊ฐ ์๊ฐ์ด ์ค๋ ๊ฑธ๋ฆฌ๋ฉด ์ ์ฒด ์ฝ๋์ ํ๋ฆ์ด ๋ฉ์ถ๋ ๋จ์ ์ด ์์ต๋๋ค. ์ด๋ฅผ ํด๊ฒฐํ๊ธฐ ์ํด setTimeout
๊ณผ ๊ฐ์ ๋น๋๊ธฐ ๋ฉ์๋๋ฅผ ํ์ฉํ์ฌ ์ฝ๋ ์คํ์ ์ง์ฐ์ํค์ง ์์ผ๋ฉด์๋, ์ํ๋ ์์ ์ ์์
์ ์ํํ ์ ์์์ต๋๋ค. ๋ํ ํ๋ก๋ฏธ์ค ๊ฐ์ฒด๋ฅผ ์ฌ์ฉํ๋ฉด ๋น๋๊ธฐ ์์
์ ์ํ๋ฅผ ๊ด๋ฆฌํ๊ณ , ์ฑ๊ณต ๋ฐ ์คํจ ์ฒ๋ฆฌ๋ฅผ ๋ ์ง๊ด์ ์ผ๋ก ํ ์ ์๋ค๋ ์ ๋ ๋ฐฐ์ ์ฃ .
ํ์ง๋ง ํ๋ก๋ฏธ์ค๋ฅผ ์ ๋๋ก ํ์ฉํ์ง ๋ชปํ๋ฉด ์ฌ์ ํ ๋ณต์กํ ์ฝ๋๊ฐ ์์ฑ๋ ์ ์์ต๋๋ค. ํนํ ์ง๋ ๊ธ์์ ์ด์ง ์ธ๊ธํ๋ โ์ฝ๋ฐฑ ์ง์ฅ(Callback Hell)โ ํ์์ ์ฝ๋ ๊ฐ๋ ์ฑ์ ์ฌ๊ฐํ๊ฒ ์ ํ์ํฌ ์ ์์ต๋๋ค.
์ด๋ฒ ๊ธ์์๋ ์ฝ๋ฐฑ ์ง์ฅ์ด ๋ฌด์์ธ์ง, ๊ทธ๋ฆฌ๊ณ ์ด๋ฅผ ์ด๋ป๊ฒ ํด๊ฒฐํ ์ ์๋์ง, ๊ทธ๋ฆฌ๊ณ ๋ ๊น๋ํ ๋น๋๊ธฐ ์ฝ๋ ์์ฑ์ ์ํด async
/await
์ ์ด๋ป๊ฒ ํ์ฉํ๋์ง์ ๋ํด ์์๋ณด๊ฒ ์ต๋๋ค. ๋ํ ์ค์ ์์ ๊ฐ์ฅ ๋ง์ด ํ์ฉ๋๋ API ํธ์ถ๊ณผ ๋น๋๊ธฐ ์ฒ๋ฆฌ์ ๊ด๊ณ์ ๋ํด์๋ ํจ๊ป ์ดํด๋ด
์๋ค.
์ฝ๋ฐฑ ์ง์ฅ๊ณผ ํ๋ก๋ฏธ์ค ๊ฐ์ฒด
๋น๋๊ธฐ ์ฒ๋ฆฌ๋ฅผ ํ๋ค ๋ณด๋ฉด ์ฌ๋ฌ ๊ฐ์ ๋น๋๊ธฐ ์์ ์ ์์ฐจ์ ์ผ๋ก ์คํํด์ผ ํ ๋๊ฐ ์์ต๋๋ค. ์ด๋ฌํ ์์ ์ ๋จ์ํ ์ฝ๋ฐฑ ํจ์๋ก ์ฐ๊ฒฐํ๋ฉด ์ฝ๋์ ๋ณต์ก๋๊ฐ ๊ธ๊ฒฉํ ์ฆ๊ฐํ ์ ์์ต๋๋ค. ํนํ ์ค์ฒฉ๋ ์ฝ๋ฐฑ์ด ๋ง์์ง์๋ก ๊ฐ๋ ์ฑ์ด ๋จ์ด์ง๊ณ ์ ์ง๋ณด์๊ฐ ์ด๋ ค์์ง๋๋ฐ์. ์ด๋ฅผ ์ฝ๋ฐฑ ์ง์ฅ์ด๋ผ๊ณ ๋ถ๋ฆ ๋๋ค. ์ฝ๋ฐฑ ์ง์ฅ์ ๋ํ๋ด๋ ์ ๋ช ํ ๊ทธ๋ฆผ์ด ์๋๋ฐ์, ์ฝ๋ฐฑ ์ง์ฅ์ด ๋ฐ์ํ ์ฝ๋์ ๋ชจ์์ ๋ํ๋ด๋ ๊ทธ๋ฆผ์ ๋๋ค.

1. ์ฝ๋ฐฑ ์ง์ฅ์ด๋?
์ฝ๋ฐฑ ์ง์ฅ์ด๋ ๋น๋๊ธฐ ํจ์ ๋ด์์ ์ฝ๋ฐฑ ํจ์๊ฐ ์ฐ์์ ์ผ๋ก ์ค์ฒฉ๋๋ ํ์์ ๋งํฉ๋๋ค. ๋น๋๊ธฐ ์์ ์ด ์ฌ๋ฌ ๊ฐ ์ฐ์์ผ๋ก ์คํ๋์ด์ผ ํ๋ ๊ฒฝ์ฐ, ๋ค์๊ณผ ๊ฐ์ ์ฝ๋๊ฐ ๋ง๋ค์ด์ง ์ ์์ต๋๋ค.
setTimeout(() => {
console.log("1์ด ํ ์คํ");
setTimeout(() => {
console.log("2์ด ํ ์คํ");
setTimeout(() => {
console.log("3์ด ํ ์คํ");
}, 1000);
}, 1000);
}, 1000);
์ด์ฒ๋ผ ์ฌ๋ฌ ๊ฐ์ setTimeout
์ด ์ค์ฒฉ๋๋ฉด ์ฝ๋์ ๊ฐ๋
์ฑ์ด ๋จ์ด์ง๊ณ ์ ์ง๋ณด์๊ฐ ์ด๋ ค์์ง๋๋ค. ํนํ API ํธ์ถ์ฒ๋ผ ์ฌ๋ฌ ๊ฐ์ ๋น๋๊ธฐ ์์
์ด ์์ฐจ์ ์ผ๋ก ์คํ๋์ด์ผ ํ๋ ๊ฒฝ์ฐ, ์ด๋ฌํ ์ฝ๋ฐฑ ์ง์ฅ ๋ฌธ์ ๋ ๋์ฑ ์ฌ๊ฐํด์ง๋๋ค.
2. ํ๋ก๋ฏธ์ค ๊ฐ์ฒด๋ฅผ ์ฌ์ฉํ ์ฝ๋ฐฑ ์ง์ฅ ํด๊ฒฐ
์ฝ๋ฐฑ ์ง์ฅ์ ํด๊ฒฐํ๋ ๋ฐฉ๋ฒ ์ค ํ๋๊ฐ ๋ฐ๋ก ํ๋ก๋ฏธ์ค ๊ฐ์ฒด๋ฅผ ์ฌ์ฉํ๋ ๊ฒ์ ๋๋ค. ์ฝ๋ฐฑ ์ง์ฅ์ ํด๊ฒฐ๋ฐฉ๋ฒ์ ๋ํด ๋ฐฐ์๋ณด๊ธฐ ์ ์, ๋จผ์ ์ ๋ฒ ์๊ฐ์ ์ดํด๋ดค๋ ํ๋ก๋ฏธ์ค ๊ฐ์ฒด์ ๋ํด ๋ค์ ํ ๋ฒ ๋ ์ดํด๋ณด๋๋ก ํ๊ฒ ์ต๋๋ค.
ํ๋ก๋ฏธ์ค๋ ๋น๋๊ธฐ ์์
์ ์๋ฃ ๋๋ ์คํจ๋ฅผ ์ฒ๋ฆฌํ๊ธฐ ์ํ ๊ฐ์ฒด์
๋๋ค. ํ๋ก๋ฏธ์ค ๊ฐ์ฒด๋ new Promise()
๋ฅผ ํตํด ์์ฑํ๋ฉฐ, ์์ฑ์ ํจ์๋ ๋ค์๊ณผ ๊ฐ์ด resolve
์ reject
๋ฅผ ์ธ์๋ก ๋ฐ๋ ์ฝ๋ฐฑ ํจ์๋ฅผ ์๊ตฌํ์ฃ .
const myPromise = new Promise((resolve, reject) => {
// ๋น๋๊ธฐ ์์
์ํ
if (/* ์์
์ฑ๊ณต */) {
resolve('์ฑ๊ณต ๊ฒฐ๊ณผ');
} else {
reject('์คํจ ์ด์ ');
}
});
resolve
ํจ์๋ ์์
์ด ์ฑ๊ณตํ์ ๋ ํธ์ถํ๋ ํจ์๋ก, ํ๋ก๋ฏธ์ค์ ์ํ๋ฅผ ์ดํ(fulfilled)์ผ๋ก ๋ณ๊ฒฝํ๊ณ , reject
ํจ์๋ ์์
์ด ์คํจํ์ ๋ ํธ์ถํ๋ฉฐ, ํ๋ก๋ฏธ์ค์ ์ํ๋ฅผ ๊ฑฐ๋ถ, ์คํจ(rejected)๋ก ๋ณ๊ฒฝํ๋ ํจ์์์ต๋๋ค.
์์ ์ดํด๋ดค๋ฏ์ด, ์ฌ๋ฌ ๋น๋๊ธฐ ์์
์ ์์ฐจ์ ์ผ๋ก ์คํํด์ผ ํ ๋ ์ฝ๋ฐฑ ํจ์๋ฅผ ์ค์ฒฉํ๋ฉด, ์ฝ๋๊ฐ ๋ณต์กํด์ ธ์ ๊ฐ๋
์ฑ์ด ๋จ์ด์ง๋ ์ฝ๋ฐฑ ์ง์ฅ์ด ๋ฐ์ํ ์ ์์ต๋๋ค. ์ด๋ฌํ ๋ฌธ์ ๋ ํ๋ก๋ฏธ์ค ๊ฐ์ฒด๋ฅผ ์ฌ์ฉํด, ์ฝ๋ฐฑ์ ์ค์ฒฉํ์ง ์๊ณ then
๋ฉ์๋๋ฅผ ์ฌ์ฉํ then()
์ฒด์ด๋์ ํตํด ๊ฐ๋
์ฑ์ ๊ฐ์ ํ๊ณ , ์ฝ๋ฐฑ ์ง์ฅ ๋ฌธ์ ๋ฅผ ํด๊ฒฐํ ์ ์์ต๋๋ค.
const delay = (ms) => {
return new Promise(resolve => setTimeout(resolve, ms));
}
delay(1000)
.then(() => {
console.log("1์ด ํ ์คํ");
return delay(1000);
})
.then(() => {
console.log("2์ด ํ ์คํ");
return delay(1000);
})
.then(() => {
console.log("3์ด ํ ์คํ");
});
์ด์ฒ๋ผ ํ๋ก๋ฏธ์ค์ then
๋ฉ์๋๋ฅผ ์ฒด์ด๋, ์ฆ then
๋ฉ์๋๋ฅผ ์ฐ๊ฒฐํด์ ์ฌ์ฉํ๋ฉด ๋น๋๊ธฐ ์์
์ ์์ฐจ์ ์ผ๋ก ์ฒ๋ฆฌํ๋ฉด์๋ ์ฝ๋์ ์ค์ฒฉ์ ํผํ ์ ์์ต๋๋ค. ๊ทธ๋ฆฌ๊ณ ์ด๋ฌํ ๋ฐฉ์์ โํ๋ก๋ฏธ์ค ์ฒด์ด๋โ ์ด๋ผ๊ณ ๋ถ๋ฅด๊ธฐ๋ ํฉ๋๋ค. ํ๋ก๋ฏธ์ค ์ฒด์ด๋์ ์ฌ์ฉํ๋ฉด ์ฝ๋ฐฑ ์ง์ฅ์ ํผํ ์ ์์ ๋ฟ๋ง ์๋๋ผ, ๋น๋๊ธฐ ์ฝ๋์ ์คํ ํ๋ฆ์ ์ง๊ด์ ์ผ๋ก ํํํ ์ ์๋ค๋ ์ฅ์ ์ด ์์ต๋๋ค.
async
์ await
์ฝ๋ฐฑ ์ง์ฅ์ ํด๊ฒฐํ๋ ๋ ๋ค๋ฅธ ๊ฐ๋ ฅํ ๋ฐฉ๋ฒ์ ๋ฐ๋ก async
/await
๋ฌธ๋ฒ์ ์ฌ์ฉํ๋ ๋ฐฉ๋ฒ์
๋๋ค. ์ด๋ฅผ ํ์ฉํ๋ฉด ๋น๋๊ธฐ ์ฝ๋๋ฅผ ๋ง์น ๋๊ธฐ ์ฝ๋์ฒ๋ผ ์์ฑํ ์ ์์ด, ๊ฐ๋
์ฑ์ด ์์ฃผ ํฌ๊ฒ ํฅ์๋๋ ๊ฒ์ ๋ณผ ์ ์์ต๋๋ค.
1. async
์ await
์ ์ญํ
async
์ await
์ ์๋ฐ์คํฌ๋ฆฝํธ์์ ๋น๋๊ธฐ ์ฝ๋๋ฅผ ๋ณด๋ค ์ง๊ด์ ์ผ๋ก ์์ฑํ ์ ์๋๋ก ๋์์ฃผ๋ ํค์๋์
๋๋ค. async
ํค์๋๋ฅผ ํจ์ ์์ ๋ถ์ด๋ฉด ํด๋น ํจ์๋ ํญ์ ํ๋ก๋ฏธ์ค ๊ฐ์ฒด๋ฅผ ๋ฐํํ๋ฉฐ, ํจ์์ ๋ด๋ถ์์๋ await
ํค์๋๋ฅผ ์ฌ์ฉํ ์ ์์ต๋๋ค.

await
์ ํน์ ๋น๋๊ธฐ ์์
์ด ์๋ฃ๋ ๋๊น์ง ๊ธฐ๋ค๋ ธ๋ค๊ฐ, ๊ทธ ๊ฒฐ๊ณผ๋ฅผ ๋ฐํํ๋ ์ญํ ์ ํฉ๋๋ค. ์ด๋ฅผ ํตํด ๋น๋๊ธฐ ์์
์ ๋๊ธฐ ์ฝ๋์ฒ๋ผ ์์ฐจ์ ์ผ๋ก ์คํํ ์ ์๊ฒ ํด์ค๋๋ค. ๊ธฐ์กด์ then
๋ฉ์๋ ์ฒด์ด๋๋ณด๋ค ๊ฐ๋
์ฑ์ด ๋ฐ์ด๋๊ณ ์ ์ง๋ณด์๊ฐ ์ฉ์ดํ๋ค๋ ์ฅ์ ์ด ์๊ธฐ ๋๋ฌธ์, ๋น๋๊ธฐ ์์
์ ํ ๋ ๋ ๋ง์ด ์ฌ์ฉ๋๋ ๋ฌธ๋ฒ์
๋๋ค.
2. ์ฌ์ฉ ๋ฐฉ๋ฒ
๊ทธ๋ผ async
์ await
์ ์ฌ์ฉ๋ฒ์ ๋ํด ์ดํด๋ด
์๋ค. ๋จผ์ ์๋์ ์ฝ๋๋ฅผ ์์๋ก ๋ค์ด๋ณด๊ฒ ์ต๋๋ค.
const delay = (ms) => {
return new Promise((resolve) => {
setTimeout(() => {
resolve('3์ด๊ฐ ์ง๋ฌ์ต๋๋ค.');
}, ms);
});
};
const start = () => {
delay(3000).then((res) => {
console.log(res);
});
};
start();
์์ ์ฝ๋๋ ๊ฐ๋จํ ๋น๋๊ธฐ ์ฝ๋์ธ๋ฐ์. delay
ํจ์์ ๋ด๋ถ์๋ ํ๋ก๋ฏธ์ค ๊ฐ์ฒด๋ฅผ ๋ฐํํ๋ ์ฝ๋๋ฅผ ์์ฑํ๊ณ , resolve
ํจ์์ โ3์ด๊ฐ ์ง๋ฌ์ต๋๋คโ๋ฅผ ์ ๋ฌํ์ต๋๋ค. ๊ทธ๋ฆฌ๊ณ start
ํจ์์์๋ delay
ํจ์๋ฅผ ํธ์ถํ๊ณ , delayTime
์ผ๋ก 3์ด๋ฅผ ์ ๋ฌํ ๋ค์, resolve
์ ์ ๋ฌ๋ ๊ฐ์ ์ถ๋ ฅํ๋ ์ฝ๋๋ฅผ ์์ฑํ์ต๋๋ค. ์ฝ๋๋ฅผ ์คํํ๋ฉด start
ํจ์๊ฐ ํธ์ถ๋์ด, 3์ด ํ์ ์๋ง์ ๋ฌธ์ฅ์ด ์ถ๋ ฅ๋๊ฒ ์ฃ .
์๋ฐ์คํฌ๋ฆฝํธ์์ async
๋ ๋น๋๊ธฐ ์์
์ ์ฒ๋ฆฌํ ๋ ์ฌ์ฉ๋๋ ํค์๋๋ก, ๋น๋๊ธฐ ์์
์ ํฌํจํ๊ณ ์๊ธฐ ๋๋ฌธ์ ํ๋ก๋ฏธ์ค ๊ฐ์ฒด๋ฅผ ๋ฐํํ๋ ํจ์์ ์์ฑํ๋ ํค์๋์
๋๋ค. async
๋ฅผ ์์ฑํ๋ฉด ์ฝ๋๋ฅผ ํจ์ฌ ์ง๊ด์ ์ผ๋ก ํด์ํ ์ ์๋๋ฐ์. async
๋ฅผ ์ฌ์ฉํด์ ์์ ์์ฑํ ์ฝ๋๋ฅผ ๋ณ๊ฒฝํด ๋ณด๊ฒ ์ต๋๋ค.
const delay = (ms) => {
return new Promise((resolve) => {
setTimeout(() => {
resolve('3์ด๊ฐ ์ง๋ฌ์ต๋๋ค.');
}, ms);
});
};
const start = async () => {
delay(3000).then((res) => {
console.log(res);
});
};
start();
async
๋ ๋น๋๊ธฐ๋ฅผ ์ํํ ํจ์์ ์ด๋ฆ ์ค๋ฅธ์ชฝ์ ์์ฑํฉ๋๋ค. ์ด๋ ํ ํจ์์ async
ํค์๋๋ฅผ ์์ฑํ๋ฉด, ํด๋น ํจ์๋ ํญ์ ์๋์ผ๋ก ํ๋ก๋ฏธ์ค ๊ฐ์ฒด๋ฅผ ๋ฐํํ๊ฒ ๋ฉ๋๋ค.

์ค์ ๋ก async
ํค์๋๊ฐ ๋ถ์ start
ํจ์์ ๋ง์ฐ์ค๋ฅผ ์ฌ๋ ค๋ณด๋ฉด, ์์ ๊ฐ์ด ํ๋ก๋ฏธ์ค ๊ฐ์ฒด๋ฅผ ๋ฐํํ๋ ํจ์๋ผ๋ ๊ฒ์ ์ ์ ์์ต๋๋ค.
๊ทธ๋ผ ์ด์ await
ํค์๋์ ๋ํด์๋ ์์๋ด์ผ๊ฒ ์ฃ . await
์ async
ํค์๋๊ฐ ์์ฑ๋ ํจ์์ ๋ด๋ถ์์ ์ฌ์ฉํ๋ ํค์๋๋ก, await
ํค์๋๊ฐ ํฌํจ๋ ์ฝ๋๊ฐ ์คํ๋๋ฉด ํด๋น ์์
์ด ์ข
๋ฃ๋ ๋๊น์ง ํ๋ก๊ทธ๋จ์ ์คํ์ด ์ค๋จ๋๋ค๋ ํน์ง์ด ์์ต๋๋ค. ๊ทธ๋ผ await
์ฝ๋๋ฅผ ์ฌ์ฉํด ์์ ์ฝ๋๋ฅผ ์์ ํด ๋ณผ๊น์?
const delay = (ms) => {
return new Promise((resolve) => {
setTimeout(() => {
resolve('3์ด๊ฐ ์ง๋ฌ์ต๋๋ค.');
}, ms);
});
};
const start = async () => {
let result = await delay(3000);
console.log(result);
};
start();
async
ํค์๋๊ฐ ๋ถ์ด์๋ start
ํจ์์ ๋ด๋ถ์ result
๋ณ์๋ฅผ ์๋ก ์์ฑํ ๋ค์, ํด๋น ๋ณ์์ delay
ํจ์๋ฅผ ํธ์ถํ ๊ฒฐ๊ด๊ฐ์ ํ ๋นํด ์ฃผ์์ต๋๋ค. ๊ทธ๋ฆฌ๊ณ ์ด delay
ํจ์์ ์์ await
ํค์๋๋ฅผ ์์ฑํ์ต๋๋ค. await
์ โ๊ธฐ๋ค๋ฆฌ๋คโ๋ผ๋ ๋ป์ผ๋ก, ํ๋ก๋ฏธ์ค ๊ฐ์ฒด๊ฐ ์ฒ๋ฆฌ๋ ๋๊น์ง ๊ธฐ๋ค๋ฆฌ๋ฉด์, ๊ทธ๋์์ ํจ์์ ์คํ์ ์ค๋จํ๋ ์ญํ ์ ํฉ๋๋ค.
๋ฐ๋ผ์ start
ํจ์๋ฅผ ํธ์ถํ๋ฉด, delay
ํจ์์ ํ๋ก๋ฏธ์ค ๊ฐ์ฒด์ ์ฒ๋ฆฌ๊ฐ ์๋ฃ๋ ๋๊น์ง ์ ์ ์ค๋จ๋์๋ค๊ฐ, ํ๋ก๋ฏธ์ค ๊ฐ์ฒด์ ์ฒ๋ฆฌ๊ฐ ์๋ฃ๋๋ฉด ์ฝ๋๊ฐ ์์๋๋ก ๋ค์ ์คํ๋ฉ๋๋ค. ์ดํ result
๋ณ์์ delay
ํจ์์ ๋ฐํ๊ฐ์ธ, ์คํ ์๋ฃ๋ ํ๋ก๋ฏธ์ค ๊ฐ์ฒด๊ฐ ํ ๋น๋์ด 3์ด ํ์ โ3์ด๊ฐ ์ง๋ฌ์ต๋๋คโ ๋ฌธ์ฅ์ด ์ถ๋ ฅ๋ฉ๋๋ค.
์ด๋ ๊ฒ await
ํค์๋๋ ํ๋ก๋ฏธ์ค ๊ฐ์ฒด๊ฐ ์ฒ๋ฆฌ๋ ๋๊น์ง ํจ์์ ์คํ์ ๊ธฐ๋ค๋ฆฌ๊ฒ ๋ง๋๋ ์ญํ ์ ํฉ๋๋ค. await
ํค์๋๋ฅผ ์ฌ์ฉํด์ ์ฝ๋๋ฅผ ์์ฑํ๋ฉด, ํ๋ก๋ฏธ์ค ๊ฐ์ฒด์ then
๋ฉ์๋๋ฅผ ์ฌ์ฉํด์ ์ฝ๋๋ฅผ ์์ฑํ๋ ๊ฒ๋ณด๋ค ํจ์ฌ ๊ฐ๋
์ฑ์ด ์ข๊ณ ํธ๋ฆฌํ๊ฒ ์์ฑํ ์ ์์ต๋๋ค. ๋ค๋ง, await
ํค์๋๋ ํ๋ก๋ฏธ์ค ๊ฐ์ฒด๋ฅผ ๋ฐํํ๋ ํจ์์ ๋ด๋ถ์์๋ง, ์ฆ async
ํค์๋๊ฐ ๋ถ์ด์๋ ํจ์์ ๋ด๋ถ์์๋ง ์ฌ์ฉํ ์ ์๋ค๋ ์ ์ ์ฃผ์ํด์ผ ํฉ๋๋ค.
3. ์๋ฌ ํธ๋ค๋ง
๊ทธ๋ผ ์ด์ ์ค๋ฅ๊ฐ ๋ฐ์ํ์ ๋ ์ด๋ป๊ฒ ์ฒ๋ฆฌํด์ผ ํ๋์ง๋ ์์๋ณด๊ฒ ์ต๋๋ค. ์๋ฌ ํธ๋ค๋ง ๋ฐฉ๋ฒ์ ์์ฃผ ๊ฐ๋จํ๋ฐ์. async
์ await
์ ์ฌ์ฉํ ๋น๋๊ธฐ ์ฒ๋ฆฌ์์๋ try
/catch
๋ฌธ์ ์ฌ์ฉํด, ์๋ฌ๋ฅผ ์ฒ๋ฆฌํ ์ ์์ต๋๋ค. async
ํจ์์ธ start
ํจ์์ ๋ด๋ถ์ try
/catch
๋ฅผ ์ฌ์ฉํด, ์ฝ๋๋ฅผ ํ๋ฒ ์์ฑํด ๋ณด๊ฒ ์ต๋๋ค.
const delay = (ms) => {
return new Promise((resolve) => {
setTimeout(() => {
resolve('3์ด๊ฐ ์ง๋ฌ์ต๋๋ค.');
}, ms);
});
};
const start = async () => {
try {
let result = await delay(3000);
console.log(result);
} catch (error) {
console.log(error);
}
};
start();
์ด๋ ๊ฒ try
/catch
๋ฌธ์ ์ฌ์ฉํด ์์ฑํ ์ฝ๋์ ์คํ ์์๋ฅผ ์ดํด๋ณด๋ฉด, ๋จผ์ try
๋ธ๋ก ์์ ์์ฑ๋ ์ฝ๋๊ฐ ์คํ๋๊ณ , ํด๋น ์ฝ๋์์ ์๋ฌ๊ฐ ๋ฐ์ํ๋ค๋ฉด ๋ฐ๋ก ์๋์ ์์ฑ๋ catch
๋ธ๋ก ๋ด๋ถ์ ์ฝ๋๊ฐ ์คํ๋ฉ๋๋ค. ๋ฐ๊ฒฌ๋ ์๋ฌ๋ catch
์ ์ ๋ฌ๋ error
๊ฐ์ฒด์ ์ ์ฅ๋๊ธฐ ๋๋ฌธ์, ์๋ฌ ๋ฐ์ ์ ์ด error
๊ฐ์ฒด๋ฅผ ์ฌ์ฉํ๋ฉด ์ด๋ค ์๋ฌ๊ฐ ๋ฐ์ํ๋์ง๋ฅผ ์ถ๋ ฅํ ์ ์์ต๋๋ค. ์ด์ฒ๋ผ try
/catch
๋ฌธ์ ํ์ฉํ๋ฉด, ๋น๋๊ธฐ ์ฝ๋์์ ๋ฐ์ํ๋ ์ค๋ฅ๋ฅผ ๋์ฑ ์์ ํ๊ฒ ์ฒ๋ฆฌํ ์ ์์ต๋๋ค.
API ํธ์ถ
์๋ฐ์คํฌ๋ฆฝํธ์์ ๋น๋๊ธฐ ์์ ์ ์ฒ๋ฆฌํ๋ ๊ฐ์ฅ ๋ํ์ ์ธ ์์๊ฐ ๋ฐ๋ก API ํธ์ถ์ด์ฃ . ์๋ฒ์ ๋ฐ์ดํฐ๋ฅผ ์ฃผ๊ณ ๋ฐ๋ ๊ณผ์ ์์๋ ๋คํธ์ํฌ ์ง์ฐ์ ํฌํจํ ๋ค์ํ ๋ณ์๋ค์ด ๋ฐ์ํ ์ ์๊ธฐ ๋๋ฌธ์, ์ด๋ฌํ ์์ ์ ๋น๋๊ธฐ์ ์ผ๋ก ์ฒ๋ฆฌํด์ผ ํฉ๋๋ค. ์ด ๊ธ์ ๋ง์ง๋ง์์๋ ์ฐ๋ฆฌ๊ฐ ๋น๋๊ธฐ๋ฅผ ๋ฐฐ์ด ๋ชฉ์ ์ธ ํด๋ผ์ด์ธํธ์ ์๋ฒ ๊ฐ์ ํต์ ์๋ฆฌ, API ํธ์ถ ๋ฐฉ์, ๊ทธ๋ฆฌ๊ณ ์๋ฌ ํธ๋ค๋ง ๋ฐฉ๋ฒ์ ๋ํด ์์๋ณด๊ฒ ์ต๋๋ค.
1. ํด๋ผ์ด์ธํธ์ ์๋ฒ ํต์
์น ๋ธ๋ผ์ฐ์ (ํด๋ผ์ด์ธํธ)๋ ๋คํธ์ํฌ๋ฅผ ํตํด ์๋ฒ์ ํต์ ํ๋ฉฐ, ์๋ฒ๋ ๋ฐ์ดํฐ๋ฒ ์ด์ค์์ ํ์ํ ์ ๋ณด๋ฅผ ๊ฐ์ ธ์ ํด๋ผ์ด์ธํธ์๊ฒ ์ ๋ฌํฉ๋๋ค. ์ด ๊ณผ์ ์ ์ฐ๋ฆฌ๊ฐ ์ปคํผ์์์ ์ปคํผ๋ฅผ ์ฃผ๋ฌธํ๋ ๊ณผ์ ๊ณผ ์ ์ฌํ๊ฒ ์ดํดํ ์ ์์ต๋๋ค.

์ปคํผ์์์ ์๋์ด ๋ฐ๋ฆฌ์คํ์๊ฒ ์ปคํผ๋ฅผ ์ฃผ๋ฌธํ๋ฉด, ๋ฐ๋ฆฌ์คํ๋ ์ฐฝ๊ณ ์์ ์๋๋ฅผ ์ฐพ์ ์ปคํผ๋ฅผ ๋ง๋ค์ด ์ ๊ณตํ๋ ๊ฒ์ฒ๋ผ, ํด๋ผ์ด์ธํธ๊ฐ ์๋ฒ์ ๋ฐ์ดํฐ๋ฅผ ์์ฒญํ๋ฉด, ์๋ฒ๋ ๋ฐ์ดํฐ๋ฒ ์ด์ค์์ ํ์ํ ์ ๋ณด๋ฅผ ์ฐพ์ ์๋ตํฉ๋๋ค.

์ฆ, ํด๋ผ์ด์ธํธ๋ ์ง์ ๋ฐ์ดํฐ๋ฒ ์ด์ค์ ์ ๊ทผํ์ง ์๊ณ , ์๋ฒ์๊ฒ ์์ฒญ์ ๋ณด๋ด ์ํ๋ ๋ฐ์ดํฐ๋ฅผ ๋ฐ์์ค๋ ๊ตฌ์กฐ์ ๋๋ค. ์ด๋ฅผ ํตํด ๋ณด์๊ณผ ํจ์จ์ฑ์ ์ ์งํ๋ฉด์ ๋ฐ์ดํฐ๋ฅผ ์ฃผ๊ณ ๋ฐ์ ์ ์์ต๋๋ค.
2. API ํธ์ถ๊ณผ ๋น๋๊ธฐ
์๋ฐ์คํฌ๋ฆฝํธ์์๋ fetch
๋ผ๋ ๋ด์ฅ ํจ์๋ฅผ ์ฌ์ฉํด์ API๋ฅผ ํธ์ถํ ์ ์์ต๋๋ค. fetch
๋ฉ์๋์ ๊ดํธ ์์ API ์ฃผ์๋ฅผ ์
๋ ฅํ๋ฉด ํด๋น API๋ฅผ ํธ์ถํฉ๋๋ค.
let response = fetch('https://jsonplaceholder.typicode.com/users');
console.log(response);;
๋ค์๊ณผ ๊ฐ์ด ์ฝ๋๋ฅผ ์์ฑํ๊ณ response
๊ฐ์ ์ถ๋ ฅํ๋ฉด, ์ฐ๋ฆฌ๊ฐ ์์ ์ดํด๋ดค๋ ํ๋ก๋ฏธ์ค ๊ฐ์ฒด๊ฐ ์ถ๋ ฅ๋๋ ๊ฒ์ ๋ณผ ์ ์์ต๋๋ค. ์ด๋ ๊ฒ state
ํ๋กํผํฐ๊ฐ fulfilled์ธ ํ๋ก๋ฏธ์ค ๊ฐ์ฒด๊ฐ ์ถ๋ ฅ๋ฉ๋๋ค.

fetch
๋ฉ์๋๋ฅผ ์ฌ์ฉํด API๋ฅผ ํธ์ถํ๋ฉด ์ด๋ ๊ฒ ํ๋ก๋ฏธ์ค ๊ฐ์ฒด๋ฅผ ๋ฐํํ๋ฏ๋ก, then ๋ฉ์๋๋ฅผ ํ์ฉํด ๊ฒฐ๊ณผ ๊ฐ์ ์ถ๋ ฅํ ์ ์๊ฒ ์ง๋ง, ์ฐ๋ฆฌ๋ ๋์ฑ ํธ๋ฆฌํ ๋น๋๊ธฐ ์ฒ๋ฆฌ ๋ฐฉ์์ async
/await
์ ๋ฐฐ์ ๊ธฐ ๋๋ฌธ์, ๋ฐ๋ก ์ ์ฉํด ๋ณด๊ฒ ์ต๋๋ค.
async
/await
์ ์ฌ์ฉํ๊ธฐ ์ํด API๋ฅผ ํธ์ถํด ๊ฐ์ ๋ฐ์์ค๋ ๊ธฐ๋ฅ์ ํจ์์ธ getData
ํจ์๋ฅผ ์์ฑํด ๋ด
์๋ค. ๊ทธ๋ฆฌ๊ณ JSON ํ์์ ๋ฐ์ดํฐ์ธ API ํธ์ถ ๊ฒฐ๊ณผ๋ฅผ, ์๋ฐ์คํฌ๋ฆฝํธ์์ ์ฌ์ฉํ ์ ์๋๋ก json()
์ด๋ผ๋ ๋ฉ์๋๋ฅผ ํ์ฉํด ๋ณ๊ฒฝํด ์ค๊ฒ์.
const getData = async () => {
let response = await fetch('https://jsonplaceholder.typicode.com/users');
let data = await response.json();
console.log(data);
};
getData();
json()
๋ฉ์๋๋ฅผ ์ฌ์ฉํด์ response
์ ๋ด๊ธด ๊ฐ์, ์๋ฐ์คํฌ๋ฆฝํธ๊ฐ ํ์ฉํ ์ ์๋ ๊ฐ์ฒด์ ํํ๋ก ๋ณํํ์ต๋๋ค. ์ด๋ fetch
ํจ์๋ ๋น๋๊ธฐ์ ์ผ๋ก ์ฒ๋ฆฌ๋๊ธฐ ๋๋ฌธ์, API ํธ์ถ์ด ์์ ํ ๋๋ ์ดํ์ response
๋ณ์๋ฅผ ๊ฐ์ฒด๋ก ๋ณํํ ์ ์๋๋ก await
ํค์๋๋ฅผ ์์ฑํด ์ค๋๋ค.

์ฝ๋๋ฅผ ์คํํ๋ฉด ์ค์ ๋ก ์์ ๊ฐ์ ๊ฐ๋ค์ด ๋ฐฐ์ด์ ๋ด๊ฒจ ์ถ๋ ฅ๋๋ ๊ฒ์ ๋ณผ ์ ์๊ณ , ์ด๋ ๊ฒ async
/await
์ ์ฌ์ฉํ๋ฉด ์๋ฐ์คํฌ๋ฆฝํธ์์ API ํธ์ถ๊ณผ ๊ฐ์ ๋น๋๊ธฐ ์์
์ ์์ฃผ ๊ฐ๋จํ๊ฒ ์ฒ๋ฆฌํ ์ ์์ต๋๋ค.
3. ์๋ฌ ํธ๋ค๋ง
API ํธ์ถ์ ํ์ํ ๋ฐ์ดํฐ๋ฅผ ์ ๋ฌ๋ฐ๊ธฐ ์ํด ๋ฐ์ดํฐ๋ฅผ ์์ฒญํ๋ ์์
์
๋๋ค. ๋ฐ์ดํฐ๋ฅผ ์์ฒญํ ๋๋ ๋คํธ์ํฌ ์ค๋ฅ ๋๋ ์ธํฐ๋ท ์๋ ๋ฑ์ ๋ค์ํ ์ด์ ๋ก, ๋ฐ์ดํฐ ์์ฒญ์ ์คํจํ ์ ์๋ค๋ ์ ์ ์ฃผ์ํด์ผ ํ๋๋ฐ์. ์ด๋ ๊ฒ ์ฑ๊ณตํ ์๋, ์คํจํ ์๋ ์๋ ๋น๋๊ธฐ ์์
์ ํญ์ ์๋ฌ๋ฅผ ์ฒ๋ฆฌํ ์ ์๋๋ก ํด์ผ ํฉ๋๋ค. ์์ ์ดํด๋ดค๋ try
/catch
๋ฌธ์ ์ฌ์ฉํด ์๋ฌ๋ฅผ ์ฒ๋ฆฌํด ๋ณผ๊ฒ์.
const getData = async () => {
try {
let response = await fetch('https://jsonplaceholder.typicode.com/users');
let data = await response.json();
console.log(data);
} catch (err) {
console.log(err);
}
};
getData();
์ด๋ ๊ฒ try
/catch
๋ฌธ์ ์ฌ์ฉํ๋ฉด ๋งค์ฐ ์ฝ๊ฒ ์๋ฌ๋ฅผ ์ฒ๋ฆฌํ ์ ์์ต๋๋ค. ์ค์ ๋ก fetch
๋ฉ์๋ ๋ด๋ถ์ ์๋ API ์ฃผ์๋ฅผ ์์๋ก ๋ณ๊ฒฝํด ๋ณผ๊น์? https://jsonplaceholder1313.typicode.com/users
๋ผ๋ ์ด์ํ ์ฃผ์๋ก ๋ณ๊ฒฝํ๊ณ ์ฝ๋๋ฅผ ์คํํ๋ฉด, catch๋ฌธ์ ํตํด ์๋ฌ ๋ฉ์ธ์ง๊ฐ ์๋ง๊ฒ ์ถ๋ ฅ๋๋ ๊ฒ๊น์ง ํ์ธํด๋ณผ ์ ์์ต๋๋ค.
์ด๋ ๊ฒ API ํธ์ถ์ async
์ await
์ ์ฌ์ฉํด์ ๋น๋๊ธฐ๋ก ์ฒ๋ฆฌํ๋ฉด, ๊ฐ๋
์ฑ์ด ์ข์ ์ฝ๋๋ฅผ ์์ฑํ ์ ์์ต๋๋ค. ์ด๋ก์จ ์ฝ๋์ ์คํ ํ๋ฆ๊ณผ ์ญํ ์ ์ง๊ด์ ์ผ๋ก ํ ์ ์๊ณ , ์๋ฌ ์ฒ๋ฆฌ ๋ํ ํธ๋ฆฌํ๊ฒ ํ ์ ์๋ค๋ ์ฅ์ ์ด ์์ต๋๋ค.
๋ง์น๋ฉฐ
์ง๊ธ๊น์ง ์๋ฐ์คํฌ๋ฆฝํธ์ ๋น๋๊ธฐ์ ๋ํ ๋ด์ฉ์ 1, 2ํธ์ผ๋ก ๋๋ ๋ค๋ค๋ณด์์ต๋๋ค. ์๋ฐ์คํฌ๋ฆฝํธ๊ฐ ๋น๋๊ธฐ ์ฒ๋ฆฌ๋ฅผ ํ์๋ก ํ๋ ์ด์ ์ setTimeout
, ํ๋ก๋ฏธ์ค ๊ฐ์ฒด, ์ฝ๋ฐฑ ์ง์ฅ, async
/await
, ๊ทธ๋ฆฌ๊ณ API ํธ์ถ๊น์ง ๋ค์ํ ๋น๋๊ธฐ ์ฒ๋ฆฌ ๋ฐฉ์์ ๋ํด ๋ฐฐ์ ๋๋ฐ์.
๋น๋๊ธฐ ํ๋ก๊ทธ๋๋ฐ์ ์ฌ๋ฐ๋ฅด๊ฒ ํ์ฉํ๋ฉด ์ฌ์ฉ์์ ๊ฒฝํ์ ๊ฐ์ ํ๊ณ , ๋ณด๋ค ์์ ์ ์ธ ์ ํ๋ฆฌ์ผ์ด์ ์ ๊ฐ๋ฐํ ์ ์์ต๋๋ค. ๋น๋๊ธฐ๋ ๋งค์ฐ ์ค์ํ ๊ฐ๋ ์ด๊ณ ์์ฃผ ํ์ฉ๋๋ฏ๋ก, ์ง์ ์ฝ๋๋ฅผ ์์ฑํด ๋ณด๋ฉฐ ๊ฒฐ๊ด๊ฐ์ ํ์ธํด ๋ณด๋ ๊ณผ์ ์ด ํ์ํฉ๋๋ค. ์ด๋ฒ ๊ธ์์ ์ฌ์ฉํ๋ ์ฌ์ดํธ๋ฅผ ํ์ฉํ๋ฉด, ๋ฌด๋ฃ๋ก ์ฌ๋ฌ API๋ฅผ ํธ์ถํด ๋ณผ ์ ์๋๋ฐ์. ๋ค์ํ ์์ ๋ฅผ ํตํด ๋น๋๊ธฐ ์ฒ๋ฆฌ๋ฅผ ์ฐ์ตํ๊ณ ์ถ์ผ์ ๋ถ๋ค์ ์ฐธ๊ณ ํด ๋ณด์๊ธธ ๋ฐ๋๋๋ค.
์ฐธ๊ณ
