Home underscore
Post
Cancel

underscore

_.identity


1
2
3
  _.identity = function(val) {
    return val;
  };

_.identity는 인자를 그대로 반환 한다.

_.first


1
2
3
  _.first = function(array, n) {
    return n === undefined ? array[0] : array.slice(0, n);
  };

_.first는 배열의 처음 n개의 element를 담은 배열을 반환한다. 만일 n이 undefined일 경우, 단순히 첫번째 element를 반환한다.

_.last


1
2
3
4
5
6
7
8
9
  _.last = function(array, n) {
    if(n === undefined){
      return array[array.length-1];
    }else if(array.length <= n){
      return array;
    }else{
      return array.slice(array.length-n, array.length);
    }
  };

_.last는 마지막 n개의 element를 담은 배열을 반환한다. 만일 n이 undefined일 경우, 단순히 마지막 element를 반환한다.

_.each


1
2
3
4
5
6
7
8
9
10
11
  _.each = function(collection, iterator) {
    if(Array.isArray(collection)){
      for(let i=0; i < collection.length; i++){
        iterator(collection[i], i, collection)
      }
    }else if(typeof collection === 'object'){
      for(let key in collection){
        iterator(collection[key], key, collection)
      }
    }
  };

_.each는 각 요소에 iteratee를 적용한다.

_.indexOf


1
2
3
4
5
6
7
8
9
10
11
12
  _.indexOf = function(array, target) {
  
    var result = -1;

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

    return result;
  };
1
2
3
4
5
6
    for(let i=0; i < array.length; i++){
      if(array[i] === target){
        return i;
      }
    }
    return -1;

_.indexOf는 target으로 전달되는 값이 배열에서 발견되면, 그 index를 반환하고, 만일 배열에서 발견할 수 없다면 -1을 반환한다.

_.filter


1
2
3
4
5
6
7
8
9
  _.filter = function(collection, test) {
    var arr = [];
    for(let i=0; i < collection.length; i++){
      if(test(collection[i])){
        arr.push(collection[i]);
      }
    }
    return arr;
  };
1
2
3
4
5
6
7
8
9
  _.filter = function(collection, test) {
    var result = [];
    _.each(collection, function(el){
      if(test(el)){
        result.push(el);
      }
    })
    return result;
  };

_.filter는 테스트 함수를 통과하는 모든 element를 담은 배열을 반환한다.

_.reject


1
2
3
4
5
6
7
8
9
  _.reject = function(collection, test) {
    var arr = [];
    for(let i=0; i < collection.length; i++){
      if(!test(collection[i])){
        arr.push(collection[i]);
      }
    }
    return arr;
  };
1
2
3
4
5
  _.reject = function(collection, test) {
    return _.filter(collection, function(el){
      return !test(el);
    });
  };

_.reject는 테스트 함수를 통과하지 않는 모든 element를 담은 배열을 반환한다.

_.uniq


1
2
3
4
5
6
7
8
9
  _.uniq = function(array) {
    var result = [];
    for(let i=0; i < array.length; i++){
      if(_.indexOf(result, array[i]) === -1){
        result.push(array[i]);
      }
    }
    return result;
  };
1
2
3
4
5
6
7
8
9
  _.uniq = function(array) {
    var arr = [];
    _.each(array, function(el){
      if(_.indexOf(arr, el) === -1){
        arr.push(el);
      }
    });
    return arr;
  };
1
2
3
4
5
6
7
  _.uniq = function(array) {
    var obj = {};
    for(let i=0; i < array.length; i++){
      obj[array[i]] = array[i];
    }
    return Object.values(obj);
  };

_.uniq는 element가 중복되지 않는 새로운 배열을 만들어 반환한다.

_.map


1
2
3
4
5
6
7
  _.map = function(collection, iterator) {
    var result = [];
    for(let i=0; i < collection.length; i++){
      result.push(iterator(collection[i]));
    }
    return result;
  };
1
2
3
4
5
6
7
  _.map = function(collection, iterator) {
    var result = [];
    _.each(collection, function(el){
      result.push(iterator(el))
    });
    return result;
  };

_.map는 iterator를 각 element에 적용한 결과를 담은 새로운 배열을 반환한다.

_.pluck


1
2
3
4
5
  _.pluck = function(collection, key) {
    return _.map(collection, function(item) {
      return item[key];
    });
  };
1
2
3
4
5
6
7
  _.pluck = function(collection, key) {
    var result = [];
    _.each(collection, function(el){
      result.push(el[key]);
    })
    return result;
  };

_.pluck은 collection의 key값이 동일한 값들만을 모아 반환한다.

_.reduce


1
2
3
4
5
6
7
8
9
10
11
12
  _.reduce = function(collection, iterator, accumulator) {
    var index = 0;

    if(accumulator === undefined){
      accumulator = collection[0];
      index = 1;
    }
    for(let i=index; i < collection.length; i++){
      accumulator = iterator(accumulator, collection[i])
    }
    return accumulator;
  };
1
2
3
4
5
6
7
8
9
10
11
12
  _.reduce = function(collection, iterator, accumulator) {
    var slice = Array.prototype.slice;

    if(accumulator === undefined){
      accumulator = collection[0];
      collection = slice.call(collection,1);
    }
    _.each(collection, function(el){
      accumulator = iterator(accumulator, el);
    });
    return accumulator
  };

_.reduce는 입력받은 collection으로부터 iteratee의 내용이 무엇인지에 따라서 하나의 결과값을 반환한다. accumulator는 초기값으로, 이 accumulator가 주어지느냐, 주어지지않느냐의 두가지 경우로 나뉜다.

_.contains


1
2
3
4
5
6
7
  _.contains = function(collection, target) {
    for(let key in collection){
      if(collection[key] === target){
        return true;
      }
    }
    return false;
1
2
3
4
5
6
7
8
9
  _.contains = function(collection, target) {
    collection = Object.values(collection);
    return _.reduce(collection, function(wasFound, item) {
      if (wasFound) {
        return true;
      }
      return item === target;
    }, false);
  };
1
2
3
4
5
6
7
8
9
10
  _.contains = function(collection, target) {
    return _.reduce(collection, function(a, b){
      if(b===target){
        b = true;
      }else{
        b = false;
      }
      return Boolean(a+b);
    },false);
  };

_.contains는 배열 또는 객체가 주어진 값을 포함하는지 체크한다. collection에 target이 존재한다면 true, 그렇지 않다면 false를 반환한다.

_.every


1
2
3
4
5
6
7
8
9
10
11
  _.every = function(collection, iterator) {
    if(!iterator){
      iterator = _.identity;
    }
    for(let i=0; i < collection.length; i++){
      if(!iterator(collection[i])){
        return false;
      }
    }
    return true;
  };
1
2
3
4
5
6
7
8
9
10
11
12
  _.every = function(collection, iterator) {
    var result = true
    if(!iterator){
      iterator = _.identity;
    }
    _.each(collection,function(el){
      if(!iterator(el)){
        result = false;
      }
    });
    return result;
  };

_.every는 모든 element가 iterator에 의해 truthy한지 체크한다. collection의 모든 element들이 iterator의 조건이 만족해야만 true를 반환한다. 단 하나의 element라도 조건에 만족하지 못한다면 false를 반환한다.

_.some


1
2
3
4
5
6
7
8
  _.some = function(collection, iterator) {
    return !_.every(collection, function(el){
      if(typeof iterator !== 'function'){
        iterator = _.identity;
      }
      return !iterator(el);
    })
  };

_.some은 element가 하나라도 iterator에 의해 truthy한지 체크한다. collection의 element들 중 하나라도 iterator의 조건에 만족한다면 true를 반환한다.

_.extend


1
2
3
4
5
6
7
8
  _.extend = function(obj) {
    for(let i=0; i < arguments.length; i++){
      for(let key in arguments[i]){
        obj[key] = arguments[i][key];
      }
    }
    return obj;
  };
1
2
3
4
5
6
7
8
  _.extend = function(obj) {
    _.each(arguments, function(el){
      for(let key in el){
        obj[key] = el[key];
      }
    });
    return obj;
  };

_.extend 주어진 객체를 전달된 인자의 모든 속성으로 확장한다.

_.defaults


1
2
3
4
5
6
7
8
9
10
  _.defaults = function(obj) {
    for(let i=0; i<arguments.length; i++){
      for(let key in arguments[i]){
        if(!obj.hasOwnProperty(key)){
          obj[key] = arguments[i][key];
        }
      }
    }
    return obj;
  };
1
2
3
4
5
6
7
8
9
10
  _.defaults = function(obj) {
    _.each(arguments, function(el){
      for(let key in el){
        if(!obj.hasOwnProperty(key)){
          obj[key] = el[key];
        }
      }
    });
    return obj;
  };

_.defaults는 주어진 객체에 전달된 인자의 속성이 없다면 전달된 인자의 속성으로 확장한다.

_.once


1
2
3
4
5
6
7
8
9
10
11
12
13
14
_.once = function(func) {
    var alreadyCalled = false;
    var result;
    
    return function() {
      if (!alreadyCalled) {
    
        result = func.apply(this, arguments);
        alreadyCalled = true;
      }
      
      return result;
    };
  };

_.once는 최대 한번만 호출할 수 있는 함수를 반환한다. 이후의 호출은 이전에 한번 리턴된 값만을 반환해야한다.

_.delay


1
2
3
4
5
  _.delay = function(func, wait, ...args) {
    setTimeout(function(){
      func(...args);
    },wait);
  };

_.delay는 주어진 시간 동안 함수를 지연한 다음 제공된 argument로 함수를 호출한다.

_.flatten


1
2
3
4
5
6
7
8
9
10
11
12
  _.flatten = function(nestedArray, result) {
    var arr = [];
  
    for(let i=0; i< nestedArray.length; i++){
      if(!Array.isArray(nestedArray[i])){
        arr.push(nestedArray[i]);
      }else{
        arr = arr.concat(_.flatten(nestedArray[i]));
      }
    }
    return arr;
  };
1
2
3
4
5
6
7
8
9
10
11
  _.flatten = function(nestedArray, result) {
    var result = [];
    _.each(nestedArray, function(el){
      if(!Array.isArray(el)){
        result.push(el);
      }else{
        result = result.concat(_.flatten(el));
      }
    })
    return result;
  };

_.flatten는 다차원 배열을 가져와서, 1차원 배열로 변환한다. 새로운 배열에는 다차원 배열의 모든 요소가 포함되어야 한다.

_.shuffle


1
2
3
4
5
6
  _.shuffle = function(array) { 
    var arr = array.slice();
    return arr.sort(function(){
      return Math.random()-Math.random();
    });
  };

_.shuffle는 배열 내용의 순서를 랜덤하게 변경한다.

_.sortBy


1
2
3
4
5
6
7
8
9
10
11
  _.sortBy = function(collection, iterator) {
    if(typeof iterator === 'string'){
      return collection.sort(function(a, b){
        return a[iterator]- b[iterator];
      });
    }else{
      return collection.sort(function(a, b){
        return iterator(a)-iterator(b);
      })
    }
  };
1
2
3
4
5
6
7
8
9
10
11
12
13
  _.sortBy = function(collection, iterator) {
    var sort = Array.prototype.sort;

    if(typeof iterator === 'string'){
      return sort.call(collection, function(a, b){
        return a.length - b.length;
      })
    }else{
      return sort.call(collection,function(a, b){
        return iterator(a)-iterator(b);
      })
    }
  };

_.sortBy는 Collection 값들을 원하는 기준으로 정렬해준다.

_.throttle


1
2
3
4
5
6
7
8
9
10
11
  _.throttle = function(func, wait) {
    var result;
    return function(){
      if(!result){
        result = setTimeout(function(){
          func.apply(this, arguments);
          result=null;
        },wait);
      }
    }
  };

_.throttle는 마지막 함수가 호출된 후 일정 시간이 지나기 전에 다시 호출되지 않도록 하는 것

Debounce


1
2
3
4
5
6
7
8
9
function debounce(fn, wait) {
    var timer;
    return function() {
        clearTimeout(timer);
        timer = setTimeout(function(){
            fn.apply(this, arguments);
        }, wait);
    }
}

Debounce는 연이어 호출되는 함수들 중 마지막 함수(또는 제일 처음)만 호출하도록 하는 것.

_.invoke


1
2
3
4
5
6
7
8
9
10
11
12
13
  _.invoke = function(collection, functionOrKey, args) {
    var arr = [];
    if(typeof functionOrKey === 'string'){
      for(let i=0; i<collection.length; i++){
        arr.push(String.prototype[functionOrKey].apply(collection[i],args));
      }
    }else{
      for(let i=0; i<collection.length; i++){
        arr.push(functionOrKey.apply(collection[i], args));
      }
    }
    return arr
  };
1
2
3
4
5
6
7
8
9
10
11
12
13
  _.invoke = function(collection, functionOrKey, args) {
    var result = [];
    if(typeof functionOrKey === 'string'){
      _.each(collection, function(el){
        result.push(String.prototype[functionOrKey].apply(el, args))
      });
    }else{
      _.each(collection,function(el){
        result.push(functionOrKey.apply(el, args));
      });
    }
    return result;
  };

_.invoke는 배열에 functionOrKey을 적용시킨 뒤, 해당 배열을 리턴시킵니다.

_.zip


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
  _.zip = function() {
    var arr = [];
    for(let i=0; i < arguments.length; i++){
      arr.push(arguments[i].length);
    }
    var maxlength = Math.max.apply(null, arr);
    
    var result = [];
    for(let i=0; i < maxlength; i++){
      let newArr = [];
      for(let j=0; j < arguments.length; j++){
        if(arguments[j][i] === undefined){
          newArr.push(undefined);
        }else{
          newArr.push(arguments[j][i])
        }
      }
      result.push(newArr);
    }
    return result;
  };

_.zip은 배열의 각 인덱스를 요소들을 새로운 배열에 병합시켜 반환한다.

예)

1
  _.zip(['a','b','c','d'], [1,2,3]) returns [['a',1], ['b',2], ['c',3], ['d',undefined]]

_.intersection


1
2
3
4
5
6
7
8
9
10
11
  _.intersection = function() {
    var arr = [];
    for(let i=0; i < arguments[0].length; i++){
      for(let j=1; j < arguments.length; j++){
        if(arguments[0][i]===arguments[j][i]){
          arr.push(arguments[0][i]);
        }
      }
    }
    return arr;
  };
1
2
3
4
5
6
7
8
9
10
11
  _.intersection = function() {
    var arr = [];
    for(let i=0; i<arguments[0].length; i++){
      for(let j=1; j<arguments.length; j++){
        if(_.contains(arguments[j], arguments[0][i])){
          arr.push(arguments[0][i]);
        }
      }
    }
    return arr;
  };

_.intersection는 배열들의 교집합을 찾아 반환한다.

_.difference


1
2
3
4
5
6
7
8
9
10
11
12
  _.difference = function(array) {
    for(let i=0; i<arguments[0].length; i++){
      for(let j=1; j < arguments.length; j++){
        if(_.contains(arguments[j], arguments[0][i])){
          arguments[0][i]=false;
        }
      }
    }
    return _.filter(arguments[0],function(el){
      return el !== false;
    });
  };

_.difference배열들의 차집합을 찾아 반환한다.

_.memoize


1
2
3
4
5
6
7
8
9
10
11
12
13
  _.memoize = function(func) {
    var results = {};
    return function() {
      var args = Array.prototype.slice.call(arguments);
      var key = JSON.stringify(args);

      if (!(key in results)) {
        results[key] = func.apply(this, args);
      }

    return results[key];
    };
  };
This post is licensed under CC BY 4.0 by the author.