고차함수

// _.take는 배열의 처음 n개의 element를 담은 새로운 배열을 리턴합니다.
// n이 undefined이거나 음수인 경우, 빈 배열을 리턴합니다.
// n이 배열의 길이를 벗어날 경우, 전체 배열을 shallow copy한 새로운 배열을 리턴합니다.
_.take = function (arr, n) {
    // TODO: 여기에 코드를 작성합니다.
    let result = [];
    if (n === undefined || n < 0) {
        return [];
    }
    else if (n > arr.length) {
        return arr;
    }
    for (let i = 0; i < n; i++) {
        result.push(arr[i]);
    }
    return result;
};

// _.drop는 _.take와는 반대로, 처음 n개의 element를 제외한 새로운 배열을 리턴합니다.
// n이 undefined이거나 음수인 경우, 전체 배열을 shallow copy한 새로운 배열을 리턴합니다.
// n이 배열의 길이를 벗어날 경우, 빈 배열을 리턴합니다.
_.drop = function (arr, n) {
    // TODO: 여기에 코드를 작성합니다.
    let result = arr;
    if (n === undefined || n < 0) {
        return arr;
    }
    else if (n > arr.length) {
        return [];
    }
    for (let i = 0; i < n; i++) {
        result.shift();
    }
    return result;
};

// _.last는 배열의 마지막 n개의 element를 담은 새로운 배열을 리턴합니다.
// n이 undefined이거나 음수인 경우, 배열의 마지막 요소만을 담은 배열을 리턴합니다.
// n이 배열의 길이를 벗어날 경우, 전체 배열을 shallow copy한 새로운 배열을 리턴합니다.
// _.take와 _.drop 중 일부 또는 전부를 활용할 수 있습니다.
_.last = function (arr, n) {
    // TODO: 여기에 코드를 작성합니다.
    let result = [];
    if (n === undefined || n < 0) {
        return [arr[arr.length - 1]];
    }
    else if (n > arr.length) {
        return arr;
    }
    return _.drop(arr, arr.length - n);
};

// _.each는 collection의 각 데이터에 반복적인 작업을 수행합니다.
//  1. collection(배열 혹은 객체)과 함수 iteratee(반복되는 작업)를 인자로 전달받아 (iteratee는 함수의 인자로 전달되는 함수이므로 callback 함수)
//  2. collection의 데이터(element 또는 property)를 순회하면서
//  3. iteratee에 각 데이터를 인자로 전달하여 실행합니다.

// _.each는 명시적으로 어떤 값을 리턴하지 않습니다.
_.each = function (collection, iteratee) {
    // TODO: 여기에 코드를 작성합니다.
    if (Array.isArray(collection)) {
        for (let i = 0; i < collection.length; i++) {
            iteratee(collection[i], i, collection);
        }
    }
    else {
        for (let i in collection) {
            iteratee(collection[i], i, collection);
        }
    }

};

// _.indexOf는 target으로 전달되는 값이 arr의 요소인 경우, 배열에서의 위치(index)를 리턴합니다.
// 그렇지 않은 경우, -1을 리턴합니다.
// target이 중복해서 존재하는 경우, 가장 낮은 index를 리턴합니다.
_.indexOf = function (arr, target) {
    // 배열의 모든 요소에 접근하려면, 순회 알고리즘(iteration algorithm)을 구현해야 합니다.
    // 반복문을 사용하는 것이 가장 일반적이지만, 지금부터는 이미 구현한 _.each 함수를 활용하여야 합니다.
    // 아래 _.indexOf의 구현을 참고하시기 바랍니다.
    let result = -1;

    _.each(arr, function (item, index) {
        if (item === target && result === -1) {
            result = index;
        }
    });

    return result;
};

// _.filter는 test 함수를 통과하는 모든 요소를 담은 새로운 배열을 리턴합니다.
// test(element)의 결과(return 값)가 truthy일 경우, 통과입니다.
// test 함수는 각 요소에 반복 적용됩니다.
_.filter = function (arr, test) {
    // TODO: 여기에 코드를 작성합니다.
    let result = [];
    _.each(arr, function (iteratee) {
        if (test(iteratee)) {
            result.push(iteratee);
        }
    })
    return result;
};

// _.reject는 _.filter와 정반대로 test 함수를 통과하지 않는 모든 요소를 담은 새로운 배열을 리턴합니다.
_.reject = function (arr, test) {
    // TODO: 여기에 코드를 작성합니다.
    // TIP: 위에서 구현한 `filter` 함수를 사용해서 `reject` 함수를 구현해 보세요.
    return _.filter(arr, function (iteratee) {
        return !test(iteratee);
    })
};

// _.uniq는 주어진 배열의 요소가 중복되지 않도록 새로운 배열을 리턴합니다.
// 중복 여부의 판단은 엄격한 동치 연산(strict equality, ===)을 사용해야 합니다.
// 입력으로 전달되는 배열의 요소는 모두 primitive value라고 가정합니다.
_.uniq = function (arr) {
    // TODO: 여기에 코드를 작성합니다.
    let result = [];
    for (let i = 0; i < arr.length; i++) {
        if (_.indexOf(result, arr[i]) === -1) {
            result.push(arr[i]);
        }
    }
    return result;
};

// _.map은 iteratee(반복되는 작업)를 배열의 각 요소에 적용(apply)한 결과를 담은 새로운 배열을 리턴합니다.
// 함수의 이름에서 드러나듯이 _.map은 배열의 각 요소를 다른 것(iteratee의 결과)으로 매핑(mapping)합니다.
_.map = function (arr, iteratee) {
    // TODO: 여기에 코드를 작성합니다.
    // _.map 함수는 매우 자주 사용됩니다.
    // _.each 함수와 비슷하게 동작하지만, 각 요소에 iteratee를 적용한 결과를 리턴합니다.
    let result = [];
    _.each(arr, function (i) {
        result.push(iteratee(i));
    })
    return result;
};

// _.pluck은
//  1. 객체 또는 배열을 요소로 갖는 배열과 각 요소에서 찾고자 하는 key 또는 index를 입력받아
//  2. 각 요소의 해당 값 또는 요소만을 추출하여 새로운 배열에 저장하고,
//  3. 최종적으로 새로운 배열을 리턴합니다.
_.pluck = function (arr, keyOrIdx) {
    // _.pluck을 _.each를 사용해 구현하면 아래와 같습니다.
    // let result = [];
    // _.each(arr, function (item) {
    //   result.push(item[keyOrIdx]);
    // });
    // return result;
    // _.pluck은 _.map을 사용해 구현하시기 바랍니다.
    // TODO: 여기에 코드를 작성합니다.
    return _.map(arr, arr => arr[keyOrIdx]);
};

// _.reduce는
//  1. 배열을 순회하며 각 요소에 iteratee 함수를 적용하고,
//  2. 그 결과값을 계속해서 누적(accumulate)합니다.
//  3. 최종적으로 누적된 결과값을 리턴합니다.
_.reduce = function (arr, iteratee, initVal) {
    // TODO: 여기에 코드를 작성합니다.
    //let acc = initVal;
    //_.each(arr, function (ele, index, array) {
    //    if (initVal === undefined && index === 0) {
    //        acc = ele;
    //    }
    //    else {
    //        acc = iteratee(acc, ele, index, array);
    //    }
    //})
    //return acc;
    let acc = initVal;
    _.each(arr, function (cur, idx, arr) {
        if (acc === undefined) {
            acc = arr[0]
        } else {
            acc = iteratee(acc, cur, idx, arr)
        }
    })