์ผ๊ธ๊ฐ์ฒด
- ๋ณ์์ ํ ๋น ๊ฐ๋ฅ // (ํจ์ ํํ์ & ํจ์ ์ ์ธ์ ๋ชจ๋ ๊ฐ๋ฅ)
- ๋ค๋ฅธ ํจ์์ ์ ๋ฌ์ธ์๋ก ์ ๋ฌ ๊ฐ๋ฅ // ์ฝ๋ฐฑํจ์ = ํจ์์ ์ธ์๋ก ์ ๋ฌ๋๋ ํจ์.
- ๋ค๋ฅธ ํจ์์ ๊ฒฐ๊ณผ๋ก์ ๋ฆฌํด ๊ฐ๋ฅ (ํจ์๊ฐ ์ผ๊ธ๊ฐ์ฒด์ด๊ธฐ ๋๋ฌธ์ ํด๋ก์ ธ๋ ์ฌ์ฉ๊ฐ๋ฅํ๊ฑฐ์๋ค. )
=> ๋ฌธ์์ด, ์ซ์ ๊ฐ์ ๋ค๋ฅธ ๋ฐ์ดํฐ์ฒ๋ผ ์ฌ์ฉ ๊ฐ๋ฅ!
==> js์์ ํจ์๋ ์ผ๊ธ๊ฐ์ฒด!!
์ปค๋งํจ์ = ํจ์๋ฅผ ๋ฆฌํดํ๋ ํจ์.
๊ณ ์ฐจํจ์
ํจ์๋ฅผ ๋ณ์์ ํ ๋นํ ์ ์๊ธฐ ๋๋ฌธ์, ํจ์๋ฅผ ๋ฐฐ์ด์ ์์๋ ๊ฐ์ฒด์ ์์ฑ๊ฐ์ผ๋ก ์ ์ฅํ ์ ์๋ค.
ํจ์๊ฐ ์ผ๊ธ๊ฐ์ฒด๋ผ์ ๊ณ ์ฐจํจ์๋ก ํ์ฉ ๊ฐ๋ฅํ๊ฑฐ๋ค!
- ํจ์๋ฅผ ์ ๋ฌ์ธ์๋ก ๋ฐ๋ ํจ์
- ํจ์๋ฅผ ๋ฆฌํดํ๋ ํจ์
์ฝ๋ฐฑํจ์
๋น๋๊ธฐ์์ ์ฝ๋ฐฑํจ์๊ฐ ๋งค์ฐ ์ค์ํ๋ค.
์ปค๋งํจ์
์ปค๋งํจ์๋๋ฌธ์ ํด๋ก์ ๊ฐ ๋์จ๊ฑฐ๋ค.
๊ฑฐ์ ๊ฐ๋ค๊ณ ๋งํ ์ ์๋ค.
๋ฐฐ์ด ๋ด์ฅ ๋งค์๋
- map
- filter
- reduce
- ๊ธฐํ ๋ฑ๋ฑ
=========
**๋ก๋ฐฅ**
๋ฉ์๋๋ ๋ฌด์์ธ๊ฐ์?
(๊ฐ์ฒด ์์ ํจ์๋ค.)
ํจ์์ ๋ฉ์๋๋ ๊ฑฐ์ ๊ฐ์๋ฐ,
ex) arr.map ์ด๋ arr.filter ๋ฅผ ๋ฉ์๋๋ผ๊ณ ํ๋ค.
์ด๊ฑธ ๊ฐ์ฒด์งํฅ ํ๋ก๊ทธ๋๋ฐ์ด๋ผ๊ณ ํ๋ค.
์ด๋ ๊ทธ ๋น๋ฐ์ ์๊ฒ ๋ ๊ฑฐ๋ค.
mdn ์์ array.prototype.map ์ฒ๋ผ prototype์ด ์์๊ฑฐ๋ค.
์ด๊ฑด ๊ฐ์ฒด์งํฅ์์ ๋ฐฐ์ธ๊ฑฐ๋ค.
prototype๋ ์ํ๊ฐ์ฒด๋ผ๊ณ ํ๋ค.
map
= ๋ฐฐ์ด์ ๊ฐ ์์์ ์ฝ๋ฐฑํจ์๋ฅผ ์ ์ฉ์์ผฐ์๋ ์๋ก์ด ๋ฐฐ์ด์ ๋ฆฌํดํ๋ค. (slice ์ฒ๋ผ immutable)
let arr = [1,2,3,4,5]
function multiply2(num) {
return num * 2
}
arr.map(multiply2);
// ์ถ๋ ฅ๊ฐ
[2,4,6,8,10]
* ์ฝ๋ฐฑํจ์์ ๋ ๋ฒ์งธ ์ ๋ฌ์ธ์๋ฅผ ์ค ๊ฒฝ์ฐ, ์ธ๋ฑ์ค๋ฅผ ๊ฐ์ ธ์จ๋ค.
let arr = [1,2,3,4,5]
function multiply2(num) {
return num * 2
}
arr.map((el,idx) => `${idx} : ${el * 2}`);
// ์ถ๋ ฅ๊ฐ
['0 : 2', '1 : 4', '2 : 6', '3 : 8', '4 : 10']
* map์ ๋ฆฌํด์ด ์์ผ๋ฉด undefined๊ฐ ๋ค์ด๊ฐ ๋ฐฐ์ด์ด ์๊ธด๋ค.
filter
๋ฐฐ์ด์ ๊ฐ ์์์ ์ฝ๋ฐฑํจ์๋ฅผ ์ ์ฉ์์ผฐ์๋, true ๋ฅผ ๋ฆฌํดํ๋ ์์๋ค๋ง ๋ชจ์ ์๋ก์ด ๋ฐฐ์ด์ ๋ฆฌํด
let arr = [1,2,3,4,5]
arr.filter((el) => el % 2 === 0);
//์ถ๋ ฅ๊ฐ
[2, 4]
let arr= [1,2,3,4,5]
arr.filter((el) => el % 2);
// ์ถ๋ ฅ๊ฐ
[1,3,5]
filter๋ ์กฐ๊ฑด์์ด true์ธ ๊ฒฝ์ฐ ๊ฐ๋ง ์ถ๋ ฅํ๋ฏ๋ก, el % 2๋ฅผ ํด์ 0์ด ๋์ค๋ ๊ฐ์ ์ถ๋ ฅ๋์ง ์๋๋ค.
์๋๋ฉด 0์ falsyํ ๊ฐ์ด๊ธฐ ๋๋ฌธ์ด๋ค.
reduce
๋ฐฐ์ด์ ๊ฐ ์์๋ฅผ ์ฝ๋ฐฑ ํจ์์ ๋ง๊ฒ ํ๋๋ก ์์ถ์ํจ ๊ฐ์ ๋ฆฌํด // ๋์ , ํ์ฌ, ์ด๊ธฐ๊ฐ์ด ์ค์ํ๋ค!
acc: accumulation ์์ถ๋ ๊ฐ
cur: current ํ์ฌ ๋ฐฐ์ด ์์
- ์ด๊ธฐ๊ฐ์ด ์์๋
acc๋ ๋ฐฐ์ด์ ์ฒซ๋ฒ์งธ ์์
cur๋ ๋ฐฐ์ด์ ๋๋ฒ์งธ ์์
๋ง์ง๋ง์๋ ์ต์ข
์ ์ธ acc๊ฐ์ด ๋ฆฌํด๋๋ค.
let arr = [1,2,3,4,5]
arr.reduce((acc,cur) => {return acc + cur});
// ์ถ๋ ฅ๊ฐ
15
let arr = [1,2,3,4,5]
arr.reduce((acc,cur) => acc + cur);
// ์ถ๋ ฅ๊ฐ
15
2. ์ด๊ธฐ๊ฐ์ด ์์๋
์ด๊ธฐ๊ฐ์ ์ด๊ธฐ๊ฐ์ด ๋๋๊ฑฐ๊ณ ,
cur์ ๋ฐฐ์ด์ ์ฒซ๋ฒ์งธ ์์๊ฐ ๋๋๊ฑฐ๋ค.
๋ง์ง๋ง์๋ ์ต์ข
์ ์ธ acc๊ฐ์ด ๋ฆฌํด๋๋ค.
์ด๊ธฐ๊ฐ ์์ผ๋ฉด ๋ฐ๋ณตํ์๊ฐ ์์๋๋ณด๋ค ํ๋ฒ ๋ ๋ง๋ค.
let arr = [1,2,3,4,5]
arr.reduce((acc,cur) => {return acc + cur},10);
// ์ถ๋ ฅ๊ฐ
25
let arr = [1,2,3,4,5]
arr.reduce((acc,cur) => acc + cur, 10);
// ์ถ๋ ฅ๊ฐ
25
let arr = [1,2,3,4,5]
arr.reduce((acc,cur) => {
if(cur % 2 === 0) {
return acc + cur
} else {
return acc
}
},0)
// ์ถ๋ ฅ๊ฐ
6
- ์ญ ๊ฐ๋ค๊ฐ ์์ถํ๋ฉด ๋๋๊น reduce ์ฐ๋ฉด๋๋ค.
reduce๋ฅผ ์ธ๋ ์๋์น์๊ฒ ์ค๋ฅ๋ฅผ ์ ๋ฐํ๊ธฐ ์ฌ์์ ๋๋๋ก์ด๋ฉด ํ๋ก๊ทธ๋จ์ ์ทจ์ง์ ๋ง์ถ์ด์ ์ทจ์ง๊ฐ์ ์ฃผ๋๊ฒ ๋ ์ข๋ค!!!
๋ด์ฅํจ์๋ก ์ถ์ถํ ๊ฐ์ ๋ณ์์ ํ ๋นํ ๋, ์ดํ์ ๋ณํ์ง ์์ ๊ฐ์ด๋ผ๊ณ ์๊ฐํด์ const๋ก ์ ์ธํ๋๊ฒ ์ข๋ค.
const ๋ก ์จ์ผ.. ๋์ค์ ํ์นญ ํ ๋ ์ด๊ฒ ํ๋ฒ์ฝ๊ณ ๋์ด์๋๋ผ ๊ฒ์ฌ > ์คํ ๋จ๊ณ์์ const ๋ก ์ ์ธํ๋ฉด ๋ฉ๋ชจ๋ฆฌ ์ชฝ์์๋ ๋๋น ๋ฅด๋ค๊ณ ํ๋๋ผ๊ณ ์ ๋ฐ๋ก๋ฐ๋ก ์ ์ฅ์ด๋์ด์ ์ด์ฐจํผ ๋ณํ๋ ๊ฐ์ด ์๋๋ผ
foreach ๊ณต๋ถํ๊ธฐ
[1,2,3,4,5].foreach(el => {
console.log(el)
})
foreach ์ถ๊ฐ๊ณต๋ถ๐
2022.05.27 - [JavaScript] - TIL) forEach, for of, filter, reduce