underbar 함수

_.includes

_.includes = function (arr, target) {
  let result = false;
  _.each(arr, function(el){
    if(el === target) {
      result = true;
    }
  });
  return result;

_.includes = function (arr, target) {
  // return _.reduce(arr, function(acc, el) {
  //   if(el === target) { // 찾으려는 값이 ele와 같다면 누적값을 true로 할당한다.
  //     acc = true;
  //   }
  //   return acc; // true로 할당된 acc 리턴
  // },false) // 그게 아니면 초기값이었던 false 리턴
};

배열이 주어진 값을 포함하는지 확인한다.

_.every

_.every = function (arr, iteratee) {
  if(arr.length === 0) {
    return true;
  } // 빈배열일 경우 true 리턴

  let result = false; // result에 false로 선언 및 할당

  for(let el of arr) { // 배열에 요소를 순환한다.
    if(iteratee === undefined) { // iteratee가 안들어오면 배열안의 요소자체를 확인
      if(el === true) {  // 요소가 true이면 
        result = true; // result true 할당
      } else {
        return false; // 그게아니면 false리턴
      }
    } else if(iteratee(el)) { // iteratee가 들어오면 그 함수안에 요소가 인자로들어감
      result = true;  // 인자가 참일때 result true 할당
    } else { 
      return false; // 인자가 거짓일때 false 리턴
    }
  }
  return result; // for문 돌린 결과값 리턴
};

배열의 모든 요소가 test 함수(iteratee)를 통과하면 true를, 그렇지 않은 경우 false를 리턴한다.
(and와 비슷하다)

_.some

_.some = function (arr, iteratee) {
  if(arr.length === 0) {
    return false;
  } // 빈배열일 경우 false 리턴

  let result = true; // result에 true로 선언 및 할당

  for(let el of arr) { // 배열에 요소를 순환한다.
    if(iteratee === undefined) { // iteratee가 안들어오면 배열안의 요소자체를 확인
      if(el === true) {  // 요소가 true이면 
        return true; // true 리턴
      } else {
        result = false; // 그게아니면 result false 할당
      }
    } else if(iteratee(el)) { // iteratee가 들어오면 그 함수안에 요소가 인자로들어감
      return true;  // 인자가 참일때 true 리턴
    } else { 
      result = false; // 인자가 거짓일때 result false 할당
    }
  }
  return result; // for문 돌린 결과값 리턴
};

배열의 요소 중 하나라도 test 함수(iteratee)를 통과하면 true를, 그렇지 않은 경우 false를 리턴한다.
(or와 비슷하다.)

_.extend

_.extend = function (obj) {
   _.each(arguments, function(el){
     for(let key in el){
       obj[key] = el[key];
     }
   });
  return obj;
};

_.extend = function (obj, ...rest) {
  _.each(rest, function(item) {
    Object.assign(obj,item)
  });
  return obj;
}

_.extend = function(obj, ...objs) {
  _.each(objs, function(pro){
    _.each(pro, function(val, key) {
        obj[key] = val;
    });
  });
  return obj;
};

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

_.defaults

_.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;
  };

_.defaults = function(obj) {
  _.each(arguments, function(el){
    for(let key in el){
      if(!obj.hasOwnProperty(key)){
        obj[key] = el[key];
      }
    }
  });
  return obj;
};

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

_.zip

_.zip = function () {
  let arg = [...arguments];
  let max = Math.max(..._.map(arg, element => element.length))
  let result = [];

  for(let i = 0; i < max; i++ ) {
    result.push(_.pluck(arg, i));
  }
  return result;
};

_.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;
  };

배열의 각 인덱스를 요소들을 새로운 배열에 병합시켜 반환한다.
=> 최종적으로 리턴되는 배열의 각 요소의 길이는 입력으로 전달되는 배열 중 가장 긴 배열의 길이로 통일된다.

_.zipStrict

_.zipStrict = function () {
  let arg = [...arguments];
  let max = Math.min(..._.map(arg, element => element.length))
  let result = [];

  for(let i = 0; i < max; i++ ) {
    result.push(_.pluck(arg, i));
  }
  return result;
};

배열의 각 인덱스를 요소들을 새로운 배열에 병합시켜 반환한다.
=> 최종적으로 리턴되는 배열의 각 요소의 길이는 입력으로 전달되는 배열 중 가장 짧은 배열의 길이로 통일된다.

_.intersection

_.intersection = function (arr, ...arrs) {
  return _.filter(arr, function(el){
    let include = true
    _.each(arrs, function(arr){
      if (!_.includes(arr, el)){
        include = false
      }
    })
    if (include) {return el}
  })
};

여러 개의 배열을 입력받아, 교집합 배열을 리턴한다.

_.difference

_.difference = function (...arg) {
  let firstArr = arg[0];
  let newArr =[];
  let isExist = false;

  for(let i =0; i < firstArr.length; i++) {
    isExist = false;
    for(let j=1; j <arg.length; j++) {
      if(_.includes(arg[j],firstArr[i])) {
        isExist =true;
      }
    }
    if(!(isExist)) {
      newArr.push(firstArr[i])
    }
  }
  return newArr;
};

_.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;
    });
  };

여러 개의 배열을 입력받아, 차집합 배열을 리턴한다.

_.sortBy

_.sortBy = function (arr, transform, order) {
  if (transform === undefined) transform = _.identity;
  if (order === undefined) order = 1;

  arr = [...arr];

  arr.sort(function(a, b) {
    a = transform(a);
    b = transform(b);

    if (a > b) return 1 * order;
    if (a < b) return -1 * order;

    return 0;
  });
  return arr;
};

Collection 값들을 원하는 기준으로 정렬한다.

_.shuffle

_.shuffle = function (arr) {
  let arrCloned = arr.slice();
  for (let fromIdx = 0; fromIdx < arr.length; fromIdx++) {
    const toIdx = Math.floor(Math.random() * arr.length);
    // 아래 코드는 두 변수의 값을 교환한다.
    let temp = arrCloned[fromIdx];
    arrCloned[fromIdx] = arrCloned[toIdx];
    arrCloned[toIdx] = temp;
  }
  return arrCloned;
};

배열 요소의 순서가 랜덤하게 변경된 새로운 배열을 리턴한다.