๋ฆฌ์กํธ ํ ์ ์ฌ์ฉํ๋ฉด์ ๋ถ์ํจ๊ณผ์ ๋ํด ์๊ฐ์ ํ๋ค๋ณด๋ ํจ์ํ ํ๋ก๊ทธ๋๋ฐ ์ฌ๊ณ ์ ์ด๋ป๊ฒ ์ ๊ทผํด์ผ ํ๋์ง์ ๋ํด ์์๋ณด๊ธฐ ์ํด ํจ์ํ ์๋ฐ์คํฌ๋ฆฝํธ ์ฑ ์ ์ ํ์ต๋๋ค.
์ดํ๋ฆฌ์ผ์ด์ ์ค๊ณ์ ์๋ฌธํด๋ด์ผํ ์์๋ค
- ํ์ฅ์ฑ : ์ถ๊ฐ๊ธฐ๋ฅ์ ์ง์ํ๊ธฐ ์ํด ๊ณ์ ๋ฆฌํฉํฐ๋ง์ ํด์ผํ๋๊ฐ?
- ๋ชจ๋ํ ์ฉ์ด์ฑ : ํ์ผํ๋๋ฅผ ๊ณ ์น๋ฉด ๋ค๋ฅธ ํ์ผ๋ ์ํฅ์ ๋ฐ๋๊ฐ?
- ์ฌ์ฌ์ฉ์ฑ: ์ค๋ณต์ด ๋ง์๊ฐ?
- ํ ์คํธ์ฑ: ํจ์๋ฅผ ๋จ์ํ ์คํธ ํ๊ธฐ ์ด๋ ค์ด๊ฐ?
- ํค์๋ฆฌ๊ธฐ ์ฌ์ : ์ฒด๊ณ๋ ์๊ณ ๋ฐ๋ผ๊ฐ๊ธฐ ์ด๋ ค์ด ์ฝ๋์ธ๊ฐ?
ํจ์ํ ํ๋ก๊ทธ๋๋ฐ ํจ๋ฌ๋ค์์ด ์ด ์์๋ค์ ๊ฐ์ ํ๋๋ฐ ๋์์ด ๋ฉ๋๋ค.
ํจ์ํ์ผ๋ก ์ฌ๊ณ ํ๋ ๊ฒ์ด ์ ์ค์ํ์ง, ํ๋ก๊ทธ๋๋ฐ์ ๋ณต์ก์ฑ์ ํด๊ฒฐํ๋๋ฐ ์ด๋ค ๋์์ ์ฃผ๋์ง ์ดํดํ๋๊ฒ ์ค์ํฉ๋๋ค.
ํจ์ํ ํ๋ก๊ทธ๋๋ฐ์ด๋?
- ์ดํ๋ฆฌ์ผ์ด์ ์ ๋ถ์ํจ๊ณผ๋ฅผ ๋ฐฉ์งํ๊ณ
- ์ํ๋ณ์ด๋ฅผ ๊ฐ์ํ๊ธฐ์ํด
- ๋ฐ์ดํฐ์ ์ ์ดํ๋ฆ๊ณผ ์ฐ์ฐ์ ์ถ์ํ๋ ๊ฒ์ ๋๋ค.
ํจ์ํ ํ๋ก๊ทธ๋๋ฐ์ ์จ์ ํ ์ดํดํ๊ธฐ์ํด ์์งํด์ผํ ๊ธฐ๋ณธ ๊ฐ๋ ๋ค
- ์ ์ธ์ ํ๋ก๊ทธ๋๋ฐ
- ์์ํจ์
- ์ฐธ์กฐํฌ๋ช ์ฑ
- ๋ถ๋ณ์ฑ
์ ์ธ์ ํ๋ก๊ทธ๋๋ฐ
Procedural, imperative (๋ช ๋ นํ, ์ ์ฐจ์ ) ๋ชจ๋ธ
var arr = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
for (let i = 0; i < arr.length; i++) {
arr[i] = Math.pow(arr[i], 2)
}
arr // [0,1,4,5,16,25,36,49,64,81]
Declarative ํจ๋ฌ๋ค์
์์ ๋ถ์ ํ๊ฐ๋ถ๋ฅผ ๋ถ๋ฆฌ ํ์ฌ ์ ์ดํ๋ฆ์ด๋ ์ํ๋ณํ๋ฅผ ํน์ ํ์ง๊ณ ๋ ํ๋ก๊ทธ๋จ ํ๋ก๊ทธ๋จ ๋ก์ง์ด ๋ฌด์์ธ์ง๋ฅผ ํํ์์ผ๋ก ๋ํ๋ ๋๋ค.
;[0, 1, 2, 3, 4].map(function (num) {
return Math.pow(num, 2)
})
๋ช ๋ นํ๊ณผ ๋น๊ต์,
- ๋ฃจํ์นด์ดํฐ๋ฅผ ๊ด๋ฆฌํ๊ณ ๋ฐฐ์ด์ธ๋ฑ์ค์ ์ ํํ๊ณ ์ ๊ทผํ๋ ์ผ์ ๊ฐ๋ฐ์์ ๋ถ๋ด์ด ์ค์ด๋ญ๋๋ค.
- ๋ช ๋ นํ์ for loop์ ์ฌ์ฌ์ฉ์ด ๋ถ๊ฐ๋ฅํ๋ค. ํจ์๋ก ์ถ์ํ๋ ์์ ์ผ๋ก ์ธํด ์ฌ์ฌ์ฉ์ด ๊ฐ๋ฅ ํฉ๋๋ค. (์ ์ธ์ ํ๋ก๊ทธ๋๋ฐ)
์์ํจ์์ ๋ถ์ํจ๊ณผ
์์ํจ์์ ํน์ฑ
- ์ฃผ์ด์ง ์ ๋ ฅ์๋ง ์์กดํ ๋ฟ, ํ๊ฐ ๋์ค ๋๋ ํธ์ถ ๊ฐ ๋ณ๊ฒฝ๋ ์ ์๋ ์จ๊ฒจ์ง ๊ฐ์ด๋ ์ธ๋ถ ์ํ์ ๋ฌด๊ดํ๊ฒ ์๋ํฉ๋๋ค.
- ์ ์ญ๊ฐ์ฒด๋ ๋ ํผ๋ฐ์ค๋ก ์ ๋ฌ๋ ๋งค๊ฐ๋ณ์๋ฅผ ์์ ํ๋ ๋ฑ ํจ์ ์ค์ฝํ ๋ฐ์์ ์ด๋ ํ ๋ณ๊ฒฝ๋ ์ผ์ผํค์ง ์์ต๋๋ค.
์์ํจ์๊ฐ ์๋ ์์.
ex1.
var counter = 0
function increment() {
return ++counter
}
์ด ํจ์๊ฐ ์์ํจ์๊ฐ ์๋ ์ด์ :
ํจ์ ์ค์ฝํ ๋ฐ์์ ๋ณ๊ฒฝ์ด ์ผ์ด๋ฉ๋๋ค. ์ธ๋ถ ๋ณ์ counter๋ฅผ ์ฝ๊ณ ์์ ํ๋ฏ๋ก ๋ถ์ํจ๊ณผ๋ฅผ ์ผ์ผํต๋๋ค.
ex2. ์์ธก ๊ฐ๋ฅํ ๊ฐ์ ๋ด์ง ์์ต๋๋ค.
Date.now() //๋งค๋ฒ ๋ค๋ฅธ ์์ธก ํ ์ ์๋ ๊ฐ์ ์ฐ์ถ
ex3. this ๋ฅผ ์ฌ์ฉํ๋ ํจ์.
this ํค์๋๋ฅผ ๊ฑฐ์ณ ์ธ์คํด์ค ๋ฐ์ดํฐ์ ์ ๊ทผํ๋ ๊ฒ ์ญ์ ๋ถ์ํจ๊ณผ๋ฅผ ์ ๋ฐํ๋ค. ๊ทธ ์ด์ ๋ this๋ ํด๋น ํจ์์ ๋ฐํ์ ์ปจํ ์คํธ์ ๋ฐ๋ผ ๋ฌ๋ผ์ง๊ธฐ ๋๋ฌธ์ ๋๋ค.
์ฐธ์กฐ ํฌ๋ช ์ฑ๊ณผ ์นํ์ฑ
์ฐธ์กฐํฌ๋ช ์ฑ์ ์์ํจ์๋ฅผ ์ ์ํ๋ ์ข ๋ ๊ณต์์ ์ธ ๋ฐฉ๋ฒ์ด๋ฉฐ, ์์์ฑ์ด๋ ํจ์์ ์ธ์์ ๊ฒฐ๊ณผ๊ฐ ์ฌ์ด์ ์์ํ ๋งคํ ๊ด๊ณ๋ฅผ ์๋ฏธ ํฉ๋๋ค. ํจ์๊ฐ ๋์ผํ ์ ๋ ฅ์ ๋ฐ์์ ๋, ๋์ผํ ๊ฒฐ๊ณผ๋ฅผ ๋ด๋ฉด ์ฐธ์กฐํฌ๋ช ์ฑ์ด๋ผ๊ณ ํฉ๋๋ค.
์ฐธ์กฐ ํฌ๋ช ํ์ง ์๋ค๋ผ๋ ๊ฒ์ ๋ฌด์์ผ๊น?
var counter = 0
function increment() {
return ++counter
}
incrementํจ์์์ ์ธ์๊ฐ ์๋ ์ธ๋ถ ๋ณ์(counter)์ ์์ ํ ์ข ์๋ ๊ฐ์ ๋ฐํํ๋ฏ๋ก ์ฐธ์กฐํฌ๋ช ํ์ง ์์ต๋๋ค.
์ฐธ์กฐํฌ๋ช ํ ํจ์๋ ์ด๋ป๊ฒ ๋ง๋ค ์ ์์๊น?
const increment = (counter) => counter + 1
๊ฐ์ ์ ๋ ฅ์ ๊ฐ์ ๊ฒฐ๊ณผ๋ฅผ ๋ฐํํ๋ ์์ ํ ํจ์์ ๋๋ค. ์ฆ, ํ ์คํธํ๊ธฐ ์ฝ๊ณ ์ ์ฒด๋ก์ง์ ํ์ ํ๊ธฐ ์ฝ์ต๋๋ค.
increment()
ํจ์๋ฅผ ์ด์ฉํ ๋ค๋ฅธ ์ฝ๋์ ์์๋ก ๋ช
๋ นํ๊ณผ ํจ์ํ์ ์ฐจ์ด๋ฅผ ๋ณด๊ฒ ์ต๋๋ค.
๋ช ๋ นํ
increment()
increment()
print(counter) // ?
ํจ์ํ
var plus2 = run(increment, increment)
print(plus2(0))
์์ ์ฝ๋์์ ํจ์ํ์ด ์ฐธ์กฐํฌ๋ช ์ฑ์ ์ ํฉํ ์ด์ ๋
- ์ธ๋ถ๋ณ์๋ฅผ ์ฐธ์กฐํ์ง ์์ต๋๋ค.
- ์ฃผ์ด์ง ์ ๋ ฅ (0) ์ด๋ผ๋ ๊ฐ์ ์์กดํ์ฌ, ํญ์ ๊ทธ ๊ฐ์ 2๋งํผ ์ฆ๊ฐ๋ฅผ ์ํต๋๋ค.
๋ฐ๋ฉด์ ๋ช ๋ นํ์
0 ์์ 2๋ฅผ ๊ธฐ๋ํ์ง๋ง, counter๊ฐ ์ ์ญ์ผ๋ก ์ฐ์ด๊ธฐ ๋๋ฌธ์, ์ด๊ธฐ๊ฐ์ด 0์ด ์๋ ๊ฐ์ผ๋ก ์ ๋ ฅ์ด ์ฃผ์ด์ง ์ ์์ผ๋ฉฐ ์์๊ณผ๋ ๋ค๋ฅธ ๊ฐ์ ์ฐ์ถ ํ ์ ์์ต๋๋ค.
์ฐธ์กฐ ํฌ๋ช ์ฑ์ ๋ํ ๋ค๋ฅธ ์์๋ฅผ ๋ค๊ฒ ์ต๋๋ค.
var input = [80, 90, 100]
var average = (arr) => divide(sum(arr), size(arr))
sum๊ณผ size ํจ์๊ฐ ์ฐธ์กฐ ํฌ๋ช ํ ํจ์๋ผ๋ฉด,
divide( 270,3) ์ด ๋๋ค. ์ฆ, ์์์ผ๋ก ํํ์ด ๊ฐ๋ฅํ๋ค๋ ๊ฒ์ธ๋ฐ ์ด ๋ง์ [80,90,100 ]์ด๋ผ๋ ํจ์์ ์ธ์๊ฐ์ด ์ธ๋ถ์ ์์กด์ฑ์ ๊ฐ๋ ๊ฐ๋ค์ด ์๋๋ฏ๋ก ํฉ์ ๊ตฌํ๋ ๋ก์ง ์์ ์ฐ๋ฆฌ๊ฐ ์์ธกํ ๊ฒฐ๊ณผ๊ฐ(80+90+100)์ ๋์ถ ํด ๋ผ ์ ์์ต๋๋ค. ์ฆ 100% ์์ ํจ์ ์ ๋๋ค.
์ ์ฒด ์ฝ๋ ์ ๋๋ค. ์์ํจ์ํ ํ๋ก๊ทธ๋๋ฐ์ ์ฌ๊ณ ๋ฐฉ์์ด ๋ด์ฌ๋ ์ฝ๋์ ๋๋ค.
const sum = (total, current) => total + current
const total = (arr) => arr.reduce(sum)
const divide = (a, b) => a / b
const average = (arr) => divide(total(arr), size(arr))
average(input) //90
๋ถ๋ณ์ฑ
primitive ์๋ฃํ์ ๋ถ๋ณ์ ๋๋ค. ํ์ง๋ง ๊ฐ์ฒด, ๋ฐฐ์ด์ ์ฌ๋ฌ๊ฐ์ ์๋ณ์๊ฐ ํ๋์ ๊ฐ์ฒด๋ฅผ ๊ณต์ ํฉ๋๋ค. ๊ทธ๋์ ์ด๋ฐ ๋ฐฉ์์ ๋ถ์์ฉ์ด ์๊ธฐ๋๋ฐ ํจ์์ฒ๋ฆฌ์์ ๊ฐ์ฒด๋๋ ๋ฐฐ์ด์ ํ๋ผ๋ฏธํฐ๋ก ๋๊ธธ ๋, ์๋ณธ ๊ฐ์ฒด์ ๋๊ฒจ์ง ๊ฐ์ฒด๋ ๋ฉ๋ชจ๋ฆฌ์ฃผ์๋ ๋ค๋ฅด์ง๋ง ๋์ผํ ์ฐธ์กฐ๊ฐ์ ๊ฐ์ต๋๋ค. ์ฆ ๋์ผํ ๊ฐ์ฒด๋ฅผ ๊ฐ๋ฆฌํค๋ฏ๋ก, ํ์ชฝ์ด ํจ์ ๋ฐํ๊ฐ์ผ๋ก ๋ณํ๋ ๊ฐ์ฒด๋ก ์๋ณธ ๊ฐ์ฒด๋ก ๊ฐ์ด ๋ฐ๋๋ ๋ถ์์ฉ์ด ๋ฐ์ํฉ๋๋ค.
const sortDesc = arr= >{
arr.sort((a,b)=>b-a)
}
const stdeuntIds = [1,2,3,4,5]
const sortedStudentIds =sortDesc(studentIds);
console.log(sortedStudetnIds) // [5,4,3,2,1]
console.log(studentIds) //[5,4,3,2,1]
์ฌ๊ธฐ์ ๋งํ๋ ๋ถ์ํจ๊ณผ๋ ์๋ณธ ๋ ํผ๋ฐ์ค๊ฐ ๊ฐ๋ฆฌํค๋ ๋ฐฐ์ด์ ์์๋ฅผ ์ ๋ ฌํ๋ ๋ถ์ํจ๊ณผ๋ฅผ ๋งํฉ๋๋ค.
๋ถ์ํจ๊ณผ๋ฅผ ๋ฐฉ์งํ๊ธฐ ์ํด ์์ ๋ณต์ฌ๋ฅผ ํ ๊ฒฝ์ฐ๋, Object.freeze()
๋ฅผ ์ด์ฉํ๊ฑฐ๋,
๊น์ ๋ณต์ฌ๋ฅผ ํ ๊ฒฝ์ฐ๋ lodash ๋๋ ๋๋คJS ๋ผ์ด๋ธ๋ฌ๋ฆฌ๋ค์ ํ์ฉํฉ๋๋ค.
์ฐธ๊ณ ์๋ฃ