Lodash工具库Array学习

一、Lodash了解

是一个一致性、模块化、高性能的 JavaScript 实用工具库。

二、Array方法学习

1_.chunk(array, [size=1])

将数组拆分成多个 size 长度的区块，并将这些区块组成一个新数组。 如果数组无法被分割成全部等长的区块，那么最后剩余的元素将组成一个区块。

var chunkArr = _.chunk(['a','b','c','d'],2);
console.log(chunkArr);

2_.compact(array)

创建一个新数组，包含原数组中所有的非假值元素。例如false, null, 0, “”, undefined, 和 NaN 都是被认为是“假值”。

var compactArr = _.compact([0,1,false,'',2]);
console.log(compactArr);

3_.difference(array, [values])

创建一个具有唯一array值的数组，每个值不包含在其他给定的数组中。（注：即创建一个新数组，这个数组中的值，为第一个数字（array 参数）排除了给定数组[values]中的值。）

var differenceArr = _.difference([1,4,6,8],[8]);
console.log(differenceArr);

4_.differenceBy(array, [values], [iteratee=_.identity])

这个方法类似_.difference ，除了它接受一个 iteratee （注：迭代器）， 调用array 和 values 中的每个元素以产生比较的标准。 结果值是从第一数组中选择。iteratee 会调用一个参数：(value)。（注：首先使用迭代器分别迭代array 和 values中的每个元素，返回的值作为比较值）。

var differenceByArr = _.differenceBy([1.5,4.2,6.1],[6.7],Math.floor);
console.log(differenceByArr);//向下取整后比较

5_.differenceWith(array, [values], [comparator])

这个方法类似_.difference ，除了它接受一个 comparator （注：比较器），它调用比较array，values中的元素。 结果值是从第一数组中选择。comparator 调用参数有两个：(arrVal, othVal)。

var arr1 = [{'x':1,'y':2},{'x':2,'y':1}];
var differenceWithArr = _.differenceWith(arr1,[{'x':1,'y':2}],_.isEqual);
console.log(differenceWithArr);//_.isEqual比较两个参数是否相等,可以比较其它

6_.drop(array, [n=1])

创建一个切片数组，去除array前面的n个元素。（n默认值为1。）

var dropArr = _.drop([1,3,5,7,9],2);
console.log(dropArr);

_.dropRight(array, [n=1])
创建一个切片数组，去除array尾部的n个元素。（n默认值为1。）

var dropRightArr = _.dropRight([1,3,5,7,9],2);
console.log(dropRightArr);

.dropWhile(array, [predicate=.identity])
创建一个切片数组，去除array中从起点开始到 predicate 返回假值结束部分。predicate 会传入3个参数： (value, index, array)。

var users = [{ 'user': 'barney',  'active': false },
             { 'user': 'fred',    'active': false },
             { 'user': 'pebbles', 'active': true }];
var dropWithArr = _.dropWhile(users, function(o) { return !o.active; });
console.log(dropWithArr);

.dropRightWhile(array, [predicate=.identity])
创建一个切片数组，去除array中从 predicate 返回假值开始到尾部的部分。predicate 会传入3个参数： (value, index, array)。

8_.take(array, [n=1])

创建一个数组切片，从array数组的起始元素开始提取n个元素。

var takeArr = _.take([1, 2, 3], 2);
console.log(takeArr);

9_.flatten(array)

减少一级array嵌套深度。

var flattenArr = _.flatten([1,[2,[3,[4]]]]);
console.log(flattenArr);

_.flattenDeep(array)
将array递归为一维数组。

var flattenDeepArr = _.flattenDeep([1,[2,[3,[4]]]]);
console.log(flattenDeepArr);

_.flattenDepth(array, [depth=1])
根据 depth 递归减少 array 的嵌套层级

10_.intersection([arrays])

创建唯一值的数组，这个数组包含所有给定数组都包含的元素，使用 SameValueZero进行相等性比较。（注：可以理解为给定数组的交集）

var intersectionArr = _.intersection([1,2],[2,3],[2,4]);
console.log(intersectionArr);

.intersectionBy([arrays], [iteratee=.identity])
这个方法类似 _.intersection，区别是它接受一个 iteratee 调用每一个arrays的每个值以产生一个值，通过产生的值进行了比较。结果值是从第一数组中选择。iteratee 会传入一个参数：(value)。

var intersectionByArr = _.intersectionBy([2.1, 1.2], [4.3, 2.4], Math.floor);
console.log(intersectionByArr);

_.intersectionWith([arrays], [comparator])
这个方法类似 _.intersection，区别是它接受一个 comparator 调用比较arrays中的元素。结果值是从第一数组中选择。comparator 会传入两个参数：(arrVal, othVal)。

var interArr1 = [{ 'x': 1, 'y': 2 }, { 'x': 2, 'y': 1 }];
var interArr2 = [{ 'x': 1, 'y': 1 }, { 'x': 1, 'y': 2 }];
var res = _.intersectionWith(interArr1, interArr2, _.isEqual);
console.log(res);

11_.union([arrays])

创建一个按顺序排列的唯一值的数组。所有给定数组的元素值使用SameValueZero做等值比较。（注： arrays（数组）的并集，按顺序返回，返回数组的元素是唯一的）

var unionArr = _.union([1,3,4],[2,3,5]);
console.log(unionArr);

.unionBy([arrays], [iteratee=.identity])
这个方法类似 _.union ，除了它接受一个 iteratee （迭代函数），调用每一个数组（array）的每个元素以产生唯一性计算的标准。iteratee 会传入一个参数：(value)。

_.unionBy([2.1], [1.2, 2.3], Math.floor);

_.unionWith([arrays], [comparator])
这个方法类似 _.union， 除了它接受一个 comparator 调用比较arrays数组的每一个元素。 comparator 调用时会传入2个参数： (arrVal, othVal)。

12_.xor([arrays])

创建一个给定数组唯一值的数组，使用symmetric difference做等值比较。返回值的顺序取决于他们数组的出现顺序。

var xorArr = _.xor([2, 1], [2, 3]);
console.log(xorArr);

.xorBy([arrays], [iteratee=.identity])
这个方法类似 _.xor ，除了它接受 iteratee（迭代器），这个迭代器 调用每一个 arrays（数组）的每一个值，以生成比较的新值。iteratee 调用一个参数： (value)。

_.xorWith([arrays], [comparator])
该方法是像 _.xor，除了它接受一个 comparator ，以调用比较数组的元素。 comparator 调用2个参数：(arrVal, othVal).

13_.nth(array, [n=0])

获取array数组的第n个元素。如果n为负数，则返回从数组结尾开始的第n个元素。

var nthArr = _.nth([1,2,3,4],2);//可负数，倒数
console.log(nthArr);//3

14_.remove(array, [predicate=_.identity])

移除数组中predicate（断言）返回为真值的所有元素，并返回移除元素组成的数组。predicate（断言） 会传入3个参数： (value, index, array)。

var removeArr = [1, 2, 3, 4];
var evens = _.remove(removeArr, function(value,index,array) {
  return index > 2;
});
console.log(evens,removeArr);

15_.without(array, [values])

创建一个剔除所有给定值的新数组，剔除值的时候，使用SameValueZero做相等比较。

var withoutArr = _.without([1,3,4,1],1,3);
console.log(withoutArr);

16_.uniq(array)

创建一个去重后的array数组副本。使用了 SameValueZero 做等值比较。只有第一次出现的元素才会被保留。

_.uniq([2, 1, 2]);//[1,2]

17_.zip([arrays])

创建一个分组元素的数组，数组的第一个元素包含所有给定数组的第一个元素，数组的第二个元素包含所有给定数组的第二个元素，以此类推。

var zipArr = _.zip(['fred', 'barney'], [30, 40], [true, false]);
console.log(zipArr);

_.zipObject([props=[]], [values=[]])
这个方法类似 _.fromPairs，除了它接受2个数组，第一个数组中的值作为属性标识符（属性名），第二个数组中的值作为相应的属性值。

var zipArr = _.zipObject(['a', 'b'], [1, 2]);;
console.log(zipArr);

.zipWith([arrays], [iteratee=.identity])
这个方法类似于_.zip，不同之处在于它接受一个 iteratee（迭代函数），来 指定分组的值应该如何被组合。 该iteratee调用每个组的元素： (…group).

var zipWithArr = _.zipWith([1, 2], [10, 20], [100, 200], function(a, b, c) {
  return a + b + c;
});;
console.log(zipWithArr);

18_.unzip(array)

这个方法类似于_.zip，除了它接收分组元素的数组，并且创建一个数组，分组元素到打包前的结构。（：返回数组的第一个元素包含所有的输入数组的第一元素，第一个元素包含了所有的输入数组的第二元素，依此类推。）

与zip方法相反，拆分数组