Modern Asynchronous JavaScript with Async and Await - Lee-hyuna/33-js-concepts-kr GitHub Wiki
์ต๊ทผ์ ์ฐ์ด๊ณ ์๋ ๋น๋๊ธฐ ๋ฐฉ์์ธ Async, Await
JavaScript์์ ๋น๋๊ธฐ์ ๋ํ ์ ๊ทผ ๋ฐฉ์์์ ์๊ฐํฉ๋๋ค.
JavaScript๋ ์ฝ๋ฐฑ์ ๋งค์ฐ ์งง์ ์๊ฐ ๋ด์ ์ฑ์ฅํ์ผ๋ฉฐ, Async, Await ๊ตฌ๋ฌธ์ ์ฌ์ฉํ๋ฉด ES2017 ๋น๋๊ฐ ํจ์ฌ ๋ ๊ฐ๋จํฉ๋๋ค.
Introduction
๋น๋๊ธฐ ๊ธฐ๋ฅ์ Promise๊ณผ Generators์ ์กฐํฉ์ด๋ฉฐ, ๊ธฐ๋ณธ์ ์ผ๋ก Promise๋ณด๋ค ๋ ๋์ ์์ค์ ์ถ์ํ์
๋๋ค.
๋ค์ ํ ๋ฒ ๋ง์๋๋ฆฌ์ง๋ง, Async/Await๋ Promise์ ๋ฐ๋ผ ๋ง๋ค์ด์ง๋๋ค.
Why were async/await introduced?
ES2015 Promise๊ฐ ๋์
๋์์ ๋, ๋น๋๊ธฐ ์ฝ๋๋ก ๋ฌธ์ ๋ฅผ ํด๊ฒฐํ๊ธฐ ์ํ ๊ฒ์
๋๋ค.
๊ทธ๋ฌ๋ ES2015์ ES2017์ ๋ถ๋ฆฌํ 2๋
๋์ Promise๋ ์ต์ข
ํด๊ฒฐ์ฑ
์ด ๋ ์ ์๋ค๋ ๊ฒ์ด ๋ช
๋ฐฑํ์ต๋๋ค.
์ ๋ช ํ ์ฝ๋ฐฑ ์ง์ฅ ๋ฌธ์ ๋ฅผ ํด๊ฒฐํ๊ธฐ ์ํด Promise๋ค์ด ๋์ ๋์์ง๋ง, ์ฝ๋๋ฅผ ์ค๊ณํ๋ค ๋ณด๋ฉด ์์ฐ์ค๋ฝ๊ฒ ์ฝ๋๋ ๋ณต์ก์ฑ๊ณผ ๊ตฌ๋ฌธ ๋ณต์ก์ฑ์ ๊ฐ๊ฒ๋ฉ๋๋ค. ๊ฐ๋ฐ์๋ค์ ๋ ๋์ ๊ตฌ๋ฌธํ์ํ ์๊ธฐ์์ต๋๋ค. ๊ทธ๋์ ์ ์ ํ ์๊ธฐ์ ๋น๋๊ธฐ ๊ธฐ๋ฅ์ ์ฌ์ฉํ๊ฒ ๋์์ต๋๋ค.
์ฝ๋๋ฅผ ๋๊ธฐ์์ผ๋ก ๋ง๋ค์ง๋ง, ๋ค์์ ๋น๋๊ธฐ์์ผ๋ก ๋ง๊ณ ์ฐจ๋จํ์ง ์์ต๋๋ค.
How it works
๋น๋๊ธฐ ๊ธฐ๋ฅ์ ๋ค์๊ณผ ๊ฐ์ Promise๋ฅผ ๋ฐํํฉ๋๋ค.
const doSomethingAsync = () => {
return new Promise(resolve => {
setTimeout(() => resolve('I did something'), 3000)
})
}
์ด ๊ธฐ๋ฅ์ ํธ์ถํ๋ ค๋ฉด ๋ฏธ๋ฆฌ ๊ธฐ๋ค๋ฆฌ์ญ์์ค.
๊ทธ๋ฌ๋ฉด Promise๊ฐ ํด๊ฒฐ๋๊ฑฐ๋ ๊ฑฐ๋ถ๋ ๋๊น์ง call์ด ์ค์ง๋ฉ๋๋ค.
ํ ๊ฐ์ง ์ฃผ์ ์ฌํญ: ํด๋ผ์ด์ธํธ ๊ธฐ๋ฅ์ ๋น๋๊ธฐ์์ผ๋ก ์ ์๋์ด์ผ ํฉ๋๋ค. ๋ค์์ ๋ค์๊ณผ ๊ฐ์ ์์ ๋๋ค.
const doSomething = async () => {
console.log(await doSomethingAsync())
}
A quick example
๋ค์์ ๋น๋๊ธฐ์์ผ๋ก ๊ธฐ๋ฅ์ ์คํํ๋ ๋ฐ ์ฌ์ฉ๋๋ Async/await์ ๊ฐ๋จํ ์์ ๋๋ค.
const doSomethingAsync = () => {
return new Promise(resolve => {
setTimeout(() => resolve('I did something'), 3000)
})
}
const doSomething = async () => {
console.log(await doSomethingAsync())
}
console.log('Before')
doSomething()
console.log('After')
์์ ์ฝ๋๋ ๋ธ๋ผ์ฐ์ ์ฝ์์ ๋ค์์ ์ถ๋ ฅํฉ๋๋ค.
Before
After
I did something //after 3s
Promise all the things
๋ชจ๋ ๊ธฐ๋ฅ์ ๋น๋๊ธฐ ํค์๋๋ฅผ ์ค๋นํ๋ค๋ ๊ฒ์ ๊ธฐ๋ฅ์ด Promise๋ฅผ ๋ฐํํ๋ค๋ ๊ฒ์ ์๋ฏธํฉ๋๋ค.
๋ช ์์ ์ผ๋ก ์ ํ๊ณ ์๋ค ํ๋๋ผ๋ ๋ด๋ถ์ ์ผ๋ก Promise๋ฅผ return ํ ๊ฒ์ ๋๋ค. ์ด ์ฝ๋๊ฐ ์ ํจํ ์ด์ ๋ ๋ค์๊ณผ ๊ฐ์ต๋๋ค.
const aFunction = async () => {
return 'test'
}
aFunction().then(alert) // This will alert 'test'
์๋์ ์ฝ๋์ ๋์ผํฉ๋๋ค.
const aFunction = async () => {
return Promise.resolve('test')
}
aFunction().then(alert) // This will alert 'test'
The code is much simpler to read
์์ ์์์ ๋ณผ ์ ์๋ฏ์ด ๋น๋๊ธฐ ์ฝ๋๋ ๋งค์ฐ ๋จ์ํด ๋ณด์
๋๋ค.
Promise, chaining ๋ฐ callback์ ์ฌ์ฉํ์ฌ ์ฝ๋์ ๋น๊ตํฉ๋๋ค.
์ฝ๋๊ฐ ํจ์ฌ ๋ ๋ณต์กํ ๋ ์ฃผ์ ์ด์ ์ด ๋ฐ์ํ ๊ฒ์ ๋๋ค.
์๋ฅผ ๋ค์ด, promise๋ฅผ ์ฌ์ฉํ์ฌ JSON ๋ฆฌ์์ค๋ฅผ ๊ฐ์ ธ์์ ๊ตฌ๋ฌธ ๋ถ์ํ๋ ๋ฐฉ๋ฒ์ ๋ค์๊ณผ ๊ฐ์ต๋๋ค.
const getFirstUserData = () => {
return fetch('/users.json') // get users list
.then(response => response.json()) // parse JSON
.then(users => users[0]) // pick first user
.then(user => fetch(`/users/${user.name}`)) // get user data
.then(userResponse => userResponse.json()) // parse JSON
}
getFirstUserData()
๋ค์์ Async/Await๋ฅผ ์ฌ์ฉํ์ฌ ์ ๊ณต๋๋ ๊ธฐ๋ฅ๊ณผ ๋์ผํ ๊ธฐ๋ฅ์ ๋๋ค.
const getFirstUserData = async () => {
const response = await fetch('/users.json') // get users list
const users = await response.json() // parse JSON
const user = users[0] // pick first user
const userResponse = await fetch(`/users/${user.name}`) // get user data
const userData = await userResponse.json() // parse JSON
return userData
}
getFirstUserData()
Multiple async functions in series
๋น๋๊ธฐํจ์๋ ์ฒด์ด๋์ ์ด์ฉํด ์ฝ๊ฒ ์ฐ๊ฒฐํ์ฌ ์ฌ์ฉํ ์ ์๊ณ , ๊ฐ๋ ์ฑ๋ ์ข์ต๋๋ค.
const promiseToDoSomething = () => {
return new Promise(resolve => {
setTimeout(() => resolve('I did something'), 10000)
})
}
const watchOverSomeoneDoingSomething = async () => {
const something = await promiseToDoSomething()
return something + ' and I watched'
}
const watchOverSomeoneWatchingSomeoneDoingSomething = async () => {
const something = await watchOverSomeoneDoingSomething()
return something + ' and I watched as well'
}
watchOverSomeoneWatchingSomeoneDoingSomething().then(res => {
console.log(res)
})
์ถ๋ ฅ
I did something and I watched and I watched as well