Ver2.0 ๐ async/await๋ก ๋ ๊ฐ ๋ฌ๊ธฐ: TypeScript์์ ๋น๋๊ธฐ ์ฝ๋๋ฅผ ์ฐ์ํ๊ฒ ๋ค๋ฃจ๋ ๋ฐฉ๋ฒ ๐

๐ async/await๋ก ๋ ๊ฐ ๋ฌ๊ธฐ: TypeScript์์ ๋น๋๊ธฐ ์ฝ๋๋ฅผ ์ฐ์ํ๊ฒ ๋ค๋ฃจ๋ ๋ฐฉ๋ฒ ๐
์๋ , ๊ฐ๋ฐ์ ์น๊ตฌ๋ค! ์ค๋์ 2025๋ 4์, ๋น๋๊ธฐ ํ๋ก๊ทธ๋๋ฐ์ ์ธ๊ณ๋ก ํจ๊ป ์ฌํ์ ๋ ๋๋ณผ๊น? async/await๋ผ๋ ๋ง๋ฒ์ ๋๊ตฌ๋ฅผ ์ด์ฉํด์ ๋ณต์กํ ๋น๋๊ธฐ ์ฝ๋๋ฅผ ์ด๋ป๊ฒ ๊ฐ๊ฒฐํ๊ณ ์ฐ์ํ๊ฒ ๋ง๋ค ์ ์๋์ง ์์๋ณด์! ๐งโโ๏ธ
๐ ๋ชฉ์ฐจ
- ๋น๋๊ธฐ ํ๋ก๊ทธ๋๋ฐ์ด ๋ญ๊ธธ๋?
- ์ฝ๋ฐฑ ์ง์ฅ์์ Promise๊น์ง
- async/await์ ๋ฑ์ฅ: ๊ตฌ์ธ์ฃผ์ธ๊ฐ?
- TypeScript์์ async/await ์ฌ์ฉํ๊ธฐ
- ์ค์ ์์ ๋ก ๋ฐฐ์ฐ๋ async/await
- ์๋ฌ ์ฒ๋ฆฌ ๋ง์คํฐํ๊ธฐ
- ์ฑ๋ฅ ์ต์ ํ ํ
- 2025๋ ์ต์ ๋น๋๊ธฐ ํจํด
- ๋ง๋ฌด๋ฆฌ ๋ฐ ์ถ๊ฐ ์๋ฃ
๐ ๋น๋๊ธฐ ํ๋ก๊ทธ๋๋ฐ์ด ๋ญ๊ธธ๋?
ํ๋ก๊ทธ๋๋ฐ ์ธ๊ณ์์ '๋น๋๊ธฐ'๋ผ๋ ๋จ์ด๋ฅผ ๋ค์ด๋ณธ ์ ์์ง? ๊ฐ๋จํ ๋งํ๋ฉด, ์ฝ๋๊ฐ ์์ฐจ์ ์ผ๋ก ์คํ๋์ง ์๊ณ ์ฌ๋ฌ ์์ ์ด ๋์์ ์งํ๋๋ ๋ฐฉ์์ด์ผ. ๋ง์น ์ฌ๋ฌ ๊ฐ์ ์ผ์ ๋์์ ์ฒ๋ฆฌํ๋ ๊ฒ์ฒ๋ผ! ๐คนโโ๏ธ
์๋ฅผ ๋ค์ด๋ณผ๊ฒ. ๋๊ฐ ์นดํ์์ ์ปคํผ๋ฅผ ์ฃผ๋ฌธํ๋ค๊ณ ์๊ฐํด๋ด:
๋๊ธฐ์ ๋ฐฉ์: ์ปคํผ๊ฐ ์์ฑ๋ ๋๊น์ง ์นด์ดํฐ ์์์ ๊ธฐ๋ค๋ฆฌ๊ธฐ (๋ค๋ฅธ ์ผ ๋ชป ํจ)
๋น๋๊ธฐ์ ๋ฐฉ์: ์ฃผ๋ฌธ ํ ์ง๋๋ฒจ ๋ฐ๊ณ ์๋ฆฌ์ ์์ ๋ค๋ฅธ ์ผ ํ๋ค๊ฐ ๋ฒจ ์ธ๋ฆฌ๋ฉด ์ปคํผ ๋ฐ์ผ๋ฌ ๊ฐ๊ธฐ
ํ๋ก๊ทธ๋๋ฐ์์๋ ๋ง์ฐฌ๊ฐ์ง์ผ. ํ์ผ์ ์ฝ๊ฑฐ๋, ๋คํธ์ํฌ ์์ฒญ์ ๋ณด๋ด๊ฑฐ๋, ๋ฐ์ดํฐ๋ฒ ์ด์ค๋ฅผ ์กฐํํ๋ ๋ฑ์ ์์ ์ ์๊ฐ์ด ์ค๋ ๊ฑธ๋ฆด ์ ์์ด. ์ด๋ฐ ์์ ๋ค์ ๋น๋๊ธฐ์ ์ผ๋ก ์ฒ๋ฆฌํ๋ฉด ํ๋ก๊ทธ๋จ์ด ๋ฉ์ถ์ง ์๊ณ ๊ณ์ ๋ค๋ฅธ ์ผ์ ํ ์ ์์ง! ๐
ํนํ ์น ๊ฐ๋ฐ์์๋ ์ฌ์ฉ์ ๊ฒฝํ์ ์ํด ๋น๋๊ธฐ ํ๋ก๊ทธ๋๋ฐ์ด ํ์์ ์ด์ผ. ์ฌ์ฉ์๊ฐ ๋ฒํผ์ ํด๋ฆญํ์ ๋ ์๋ฒ์์ ๋ฐ์ดํฐ๋ฅผ ๊ฐ์ ธ์ค๋ ๋์ ์ ์ฒด ํ์ด์ง๊ฐ ๋ฉ์ถฐ๋ฒ๋ฆฐ๋ค๋ฉด... ๋์ฐํ์ง ์์๊น? ๐ฑ
๐ฐ๏ธ ์ฝ๋ฐฑ ์ง์ฅ์์ Promise๊น์ง
๋น๋๊ธฐ ํ๋ก๊ทธ๋๋ฐ์ ์ญ์ฌ๋ ๊ฝค ํฅ๋ฏธ๋ก์. ์ฒ์์๋ '์ฝ๋ฐฑ ํจ์'๋ผ๋ ๊ฐ๋ ์ผ๋ก ๋น๋๊ธฐ ์์ ์ ์ฒ๋ฆฌํ์ด. ์ฝ๋ฐฑ์ ๊ฐ๋จํ ๋งํด์ "์ด ์์ ์ด ๋๋๋ฉด ์ด ํจ์๋ฅผ ์คํํด์ค"๋ผ๊ณ ์ง์ํ๋ ๋ฐฉ์์ด์ผ.
// ์ฝ๋ฐฑ ํจ์๋ฅผ ์ฌ์ฉํ ๋น๋๊ธฐ ์ฒ๋ฆฌ
fs.readFile('file1.txt', (err, data1) => {
if (err) throw err;
fs.readFile('file2.txt', (err, data2) => {
if (err) throw err;
fs.readFile('file3.txt', (err, data3) => {
if (err) throw err;
// ์ธ ํ์ผ์ ๋ด์ฉ์ ๋ชจ๋ ์ฝ์ ํ ์ฒ๋ฆฌํ๋ ์ฝ๋
console.log(data1.toString() + data2.toString() + data3.toString());
});
});
});
๋ณด์ด์ง? ์ด๋ฐ ์์ผ๋ก ์ฝ๋ฐฑ ์์ ์ฝ๋ฐฑ, ๋ ๊ทธ ์์ ์ฝ๋ฐฑ... ๐ ์ด๋ ๊ฒ ์ค์ฒฉ๋ ๊ตฌ์กฐ๋ฅผ '์ฝ๋ฐฑ ์ง์ฅ(Callback Hell)'์ด๋ผ๊ณ ๋ถ๋ฌ. ์ฝ๋๊ฐ ์ค๋ฅธ์ชฝ์ผ๋ก ๊ณ์ ๋ค์ฌ์ฐ๊ธฐ ๋๋ฉด์ ๊ฐ๋ ์ฑ์ด ๋จ์ด์ง๊ณ ์ ์ง๋ณด์๊ฐ ์ด๋ ค์์ง์ง.
์ด๋ฐ ๋ฌธ์ ๋ฅผ ํด๊ฒฐํ๊ธฐ ์ํด ES6์์ 'Promise'๋ผ๋ ๊ฐ๋ ์ด ๋ฑ์ฅํ์ด! Promise๋ "๋์ค์ ์๋ฃ๋ ์์ "์ ๋ํ๋ด๋ ๊ฐ์ฒด์ผ. ๋น๋๊ธฐ ์์ ์ ์ต์ข ์๋ฃ(๋๋ ์คํจ)์ ๊ทธ ๊ฒฐ๊ณผ๊ฐ์ ๋ํ๋ด์ง.
// Promise๋ฅผ ์ฌ์ฉํ ๋น๋๊ธฐ ์ฒ๋ฆฌ
function readFilePromise(filename) {
return new Promise((resolve, reject) => {
fs.readFile(filename, (err, data) => {
if (err) reject(err);
else resolve(data);
});
});
}
readFilePromise('file1.txt')
.then(data1 => {
console.log(data1.toString());
return readFilePromise('file2.txt');
})
.then(data2 => {
console.log(data2.toString());
return readFilePromise('file3.txt');
})
.then(data3 => {
console.log(data3.toString());
})
.catch(err => {
console.error('์๋ฌ ๋ฐ์:', err);
});
Promise๋ฅผ ์ฌ์ฉํ๋ฉด ์ฝ๋ฐฑ ์ง์ฅ์์ ๋ฒ์ด๋ ์ฝ๋๋ฅผ ์ข ๋ ์ ํ์ ์ผ๋ก ์์ฑํ ์ ์์ด. ํ์ง๋ง ์ฌ์ ํ .then().then().then()... ์ด๋ฐ ์ฒด์ธ ๊ตฌ์กฐ๊ฐ ๋ณต์กํด ๋ณด์ด์ง ์์? ๐ค
์ฌ๊ธฐ์ ์ฐ๋ฆฌ์ ์ฃผ์ธ๊ณต async/await๊ฐ ๋ฑ์ฅํ๊ฒ ๋ผ! ๐ฆธโโ๏ธ
โจ async/await์ ๋ฑ์ฅ: ๊ตฌ์ธ์ฃผ์ธ๊ฐ?
ES2017(ES8)์์ ๋์ ๋ async/await๋ Promise๋ฅผ ๊ธฐ๋ฐ์ผ๋ก ํ์ง๋ง, ๋น๋๊ธฐ ์ฝ๋๋ฅผ ๋ง์น ๋๊ธฐ ์ฝ๋์ฒ๋ผ ๋ณด์ด๊ฒ ๋ง๋ค์ด์ฃผ๋ ๋ง๋ฒ ๊ฐ์ ๋ฌธ๋ฒ์ด์ผ. ์ด๊ฒ ์ ํ๋ช ์ ์ด๋๋ฉด, ์ฝ๋์ ๊ฐ๋ ์ฑ๊ณผ ๋๋ฒ๊น ์ด ์์ฒญ๋๊ฒ ์ฌ์์ง๊ฑฐ๋ ! ๐ฏ
async/await๋ ๋ ๊ฐ์ง ํค์๋๋ก ๊ตฌ์ฑ๋ผ:
- async: ํจ์ ์์ ๋ถ์ฌ์ "์ด ํจ์๋ ๋น๋๊ธฐ ํจ์์ผ"๋ผ๊ณ ์ ์ธํด. ์ด ํจ์๋ ํญ์ Promise๋ฅผ ๋ฐํํด.
- await: Promise๊ฐ ์ฒ๋ฆฌ๋ ๋๊น์ง ํจ์์ ์คํ์ ์ผ์ ์ค์งํด. await๋ async ํจ์ ๋ด์์๋ง ์ฌ์ฉํ ์ ์์ด.
async/await์ ๊ฐ์ฅ ํฐ ์ฅ์ ์ ๋น๋๊ธฐ ์ฝ๋๋ฅผ ๋ง์น ๋๊ธฐ ์ฝ๋์ฒ๋ผ ์ฝ๊ณ ์ธ ์ ์๋ค๋ ๊ฑฐ์ผ. ์ฝ๋์ ํ๋ฆ์ด ์์์ ์๋๋ก ์์ฐ์ค๋ฝ๊ฒ ์ฝํ๊ธฐ ๋๋ฌธ์ ์ดํดํ๊ธฐ ํจ์ฌ ์ฌ์์ง์ง! ๐
// async/await๋ฅผ ์ฌ์ฉํ ๋น๋๊ธฐ ์ฒ๋ฆฌ
async function readFiles() {
try {
const data1 = await readFilePromise('file1.txt');
console.log(data1.toString());
const data2 = await readFilePromise('file2.txt');
console.log(data2.toString());
const data3 = await readFilePromise('file3.txt');
console.log(data3.toString());
} catch (err) {
console.error('์๋ฌ ๋ฐ์:', err);
}
}
readFiles();
์ด๋? ํจ์ฌ ๊น๋ํ๊ณ ์ดํดํ๊ธฐ ์ฝ์ง? ๋ง์น ๋๊ธฐ ์ฝ๋๋ฅผ ์์ฑํ๋ ๊ฒ์ฒ๋ผ ์์ฐ์ค๋ฌ์์ก์ด! ๐
๐ท TypeScript์์ async/await ์ฌ์ฉํ๊ธฐ
์ด์ ์ฐ๋ฆฌ์ ์ฃผ์ ์ธ TypeScript์์ async/await๋ฅผ ์ด๋ป๊ฒ ํ์ฉํ๋์ง ์์๋ณผ๊น? TypeScript๋ JavaScript์ ํ์ ์์คํ ์ ์ถ๊ฐํ ์ธ์ด๋ก, ์ฝ๋์ ์์ ์ฑ๊ณผ ๊ฐ๋ฐ ๊ฒฝํ์ ํฌ๊ฒ ํฅ์์์ผ์ค. 2025๋ ํ์ฌ, TypeScript๋ ํ๋ก ํธ์๋๋ถํฐ ๋ฐฑ์๋๊น์ง ์น ๊ฐ๋ฐ์ ํ์ค์ผ๋ก ์๋ฆฌ ์ก์์ง! ๐
TypeScript์์ async/await๋ฅผ ์ฌ์ฉํ ๋์ ๊ฐ์ฅ ํฐ ์ฅ์ ์ ํ์ ์์ ์ฑ์ด์ผ. Promise๊ฐ ๋ฐํํ๋ ๊ฐ์ ํ์ ์ ๋ช ํํ๊ฒ ์ง์ ํ ์ ์์ด์ ์ฝ๋์ ์์ธก ๊ฐ๋ฅ์ฑ์ด ๋์์ง์ง.
// TypeScript์์ async/await ์ฌ์ฉํ๊ธฐ
interface User {
id: number;
name: string;
email: string;
}
interface Post {
id: number;
userId: number;
title: string;
body: string;
}
async function fetchUserById(id: number): Promise<User> {
const response = await fetch(`https://api.example.com/users/${id}`);
if (!response.ok) {
throw new Error(`HTTP error! status: ${response.status}`);
}
return await response.json() as User;
}
async function fetchPostsByUser(userId: number): Promise<Post[]> {
const response = await fetch(`https://api.example.com/users/${userId}/posts`);
if (!response.ok) {
throw new Error(`HTTP error! status: ${response.status}`);
}
return await response.json() as Post[];
}
async function getUserWithPosts(userId: number): Promise<{user: User, posts: Post[]}> {
const user = await fetchUserById(userId);
const posts = await fetchPostsByUser(user.id);
return {
user,
posts
};
}
์ ์ฝ๋์์ ๋ณผ ์ ์๋ฏ์ด, TypeScript๋ฅผ ์ฌ์ฉํ๋ฉด ํจ์๊ฐ ๋ฐํํ๋ Promise์ ํ์
์ ๋ช
ํํ๊ฒ ์ง์ ํ ์ ์์ด. Promise<User>, Promise<Post[]> ๊ฐ์ ์์ผ๋ก ๋ง์ด์ผ. ์ด๋ ๊ฒ ํ๋ฉด IDE์์ ์๋ ์์ฑ ๊ธฐ๋ฅ๋ ์ ๋๋ก ๋์ํ๊ณ , ํ์
์ค๋ฅ๋ ์ปดํ์ผ ์์ ์ ์ก์๋ผ ์ ์์ด์ ๊ฐ๋ฐ ์์ฐ์ฑ์ด ํฌ๊ฒ ํฅ์๋ผ! ๐
TypeScript์ ํ์ ์์คํ ์ ํนํ ๋๊ท๋ชจ ํ๋ก์ ํธ์์ ์ง๊ฐ๋ฅผ ๋ฐํํด. ์ฌ๋ฌ ๊ฐ๋ฐ์๊ฐ ํจ๊ป ์์ ํ ๋ ์ฝ๋์ ์ผ๊ด์ฑ์ ์ ์งํ๊ณ ๋ฒ๊ทธ๋ฅผ ์ค์ด๋ ๋ฐ ํฐ ๋์์ด ๋์ง!
์ฌ๋ฅ๋ท ๊ฐ์ ํ๋ซํผ์ ๊ฐ๋ฐํ ๋๋ TypeScript์ async/await์ ์กฐํฉ์ ์ ๋ง ๊ฐ๋ ฅํด. ์ฌ์ฉ์ ์ ๋ณด ์กฐํ, ์ฌ๋ฅ ๋ชฉ๋ก ๊ฐ์ ธ์ค๊ธฐ, ๊ฒฐ์ ์ฒ๋ฆฌ ๋ฑ ๋ค์ํ ๋น๋๊ธฐ ์์ ์ ํ์ ์์ ํ๊ฒ ์ฒ๋ฆฌํ ์ ์์ผ๋๊น! ๐ช
๐ป ์ค์ ์์ ๋ก ๋ฐฐ์ฐ๋ async/await
์ด๋ก ์ ์ถฉ๋ถํ ๋ฐฐ์ ์ผ๋, ์ด์ ์ค์ ์์ ๋ฅผ ํตํด async/await๋ฅผ ์ด๋ป๊ฒ ํ์ฉํ ์ ์๋์ง ์์๋ณด์! ์ฌ๋ฌ ๊ฐ์ง ์ค์ฉ์ ์ธ ์๋๋ฆฌ์ค๋ฅผ ํตํด async/await์ ๊ฐ๋ ฅํจ์ ์ฒดํํด๋ณผ ๊ฑฐ์ผ. ๐งช
1. API ๋ฐ์ดํฐ ๊ฐ์ ธ์ค๊ธฐ
์น ๊ฐ๋ฐ์์ ๊ฐ์ฅ ํํ ๋น๋๊ธฐ ์์ ์ค ํ๋๋ API์์ ๋ฐ์ดํฐ๋ฅผ ๊ฐ์ ธ์ค๋ ๊ฑฐ์ผ. fetch API์ async/await๋ฅผ ํจ๊ป ์ฌ์ฉํ๋ฉด ์ ๋ง ๊น๋ํ๊ฒ ์ฒ๋ฆฌํ ์ ์์ด!
// TypeScript์์ API ๋ฐ์ดํฐ ๊ฐ์ ธ์ค๊ธฐ
interface Product {
id: number;
title: string;
price: number;
description: string;
category: string;
image: string;
}
async function getProducts(): Promise<Product[]> {
try {
const response = await fetch('https://fakestoreapi.com/products');
if (!response.ok) {
throw new Error(`HTTP error! status: ${response.status}`);
}
const products = await response.json() as Product[];
return products;
} catch (error) {
console.error('์ํ์ ๊ฐ์ ธ์ค๋ ์ค ์ค๋ฅ ๋ฐ์:', error);
return [];
}
}
// ์ฌ์ฉ ์์
async function displayProducts() {
const products = await getProducts();
products.forEach(product => {
console.log(`${product.title} - $${product.price}`);
// DOM์ ์ํ ์ ๋ณด ํ์ํ๋ ์ฝ๋
});
}
2. ๋ณ๋ ฌ ๋น๋๊ธฐ ์ฒ๋ฆฌ
๋๋ก๋ ์ฌ๋ฌ ๋น๋๊ธฐ ์์ ์ ๋์์ ์คํํ๊ณ ์ถ์ ๋๊ฐ ์์ด. Promise.all๊ณผ async/await๋ฅผ ์กฐํฉํ๋ฉด ์ด๋ฐ ๋ณ๋ ฌ ์ฒ๋ฆฌ๋ฅผ ์ฝ๊ฒ ๊ตฌํํ ์ ์์ง!
// ์ฌ๋ฌ API ์์ฒญ์ ๋ณ๋ ฌ๋ก ์ฒ๋ฆฌํ๊ธฐ
async function fetchDashboardData(userId: number) {
try {
// ์ธ ๊ฐ์ง API ์์ฒญ์ ๋์์ ์์
const [userPromise, postsPromise, notificationsPromise] = [
fetch(`https://api.example.com/users/${userId}`),
fetch(`https://api.example.com/users/${userId}/posts`),
fetch(`https://api.example.com/users/${userId}/notifications`)
];
// ๋ชจ๋ ์๋ต์ด ๋์ฐฉํ ๋๊น์ง ๊ธฐ๋ค๋ฆผ
const [userResponse, postsResponse, notificationsResponse] = await Promise.all([
userPromise, postsPromise, notificationsPromise
]);
// ์๋ต์ JSON์ผ๋ก ๋ณํ
const userData = await userResponse.json();
const postsData = await postsResponse.json();
const notificationsData = await notificationsResponse.json();
return {
user: userData,
posts: postsData,
notifications: notificationsData
};
} catch (error) {
console.error('๋์๋ณด๋ ๋ฐ์ดํฐ๋ฅผ ๊ฐ์ ธ์ค๋ ์ค ์ค๋ฅ ๋ฐ์:', error);
throw error;
}
}
์ ์์ ์์๋ Promise.all์ ์ฌ์ฉํด ์ธ ๊ฐ์ API ์์ฒญ์ ๋ณ๋ ฌ๋ก ์ฒ๋ฆฌํ๊ณ ์์ด. ์ด๋ ๊ฒ ํ๋ฉด ์ธ ์์ฒญ์ ์์ฐจ์ ์ผ๋ก ์ฒ๋ฆฌํ๋ ๊ฒ๋ณด๋ค ํจ์ฌ ๋น ๋ฅด๊ฒ ๋ฐ์ดํฐ๋ฅผ ๊ฐ์ ธ์ฌ ์ ์์ง! โก
3. ์์ฐจ์ ๋น๋๊ธฐ ์ฒ๋ฆฌ
๋๋ก๋ ๋น๋๊ธฐ ์์ ์ ์์ฐจ์ ์ผ๋ก ์ฒ๋ฆฌํด์ผ ํ ๋๋ ์์ด. ์๋ฅผ ๋ค์ด, ์ฒซ ๋ฒ์งธ ์์ ์ ๊ฒฐ๊ณผ๊ฐ ๋ ๋ฒ์งธ ์์ ์ ์ ๋ ฅ์ผ๋ก ํ์ํ ๊ฒฝ์ฐ์ง.
// ์์ฐจ์ ๋น๋๊ธฐ ์ฒ๋ฆฌ
interface AuthResponse {
token: string;
userId: number;
}
interface UserProfile {
id: number;
name: string;
email: string;
profilePicture: string;
}
async function loginAndGetProfile(email: string, password: string): Promise<UserProfile> {
// 1. ๋ก๊ทธ์ธ ์์ฒญ
const authResponse = await fetch('https://api.example.com/login', {
method: 'POST',
headers: { 'Content-Type': 'application/json' },
body: JSON.stringify({ email, password })
});
if (!authResponse.ok) {
throw new Error('๋ก๊ทธ์ธ ์คํจ');
}
const authData: AuthResponse = await authResponse.json();
// 2. ์ธ์ฆ ํ ํฐ์ ์ฌ์ฉํด ์ฌ์ฉ์ ํ๋กํ ๊ฐ์ ธ์ค๊ธฐ
const profileResponse = await fetch(`https://api.example.com/users/${authData.userId}`, {
headers: {
'Authorization': `Bearer ${authData.token}`
}
});
if (!profileResponse.ok) {
throw new Error('ํ๋กํ ์ ๋ณด๋ฅผ ๊ฐ์ ธ์ค๋๋ฐ ์คํจํ์ต๋๋ค');
}
return await profileResponse.json() as UserProfile;
}
์ด ์์ ์์๋ ๋จผ์ ๋ก๊ทธ์ธ ์์ฒญ์ ๋ณด๋ด๊ณ , ๊ทธ ์๋ต์ผ๋ก ๋ฐ์ ํ ํฐ์ ์ฌ์ฉํด ์ฌ์ฉ์ ํ๋กํ์ ๊ฐ์ ธ์ค๊ณ ์์ด. ๋ ๋ฒ์งธ ์์ฒญ์ ์ฒซ ๋ฒ์งธ ์์ฒญ์ ๊ฒฐ๊ณผ์ ์์กดํ๊ธฐ ๋๋ฌธ์ ์์ฐจ์ ์ผ๋ก ์ฒ๋ฆฌํด์ผ ํด. async/await๋ฅผ ์ฌ์ฉํ๋ฉด ์ด๋ฐ ์์กด์ฑ ์๋ ๋น๋๊ธฐ ์์ ์ ์์ฃผ ๋ช ํํ๊ฒ ํํํ ์ ์์ง! ๐
4. ํ์์์ ์ฒ๋ฆฌ
API ์์ฒญ์ด ๋๋ฌด ์ค๋ ๊ฑธ๋ฆด ๊ฒฝ์ฐ๋ฅผ ๋๋นํด ํ์์์์ ์ค์ ํ๋ ๊ฒ๋ ์ค์ํด. Promise.race์ async/await๋ฅผ ์กฐํฉํ๋ฉด ์ฝ๊ฒ ๊ตฌํํ ์ ์์ด!
// ํ์์์ ๊ธฐ๋ฅ ๊ตฌํํ๊ธฐ
function timeout(ms: number): Promise<never> {
return new Promise((_, reject) => {
setTimeout(() => reject(new Error(`์์ฒญ ์๊ฐ ์ด๊ณผ: ${ms}ms`)), ms);
});
}
async function fetchWithTimeout<T>(url: string, ms: number = 5000): Promise<T> {
try {
// Promise.race๋ ๊ฐ์ฅ ๋จผ์ ์๋ฃ๋๋ Promise์ ๊ฒฐ๊ณผ๋ฅผ ๋ฐํ
const result = await Promise.race([
fetch(url).then(res => res.json()),
timeout(ms)
]);
return result as T;
} catch (error) {
console.error('์์ฒญ ์คํจ:', error);
throw error;
}
}
// ์ฌ์ฉ ์์
async function getProductWithTimeout() {
try {
const product = await fetchWithTimeout<Product>('https://fakestoreapi.com/products/1', 3000);
console.log('์ํ ์ ๋ณด:', product);
} catch (error) {
console.error('์ํ ์ ๋ณด๋ฅผ ๊ฐ์ ธ์ค์ง ๋ชปํ์ต๋๋ค:', error);
}
}
์ด ์์ ์์๋ Promise.race๋ฅผ ์ฌ์ฉํด API ์์ฒญ๊ณผ ํ์์์ ์ค ๋จผ์ ์๋ฃ๋๋ ๊ฒ์ ๊ฒฐ๊ณผ๋ฅผ ๋ฐํํด. ๋ง์ฝ API ์์ฒญ์ด ์ง์ ๋ ์๊ฐ(ms)๋ณด๋ค ์ค๋ ๊ฑธ๋ฆฌ๋ฉด ํ์์์ ์๋ฌ๊ฐ ๋ฐ์ํ๊ฒ ๋ผ. ์ด๋ ๊ฒ ํ๋ฉด ์ฌ์ฉ์๊ฐ ์๋ต์ ๋ฌดํ์ ๊ธฐ๋ค๋ฆฌ๋ ์ํฉ์ ๋ฐฉ์งํ ์ ์์ด! โฑ๏ธ
๐ก๏ธ ์๋ฌ ์ฒ๋ฆฌ ๋ง์คํฐํ๊ธฐ
๋น๋๊ธฐ ์ฝ๋์์ ์๋ฌ ์ฒ๋ฆฌ๋ ์ ๋ง ์ค์ํด. async/await๋ฅผ ์ฌ์ฉํ๋ฉด ๋๊ธฐ ์ฝ๋์ ๋น์ทํ ๋ฐฉ์์ผ๋ก try-catch ๊ตฌ๋ฌธ์ ํตํด ์๋ฌ๋ฅผ ์ฒ๋ฆฌํ ์ ์์ด์ ์ ๋ง ํธ๋ฆฌํด! ๐งฏ
1. ๊ธฐ๋ณธ์ ์ธ try-catch ์ฌ์ฉ๋ฒ
async/await๋ฅผ ์ฌ์ฉํ๋ฉด ๋๊ธฐ ์ฝ๋์ ๋์ผํ ๋ฐฉ์์ผ๋ก try-catch ๊ตฌ๋ฌธ์ ์ฌ์ฉํ ์ ์์ด. ์ด๊ฒ async/await์ ๊ฐ์ฅ ํฐ ์ฅ์ ์ค ํ๋์ง!
// ๊ธฐ๋ณธ์ ์ธ try-catch ์๋ฌ ์ฒ๋ฆฌ
async function fetchUserData(userId: number) {
try {
const response = await fetch(`https://api.example.com/users/${userId}`);
if (!response.ok) {
throw new Error(`HTTP error! status: ${response.status}`);
}
const userData = await response.json();
return userData;
} catch (error) {
console.error('์ฌ์ฉ์ ๋ฐ์ดํฐ๋ฅผ ๊ฐ์ ธ์ค๋ ์ค ์ค๋ฅ ๋ฐ์:', error);
// ์๋ฌ ์ฒ๋ฆฌ ๋ก์ง (์: ์ฌ์ฉ์์๊ฒ ์๋ฆผ, ๊ธฐ๋ณธ๊ฐ ๋ฐํ ๋ฑ)
return null;
}
}
์ค์ํ ์ ์ await ํค์๋๊ฐ ์๋ ์ค์์ ๋ฐ์ํ๋ ๋ชจ๋ ์๋ฌ(๋คํธ์ํฌ ์ค๋ฅ, JSON ํ์ฑ ์ค๋ฅ ๋ฑ)๋ฅผ catch ๋ธ๋ก์์ ์ก์ ์ ์๋ค๋ ๊ฑฐ์ผ. ์ด๋ ๊ฒ ํ๋ฉด ์๋ฌ ์ฒ๋ฆฌ ์ฝ๋๋ฅผ ํ ๊ณณ์ ๋ชจ์ ์ ์์ด์ ์ฝ๋๊ฐ ํจ์ฌ ๊น๋ํด์ ธ! ๐งน
2. ์๋ฌ ํ์ ๊ตฌ๋ถํ๊ธฐ
TypeScript๋ฅผ ์ฌ์ฉํ๋ฉด ์๋ฌ์ ํ์ ์ ์ข ๋ ์ ํํ๊ฒ ๊ตฌ๋ถํ ์ ์์ด. ์ด๋ฅผ ํตํด ์๋ฌ ์ ํ์ ๋ฐ๋ผ ๋ค๋ฅธ ์ฒ๋ฆฌ๋ฅผ ํ ์ ์์ง!
// ์๋ฌ ํ์
๊ตฌ๋ถํ๊ธฐ
class NetworkError extends Error {
constructor(message: string) {
super(message);
this.name = 'NetworkError';
}
}
class ValidationError extends Error {
constructor(message: string) {
super(message);
this.name = 'ValidationError';
}
}
async function processUserData(userId: number) {
try {
// ์ฌ์ฉ์ ๋ฐ์ดํฐ ๊ฐ์ ธ์ค๊ธฐ
const response = await fetch(`https://api.example.com/users/${userId}`);
if (!response.ok) {
if (response.status === 404) {
throw new ValidationError(`์ฌ์ฉ์ ID ${userId}๋ฅผ ์ฐพ์ ์ ์์ต๋๋ค.`);
} else {
throw new NetworkError(`HTTP ์ค๋ฅ! ์ํ: ${response.status}`);
}
}
const userData = await response.json();
// ๋ฐ์ดํฐ ์ฒ๋ฆฌ ๋ก์ง
return processData(userData);
} catch (error) {
if (error instanceof ValidationError) {
// ์ ํจ์ฑ ๊ฒ์ฌ ์ค๋ฅ ์ฒ๋ฆฌ
console.error('์ ํจ์ฑ ๊ฒ์ฌ ์ค๋ฅ:', error.message);
return null;
} else if (error instanceof NetworkError) {
// ๋คํธ์ํฌ ์ค๋ฅ ์ฒ๋ฆฌ
console.error('๋คํธ์ํฌ ์ค๋ฅ:', error.message);
// ์ฌ์๋ ๋ก์ง ๋๋ ์คํ๋ผ์ธ ๋ฐ์ดํฐ ์ฌ์ฉ
return getOfflineData(userId);
} else {
// ๊ธฐํ ์์์น ๋ชปํ ์ค๋ฅ
console.error('์์์น ๋ชปํ ์ค๋ฅ:', error);
throw error; // ์์ ํธ์ถ์์๊ฒ ์ค๋ฅ ์ ํ
}
}
}
์ด ์์ ์์๋ ์ปค์คํ
์๋ฌ ํด๋์ค๋ฅผ ์ ์ํ๊ณ , instanceof ์ฐ์ฐ์๋ฅผ ์ฌ์ฉํด ์๋ฌ ํ์
์ ๊ตฌ๋ถํ๊ณ ์์ด. ์ด๋ ๊ฒ ํ๋ฉด ์๋ฌ ์ ํ์ ๋ฐ๋ผ ๋ค๋ฅธ ๋ณต๊ตฌ ์ ๋ต์ ์ ์ฉํ ์ ์์ง! ๐
3. ์๋ฌ ๋ํ ํจํด
Go ์ธ์ด์์ ์๊ฐ์ ๋ฐ์ ์๋ฌ ๋ํ ํจํด๋ async/await์ ํจ๊ป ์ฌ์ฉํ๋ฉด ์์ฃผ ํจ๊ณผ์ ์ด์ผ. ์ด ํจํด์ ํจ์๊ฐ ๊ฒฐ๊ณผ์ ์๋ฌ๋ฅผ ํจ๊ป ๋ฐํํ๋ ๋ฐฉ์์ด์ผ.
// ์๋ฌ ๋ํ ํจํด
async function safeAsync<T>(promise: Promise<T>): Promise<[T | null, Error | null]> {
try {
const data = await promise;
return [data, null];
} catch (error) {
return [null, error as Error];
}
}
// ์ฌ์ฉ ์์
async function getUserDetails(userId: number) {
const [userData, userError] = await safeAsync(fetchUserData(userId));
if (userError) {
console.error('์ฌ์ฉ์ ๋ฐ์ดํฐ๋ฅผ ๊ฐ์ ธ์ค๋ ์ค ์ค๋ฅ ๋ฐ์:', userError);
return null;
}
// ์ฌ์ฉ์์ ์ฃผ๋ฌธ ๋ด์ญ ๊ฐ์ ธ์ค๊ธฐ
const [orderData, orderError] = await safeAsync(fetchUserOrders(userId));
if (orderError) {
console.error('์ฃผ๋ฌธ ๋ด์ญ์ ๊ฐ์ ธ์ค๋ ์ค ์ค๋ฅ ๋ฐ์:', orderError);
// ์ฌ์ฉ์ ๋ฐ์ดํฐ๋ ์์ง๋ง ์ฃผ๋ฌธ ๋ด์ญ์ ์๋ ๊ฒฝ์ฐ
return {
...userData,
orders: []
};
}
// ๋ชจ๋ ๋ฐ์ดํฐ๋ฅผ ์ฑ๊ณต์ ์ผ๋ก ๊ฐ์ ธ์จ ๊ฒฝ์ฐ
return {
...userData,
orders: orderData
};
}
์ด ํจํด์ ์ฅ์ ์ try-catch ๋ธ๋ก์ ์ฌ๋ฌ ๋ฒ ์ค์ฒฉํ์ง ์๊ณ ๋ ์ฌ๋ฌ ๋น๋๊ธฐ ์์ ์ ์๋ฌ๋ฅผ ๊ฐ๋ณ์ ์ผ๋ก ์ฒ๋ฆฌํ ์ ์๋ค๋ ๊ฑฐ์ผ. ์ฝ๋๊ฐ ๋ ์ ํ์ ์ด๊ณ ์ฝ๊ธฐ ์ฌ์์ง์ง! ๐
์ฌ๋ฅ๋ท ๊ฐ์ ์๋น์ค์์๋ ์ฌ์ฉ์ ํ๋กํ, ์ฌ๋ฅ ๋ชฉ๋ก, ๋ฆฌ๋ทฐ ๋ฑ ๋ค์ํ ๋ฐ์ดํฐ๋ฅผ ๋น๋๊ธฐ์ ์ผ๋ก ๊ฐ์ ธ์์ผ ํ ๋๊ฐ ๋ง์. ์ด๋ฐ ์๋ฌ ์ฒ๋ฆฌ ํจํด์ ํ์ฉํ๋ฉด ์ผ๋ถ ๋ฐ์ดํฐ๋ฅผ ๊ฐ์ ธ์ค์ง ๋ชปํ๋๋ผ๋ ์ฌ์ฉ์ ๊ฒฝํ์ ์ต๋ํ ์ ์งํ ์ ์์ด!
โก ์ฑ๋ฅ ์ต์ ํ ํ
async/await๋ ์ฝ๋๋ฅผ ๊น๋ํ๊ฒ ๋ง๋ค์ด์ฃผ์ง๋ง, ์๋ชป ์ฌ์ฉํ๋ฉด ์ฑ๋ฅ ๋ฌธ์ ๊ฐ ๋ฐ์ํ ์ ์์ด. ์ฌ๊ธฐ์๋ async/await๋ฅผ ์ฌ์ฉํ ๋ ์ฑ๋ฅ์ ์ต์ ํํ๋ ๋ช ๊ฐ์ง ํ์ ์์๋ณผ๊ฒ! ๐
1. ๋ณ๋ ฌ ์ฒ๋ฆฌ ํ์ฉํ๊ธฐ
์์ ์ดํด๋ดค๋ฏ์ด, ์๋ก ์์กด์ฑ์ด ์๋ ๋น๋๊ธฐ ์์
๋ค์ Promise.all์ ์ฌ์ฉํด ๋ณ๋ ฌ๋ก ์ฒ๋ฆฌํ๋ ๊ฒ์ด ์ข์. ์ด๋ ๊ฒ ํ๋ฉด ์ ์ฒด ์คํ ์๊ฐ์ ํฌ๊ฒ ๋จ์ถํ ์ ์์ง!
// โ ์ข์ง ์์ ๋ฐฉ๋ฒ (์์ฐจ ์ฒ๋ฆฌ)
async function loadAllData() {
const users = await fetchUsers();
const products = await fetchProducts();
const orders = await fetchOrders();
return { users, products, orders };
}
// โ
์ข์ ๋ฐฉ๋ฒ (๋ณ๋ ฌ ์ฒ๋ฆฌ)
async function loadAllData() {
const [users, products, orders] = await Promise.all([
fetchUsers(),
fetchProducts(),
fetchOrders()
]);
return { users, products, orders };
}
๋ ๋ฒ์งธ ๋ฐฉ๋ฒ์ ์ธ API ์์ฒญ์ ๋์์ ์์ํ๊ธฐ ๋๋ฌธ์, ๊ฐ์ฅ ์ค๋ ๊ฑธ๋ฆฌ๋ ์์ฒญ์ ์๊ฐ๋งํผ๋ง ๊ธฐ๋ค๋ฆฌ๋ฉด ๋ผ. ๋ฐ๋ฉด ์ฒซ ๋ฒ์งธ ๋ฐฉ๋ฒ์ ์ธ ์์ฒญ์ ์๊ฐ์ ๋ชจ๋ ํฉํ ๋งํผ ๊ธฐ๋ค๋ ค์ผ ํด! โฑ๏ธ
2. ๋ถํ์ํ await ํผํ๊ธฐ
๋ชจ๋ Promise์ await๋ฅผ ์ฌ์ฉํ๋ ๊ฒ์ด ํญ์ ์ต์ ์ ์๋์ผ. ํนํ Promise๋ฅผ ์ฆ์ ๋ฐํํ๋ ๊ฒฝ์ฐ์๋ await๋ฅผ ์๋ตํ๋ ๊ฒ์ด ๋ ํจ์จ์ ์ผ ์ ์์ด.
// โ ๋ถํ์ํ await
async function getUserName(userId: number): Promise<string> {
const user = await fetchUser(userId);
return await Promise.resolve(user.name); // ๋ถํ์ํ await
}
// โ
๊ฐ์ ๋ ๋ฐฉ๋ฒ
async function getUserName(userId: number): Promise<string> {
const user = await fetchUser(userId);
return user.name; // ๋จ์ ๊ฐ ๋ฐํ
}
// ๋๋ Promise๋ฅผ ์ง์ ๋ฐํ
function getUserName(userId: number): Promise<string> {
return fetchUser(userId).then(user => user.name);
}
๋ ๋ฒ์งธ์ ์ธ ๋ฒ์งธ ๋ฐฉ๋ฒ์ ๋ถํ์ํ ๋น๋๊ธฐ ์์ ์ ์ค์ฌ ์ฑ๋ฅ์ ํฅ์์์ผ. ํนํ ๋ง์ ๋น๋๊ธฐ ์์ ์ ์ฒ๋ฆฌํ ๋๋ ์ด๋ฐ ์ต์ ํ๊ฐ ์ค์ํด! ๐ง
3. ์บ์ฑ ํ์ฉํ๊ธฐ
๊ฐ์ ๋น๋๊ธฐ ์์ ์ ์ฌ๋ฌ ๋ฒ ์ํํด์ผ ํ ๋๋ ๊ฒฐ๊ณผ๋ฅผ ์บ์ฑํ๋ ๊ฒ์ด ์ข์. ์ด๋ ๊ฒ ํ๋ฉด ์ค๋ณต ์์ฒญ์ ์ค์ฌ ์ฑ๋ฅ์ ํฌ๊ฒ ํฅ์์ํฌ ์ ์์ง!
// ๊ฒฐ๊ณผ ์บ์ฑ์ ์ํ Map ๊ฐ์ฒด
const cache = new Map<string, Promise<any>>();
async function fetchWithCache<T>(url: string): Promise<T> {
// ์บ์์ ํด๋น URL์ ๊ฒฐ๊ณผ๊ฐ ์๋์ง ํ์ธ
if (!cache.has(url)) {
// ์บ์์ ์์ผ๋ฉด ์๋ก์ด ์์ฒญ์ ์์ํ๊ณ ๊ทธ Promise๋ฅผ ์บ์์ ์ ์ฅ
console.log(`์บ์ ๋ฏธ์ค: ${url} ์์ฒญ ์์`);
const promise = fetch(url)
.then(response => {
if (!response.ok) {
throw new Error(`HTTP error! status: ${response.status}`);
}
return response.json();
})
.catch(error => {
// ์๋ฌ ๋ฐ์ ์ ์บ์์์ ํด๋น URL ์ ๊ฑฐ
cache.delete(url);
throw error;
});
cache.set(url, promise);
} else {
console.log(`์บ์ ํํธ: ${url} ์บ์๋ ๊ฒฐ๊ณผ ์ฌ์ฉ`);
}
// ์บ์๋ Promise ๋ฐํ
return cache.get(url) as Promise<T>;
}
// ์ฌ์ฉ ์์
async function getProductDetails(productId: number) {
const url = `https://api.example.com/products/${productId}`;
return await fetchWithCache<Product>(url);
}
์ด ์์ ์์๋ URL์ ํค๋ก ์ฌ์ฉํด Promise ์์ฒด๋ฅผ ์บ์ฑํ๊ณ ์์ด. ์ด๋ ๊ฒ ํ๋ฉด ๊ฐ์ URL์ ๋ํ ์์ฒญ์ด ์ฌ๋ฌ ๋ฒ ๋ฐ์ํด๋ ์ค์ ๋คํธ์ํฌ ์์ฒญ์ ํ ๋ฒ๋ง ์ํ๋ผ! ๐พ
4. ๋น๋๊ธฐ ๋ฐ๋ณต๋ฌธ ์ต์ ํ
๋ฐฐ์ด์ ๊ฐ ์์์ ๋ํด ๋น๋๊ธฐ ์์ ์ ์ํํ ๋๋ ์ด๋ค ๋ฐฉ์์ ์ฌ์ฉํ๋๋์ ๋ฐ๋ผ ์ฑ๋ฅ์ด ํฌ๊ฒ ๋ฌ๋ผ์ง ์ ์์ด.
// ์ฌ๋ฌ ํญ๋ชฉ์ ๋ํ ๋น๋๊ธฐ ์์
์ฒ๋ฆฌํ๊ธฐ
// 1. ์์ฐจ ์ฒ๋ฆฌ (๊ฐ ์์
์ด ์ด์ ์์
์๋ฃ ํ ์์)
async function processItemsSequentially(items: number[]) {
const results = [];
for (const item of items) {
// ๊ฐ ํญ๋ชฉ์ ์์ฐจ์ ์ผ๋ก ์ฒ๋ฆฌ
const result = await processItem(item);
results.push(result);
}
return results;
}
// 2. ๋ณ๋ ฌ ์ฒ๋ฆฌ (๋ชจ๋ ์์
์ ๋์์ ์์)
async function processItemsParallel(items: number[]) {
// ๋ชจ๋ ํญ๋ชฉ์ ๋ํ Promise ๋ฐฐ์ด ์์ฑ
const promises = items.map(item => processItem(item));
// ๋ชจ๋ Promise๊ฐ ์๋ฃ๋ ๋๊น์ง ๊ธฐ๋ค๋ฆผ
return await Promise.all(promises);
}
// 3. ์ ํ๋ ๋ณ๋ ฌ ์ฒ๋ฆฌ (๋์์ ์คํํ ์์
์ ์ ํ)
async function processItemsWithConcurrencyLimit(items: number[], concurrency = 3) {
const results = [];
const inProgress = new Set();
for (const item of items) {
// ํ์ฌ ์คํ ์ค์ธ ์์
์ด concurrency ํ๋์ ๋๋ฌํ๋ฉด ๊ธฐ๋ค๋ฆผ
if (inProgress.size >= concurrency) {
await Promise.race(inProgress);
}
// ์ ์์
์์
const promise = processItem(item)
.then(result => {
results.push(result);
inProgress.delete(promise);
return result;
});
inProgress.add(promise);
}
// ๋จ์ ์์
๋ค์ด ๋ชจ๋ ์๋ฃ๋ ๋๊น์ง ๊ธฐ๋ค๋ฆผ
await Promise.all(inProgress);
return results;
}
์ ์์ ์์ ์ธ ๊ฐ์ง ๋ค๋ฅธ ์ ๊ทผ ๋ฐฉ์์ ๋ณผ ์ ์์ด:
- ์์ฐจ ์ฒ๋ฆฌ: ๊ฐ ํญ๋ชฉ์ ํ๋์ฉ ์ฒ๋ฆฌํด. ๊ฐ๋จํ์ง๋ง ๊ฐ์ฅ ๋๋ ค.
- ๋ณ๋ ฌ ์ฒ๋ฆฌ: ๋ชจ๋ ํญ๋ชฉ์ ๋์์ ์ฒ๋ฆฌํด. ๊ฐ์ฅ ๋น ๋ฅด์ง๋ง ๋๋ฌด ๋ง์ ๋์ ์์ฒญ์ ์๋ฒ์ ๋ถ๋ด์ ์ค ์ ์์ด.
- ์ ํ๋ ๋ณ๋ ฌ ์ฒ๋ฆฌ: ๋์์ ์ฒ๋ฆฌํ ํญ๋ชฉ ์๋ฅผ ์ ํํด. ์๋์ ๋ฆฌ์์ค ์ฌ์ฉ ์ฌ์ด์ ๊ท ํ์ ๋ง์ถ ์ ์์ด.
์ํฉ์ ๋ง๋ ๋ฐฉ์์ ์ ํํ๋ ๊ฒ์ด ์ค์ํด. ์๋ฅผ ๋ค์ด, ์ฌ๋ฅ๋ท์์ ์์ฒ ๊ฐ์ ์ฌ๋ฅ ๋ชฉ๋ก์ ์ฒ๋ฆฌํด์ผ ํ๋ค๋ฉด, ์ ํ๋ ๋ณ๋ ฌ ์ฒ๋ฆฌ ๋ฐฉ์์ด ๊ฐ์ฅ ์ ํฉํ ๊ฑฐ์ผ! ๐ฏ
๐ฎ 2025๋ ์ต์ ๋น๋๊ธฐ ํจํด
2025๋ ํ์ฌ, ๋น๋๊ธฐ ํ๋ก๊ทธ๋๋ฐ์ ๊ณ์ ๋ฐ์ ํ๊ณ ์์ด. ์ฌ๊ธฐ์๋ ์ต์ ๋น๋๊ธฐ ํจํด๊ณผ ๊ธฐ์ ์ ๋ช ๊ฐ์ง ์ดํด๋ณผ๊ฒ! ๐
1. Top-Level await
ES2022๋ถํฐ ๋ชจ๋ ์ต์์ ๋ ๋ฒจ์์๋ async ํจ์ ์์ด await๋ฅผ ์ฌ์ฉํ ์ ์๊ฒ ๋์ด. ์ด๋ฅผ 'Top-Level await'๋ผ๊ณ ํด. 2025๋ ์๋ ์ด ๊ธฐ๋ฅ์ด ๊ฑฐ์ ๋ชจ๋ ๋ธ๋ผ์ฐ์ ์ Node.js์์ ์ง์๋๊ณ ์์ง!
// ๋ชจ๋ ์ต์์ ๋ ๋ฒจ์์ await ์ฌ์ฉํ๊ธฐ (ES2022 ์ด์)
// config.ts
const response = await fetch('https://api.example.com/config');
const config = await response.json();
export default config;
// ๋ค๋ฅธ ๋ชจ๋์์ ์ฌ์ฉ
import config from './config.js';
// config๊ฐ ์ด๋ฏธ ๋ก๋๋์ด ์์, ์ถ๊ฐ await ํ์ ์์
console.log(config.apiKey);
Top-Level await๋ฅผ ์ฌ์ฉํ๋ฉด ๋ชจ๋์ด ๋ก๋๋ ๋ ํ์ํ ๋น๋๊ธฐ ์ด๊ธฐํ ์์ ์ ๋ ๊น๋ํ๊ฒ ์ฒ๋ฆฌํ ์ ์์ด. ๋ชจ๋์ ๊ฐ์ ธ์ค๋ ์ชฝ์์๋ ์ถ๊ฐ์ ์ธ ๋น๋๊ธฐ ์ฒ๋ฆฌ ์์ด ๋ฐ๋ก ๋ฐ์ดํฐ๋ฅผ ์ฌ์ฉํ ์ ์์ง! ๐
2. ๋น๋๊ธฐ ์ดํฐ๋ ์ดํฐ์ for-await-of
๋์ฉ๋ ๋ฐ์ดํฐ๋ฅผ ์คํธ๋ฆฌ๋ฐ ๋ฐฉ์์ผ๋ก ์ฒ๋ฆฌํด์ผ ํ ๋๋ ๋น๋๊ธฐ ์ดํฐ๋ ์ดํฐ์ for-await-of ๋ฃจํ๊ฐ ์์ฃผ ์ ์ฉํด!
// ๋น๋๊ธฐ ์ดํฐ๋ ์ดํฐ์ for-await-of ์ฌ์ฉํ๊ธฐ
async function* fetchPaginatedData(endpoint: string, pageSize: number = 100) {
let page = 1;
let hasMore = true;
while (hasMore) {
const response = await fetch(`${endpoint}?page=${page}&pageSize=${pageSize}`);
const data = await response.json();
if (data.items.length === 0) {
hasMore = false;
} else {
yield* data.items;
page++;
}
}
}
// ์ฌ์ฉ ์์
async function processAllUsers() {
const userIterator = fetchPaginatedData('https://api.example.com/users', 50);
// for-await-of๋ฅผ ์ฌ์ฉํด ๊ฐ ์ฌ์ฉ์ ์ฒ๋ฆฌ
for await (const user of userIterator) {
console.log(`์ฒ๋ฆฌ ์ค: ${user.name}`);
await processUser(user);
}
console.log('๋ชจ๋ ์ฌ์ฉ์ ์ฒ๋ฆฌ ์๋ฃ!');
}
์ด ํจํด์ ๋ฉ๋ชจ๋ฆฌ ํจ์จ์ฑ์ด ๋ฐ์ด๋. ๋ชจ๋ ๋ฐ์ดํฐ๋ฅผ ํ ๋ฒ์ ๋ฉ๋ชจ๋ฆฌ์ ๋ก๋ํ๋ ๋์ , ํ์ํ ๋๋ง๋ค ๋ค์ ํ์ด์ง๋ฅผ ๊ฐ์ ธ์ค๊ธฐ ๋๋ฌธ์ด์ง. ํนํ ๋๊ท๋ชจ ๋ฐ์ดํฐ์ ์ ์ฒ๋ฆฌํ ๋ ์์ฃผ ์ ์ฉํด! ๐
3. ๋น๋๊ธฐ ์ปจํ ์คํธ ๊ด๋ฆฌ์ (Async Context Manager)
Python์ async with ๋ฌธ์์ ์๊ฐ์ ๋ฐ์ ํจํด์ผ๋ก, ๋ฆฌ์์ค์ ์ค์ ๊ณผ ์ ๋ฆฌ๋ฅผ ์๋์ผ๋ก ์ฒ๋ฆฌํด. TypeScript์์๋ ํด๋์ค์ ํจ์๋ฅผ ์กฐํฉํด ๋น์ทํ ํจํด์ ๊ตฌํํ ์ ์์ด.
// ๋น๋๊ธฐ ์ปจํ
์คํธ ๊ด๋ฆฌ์ ํจํด
class AsyncDatabase {
private connection: any = null;
async connect() {
console.log('๋ฐ์ดํฐ๋ฒ ์ด์ค ์ฐ๊ฒฐ ์ค...');
this.connection = await openDatabaseConnection();
return this;
}
async disconnect() {
if (this.connection) {
console.log('๋ฐ์ดํฐ๋ฒ ์ด์ค ์ฐ๊ฒฐ ์ข
๋ฃ ์ค...');
await this.connection.close();
this.connection = null;
}
}
async query(sql: string, params: any[] = []) {
if (!this.connection) {
throw new Error('๋ฐ์ดํฐ๋ฒ ์ด์ค์ ์ฐ๊ฒฐ๋์ด ์์ง ์์ต๋๋ค.');
}
return await this.connection.query(sql, params);
}
}
// ์ปจํ
์คํธ ๊ด๋ฆฌ์ ํจ์
async function withDatabase<T>(callback: (db: AsyncDatabase) => Promise<T>): Promise<T> {
const db = new AsyncDatabase();
try {
await db.connect();
return await callback(db);
} finally {
await db.disconnect();
}
}
// ์ฌ์ฉ ์์
async function getUserCount() {
return await withDatabase(async (db) => {
const result = await db.query('SELECT COUNT(*) as count FROM users');
return result[0].count;
});
}
์ด ํจํด์ ์ฌ์ฉํ๋ฉด ๋ฆฌ์์ค ๊ด๋ฆฌ ์ฝ๋(์ฐ๊ฒฐ ์ด๊ธฐ/๋ซ๊ธฐ)๋ฅผ ๋ฐ๋ณต ์์ฑํ ํ์ ์์ด, ๋น์ฆ๋์ค ๋ก์ง์๋ง ์ง์คํ ์ ์์ด. ํนํ ๋ฐ์ดํฐ๋ฒ ์ด์ค ์ฐ๊ฒฐ, ํ์ผ ํธ๋ค, ๋คํธ์ํฌ ์์ผ ๋ฑ์ ๋ฆฌ์์ค๋ฅผ ๋ค๋ฃฐ ๋ ์ ์ฉํ์ง! ๐
4. ๋น๋๊ธฐ ์ํ ๊ด๋ฆฌ ํจํด
2025๋ ์๋ React, Vue ๊ฐ์ ํ๋ก ํธ์๋ ํ๋ ์์ํฌ์์ ๋น๋๊ธฐ ์ํ ๊ด๋ฆฌ๊ฐ ๋์ฑ ์ค์ํด์ก์ด. ์ฌ๊ธฐ ์ต์ ํจํด ์ค ํ๋๋ฅผ ์๊ฐํ ๊ฒ!
// ๋น๋๊ธฐ ์ํ ๊ด๋ฆฌ ํจํด (React + TypeScript)
import { useState, useEffect } from 'react';
// ๋น๋๊ธฐ ์ํ๋ฅผ ์ํ ์ปค์คํ
ํ
function useAsync<T>(asyncFunction: () => Promise<T>, dependencies: any[] = []) {
const [state, setState] = useState<{
data: T | null;
loading: boolean;
error: Error | null;
}>({
data: null,
loading: true,
error: null
});
useEffect(() => {
let isMounted = true;
setState({ data: null, loading: true, error: null });
asyncFunction()
.then(data => {
if (isMounted) {
setState({ data, loading: false, error: null });
}
})
.catch(error => {
if (isMounted) {
setState({ data: null, loading: false, error });
}
});
return () => {
isMounted = false;
};
}, dependencies);
return state;
}
// ์ฌ์ฉ ์์
function UserProfile({ userId }: { userId: number }) {
const { data: user, loading, error } = useAsync(
() => fetchUserById(userId),
[userId]
);
if (loading) return <div>๋ก๋ฉ ์ค...</div>;
if (error) return <div>์ค๋ฅ ๋ฐ์: {error.message}</div>;
if (!user) return <div>์ฌ์ฉ์๋ฅผ ์ฐพ์ ์ ์์ต๋๋ค.</div>;
return (
<div>
<h1>{user.name}</h1>
<p>์ด๋ฉ์ผ: {user.email}</p>
</div>
);
}
์ด ํจํด์ ๋น๋๊ธฐ ๋ฐ์ดํฐ ๋ก๋ฉ์ ์ธ ๊ฐ์ง ์ํ(๋ก๋ฉ ์ค, ์ฑ๊ณต, ์ค๋ฅ)๋ฅผ ๋ช ํํ๊ฒ ๊ด๋ฆฌํด. 2025๋ ์๋ ์ด๋ฐ ํจํด์ด ๋์ฑ ๋ฐ์ ํด Suspense, React Query, SWR ๊ฐ์ ๋ผ์ด๋ธ๋ฌ๋ฆฌ์ ํจ๊ป ์ฌ์ฉ๋๊ณ ์์ด! ๐
์ฌ๋ฅ๋ท ๊ฐ์ ํ๋ซํผ์์๋ ์ด๋ฐ ๋น๋๊ธฐ ์ํ ๊ด๋ฆฌ ํจํด์ด ํนํ ์ค์ํด. ์ฌ์ฉ์ ํ๋กํ, ์ฌ๋ฅ ๋ชฉ๋ก, ๋ฆฌ๋ทฐ ๋ฑ ๋ค์ํ ๋ฐ์ดํฐ๋ฅผ ํจ์จ์ ์ผ๋ก ๋ก๋ํ๊ณ ํ์ํด์ผ ํ๋๊น! ๐ผ
๐ฌ ๋ง๋ฌด๋ฆฌ ๋ฐ ์ถ๊ฐ ์๋ฃ
์ฌ๊ธฐ๊น์ง async/await๋ฅผ ์ด์ฉํ ๋น๋๊ธฐ ์ฝ๋ ๊ฐ์ํ์ ๋ํด ์์๋ดค์ด! ์ด์ ๋๋ ๋น๋๊ธฐ ํ๋ก๊ทธ๋๋ฐ์ ๋ง๋ฒ์ฌ๊ฐ ๋ ๊ฒ ๊ฐ์๋ฐ? ๐
๐ ์์ฝ
- async/await๋ Promise ๊ธฐ๋ฐ ๋น๋๊ธฐ ์ฝ๋๋ฅผ ๋๊ธฐ ์ฝ๋์ฒ๋ผ ์์ฑํ ์ ์๊ฒ ํด์ฃผ๋ ๋ฌธ๋ฒ์ด์ผ.
- TypeScript์ ํจ๊ป ์ฌ์ฉํ๋ฉด ํ์ ์์ ์ฑ๊น์ง ํ๋ณดํ ์ ์์ด ๋์ฑ ๊ฐ๋ ฅํด์ ธ!
- try-catch ๊ตฌ๋ฌธ์ผ๋ก ๋น๋๊ธฐ ์ฝ๋์ ์๋ฌ ์ฒ๋ฆฌ๋ฅผ ๊ฐ์ํํ ์ ์์ด.
- Promise.all, Promise.race ๋ฑ๊ณผ ์กฐํฉํด ๋ค์ํ ๋น๋๊ธฐ ํจํด์ ๊ตฌํํ ์ ์์ง.
- ์ฑ๋ฅ ์ต์ ํ๋ฅผ ์ํด ๋ณ๋ ฌ ์ฒ๋ฆฌ, ์บ์ฑ ๋ฑ์ ๊ธฐ๋ฒ์ ํ์ฉํ๋ ๊ฒ์ด ์ค์ํด.
- 2025๋ ์๋ Top-Level await, ๋น๋๊ธฐ ์ดํฐ๋ ์ดํฐ ๋ฑ ๋ ๋ฐ์ ๋ ํจํด๋ค์ด ๋๋ฆฌ ์ฌ์ฉ๋๊ณ ์์ด!
๋น๋๊ธฐ ํ๋ก๊ทธ๋๋ฐ์ ํ๋ ์น ๊ฐ๋ฐ์ ํต์ฌ์ด์ผ. ํนํ ์ฌ๋ฅ๋ท ๊ฐ์ ๋๊ท๋ชจ ํ๋ซํผ์์๋ ํจ์จ์ ์ธ ๋น๋๊ธฐ ์ฝ๋ ์์ฑ์ด ์ฌ์ฉ์ ๊ฒฝํ๊ณผ ์ฑ๋ฅ์ ์ง์ ์ ์ธ ์ํฅ์ ๋ฏธ์น์ง! ๐
๐ ์ถ๊ฐ ํ์ต ์๋ฃ
- TypeScript ๊ณต์ ๋ฌธ์์ ๋น๋๊ธฐ ํ๋ก๊ทธ๋๋ฐ ์น์
- Jake Archibald์ "Async functions - making promises friendly"
- Dr. Axel Rauschmayer์ "Exploring ES2018 and ES2019"
- Kyle Simpson์ "You Don't Know JS: Async & Performance"
- MDN Web Docs์ async/await ๊ฐ์ด๋
๋น๋๊ธฐ ํ๋ก๊ทธ๋๋ฐ์ ๊ณ์ ๋ฐ์ ํ๊ณ ์์ด. ์๋ก์ด ํจํด๊ณผ ๊ธฐ์ ์ด ๋ฑ์ฅํ ๋๋ง๋ค ํ์ตํ๊ณ ์ ์ฉํด๋ณด๋ ๊ฒ์ด ์ค์ํด! ๐ฑ
์ค๋ ๋ฐฐ์ด ๋ด์ฉ์ด ๋์์ด ๋์ผ๋ฉด ์ข๊ฒ ์ด. ๋ค์์ ๋ ๋ค๋ฅธ ํฅ๋ฏธ๋ก์ด ์ฃผ์ ๋ก ๋ง๋์! ๐
๊ด๋ จ ํค์๋
๋๊ธ ์์ฑ
์ด ๊ธ์ ๋ํ ์ฌ๋ฌ๋ถ์ ์๊ฐ์ ๋ค๋ ค์ฃผ์ธ์
๋ก๊ทธ์ธ์ด ํ์ํฉ๋๋ค
๋๊ธ์ ์์ฑํ๋ ค๋ฉด ๋จผ์ ๋ก๊ทธ์ธํด์ฃผ์ธ์.
๋๊ธ 0
์ง์์ธ์ ์ฒ - ์ง์ ์ฌ์ฐ๊ถ ๋ณดํธ ๊ณ ์ง
์ง์ ์ฌ์ฐ๊ถ ๋ณดํธ ๊ณ ์ง
- ์ ์๊ถ ๋ฐ ์์ ๊ถ: ๋ณธ ์ปจํ ์ธ ๋ ์ฌ๋ฅ๋ท์ ๋ ์ AI ๊ธฐ์ ๋ก ์์ฑ๋์์ผ๋ฉฐ, ๋ํ๋ฏผ๊ตญ ์ ์๊ถ๋ฒ ๋ฐ ๊ตญ์ ์ ์๊ถ ํ์ฝ์ ์ํด ๋ณดํธ๋ฉ๋๋ค.
- AI ์์ฑ ์ปจํ ์ธ ์ ๋ฒ์ ์ง์: ๋ณธ AI ์์ฑ ์ปจํ ์ธ ๋ ์ฌ๋ฅ๋ท์ ์ง์ ์ฐฝ์๋ฌผ๋ก ์ธ์ ๋๋ฉฐ, ๊ด๋ จ ๋ฒ๊ท์ ๋ฐ๋ผ ์ ์๊ถ ๋ณดํธ๋ฅผ ๋ฐ์ต๋๋ค.
- ์ฌ์ฉ ์ ํ: ์ฌ๋ฅ๋ท์ ๋ช ์์ ์๋ฉด ๋์ ์์ด ๋ณธ ์ปจํ ์ธ ๋ฅผ ๋ณต์ , ์์ , ๋ฐฐํฌ, ๋๋ ์์ ์ ์ผ๋ก ํ์ฉํ๋ ํ์๋ ์๊ฒฉํ ๊ธ์ง๋ฉ๋๋ค.
- ๋ฐ์ดํฐ ์์ง ๊ธ์ง: ๋ณธ ์ปจํ ์ธ ์ ๋ํ ๋ฌด๋จ ์คํฌ๋ํ, ํฌ๋กค๋ง, ๋ฐ ์๋ํ๋ ๋ฐ์ดํฐ ์์ง์ ๋ฒ์ ์ ์ฌ์ ๋์์ด ๋ฉ๋๋ค.
- AI ํ์ต ์ ํ: ์ฌ๋ฅ๋ท์ AI ์์ฑ ์ปจํ ์ธ ๋ฅผ ํ AI ๋ชจ๋ธ ํ์ต์ ๋ฌด๋จ ์ฌ์ฉํ๋ ํ์๋ ๊ธ์ง๋๋ฉฐ, ์ด๋ ์ง์ ์ฌ์ฐ๊ถ ์นจํด๋ก ๊ฐ์ฃผ๋ฉ๋๋ค.
์์ง ๋๊ธ์ด ์์ต๋๋ค.