Underscore.js 직접 라이브러리 만들어 보기

// _.last 구현해보기
function last_1(array, n) {
    if(n === undefined) {
        return array[array.length - 1];
    } else {
        var newArray = [];
        for(var i = 1; i <= n && i <= array.length; i++) {
            newArray.unshift(array[array.length - i])
        }
        return newArray;
    }
};

                          ↓↓↓

// 위에서 for문을 사용했는데 장황한 느낌이 있어, 다시 수정했습니다..;;
function last_1(array, n) {
    if(n === undefined) {
        return array[array.length - 1];
    } else {
        return n === 0? []: array.slice(-n);
    }
};

// Underscore.js 소스코드
_.last = function(array, n, guard) {
  if (array == null) return void 0;
  if (n != null && !guard) {
    return slice.call(array, Math.max(array.length - n, 0));
  } else {
    return array[array.length - 1];
  }
};

// _.each 구현해보기
_.each = function(collection, iteratee) {
  if (Array.isArray(collection)) {
    for (var i = 0; i < collection.length; i++) {
      iteratee(collection[i], i, collection);
    }
  } else {
    for (var key in collection) {
      iteratee(collection[key], key, collection);
    }
  }
};

// _.indexOf 구현해보기
_.indexOf = function(array, target) {
  var indexValue = -1;
  for(var i = 0; i < array.length; i++) {
    if(array[i] === target) {
      return indexValue = i;
    }
  }
  return indexValue;
}

// 위와 같이 일반적인 for loop을 통해 indexOf를 구현할 수 있습니다.
// 밑의 코드는 위의 2번에서 작성한 _.each 함수를 이용해 보았습니다.

-.indexOf = function(array, target) {
  var indexValue = -1;
  _.each(array, functioin(current, index) {
    if(current === target) {
      return indexValue = index;
    }
  })
}

// _.filter 구현해보기
_.filter(list, testFunc) {
  var newArray = [];
  _.each(list, function(cur, x) {
    if(testFunc(cur, x)) {
      newArray.push(cur);
    }
  })
  return newArray;
}

_.reject(list, testFunc) {
  var newArray = [];
  var doNotInclude = _.filter(list, testFunc);
  _.each(list, function(cur) {
    if(!doNotInclude.includes(cur)) {
      newArray.push(cur);
    }
  });
  return newArray;
}

_.uniq = function(array) {
  return array.reduce(function(acc, cur) {
    if (acc.indexOf(cur) < 0) {
      acc.push(cur);
    }
    return acc;
  }, []);
};

//위의 _.each method를 사용하여 작성한 uniq
_.uniq = function(array) {
  var newArr = [];
  _.each(array, function(cur, index, context) {
    if (!newArr.includes(cur)) {
      newArr.push(cur);
    }
  });
  return newArr;
};

_.map = function(collection, callback) {
  var newArr = new Array();
  if (Array.isArray(collection)) {
    for (var i = 0; i < collection.length; i++) {
      newArr.push(callback(collection[i], i));
    }
  } else {
    for (var key in collection) {
      newArr.push(callback(collection[key], key));
    }
  }
  return newArr;
};

// 아래는 _.each()를 사용해 _.map() 작성해 보았습니다.
_.map = function(collection, callback) {
  var newArr = [];

  _.each(collection, function(current, indexOrKey) {
    newArr.push(callback(current, indexOrKey));
  });

  return newArr;
};

_.pluck = function(list, propertyName) {
  return _.map(list, function(current, index) {
    return current[propertyName];
  });
};

// _.map method를 사용하지 않고 구현해 보았습니다.
_.pluck = function(list, propertyName) {
  var newArr = [];
  if (Array.isArray(list)) {
    for (var i = 0; i < list.length; i++) {
      newArr.push(list[i][propertyName]);
    }
  }
  return newArr;
};

_.reduce = function(collection, callback, accumulator) {
  var result;

  if (Array.isArray(collection)) {
    if (accumulator === undefined) {
      accumulator = collection[0];

      for (var i = 1; i < collection.length; i++) {
        accumulator = iterator(accumulator, collection[i], i);
      }
    } else {
      for (var i = 0; i < collection.length; i++) {
        accumulator = iterator(accumulator, collection[i], i);
      }
    }
    return accumulator;
  }
};

_.reduce = function(collection, callback, accumulator) {

    else {

      var keyList = Object.keys(collection);

      if(accumulator === undefined) {

        accumulator = collection[keyList[0]];
        for(var i = 1; i < keyList.length; i++) {
          accumulator = callback(accumulator, collection[keyList[i]], i);
        }
      } else {
        for(var i = 0; i < keyList.length; i++) {
          accumulator = callback(accumulator, collection[keyList[i]], i);
        }
      }
      return accumulator;
    }
}

_.contains = function(list, target) {
  _.reduce(
    collection,
    function(wasFound, item) {
      if (wasFound) {
        return true;
      } else {
        return item === target;
      }
    },
    false
  );
};

_.contains = _.include = function(obj, target) {
  if (obj === null) {
    return false;
  }
  if (nativeIndexOf && obj.indexOf === nativeIndecOf) {
    return obj.IndexOf(target) !== -1;
  }
  // 여기서 nativeIndexOf는 변수이며, 값은 Array.prototype.indexOf 입니다.
  return any(obj, function(value) {
    return value === target;
  });
};

_.once = function(func) {
  var isFuncCalled = false;
  var result;

  return function(func) {
    if (!isFuncCalled) {
      isFuncCalled = true;
      result = func.apply(this, arguments);
      // apply는 함수의 인자를 배열로 전달 가능합니다.
      // 따라서, apply를 이용해 func 함수의 접근 가능한 정보를 전달해 함수 호출 시 이용할 수 있습니다.
    }

    return result;
    // 함수가 한 번 호출 후 boolean 값이 변경되기 때문에, 항상 같은 결과값을 반환해 줍니다.
  };
};

_.delay = function(func, wait) {
  // callback에 추가 인자를 전달하기 위해서, 첫 번째, 두 번째 인자를 제외한 인자를 배열로 변경해 줍니다.
  var args = Array.prototype.slice.call(arguments, 2);

  // apply method로 func 함수에 인자를 묶어줍니다. apply method는 즉시 실행되기 때문에 wrapper 함수를 사용해 return 값으로 지정을 해 줍니다.
  var callback = function() {
    return func.apply(null, args);
  };

  // setTimeout을 이용해 위의 callback을 정해진 시간 후 호출시킵니다.
  setTimeout(callback, wait);
};