ES6+ Basic3

์ธํ”„๋Ÿฐ ํ•จ์ˆ˜ํ˜• ํ”„๋กœ๊ทธ๋ž˜๋ฐ๊ณผ JavaScript ES6+ / ์œ ์ธ๋™

range

const range = l => {
    let i = -1;
    let res = [];
    while (++i < l) {
        res.push(i);
    }
    return res;
};

// range๊ฐ’ ๋ชจ๋‘ ๋”ํ•˜๊ธฐ
var list = range(4);
log(list);
log(reduce(add, list));
  • range๋ฅผ ์‹คํ–‰ํ•œ ์ฆ‰์‹œ ๋ฐฐ์—ด๋กœ ํ‰๊ฐ€๊ฐ€ ๋จ(๊ฐ’์ด ๋งŒ๋“ค์–ด์ง)

๋А๊ธ‹ํ•œ L.range

const L = {}
L.range = function *(l) {
    let i = -1;
    while (++i < l) {
        yield i;
    }
};

// range๊ฐ’ ๋ชจ๋‘ ๋”ํ•˜๊ธฐ
var list = L.range(4);
log(list); // ์ดํ„ฐ๋ ˆ์ดํ„ฐ
log(reduce(add, list));
  • ์ดํ„ฐ๋ ˆ์ดํ„ฐ์˜ ๋‚ด๋ถ€๋ฅผ ์‹ค์ œ๋กœ ์ˆœํšŒํ•  ๋•Œ ๋งˆ๋‹ค ๊ฐ’์ด ํ•˜๋‚˜์”ฉ ํ‰๊ฐ€๊ฐ€ ๋จ(ํ•จ์ˆ˜๋‚ด๋ถ€์—์„œ๋Š” ํ‰๊ฐ€X, nextํ• ๋•Œ ํ‰๊ฐ€๋จ)

  • ๋ฐฐ์—ด์„ ๋งŒ๋“ค์ง€ ์•Š๊ณ  ํ•˜๋‚˜์”ฉ ๊ฐ’์„ ๊บผ๋‚ด๊ธฐ๋งŒ ํ•จ

  • ์กฐ๊ธˆ ๋” ํšจ์œจ์ ์ด๋ผ๊ณ  ๋ณผ ์ˆ˜ ์žˆ์Œ(์ง€์—ฐ์„ฑ)

take

const take = (l, iter) => {
    let res = [];
    for (const a of iter) {
        res.push(a);
        if (res.length == l) return res;
    }
    return res;
}
// ๋งŽ์€ ๊ฐ’์„ ๋ฐ›์•„์„œ ์ž˜๋ผ์ฃผ๋Š” ํ•จ์ˆ˜
log(take(5, range(10000)));
// ๋น„ํšจ์œจ์ 
log(take(5, L.range(10000)));
// ํšจ์œจ์ 
  • ์ง€์—ฐ์„ฑ์€ ์—ฐ์‚ฐ์„ ํ•˜์ง€ ์•Š๊ณ  ์žˆ๋‹ค๊ฐ€ take๋‚˜ reduce๊ฐ™์€ ํ•จ์ˆ˜๋ฅผ ๋งŒ๋‚  ๋•Œ ์—ฐ์‚ฐ์„ ์ฒ˜์Œํ•˜๋Š” ๊ธฐ๋ฒ•

์ดํ„ฐ๋Ÿฌ๋ธ”(๋ฆฌ์ŠคํŠธ) ์ค‘์‹ฌ ํ”„๋กœ๊ทธ๋ž˜๋ฐ์—์„œ์˜ ์ง€์—ฐ ํ‰๊ฐ€ Lazy Evaluation

  • ์ œ๋•Œ ๊ณ„์‚ฐ๋ฒ•(์˜๋ฆฌํ•œ ๊ณ„์‚ฐ๋ฒ•)

  • ๋А๊ธ‹ํ•œ ๊ณ„์‚ฐ๋ฒ•

  • ์ œ๋„ˆ๋ ˆ์ดํ„ฐ/์ดํ„ฐ๋ ˆ์ดํ„ฐ ํ”„๋กœํ† ์ฝœ์„ ๊ธฐ๋ฐ˜์œผ๋กœ ๊ตฌํ˜„

L.map

L.map = function *(f, iter) {
    for(const a of iter) yield f(a);
};
// next๋ฅผ ํ†ตํ•ด ํ‰๊ฐ€ํ•˜๋Š” ๊ฐ’๋งŒ ์–ป์–ด์˜ฌ ์ˆ˜ ์žˆ์Œ
// L.map ์ž์ฒด๋Š” ๋ฐฐ์—ด์„ ๋งŒ๋“ค์ง€ ์•Š์Œ
  • ํ‰๊ฐ€๋ฅผ ๋ฏธ๋ฃจ๋Š” ์„ฑ์งˆ์„ ๊ฐ€์ง€๊ณ  ํ‰๊ฐ€์ˆœ์„œ๋ฅผ ๋‹ฌ๋ฆฌ ์กฐ์ž‘ํ•  ์ˆ˜ ์žˆ๋Š” ์ค€๋น„๊ฐ€ ๋˜์–ด์žˆ๋Š” ์ดํ„ฐ๋ ˆ์ดํ„ฐ๋ฅผ ๋ฐ˜ํ™˜ํ•˜๋Š” ์ œ๋„ˆ๋ ˆ์ดํ„ฐ ํ•จ์ˆ˜

L.filter

L.filter = function *(f, iter) {
    for(const a of iter) if (f(a)) yield a;
};
  • ๋งˆ์ฐฌ๊ฐ€์ง€๋กœ ํ•จ์ˆ˜๋ฅผ ์ˆ˜ํ–‰ํ•˜๋Š” ๋™์•ˆ์—๋Š” ํ‰๊ฐ€๊ฐ€ ์ด๋ฃจ์–ด์ง€์ง€ ์•Š์Œ

range, map, filter, take, reduce ์ค‘์ฒฉ ์‚ฌ์šฉ

go(range(10),
    map(n => n + 10),
    filter(n => n % 2),
    take(2),
    log);
  • ์œ„๋ถ€ํ„ฐ ์ˆœ์„œ๋Œ€๋กœ ํ‰๊ฐ€ํ•˜๋ฉด์„œ ๋‚ด๋ ค์˜ด

L.range, L.map, L.filter, take, reduce ์ค‘์ฒฉ ์‚ฌ์šฉ

go(L.range(10),
    L.map(n => n + 10),
    L.filter(n => n % 2),
    take(2),
    log);
  • ์•„๋ž˜์„œ ์œ„๋กœ ๋‹ค์‹œ ์œ„์—์„œ ์•„๋ž˜๋กœ ์„ธ๋กœ๋กœ ํ‰๊ฐ€๋จ

  • ์ตœ์ข…์ ์œผ๋กœ takeํ•  ์ˆ˜๋งŒํผ๋งŒ ๋™์ž‘ํ•˜๊ธฐ ๋•Œ๋ฌธ์— range์˜ ์ˆ˜๊ฐ€ ์•„๋ฌด๋ฆฌ ๋งŽ์•„๋„ ์‹œ๊ฐ„์€ ๋˜‘๊ฐ™์Œ

map, filter ๊ณ„์—ด์˜ ํ•จ์ˆ˜๋“ค์ด ๊ฐ€์ง€๋Š” ๊ฒฐํ•ฉ ๋ฒ•์น™

  • ์‚ฌ์šฉํ•˜๋Š” ๋ฐ์ดํ„ฐ๊ฐ€ ๋ฌด์—‡์ด๋“ ์ง€

  • ์‚ฌ์šฉํ•˜๋Š” ๋ณด์กฐ ํ•จ์ˆ˜๊ฐ€ ์ˆœ์ˆ˜ ํ•จ์ˆ˜๋ผ๋ฉด ๋ฌด์—‡์ด๋“ ์ง€

  • ์•„๋ž˜์™€ ๊ฐ™์ด ๊ฒฐํ•ฉํ•œ๋‹ค๋ฉด ๋‘˜ ๋‹ค ๊ฒฐ๊ณผ๊ฐ€ ๊ฐ™์Œ

  • ex) [[mapping, mapping], [filtering, filtering], [mapping, mapping]] == [[mapping, filtering, mapping], [mapping, filtering, mapping]]

ES6์˜ ๊ธฐ๋ณธ ๊ทœ์•ฝ์„ ํ†ตํ•ด ๊ตฌํ˜„ํ•˜๋Š” ์ง€์—ฐ ํ‰๊ฐ€์˜ ์žฅ์ 

  • ์„œ๋กœ ๋‹ค๋ฅธ ๋ผ์ด๋ธŒ๋Ÿฌ๋ฆฌ, ๋‹ค๋ฅธ ์‚ฌ๋žŒ์ด ๋งŒ๋“  ํ•จ์ˆ˜์—ฌ๋„ ๊ธฐ๋ณธ ๊ทœ์•ฝ์„ ๊ธฐ๋ฐ˜์œผ๋กœ ํ•จ์œผ๋กœ ์•ˆ์ „ํ•œ ๋ฐฉ์‹์œผ๋กœ ํ•ฉ์„ฑํ•  ์ˆ˜ ์žˆ์Œ

Last updated