Lodash 4.1.6 API学习--Array

作者：Yeaseon

Lodash是一个具有一致接口、模块化、高性能等特性的 JavaScript 工具库。还有一个类似的库是underscore，不过underscore不能按需加载。
朋友说：这种工具库，平时都是先用先写的。
不过我觉得，还是很有必要学习一下的，看下源码的实现。
本文主要是对Lodash的API,用自己理解的方式做一下说明。可能理解有误，不过还是要记录下来，当再用的时候有据可查。

`_.chunk`

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

将数组进行分块，按照size指定的长度，默认长度1

`_.compact`

_.compact(array)

剔除数组中没有意义的值，比如false, null, 0, "", undefined 和 NaN

`_.concat`

_.concat(array, [values])

创建一个新的数组来保存原始数组，增加值/数组之后的结果

例子：

var array = [1];
var other = _.concat(array, 2, [3], [[4]]);
 
console.log(other);
// => [1, 2, 3, [4]]
 
console.log(array);
// => [1]

`_.difference`

_.difference(array, [values])

这个函数就比较复杂了，就想看一下源码，发现嵌套的函数太多。就投机取巧直接测试吧。这个函数，大概的作用就是将array和[values]进行比较，将array中比[values]中多出的值，保存到一个新的数组中。

例子：

//官网就比较敷衍了
_.difference([2, 1], [2, 3]);
// => [1]

//下面是我做的一些测试
_.difference([1, 1, "1", 2, 2], [1]);
// => ["1", 2, 2]
// 只要array中比[values]中多出的值，都会返回，不管个数出现了几次

`_.differenceBy`

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

这个方法就是在_.difference方法的基础上，增加了一个参数。反正是看了一会，才看明白这个第三个参数，怎么工作的。

例子：

_.differenceBy([2.1, 1.2], [2.3, 3.4], Math.floor);
// => [1.2]
 
// The `_.property` iteratee shorthand.
_.differenceBy([{ 'x': 2 }, { 'x': 1 }], [{ 'x': 1 }], 'x');
// => [{ 'x': 2 }]

第一个官方例子，就是看了半天没看懂。我以为是先_.difference在对得到的结果进行Math.floor运算，其实是想错了。如果这么工作的话，就没必要设计_.differenceBy了，直接用_.difference.xx()就可以，所以我一开始的想当然是有问题的。
正确地工作步骤是，对前两个参数，分别执行第三个参数过滤，然后再比较找出array中比[values]中多出的部分，然后返回这些多余部分的原始值的一个数组。
就拿第一个说吧，执行过滤之后是[2,1]和[2,3]，应该是返回[1]的原始值[1.2]，就酱。

`_.differenceWith`

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

没太看懂。。。

`_.drop`

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

我理解的是抛弃前n个数组元素，返回剩下的数组元素，默认抛弃第一个。

例子：

_.drop([1, 2, 3]);
// => [2, 3]
 
_.drop([1, 2, 3], 2);
// => [3]
 
_.drop([1, 2, 3], 5);
// => []
 
_.drop([1, 2, 3], 0);
// => [1, 2, 3]

`_.dropRight`

_.dropRight(array, [n=1])

_.dropRight和_.drop功能是一样的，就是_.drop是从后往前抛弃n个数组元素，默认抛弃最后一个。

例子：

_.dropRight([1, 2, 3]);
// => [1, 2]
 
_.dropRight([1, 2, 3], 2);
// => [1]
 
_.dropRight([1, 2, 3], 5);
// => []
 
_.dropRight([1, 2, 3], 0);
// => [1, 2, 3]

`_.dropRightWhile`

_.dropRightWhile(array, [predicate=_.identity])

从尾端查询数组array，第一个不满足predicate条件的元素开始截取数组。
参数predicate提供的是一个属性名称，就通过提供的参数使用_.property方法返回一个回调函数。
参数predicate提供的是一个对象，就用_.matches方法匹配相同的元素，相同返回true，不同返回false。
参数predicate也可以提供一个函数，该函数有三个参数value, index, array

_.dropRightWhile这个函数还牵扯到另外两个函数，_.property和_.matches。

例子：

var users = [
  { 'user': 'barney',  'active': true },
  { 'user': 'fred',    'active': false },
  { 'user': 'pebbles', 'active': false }
];
 
_.dropRightWhile(users, function(o) { return !o.active; });
// => objects for ['barney']
 
// The `_.matches` iteratee shorthand.
_.dropRightWhile(users, { 'user': 'pebbles', 'active': false });
// => objects for ['barney', 'fred']
 
// The `_.matchesProperty` iteratee shorthand.
_.dropRightWhile(users, ['active', false]);
// => objects for ['barney']
 
// The `_.property` iteratee shorthand.
_.dropRightWhile(users, 'active');
// => objects for ['barney', 'fred', 'pebbles']

`_.dropWhile`

_.dropWhile(array, [predicate=_.identity])

这个方法与上面_.dropRightWhile不同之处，是从数组的首端开始查询。

`_.fill`

_.fill(array, value, [start=0], [end=array.length])

将value填充到array中，start默认为0，end默认为array.length。这个就比较好理解了。

例子：

var array = [1, 2, 3];
 
_.fill(array, 'a');
console.log(array);
// => ['a', 'a', 'a']
 
_.fill(Array(3), 2);
// => [2, 2, 2]
 
_.fill([4, 6, 8, 10], '*', 1, 3);
// => [4, '*', '*', 10]

`_.findIndex`

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

返回满足predicate条件的一个array数组的index，也可以指定从哪里开始查询，没找到满足条件的返回-1

例子：

var users = [
  { 'user': 'barney',  'active': false },
  { 'user': 'fred',    'active': false },
  { 'user': 'pebbles', 'active': true }
];
 
_.findIndex(users, function(o) { return o.user == 'barney'; });
// => 0
 
// The `_.matches` iteratee shorthand.
_.findIndex(users, { 'user': 'fred', 'active': false });
// => 1
 
// The `_.matchesProperty` iteratee shorthand.
_.findIndex(users, ['active', false]);
// => 0
 
// The `_.property` iteratee shorthand.
_.findIndex(users, 'active');
// => 2

`_.findLastIndex`

_.findLastIndex(array, [predicate=_.identity], [fromIndex=array.length -1])

和_.findIndex基本相同，不过_.findLastIndex是从尾部往首部开始查找。

例子：

var users = [
  { 'user': 'barney',  'active': true },
  { 'user': 'fred',    'active': false },
  { 'user': 'pebbles', 'active': false }
];
 
_.findLastIndex(users, function(o) { return o.user == 'pebbles'; });
// => 2
 
// The `_.matches` iteratee shorthand.
_.findLastIndex(users, { 'user': 'barney', 'active': true });
// => 0
 
// The `_.matchesProperty` iteratee shorthand.
_.findLastIndex(users, ['active', false]);
// => 2
 
// The `_.property` iteratee shorthand.
_.findLastIndex(users, 'active');
// => 0

`_.flatten`

_.flatten(array)

这个函数的作用是将array减少一个维度。

例子：

_.flatten([1, [2, [3, [4]], 5]]);
// => [1, 2, [3, [4]], 5]

`_.flattenDeep`

_.flattenDeep(array)

相当于递归执行_.flatten，最终将array变成一维数组。

例子：

_.flattenDeep([1, [2, [3, [4]], 5]]);
// => [1, 2, 3, 4, 5]

`_.flattenDepth`

_.flattenDepth(array, [depth=1])

相当于指定执行_.flattenDepth``depth次，默认depth为1。

例子：

var array = [1, [2, [3, [4]], 5]];
 
_.flattenDepth(array, 1);
// => [1, 2, [3, [4]], 5]
 
_.flattenDepth(array, 2);
// => [1, 2, 3, [4], 5]

`_.fromPairs`

_.fromPairs(pairs)

将pairs键值对转换成一个对象。

例子：

_.fromPairs([['a', 1], ['b', 2]]);
// => { 'a': 1, 'b': 2 }

_.fromPairs([['a', 1], ['b', 2], ['c', ['d', 4]]]);
// => { 'a': 1, 'b': 2, 'c': [ 'd', 4 ] }

`_.head`

_.head(array)

返回array的第一个元素，别名_.first

例子：

_.head([1, 2, 3]);
// => 1
 
_.head([]);
// => undefined

_.head([[1, 4], 2, 3]);
// => [1, 4]

`_.last`

_.last(array)

返回array的最后一个元素。

例子：

_.last([1, 2, 3]);
// => 3

`_.nth`

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

获取指定index的array数组元素。

例子：

var array = ['a', 'b', 'c', 'd'];
 
_.nth(array, 1);
// => 'b'
 
_.nth(array, -2);
// => 'c';

`_.tail`

_.tail(array)

返回去除第一个元素的数组。

例子：

_.tail([1, 2, 3]);
// => [2, 3]

`_.indexOf`

_.indexOf(array, value, [fromIndex=0])

在array中查找value，返回找到的第一个匹配的index，没找到则返回-1，第三个参数fromIndex指定查找的起始位置，默认为0；

例子：

_.indexOf([1, 2, 1, 2], 2);
// => 1

_.indexOf([1, 2, 1, 2], 3);
// => -1
 
// Search from the `fromIndex`.
_.indexOf([1, 2, 1, 2], 2, 2);
// => 3

`_.lastIndexOf`

_.lastIndexOf(array, value, [fromIndex=array.length-1])

和_.indexOf方法一样，不过是从尾部开始查找。

例子：

_.lastIndexOf([1, 2, 1, 2], 2);
// => 3
 
// Search from the `fromIndex`.
_.lastIndexOf([1, 2, 1, 2], 2, 2);
// => 1

`_.initial`

_.initial(array)

去除array最后一个元素，并返回。

例子：

_.initial([1, 2, 3]);
// => [1, 2]

_.initial([1, 2, 3, [4, 5]]);
// => [1, 2, 3]

`_.intersection`

_.intersection([arrays])

取出各数组中全等的元素，使用SameValueZero方式平等比较。

例子：

_.intersection([2, 1], [2, 3]);
// => [2]

_.intersection([1, 2], [4, 2], [2, 1]);
// => [2]

`_.intersectionBy`

_.intersectionBy([arrays], [iteratee=_.identity])

_.intersectionBy就是在_.intersection的基础上接受了一个iteratee迭代器，生成了一个比较的标准，类似于_.differenceBy。

例子：

_.intersectionBy([2.1, 1.2], [2.3, 3.4], Math.floor);
// => [2.1]
 
// The `_.property` iteratee shorthand.
_.intersectionBy([{ 'x': 1 }], [{ 'x': 2 }, { 'x': 1 }], 'x');
// => [{ 'x': 1 }]

`_.intersectionWith`

_.intersectionWith([arrays], [comparator])

这个函数和_.differenceWith差不多，一样没太看懂。
先略过。

`_.join`

_.join(array, [separator=','])

将array转换成字符串类型并通过separator分隔开，默认使用,分隔。

例子：

_.join(['a', 'b', 'c'], '~');
// => 'a~b~c'

_.join(['a', 'b', 'c', ['d', 'e']], '-');
// => 'a-b-c-d,e'

`_.pull`

_.pull(array, [values])

移除array中所有的指定values，需要注意的是这个函数会对原始array做修改。

例子：

var array = ['a', 'b', 'c', 'a', 'b', 'c'];
 
_.pull(array, 'a', 'c');
console.log(array);
// => ['b', 'b']

`_.pullAll`

_.pullAll(array, values)

_.pullAll方法应该是_.pull方法的升级，这个方法是在Lodash 4.0.0中提出的。

例子：

var array = ['a', 'b', 'c', 'a', 'b', 'c'];
 
_.pullAll(array, ['a', 'c']);
console.log(array);
// => ['b', 'b']

`_.pullAllBy`

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

_.pullAllBy方法很像_.pullAll方法，除了可以接受一个迭代器iteratee，为每一个数组元素执行迭代器并生成一个比较的标准，这个迭代器调用一个参数value。
注：原始数组改变

例子：

var array1 = [{ 'x': 1 }, { 'x': 2 }, { 'x': 3 }, { 'x': 1 }];
 
_.pullAllBy(array1, [{ 'x': 1 }, { 'x': 3 }], 'x');
console.log(array);
// => [{ 'x': 2 }]

var array2 = [{ 'x': 1 }, { 'x': 2 }, { 'x': 3 }, { 'x': 1 }, { 'y': 4}];
 
_.pullAllBy(array, [{ 'x': 1 }], 'y');
console.log(array);
// => [{ 'y': 4 }]

`_.pullAllWith`

_.pullAllWith(array, values, [comoarator])

这个跳过。。。

`_.pullAt`

_.pullAt(array, [indexes])

移除相应index的元素，返回被移除元素的数组。
注：原始数组改变

例子：

var array = ['a', 'b', 'c', 'd'];
var pulled = _.pullAt(array, [1, 3]);
 
console.log(array);
// => ['a', 'c']
 
console.log(pulled);
// => ['b', 'd']

`_.remove`

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

移除所有predicate返回真的数组元素，并返回被移除的数组元素。predicate调用三个参数value, index, array。

例子：

var array = [1, 2, 3, 4];
var evens = _.remove(array, function(n) {
  return n % 2 == 0;
});
 
console.log(array);
// => [1, 3]
 
console.log(evens);
// => [2, 4]

`_.reverse`

_.reverse(array)

这个就比较简单了，是一个反序排列的方法，也会对原始方法进行更改

例子：

var array = [1, 2, 3];
 
_.reverse(array);
// => [3, 2, 1]
 
console.log(array);
// => [3, 2, 1]

`_.slice`

_.slice(array, [start=0], [end=array.length])

对数组进行分割。

例子：

var array = [1, 2, 3];
 
_.slice(array, 1, 2);
// => [2]

`_.sortedIndex`

_.sortedIndex(array, value)
向一个有序数组中插入一个value，将返回这个值插入之后的有序位置。（使用二分查找）

例子：

_.sortedIndex([30, 50], 40);
// => 1

_.sortedIndex([30, 50], 30);
// => 0

`_.sortedIndexBy`

_.sortedIndexBy(array, value, [iteratee=_.identity])

凡是带By的方法方法，都是这种结构的函数。
_.sortIndexBy比_.sortIndex方法多一个参数，接收一个迭代器iteratee去计算排序，这个iteratee调用一个参数value。

例子：

var objects = [{ 'x': 4 }, { 'x': 5 }];
 
_.sortedIndexBy(objects, { 'x': 4 }, function(o) { return o.x; });
// => 0
 
// The `_.property` iteratee shorthand.
_.sortedIndexBy(objects, { 'x': 4 }, 'x');
// => 0

`_.sortedIndexOf`

_.sortedIndexOf(array, value)

这个方法很像_.indexOf，_.sortedIndexOf是对一个有序数组进行二分查找。

例子：

_.sortedIndexOf([4, 5, 5, 5, 6], 5);
// => 1

`_.sortedLastIndex`

_.sortedLastIndex(array, value)

这个方法很像_.sortedIndex，这个方法在保持有序的前提下会把value插进最大的那个位置。

例子：

_.sortedLastIndex([4, 5, 5, 5, 6], 5);
// => 4

`_.sortedLastIndexBy`

_.sortedLastIndexBy(array, value, [iteratee=_.identity])

这个方法很像_.sortedLastIndex，只不过多了一个参数iteratee,这个迭代器为每个元素值计算他们的排序，这个迭代器调用一个参数value。返回应该被插入后的数组下标。

例子：

var objects = [{ 'x': 4 }, { 'x': 5 }];
 
_.sortedLastIndexBy(objects, { 'x': 4 }, function(o) { return o.x; });
// => 1
 
// The `_.property` iteratee shorthand.
_.sortedLastIndexBy(objects, { 'x': 4 }, 'x');
// => 1

`_.sortedLastIndexOf`

_.sortedLastIndexOf(array, value)

这个方法很像_.lastIndexOf，只不过它对一个有序数组进行二分查找。

例子：

_.sortedLastIndexOf([4, 5, 5, 5, 6], 5);
// => 3

`_.sortedUniq`

_.sortedUniq(array)

这个方法很像_.uniq，这个方法是为了有序数组设计且优化的，返回一个去重的数组。

例子：

_.sortedUniq([1, 1, 2]);
// => [1, 2]

`_.sortedUniqBy`

_.sortedUniqBy(array, [iteratee])

这个方法很像_.uniqBy，它返回经过iteratee计算之后，去除重复值，只返回重复值的第一个原值和不重复值组成的有序数组。

例子：

_.sortedUniqBy([1.1, 1.2, 2.3, 2.4], Math.floor);
// => [1.1, 2.3]

`_.take`

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

创建一个分割后的数组，从array数组的开始到第n个元素。

例子：

_.take([1, 2, 3]);
// => [1]
 
_.take([1, 2, 3], 2);
// => [1, 2]
 
_.take([1, 2, 3], 5);
// => [1, 2, 3]
 
_.take([1, 2, 3], 0);
// => []

`_.takeRight`

_.takeRight(array, [n=1])

创建一个分割后的数组，从array数组的结尾开始，分割n个元素出来。

例子：

_.takeRight([1, 2, 3]);
// => [3]
 
_.takeRight([1, 2, 3], 2);
// => [2, 3]
 
_.takeRight([1, 2, 3], 5);
// => [1, 2, 3]
 
_.takeRight([1, 2, 3], 0);
// => []

`_.takeRightWhile`

_.takeRightWhile(array, [predicate=_.identity])

同样是从array结尾开始分割数组，不过是通过predicate控制，直到返回falsey停止。predicate调用三个参数value, index, array

例子：

var users = [
  { 'user': 'barney',  'active': true },
  { 'user': 'fred',    'active': false },
  { 'user': 'pebbles', 'active': false }
];
 
_.takeRightWhile(users, function(o) { return !o.active; });
// => objects for ['fred', 'pebbles']
 
// The `_.matches` iteratee shorthand.
_.takeRightWhile(users, { 'user': 'pebbles', 'active': false });
// => objects for ['pebbles']
 
// The `_.matchesProperty` iteratee shorthand.
_.takeRightWhile(users, ['active', false]);
// => objects for ['fred', 'pebbles']
 
// The `_.property` iteratee shorthand.
_.takeRightWhile(users, 'active');
// => []

`_.takeWhile`

_.takeWhile(array, [predivate=_.identity])

是从array开头开始分割数组，不过是通过predicate控制，直到返回falsey停止。predicate调用三个参数value, index, array

例子：

var users = [
  { 'user': 'barney',  'active': false },
  { 'user': 'fred',    'active': false},
  { 'user': 'pebbles', 'active': true }
];
 
_.takeWhile(users, function(o) { return !o.active; });
// => objects for ['barney', 'fred']
 
// The `_.matches` iteratee shorthand.
_.takeWhile(users, { 'user': 'barney', 'active': false });
// => objects for ['barney']
 
// The `_.matchesProperty` iteratee shorthand.
_.takeWhile(users, ['active', false]);
// => objects for ['barney', 'fred']
 
// The `_.property` iteratee shorthand.
_.takeWhile(users, 'active');
// => []

`_.union`

_.union([arrays])

创建一个没有重复值的数组，组合所有被传入的数组元素。

例子：

_.union([2], [1, 2]);
// => [2, 1]

`_.unionBy`

_.unionBy([arrays], [iteratee=_.identity])

通过iteratee对每个元素值进行执行，生成一个唯一性的标准，并选择第一个出现的值，作为要返回的值，去除重复的元素。iteratee调用一个参数value。

例子：

_.unionBy([2.1], [1.2, 2.3], Math.floor);
// => [2.1, 1.2]
 
// The `_.property` iteratee shorthand.
_.unionBy([{ 'x': 1 }], [{ 'x': 2 }, { 'x': 1 }], 'x');
// => [{ 'x': 1 }, { 'x': 2 }]

`_.unionWith`

_.unionWith([arrays], [comparator])

这个没太看懂。。。

例子：

var objects = [{ 'x': 1, 'y': 2 }, { 'x': 2, 'y': 1 }];
var others = [{ 'x': 1, 'y': 1 }, { 'x': 1, 'y': 2 }];
 
_.unionWith(objects, others, _.isEqual);
// => [{ 'x': 1, 'y': 2 }, { 'x': 2, 'y': 1 }, { 'x': 1, 'y': 1 }]

`_.uniq`

_.uniq(array)

数组去重。

例子：

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

`_.uniqBy`

_.uniqBy(array, [iteratee=_.identity])

这个方法是有条件的数组去重，通过iteratee迭代器生成一个唯一性的标准。iteratee调用一个参数value.

例子：

_.uniqBy([2.1, 1.2, 2.3], Math.floor);
// => [2.1, 1.2]
 
// The `_.property` iteratee shorthand.
_.uniqBy([{ 'x': 1 }, { 'x': 2 }, { 'x': 1 }], 'x');
// => [{ 'x': 1 }, { 'x': 2 }]

`_.uniqWith`

_.uniqWith(array, [comparator])

没太分清_.uniqWith和_.uniqBy之间有什么区别。_.uniqWith传入的是一个比较器。comparator调用两个参数arrVal, othVal。

例子：

var objects = [{ 'x': 1, 'y': 2 }, { 'x': 2, 'y': 1 }, { 'x': 1, 'y': 2 }];
 
_.uniqWith(objects, _.isEqual);
// => [{ 'x': 1, 'y': 2 }, { 'x': 2, 'y': 1 }]

`_.without`

_.without(array, [values])

创建一个新的数组，去除所有传入的values。

例子：

_.without([2, 1, 2, 3], 1, 2);
// => [3]

`_.xor`

_.xor([arrays])

xor就是异或，相同为0，不同为1，1为true，应该被返回。
创建一个唯一值的数组，返回被给数组之间对称差（没有交集的部分）的元素。结果值的顺序由它们在数组中出现的顺序确定。

例子：

_.xor([2, 1, 4], [2, 3, 5]);
// => [1, 4, 3, 5]

_.xor([2, 2, 3], [4, 4, 5, 6]);
// => [2, 3, 4, 5, 6]

`_.xorBy`

_.xorBy([arrays], [iteratee=_.identity])

有条件的_.xor方法，和所有_.xxBy方法一样，接收一个iteratee方法生成一个标准，iteratee接受一个参数value。

例子：

_.xorBy([2.1, 1.2], [2.3, 3.4], Math.floor);
// => [1.2, 3.4]
 
// The `_.property` iteratee shorthand.
_.xorBy([{ 'x': 1 }], [{ 'x': 2 }, { 'x': 1 }], 'x');
// => [{ 'x': 2 }]

`_.xorWith`

_.xorWith([arrays], [comparator])

这个方法类似于_.xor，除了它接受比较器comparator，它被调用来比较数组的元素。结果值的顺序由它们在数组中出现的顺序确定。comparator调用两个参数arrVal，othVal。

例子：

var objects = [{ 'x': 1, 'y': 2 }, { 'x': 2, 'y': 1 }];
var others = [{ 'x': 1, 'y': 1 }, { 'x': 1, 'y': 2 }];
 
_.xorWith(objects, others, _.isEqual);
// => [{ 'x': 2, 'y': 1 }, { 'x': 1, 'y': 1 }]

`_.zip`

_.zip([arrays])

创建一个元素组数组，把每个传入数组，第一个元素组合到一起，第二个元素组合在一起，以此类推。

例子：

_.zip(['a', 'b'], [1, 2], [true, false]);
// => [['a', 1, true], ['b', 2, false]]

_.zip(['a', 'b'], [1], [true, false]);
// => [['a', 1, true], ['b', undefined, false]]

`_.unzip`

_.unzip(array)

就是把_.zip函数打包好的，或是元素组数组，对其进行解包。

例子：

var zipped = _.zip(['a', 'b'], [1, 2], [true, false]);
// => [['a', 1, true], ['b', 2, false]]
 
_.unzip(zipped);
// => [['a', 'b'], [1, 2], [true, false]]

`_.zipObject`

_.zipObject([props=[]], [values=[]])

这个方法很像_.fromPairs，_.zipObject接受两个数组，一个属性数组和一个相应的对应值数组。

例子：

_.zipObject(['a', 'b'], [1, 2]);
// => { 'a': 1, 'b': 2 }

_.zipObject(['a', 'b'], [1]);
// => { 'a': 1, 'b': undefined }

`_.zipObjectDeep`

`_.zipObjectDeep([props=[]], [values=[]])

这个方法像_.zipObject方法一样，不过它支持属性路径property paths

例子：

_.zipObjectDeep(['a.b[0].c', 'a.b[1].d'], [1, 2]);
// => { 'a': { 'b': [{ 'c': 1 }, { 'd': 2 }] } }

`_.zipWith`

_.zipWith([arrays], [iteratee=_.identity])

这个方法像类似_.zip，接受一个迭代器iteratee去指定怎么如何组合分组值。这个迭代器为每个组的元素调用...group，还是看例子比较直观。

例子：

_.zipWith([1, 2], [10, 20], [100, 200], function(a, b, c) {
  return a + b + c;
});
// => [111, 222]

`_.unzipWith`

_.unzipWith(array, [iteratee=_.identity])

这个方法很像_.unzip，它接受一个迭代器iteratee去指定怎样重组组合值。iteratee调用一个参数...group。

例子：

var zipped = _.zip([1, 2], [10, 20], [100, 200]);
// => [[1, 10, 100], [2, 20, 200]]
 
_.unzipWith(zipped, _.add);
// => [3, 30, 300]

最后编辑于：2017.12.04 07:47:15

人面猴
序言：七十年代末，一起剥皮案震惊了整个滨河市，随后出现的几起案子，更是在滨河造成了极大的恐慌，老刑警刘岩，带你破解...
沈念sama阅读 203,362评论 5赞 477
死咒
序言：滨河连续发生了三起死亡事件，死亡现场离奇诡异，居然都是意外死亡，警方通过查阅死者的电脑和手机，发现死者居然都...
沈念sama阅读 85,330评论 2赞 381
救了他两次的神仙让他今天三更去死
文/潘晓璐我一进店门，熙熙楼的掌柜王于贵愁眉苦脸地迎上来，“玉大人，你说我怎么就摊上这事。” “怎么了？”我有些...
开封第一讲书人阅读 150,247评论 0赞 337
道士缉凶录：失踪的卖姜人
文/不坏的土叔我叫张陵，是天一观的道长。经常有香客问我，道长，这世上最难降的妖魔是什么？我笑而不...
开封第一讲书人阅读 54,560评论 1赞 273
港岛之恋（遗憾婚礼）
正文为了忘掉前任，我火速办了婚礼，结果婚礼上，老公的妹妹穿的比我还像新娘。我一直安慰自己，他们只是感情好，可当我...
茶点故事阅读 63,580评论 5赞 365
恶毒庶女顶嫁案：这布局不是一般人想出来的
文/花漫我一把揭开白布。她就那样静静地躺着，像睡着了一般。火红的嫁衣衬着肌肤如雪。梳的纹丝不乱的头发上，一...
开封第一讲书人阅读 48,569评论 1赞 281
城市分裂传说
那天，我揣着相机与录音，去河边找鬼。笑死，一个胖子当着我的面吹牛，可吹牛的内容都是我干的。我是一名探鬼主播，决...
沈念sama阅读 37,929评论 3赞 395
双鸳鸯连环套：你想象不到人心有多黑
文/苍兰香墨我猛地睁开眼，长吁一口气：“原来是场噩梦啊……” “哼！你这毒妇竟也来了？” 一声冷哼从身侧响起，我...
开封第一讲书人阅读 36,587评论 0赞 258
万荣杀人案实录
序言：老挝万荣一对情侣失踪，失踪者是张志新（化名）和其女友刘颖，没想到半个月后，有当地人在树林里发现了一具尸体，经...
沈念sama阅读 40,840评论 1赞 297
护林员之死
正文独居荒郊野岭守林人离奇死亡，尸身上长有42处带血的脓包…… 初始之章·张勋以下内容为张勋视角年9月15日...
茶点故事阅读 35,596评论 2赞 321
白月光启示录
正文我和宋清朗相恋三年，在试婚纱的时候发现自己被绿了。大学时的朋友给我发了我未婚夫和他白月光在一起吃饭的照片。...
茶点故事阅读 37,678评论 1赞 329
活死人
序言：一个原本活蹦乱跳的男人离奇死亡，死状恐怖，灵堂内的尸体忽然破棺而出，到底是诈尸还是另有隐情，我是刑警宁泽，带...
沈念sama阅读 33,366评论 4赞 318
日本核电站爆炸内幕
正文年R本政府宣布，位于F岛的核电站，受9级特大地震影响，放射性物质发生泄漏。R本人自食恶果不足惜，却给世界环境...
茶点故事阅读 38,945评论 3赞 307
男人毒药：我在死后第九天来索命
文/蒙蒙一、第九天我趴在偏房一处隐蔽的房顶上张望。院中可真热闹，春花似锦、人声如沸。这庄子的主人今日做“春日...
开封第一讲书人阅读 29,929评论 0赞 19
一桩弑父案，背后竟有这般阴谋
文/苍兰香墨我抬头看了看天上的太阳。三九已至，却和暖如春，着一层夹袄步出监牢的瞬间，已是汗流浃背。一阵脚步声响...
开封第一讲书人阅读 31,165评论 1赞 259
情欲美人皮
我被黑心中介骗来泰国打工，没想到刚下飞机就差点儿被人妖公主榨干…… 1. 我叫王不留，地道东北人。一个月前我还...
沈念sama阅读 43,271评论 2赞 349
代替公主和亲
正文我出身青楼，却偏偏与公主长得像，于是被迫代替她去往敌国和亲。传闻我的和亲对象是个残疾皇子，可洞房花烛夜当晚...
茶点故事阅读 42,403评论 2赞 342

Lodash 4.1.6 API学习--Array

_.chunk

_.compact

_.concat

_.difference

_.differenceBy

_.differenceWith

_.drop

_.dropRight

_.dropRightWhile

_.dropWhile

_.fill

_.findIndex

_.findLastIndex

_.flatten

_.flattenDeep

_.flattenDepth

_.fromPairs

_.head

_.last

_.nth

_.tail

_.indexOf

_.lastIndexOf

_.initial

_.intersection

_.intersectionBy

_.intersectionWith

_.join

_.pull

_.pullAll

_.pullAllBy

_.pullAllWith

_.pullAt

_.remove

_.reverse

_.slice

_.sortedIndex

_.sortedIndexBy

_.sortedIndexOf

_.sortedLastIndex

_.sortedLastIndexBy

_.sortedLastIndexOf

_.sortedUniq

_.sortedUniqBy

_.take

_.takeRight

_.takeRightWhile

_.takeWhile

_.union

_.unionBy

_.unionWith

_.uniq

_.uniqBy

_.uniqWith

_.without

_.xor

_.xorBy

_.xorWith

_.zip

_.unzip

_.zipObject

_.zipObjectDeep

_.zipWith

_.unzipWith

推荐阅读更多精彩内容