Lodash

Lodash-Array

Array

• _.chunk
  按照一定的长度将数组均匀切割成 chunk，将切割后的 chunk 组合成新数组，若不能均匀切割，最后剩下的元素组合成一个数组
  // _.chunk(array,[size=1]),array 表示将要切割的数组，size 表示每个 chunk 的长度,默认是1
  var a = _.chunk(['a','b','c','d','e'],2);
  console.log(a); // [['a','b'],['c','d'],['e']]

• _.compact
  创建一个不包含所有 falsey value 的数组，其中 false，null，0，""，undefined，NaN 是 falsey value。
  // _.compact(array),array 表示被处理的数组
  _.compact([0,1,false,2,'',3,undefined,4,NaN])
  // 输出 [1，2，3，4]

• _.concat
  将数组或者数值组合起来，创建一个新的数组，不会影响原来的数组
  // _.concat(array,[values]) 参数可以是任何数组或者数值
  var a = [1];
  var b = _.concat(a,2,[3],[[4]]);
  console.log(b);
  // => [1,2,3,[4]]
  console.log(a);
  // => [1]

• _.difference
  提取出左边数组和右边数组不一样的元素，返回一个新的数组
  // _.difference(array,[values]) array 表示要比较的数组， values 表示被比较的值，array 元素与 values 内的值相等则不输出
  var a = _.difference([1,2,3,4],[3,4,5,6]);
  // => [1,2]

• _.differenceBy？？
  类似于 _.difference 不过它会接受一个 iteratee ，iteratee 是引用数组的所有元素和 values 的内容，处理后再将它们进行比较（即比较的是处理过的元素），依旧以左边数组为基准 ，
  // .differenceBy(array,[values],[iteratee=.identity])
  var a = _.differenceBy([1.1,2.2,3.3],[2.3,3.4],Math.floor)
  // => [1.1]
  //因为 Math.floor 就是取整,比较的就是[1，2，3] 和 [2，3] ，所以输出 [1.1]

  var b = _.differenceBy([{ 'x': 1,'y':1 }, { 'x': 1,'y':2 },{'x':2,'y':1},{'x':2,'y':2}], [{ 'x': 1 },{ 'y': 1 }], 'x');
  // => [ { x: 2, y: 1 }, { x: 2, y: 2 } ] 
  // 此处以 x 为基础，只要 x 的值不同的就可以输出
  
  var c = _.differenceBy([{ 'x': 1,'y':1 }, { 'x': 1,'y':2 },{'x':2,'y':1},{'x':2,'y':2}], [{ 'x': 1 },{ 'y' : 1 }], 'y');
  // => [ { x: 1, y: 2 }, { x: 2, y: 2 } ]
  // 此处以 y 为基础，只要 y 的值不同就会输出,可以看到输出的都是 y 为2的元素
  

• _.differenceWith？？

• _.drop
  丢弃 N 个元素，从第一个元素开始算，创建一个新的数组
  // _.drop(array,[n=1]) array 表示被操作的数组，n 表示丢弃n个元素，默认为1
  _.drop([1,2,3]);
  // =>[2,3]
  _.drop([1,2,3,4],3);
  // => [4]
  _.drop([1,2,3,4],5);
  // => []
  _.frop([1,2,3,4],0);
  // => [1,2,3,4]

• _.dropRight
  丢弃N个元素，从最后一个元素开始算，创建一个新的数组
  // _.dropRight(array,[n=1])
  _.dropRight([1,2,3]);
  // => [1,2]
  _.dropRight([1,2,3,4,5],2);
  // => [1,2,3]
  _.dropRight([1,2,3],5);
  // => []
  _.dropRight([1,2,3],0);
  // => [1,2,3]

• _.dropRightWhile ？？
  从最后一个元素开始丢弃，元素将会被丢弃除非 predicate 返回 falsey，所以其实满足右边表达式的元素将会被丢弃。
  var a = [1,2,3,4,5];
  var b = _.dropRightWhile(user,function(item){return item >3})
  // => [1,2,3]
  // 由于右边的 function 输出 4，5 作为 values，而 user 需要跟右边的 values 进行比较，不同则输出，所以输出[1，2，3]

  var users = [
    {'user':'a','active':true},
    {'user':'b','active':false},
    {'user':'c','active':false}
  ]
  
  _.dropRightWhile(users,{'user':'a'});
  // => objects for ['b','c']
  _.dropRightWhile(users,{'user':'a'});
  

• _.dropWhile

  从第一个元素开始丢弃，其余同上
  

• .fill
  填充数组，该操作会直接改变数组
  //.fill(array,value,[start=0],[end=array.length])
  // array 表示被填充的数组,value 表示填充到数组的值
  // start 表示起始位置，默认为0，end 表示结束位置，默认为数组长度
  var array = [1,2,3]
  _.fill(array,'a');
  // => ['a','a','a'] 默认将从0到最后一个位置都填充为'a'

  _.fill(Array(3),2);
  // => [2,2,2] 解释同上
  
  _.fill([4,6,8,10],"*",1,3); 
  // => [4,'*','*',10] 下标从1-3，不包含3
  

• _.findIndex
  // .findIndex(array,[predicate=.identity,[fromIndex=0]])
  // array

• _findLastIndex