๊ณ ์ฐจ ํจ์๋
์๋ ์กฐ๊ฑด ์ค ํ๋ ์ด์์ ๋ง์กฑํ๋ ํจ์์ด๋ค.
- ํ๋ ์ด์์ ํจ์๋ฅผ ์ธ์๋ก ๋ฐ๊ธฐ
- ๊ฒฐ๊ณผ๋ก ํจ์ ๋ฐํํ๊ธฐ
์์ 1.
์กฐ๊ฑด 1, 2๋ฅผ ๋ง์กฑํ๋ ๊ณ ์ฐจํจ์ ์์ ์ด๋ค. ๊ณ ์ฐจํจ์ not
์ ์ธ์๋ก ์ ๋ฌ๋ฐ์ ํจ์ f
์ ์คํ ๊ฒฐ๊ณผ๊ฐ์ ๋ถ์ ํ๋ค.
function not(f) {
return function(...args) {
let result = f.apply(this, args);
return !result; // f์ ๊ฒฐ๊ณผ๋ฅผ ๋ถ์ ํ๋ค.
}
}
์ซ์๊ฐ ์ง์์ธ์ง ํ๋ณํ๋ ํจ์ isEven
์ ๊ณ ์ฐจํจ์ not
์ ํ๋ผ๋ฏธํฐ๋ก ์ ๋ฌํ๋ค๋ฉด, ๊ทธ ๊ฒฐ๊ณผ๋ ์ซ์๊ฐ ํ์์ธ์ง๋ฅผ ํ๋ณํ๋ ๊ฒ๊ณผ ๊ฐ์ ๊ฒ์ด๋ค.
const isEven = x => x % 2 === 0;
const isOdd = not(isEven);
๋ฐ๋ผ์ ๋ฐฐ์ด์ ์์๋ ์ ๋ถ ํ์์ด๋ฏ๋ก ์๋ ์ฝ๋์ ๊ฒฐ๊ณผ๋ true
๊ฐ ๋๋ค.
[1, 1, 3, 5, 5].every(isOdd);
์์ 2.
JavaScript Array์ ๋ด์ฅ ๋ฉ์๋ forEach()
, map()
, filter()
๋ฑ์ ์กฐ๊ฑด 1์ ๋ง์กฑํ๋ ๋ํ์ ์ธ ๊ณ ์ฐจํจ์์ด๋ค. ์ฒซ ๋ฒ์งธ ์ธ์์ ๋ฐฐ์ด์ ๊ฐ ์์๋ฅผ ์ธ์๋ก ์ ๋ฌ๋ฐ์ ์คํ๋ ์ฝ๋ฐฑ ํจ์๊ฐ ์ ๋ฌ๋์ด์ผ ํ๋ค.
const nums = [1, 2, 3, 4];
// ์ต๋ช
ํจ์๋ฅผ ๊ณง๋ฐ๋ก ์ ๋ฌํ ์ ์๋ค.
nums.forEach(num => console.log(num));
// ์ฝ๋ฐฑ ํจ์๋ฅผ ๋ถ๋ฆฌํ์ฌ ์ ์ธํ ๋ค ์ ๋ฌํ ์๋ ์๋ค.
function log(num) {
console.log(`Test Log: ${num}`);
}
name.forEach(log);
์ด ๋ ๊ณ ์ฐจ ํจ์ forEach
์ ๋ด๋ถ ๊ตฌํ์ ๋ด ๋ง๋๋ก(?) ํด๋ณด์๋ค. ์ฐธ๊ณ ๋ก ์ฝ๋ฐฑ ํจ์ predicate
์ ํ์ค ํ์
์ (value: T, index: number, array: readonly T[]) => void
์ด๋ค. ์ฆ, ์ด 3๊ฐ์ ํ๋ผ๋ฏธํฐ๋ฅผ ๊ฐ์ง๋ฉฐ ์ฒซ ๋ฒ์งธ๋ ์ํ์ค์ธ ๋ฐฐ์ด์ ์์, ๋ ๋ฒ์งธ๋ ์ํ์ค์ธ ๋ฐฐ์ด ์์์ ์ธ๋ฑ์ค, ์ธ ๋ฒ์งธ๋ ์ํ์ค์ธ ๋ฐฐ์ด์ ์ ๋ฌ๋ฐ๋๋ค.
function forEach(predicate) {
// this: forEach๋ฅผ ํธ์ถํ ๋ฐฐ์ด
for(let i = 0, len = this.length; i < len; i++) {
predicate(this[i], i, this);
}
}
filter()
๋ฉ์๋๋ ์กฐ๊ฑด์ ๋ง๋ ์์๋ง ์ถ์ถํด์ ์๋ก์ด ๋ฐฐ์ด์ ๋ง๋ค์ด ๋ฐํํ๋ ๊ณ ์ฐจํจ์์ด๋ค. ์ ์์ 1์์ ๋ง๋ isEven
ํจ์๋ฅผ ์ฌ์ฉํด ์ง์์ธ ์์๋ง ๊ฐ์ง๊ณ ์๋ ์ ๋ฐฐ์ด์ ๋ง๋ค ์ ์๋ค.
const nums = [1, 2, 3, 4];
const evenNums = nums.filter(isEven); // [2, 4]
// ๊ทธ๋ฅ ๋ ํ ๋ฒ ๊ตฌํํด๋ณธ filter ๋ฉ์๋
function filter(predicate) {
const newArray = [];
for(let i = 0, len = this.length; i < len; i++) {
if(predicate(this[i], i, this)) {
newArray.push(this[i]);
}
}
return newArray;
}
์ฐธ๊ณ
- ์๋ฐ์คํฌ๋ฆฝํธ ์๋ฒฝ๊ฐ์ด๋, ๋ฐ์ด๋น๋ ํ๋๋๊ฑด, ์ธ์ฌ์ดํธ
- https://dev.to/spukas/higher-order-functions-in-javascript-1f4n