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