[FP&ES6+] take

함수형 프로그래밍과 JavaScript ES6+ 강의를 듣고 정리한 내용입니다.

 

 

✅ take

const take = (limit, iter) => {
    let res = [];
    for (const a of iter) {
        res.push(a);
        if (res.length == limit) return res;
    }
    return res;
}

 

limit값과 이터러블을 인자로 받는 함수이다.

take 함수에서는 이터러블을 순회하다 이터러블의 limit번째 까지만 담아 리턴한다.

즉, 많은 값을 받아서 일정한 값 만큼 잘라주는 함수라고 할 수 있다.

 

console.log(take(2, [1, 2, 3]));

// output
// [1, 2]

 

 

✅ 지연 평가의 효율성

L.range와 같이 지연성을 가지는 값을 이터레이터로 만들게 되면 이터러블 프로토콜을 따르는 함수와 완전한 소통이 가능하다.

그렇기에 range(1000000)와 같이 큰 값을 다루는 경우 L.range()로 지연성을 가지게 하고 이터러블 프로토콜을 가지는 함수를 사용하면 효율적이다.

 

예를 들어 1,000,000개의 요소가 담긴 배열에서 0번 인덱스부터 4번 인덱스까지 5개의 요소만을 가져와야 한다고 하자.

이때 range(1000000)을 사용하는 것과 L.range(1000000)을 사용하는 것은 큰 차이가 있다.

 

range(1000000)은 1,000,000개의 요소를 가진 배열을 반환하고 이 1,000,000개의 요소를 가진 배열을 직접 take 함수에 넣어 5개의 요소를 가져온다.

이러한 경우 1,000,000개의 요소를 가진 배열을 만드는 것과 이 요소를 순회하는 것까지 하면 연산에 시간이 좀 걸린다.

 

L.range(1000000)는 1,000,000개의 요소를 가진다고 명시만 해두고 평가가 필요한 시점, 즉 take 함수를 만나 요소를 순회한다고 할 때 5개의 요소만을 반환한다.

필요에 맞게 5개까지만 꺼내고 작업을 끝내는 것이다.

 

콘솔 로그로 찍어보면 이 둘의 차이를 명확히 알 수 있다.

 

const range = length => {
    let i = -1;
    let res = [];
    while (++i < length) {
        res.push(i);
    }
    return res;
};
const L = {};
L.range = function* (l) {
    let i = -1;
    while (++i < l) {
        yield i;
    }
};
console.time('range');
console.log(take(5, range(1000000)));
console.timeEnd('range');

console.time('L.range');
console.log(take(5, L.range(1000000)));
console.timeEnd('L.range');

// output
// [0, 1, 2, 3, 4]
// range: 21.506103515625 ms
// [0, 1, 2, 3, 4]
// L.range: 0.14404296875 ms

 

 

✅ curry + take

take에 curry문을 더하면 위의 예시와 비슷하면서도 좀 더 효율적으로 사용할 수 있다.

 

const take = curry((limit, iter) => {
    let res = [];
    for (const a of iter) {
        res.push(a);
        if (res.length == limit) return res;
    }
    return res;
})

const add = (a, b) => a + b;
go(
    L.range(100000),
    take(5),
    reduce(add),
    console.log,
);

// output
// 10