Lodash 中文文档 (v3.10.1) - Array 方法

摘要：参数待检查的已整理过的数组待计算的值每次迭代执行的函数绑定的返回返回在中应该插入的索引位置示例使用迭代器函数使用回调函数简称该方法类似，但其返回的是插入的最大的索引位置。

Translated by PeckZeg
Original Docs: Lodash v3.10.1 Docs

感谢 @neuront 对 _.flatten 翻译的建议

创建一个元素分成长度为 size 的分组的数组。如果 collection 不能被均匀的分割，那么最后一个区块将会包含剩余的元素。

参数

array (Array) : 待处理的数组

[size=1] (number) : 每个区块的长度

返回
(Array) : 返回包含每个区块的新数组

示例

_.chunk(["a", "b", "c", "d"], 2);
// → [["a", "b"], ["c", "d"]]

_.chunk(["a", "b", "c", "d"], 3);
// → [["a", "b", "c"], ["d"]]

创建一个移除了所有假值的数组。值 false, null, 0, "", undefined 和 NaN 均为假值。

参数

array (Array) : 待简化的数组

返回

(Array) : 返回过滤值后的新数组

示例

_.compact([0, 1, false, 2, "", 3]);
// → [1, 2, 3]

创建一个每个值都不包含在其他的提供的的数组内的值的数组（使用 SameValueZero 进行相等比较）。

参数

array (Array) : 待检查的数组

[values] (…Array) : 待排除值的数组

返回

(Array) : 返回过滤值后的新数组

示例

_.difference([1, 2, 3], [4, 2]);
// → [1, 3]

创建一个从起始位置开始删除 n 个元素后的数组分片。

参数

array (Array) : 待查询的数组

[n=1] (number) : 待删除的元素个数

返回

(Array) : 返回分片后的 array

示例

_.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]

创建一个从尾部位置开始删除 n 个元素后的数组分片。

参数

array (Array) : 待查询的数组

[n=1] (number) : 删除元素的个数

返回

(Array) : 返回分片后的 array

示例

_.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]

创建一个从尾部开始舍弃元素 array 的分片。在 predicate 返回假值之前一直舍弃元素。断言将被绑定 thisArg 参数并在执行时传入三个参数：value, index, array。

如果提供的是属性名，那么 predicate 将创建 _.property 风格的回调函数，并返回给定元素的属性的值。

如果值还提供了 thisArg，那么 predicate 将创建 _.matchesProperty 风格的回调，并在元素含有匹配的属性值的时候返回 true，否则返回 false。

如果提供的是对象，那么 predicate 将创建 _.matches 风格的回调函数，并在匹配给定对象的属性的元素时返回 true，否则返回 false。

参数

array (Array) : 待查询的数组

[predicate=_.identity] (Function|Object|string) : 每次迭代将会执行的函数

[thisArg] (*) : predicate 将要绑定的 this

返回

(Array) : 返回 array 的分片

示例

_.dropRightWhile([1, 2, 3], function(n) {
  return n > 1;
});
// → [1]

var users = [
  { "user": "barney",  "active": true },
  { "user": "fred",    "active": false },
  { "user": "pebbles", "active": false }
];

// 使用 `_.matches` 回调函数的简称
_.pluck(_.dropRightWhile(users, { "user": "pebbles", "active": false }), "user");
// → ["barney", "fred"]

// 使用 `_.matchesProperty` 回调函数的简称
_.pluck(_.dropRightWhile(users, "active", false), "user");
// → ["barney"]

// 使用 `_.property` 回调函数的简称
_.pluck(_.dropRightWhile(users, "active"), "user");
// → ["barney", "fred", "pebbles"]

创建一个从起始位置开始舍弃元素 array 的分片。在 predicate 返回假值之前一直舍弃元素。断言将被绑定 thisArg 参数并在执行时传入三个参数：value, index, array。

如果提供的是属性名，那么 predicate 将创建 _.property 风格的回调函数，并返回给定元素的属性的值。

如果值还提供了 thisArg，那么 predicate 将创建 _.matchesProperty 风格的回调，并在元素含有匹配的属性值的时候返回 true，否则返回 false。

如果提供的是对象，那么 predicate 将创建 _.matches 风格的回调函数，并在匹配给定对象的属性的元素时返回 true，否则返回 false。

参数

array (Array) : 待查询的数组

[predicate=_.identity] (Function|Object|string) : 每次迭代将会执行的函数

[thisArg] (*) : predicate 将要绑定的 this

返回

(Array) : 返回 array 的分片

示例

_.dropWhile([1, 2, 3], function(n) {
  return n < 3;
});
// → [3]

var users = [
  { "user": "barney",  "active": false },
  { "user": "fred",    "active": false },
  { "user": "pebbles", "active": true }
];

// 使用 `_.matches` 回调函数的简称
_.pluck(_.dropWhile(users, { "user": "barney", "active": false }), "user");
// → ["fred", "pebbles"]

// 使用 `_.matchesProperty` 回调函数的简称
_.pluck(_.dropWhile(users, "active", false), "user");
// → ["pebbles"]

// 使用 `_.property` 回调函数的简称
_.pluck(_.dropWhile(users, "active"), "user");
// → ["barney", "fred", "pebbles"]

使用 value 填充 array 的元素（从 start 位置开始，但不包括 end）

注意：该方法将改变数组

参数

array (Array) : 带填充的数组

value (*) : 填充至 array 的值

[start=0] (number) : 起始位置

[end=array.length] (number) : 结束位置

返回

(Array) : 返回 array

示例

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], "*", 1, 2);
// → [4, "*", 8]

这个函数类似 _.find 但它返回的是通过 predicate 返回真值的第一个元素的索引值，而不是其元素本身。

如果提供的是属性名，那么 predicate 将创建 _.property 风格的回调函数，并返回给定元素的属性的值。

如果值还提供了 thisArg，那么 predicate 将创建 _.matchesProperty 风格的回调，并在元素含有匹配的属性值的时候返回 true，否则返回 false。

如果提供的是对象，那么 predicate 将创建 _.matches 风格的回调函数，并在匹配给定对象的属性的元素时返回 true，否则返回 false。

参数

array (Array) : 待查找的数组

[predicate=_.identity] (Function|Object|string) : 每次迭代执行的函数

[thisArg] (*) : predicate 绑定的 this

返回

(number) : 返回查找到的元素的索引值，否则为 -1

示例

var users = [
  { "user": "barney",  "active": false },
  { "user": "fred",    "active": false },
  { "user": "pebbles", "active": true }
];

_.findIndex(users, function(chr) {
  return chr.user == "barney";
});
// → 0

// 使用 `_.matches` 回调函数的简称
_.findIndex(users, { "user": "fred", "active": false });
// → 1

// 使用 `_.matchesProperty` 回调函数的简称
_.findIndex(users, "active", false);
// → 0

// 使用 `_.property` 回调函数的简称
_.findIndex(users, "active");
// → 2

这个函数类似 _.findIndex，但它会从右往左遍历 collection 的元素。

如果提供的是属性名，那么 predicate 将创建 _.property 风格的回调函数，并返回给定元素的属性的值。

如果值还提供了 thisArg，那么 predicate 将创建 _.matchesProperty 风格的回调，并在元素含有匹配的属性值的时候返回 true，否则返回 false。

如果提供的是对象，那么 predicate 将创建 _.matches 风格的回调函数，并在匹配给定对象的属性的元素时返回 true，否则返回 false。

参数

array (Array) : 待查找的数组

[predicate=_.identity] (Function|Object|string) : 每次迭代执行的函数

[thisArg] (*) : predicate 绑定的 this

返回

(number) : 返回查找到的元素的索引值，否则为 -1

示例

var users = [
  { "user": "barney",  "active": true },
  { "user": "fred",    "active": false },
  { "user": "pebbles", "active": false }
];

_.findLastIndex(users, function(chr) {
  return chr.user == "pebbles";
});
// → 2

// 使用 `_.matches` 回调函数的简称
_.findLastIndex(users, { "user": "barney", "active": true });
// → 0

// 使用 `_.matchesProperty` 回调函数的简称
_.findLastIndex(users, "active", false);
// → 2

// 使用 `_.property` 回调函数的简称
_.findLastIndex(users, "active");
// → 0

获取 array 的第一个元素

别称

_.head

参数

array (Array) : 待查询的数组

返回

(*) : 返回 array 的第一个元素

示例

_.first([1, 2, 3]);
// → 1

_.first([]);
// → undefined

连接所有数组元素。如果 isDeep 指定为 true，那么数组元素会递归连接，否则它将只连接一层数组元素。

参数

array (Array) : 待连接的数组

[isDeep] (boolean) : 指定是否连接深层的数组元素

返回

(Array) : 返回一个连接所有数组元素的新数组

示例

_.flatten([1, [2, 3, [4]]]);
// → [1, 2, 3, [4]]

// 使用 `isDeep`
_.flatten([1, [2, 3, [4]]], true);
// → [1, 2, 3, 4]

递归拍平一个嵌套数组

参数

array (Array) : 待递归拍平的数组

返回

(Array) : 返回一个被拍平过的数组

示例

_.flattenDeep([1, [2, 3, [4]]]);
// → [1, 2, 3, 4]

获取 value 首次在 array 出现的索引（使用 SameValueZero 进行相等性比较）。如果 fromIndex 为负数，则作为 array 从尾部的位移。如果 array 已整理，且传入 fromIndex 值为 true，则将使用更高效的二分查找。

参数

array (Array) : 待查找的数组

value (*) : 待查找的值

[fromIndex=0] (boolean|number) : 开始查找的索引位置或传入 true 以代表使用二分查找

返回

(number) : 返回匹配值的索引，否则返回 -1

示例

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

// 使用 `fromIndex`
_.indexOf([1, 2, 1, 2], 2, 2);
// → 3

// 执行二分查找
_.indexOf([1, 1, 2, 2], 2, true);
// → 2

Gets all but the last element of array.

获取 array 中所有元素（除了最后一个元素）

参数

array (Array) : 待查询的数组

返回

(Array) : 返回 array 的分片

示例

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

获取所有传入数组中都包含的元素（使用 SameValueZero 进行相等性比较）

参数

[arrays] (…Array) : 待检查的数组

返回

(Array) : 返回一个包含所有传入数组中都包含的元素的新数组

示例

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

Gets the last element of array.

获取 array 的最后一个元素

参数

array (Array) : 待查询的数组

返回

(*) : 返回 array 的最后一个元素

示例

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

这个函数类似 _.indexOf，但它从右到左遍历 array 的所有元素

参数

array (Array) : 待查找的数组

value (*) : 待查找的值

[fromIndex=0] (boolean|number) : 开始查找的索引位置或传入 true 以代表使用二分查找

参数

(number) : 返回匹配值的索引，否则返回 -1

示例

_.lastIndexOf([1, 2, 1, 2], 2);
// → 3

// using `fromIndex`
_.lastIndexOf([1, 2, 1, 2], 2, 2);
// → 1

// performing a binary search
_.lastIndexOf([1, 1, 2, 2], 2, true);
// → 3

从 array 中移除所有指定的值（使用 SameValueZero 进行相等性比较）。

注意：和 _.without 不同，这个方法将会改变数组

参数

array (Array) : 待修改的数组

[values] (…*) : 待移除的值

返回

(Array) : 返回 array

示例

var array = [1, 2, 3, 1, 2, 3];

_.pull(array, 2, 3);
console.log(array);
// → [1, 1]

从 array 移除给定索引的元素，并返回一个移除元素的数组。索引可以被指定为一个数组或多个参数。

注意：与 _.at 不同，该方法会修改 array。

参数

array (Array) : 待修改的数组

[indexes] (…(number|number[]) : 待移除元素的索引，可以指定为多个参数或者索引数组

返回
(Array) : 返回含有已移除元素的数组

示例

var array = [5, 10, 15, 20];
var evens = _.pullAt(array, 1, 3);

console.log(array);
// → [5, 15]

console.log(evens);
// → [10, 20]

移除所有在 array 中并通过 predicate 的元素，并返回所有移除元素的数组。断言函数绑定 thisArg 并传入三个参数：value, index, array。

如果提供的是属性名，那么 predicate 将创建 _.property 风格的回调函数，并返回给定元素的属性的值。

如果值还提供了 thisArg，那么 predicate 将创建 _.matchesProperty 风格的回调，并在元素含有匹配的属性值的时候返回 true，否则返回 false。

如果提供的是对象，那么 predicate 将创建 _.matches 风格的回调函数，并在匹配给定对象的属性的元素时返回 true，否则返回 false。

注意：和 _.filter 不同，该方法将改变数组

参数

array (Array) : 待修改的数组

[predicate=_.identity] (Function|Object|string) : 每次迭代执行的函数

[thisArg] (*) : predicate 绑定的 this

返回

(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]

Gets all but the first element of array.

获取 array 的除第一个外的所有元素。

别名

_.tail

参数

返回 (Array) : 待查询的数组

返回

(Array) : 返回 array 的分片

示例

_.rest([1, 2, 3]);
// → [2, 3]

创建一个从 start 位置开始，但不包含 end 位置元素的 array 的分片

注意：该方法通常用来替代 IE < 9 以下的 Array#slice 函数，以确保密集数组的返回。

参数

array (Array) : 待分片的数组

[start=0] (number) : 起始位置

[end=array.length] (number) : 结束位置

返回
(Array) : 返回 array 的分片

使用二分查找来确定 value 在 array 中应该插入的最小的索引位置（为了保持 array 的排序顺序）。如果为了计算其排序值而将 value 和每次遍历的元素传入迭代函数，那么迭代器将绑定 thisArg 并在执行时传入一个参数 value。

如果提供的是属性名，那么 predicate 将创建 _.property 风格的回调函数，并返回给定元素的属性的值。

如果值还提供了 thisArg，那么 predicate 将创建 _.matchesProperty 风格的回调，并在元素含有匹配的属性值的时候返回 true，否则返回 false。

如果提供的是对象，那么 predicate 将创建 _.matches 风格的回调函数，并在匹配给定对象的属性的元素时返回 true，否则返回 false。

参数

array (Array) : 待检查的已整理过的数组

value (*) : 待计算的值

[iteratee=_.identity] (Function|Object|string) : 每次迭代执行的函数

[thisArg] (*) : iteratee 绑定的 this

返回

(number) : 返回 value 在 array 中应该插入的索引位置

示例

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

_.sortedIndex([4, 4, 5, 5], 5);
// → 2

var dict = { "data": { "thirty": 30, "forty": 40, "fifty": 50 } };

// 使用迭代器函数
_.sortedIndex(["thirty", "fifty"], "forty", function(word) {
  return this.data[word];
}, dict);
// → 1

// 使用 `_.property` 回调函数简称
_.sortedIndex([{ "x": 30 }, { "x": 50 }], { "x": 40 }, "x");
// → 1

该方法类似 _.sortedIndex，但其返回的是 array 插入 value的最大的索引位置。

参数

array (Array) : 待检查的已整理的数组

value (*) : 待计算的值

[iteratee=_.identity] _(Function|Object|string)_: 每次迭代时执行的函数

[thisArg] (*) : iteratee 绑定的 this

返回

(number) : 返回 value 在 array 中应该插入的索引位置

示例

_.sortedLastIndex([4, 4, 5, 5], 5);
// → 4

创建一个从 array 的起始位置开始起共 n 个元素的分片。

参数

array (Array) : 待查询的数组

[n=1] (number) : 获取元素的个数

返回

(Array) : 返回 array 的分片

示例

_.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);
// → []

创建一个从 array 的结束位置开始起共 n 个元素的分片。

参数

array (Array) : 待查询的数组

[n=1] (number) : 获取元素的个数

返回

(Array) : 返回 array 的分片

示例

_.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);
// → []

创建一个从 array 的结束位置开始起包含若干个元素的分片。在 predicate 返回假值之前，元素都将被传入分片之中。断言函数将绑定 thisArg 并传入三个参数：value, index, array。

如果提供的是属性名，那么 predicate 将创建 _.property 风格的回调函数，并返回给定元素的属性的值。

如果值还提供了 thisArg，那么 predicate 将创建 _.matchesProperty 风格的回调，并在元素含有匹配的属性值的时候返回 true，否则返回 false。

如果提供的是对象，那么 predicate 将创建 _.matches 风格的回调函数，并在匹配给定对象的属性的元素时返回 true，否则返回 false。

参数

array (Array) : 待查询的数组

[predicate=_.identity] (Function|Object|string) : 每次迭代执行的函数

[thisArg] (*) : predicate 绑定的 this

返回

(Array) : 返回 array 的分片

示例

_.takeRightWhile([1, 2, 3], function(n) {
  return n > 1;
});
// → [2, 3]

var users = [
  { "user": "barney",  "active": true },
  { "user": "fred",    "active": false },
  { "user": "pebbles", "active": false }
];

// 使用 `_.matches` 回调函数简称
_.pluck(_.takeRightWhile(users, { "user": "pebbles", "active": false }), "user");
// → ["pebbles"]

// 使用 `_.matchesProperty` 回调函数简称
_.pluck(_.takeRightWhile(users, "active", false), "user");
// → ["fred", "pebbles"]

// 使用 `_.property` 回调函数简称
_.pluck(_.takeRightWhile(users, "active"), "user");
// → []

创建一个从 array 的起始位置开始起包含若干个元素的分片。在 predicate 返回假值之前，元素都将被传入分片之中。断言函数将绑定 thisArg 并传入三个参数：value, index, array。

如果提供的是属性名，那么 predicate 将创建 _.property 风格的回调函数，并返回给定元素的属性的值。

如果值还提供了 thisArg，那么 predicate 将创建 _.matchesProperty 风格的回调，并在元素含有匹配的属性值的时候返回 true，否则返回 false。

如果提供的是对象，那么 predicate 将创建 _.matches 风格的回调函数，并在匹配给定对象的属性的元素时返回 true，否则返回 false。

参数

array (Array) : 待查询的数组

[predicate=_.identity] (Function|Object|string) : 每次迭代执行的函数

[thisArg] (*) : predicate 绑定的 this

返回

(Array) : 返回 array 的分片

示例

_.takeWhile([1, 2, 3], function(n) {
  return n < 3;
});
// → [1, 2]

var users = [
  { "user": "barney",  "active": false },
  { "user": "fred",    "active": false},
  { "user": "pebbles", "active": true }
];

// 使用 `_.matches` 回调函数简称
_.pluck(_.takeWhile(users, { "user": "barney", "active": false }), "user");
// → ["barney"]

// 使用 `_.matchesProperty` 回调函数简称
_.pluck(_.takeWhile(users, "active", false), "user");
// → ["barney", "fred"]

// 使用 `_.property` 回调函数简称
_.pluck(_.takeWhile(users, "active"), "user");
// → []

创建一个含有唯一值的数组，从每个数组获取的值在插入时都会使用 SameValueZero 和归并后的数组的值进行相等性比较。

参数

[arrays] (…Array) : 待检查的数组

返回

(Array) : 返回组合值的新数组

示例

_.union([1, 2], [4, 2], [2, 1]);
// → [1, 2, 4]

Creates a duplicate-free version of an array, using SameValueZero for equality comparisons, in which only the first occurrence of each element is kept. Providing true for isSorted performs a faster search algorithm for sorted arrays. If an iteratee function is provided it’s invoked for each element in the array to generate the criterion by which uniqueness is computed. The iteratee is bound to thisArg and invoked with three arguments: (value, index, array).

如果提供的是属性名，那么 predicate 将创建 _.property 风格的回调函数，并返回给定元素的属性的值。

如果值还提供了 thisArg，那么 predicate 将创建 _.matchesProperty 风格的回调，并在元素含有匹配的属性值的时候返回 true，否则返回 false。

如果提供的是对象，那么 predicate 将创建 _.matches 风格的回调函数，并在匹配给定对象的属性的元素时返回 true，否则返回 false。

别名

_.unique

参数

array (Array) : 待检查的数组

[isSorted] (boolean) : 指定数组是否已整理

[iteratee] (Function|Object|string) : 每次迭代执行的函数

[thisArg] (*) : iteratee 绑定的 this

返回

(Array) : 返回一个无重复值的新数组

示例

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

// 使用 `isSorted`
_.uniq([1, 1, 2], true);
// → [1, 2]

// 使用迭代器函数
_.uniq([1, 2.5, 1.5, 2], function(n) {
  return this.floor(n);
}, Math);
// → [1, 2.5]

// 使用 `_.property` 回调函数简称
_.uniq([{ "x": 1 }, { "x": 2 }, { "x": 1 }], "x");
// → [{ "x": 1 }, { "x": 2 }]

该方法类似 _.zip，但其接受一个含有分组元素的数组，并创建一个含有使用预压缩配置的重组元素的数组（creates an array regrouping the elements to their pre-zip configuration）。

参数

array (Array) : 待处理的各元素数组

返回

(Array) : 返回含有重组的元素的新数组

示例

var zipped = _.zip(["fred", "barney"], [30, 40], [true, false]);
// → [["fred", 30, true], ["barney", 40, false]]

_.unzip(zipped);
// → [["fred", "barney"], [30, 40], [true, false]]

该函数类似 _.unzip，但其接受一个指定值应该如何结合的迭代器。iteratee 迭代器绑定 thisArg 并在执行时传入四个参数：accumulator, value, index, group。

参数

array (Array) : 待处理的各元素数组

[iteratee] (Function) : 处理重组值的函数

[thisArg] (*) : iteratee 绑定的 this

返回

(Array) : 返回含有重组的元素的新数组

示例

var zipped = _.zip([1, 2], [10, 20], [100, 200]);
// → [[1, 10, 100], [2, 20, 200]]

_.unzipWith(zipped, _.add);
// → [3, 30, 300]

创建一个不包含所有传入的值的数组（使用 SameValueZero 进行相等性比较）。

参数

array (Array) : 待过滤的数组

[values] (…*) : 待排除的值

返回

(Array) : 返回一个含有过滤后的值的新数组

示例

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

Creates an array of unique values that is the symmetric difference of the provided arrays.

创建一个含有唯一值（每个值在各个数组中 对称差）的数组。

参数

[arrays] (…Array) : 待检查的数组

返回
(Array) : 返回一个含有值的新数组

示例

_.xor([1, 2], [4, 2]);
// → [1, 4]

创建一个含有同组元素的新数组，第一个元素含有每个给定数组的第一个元素，第二个元素含有每个给定数组的第二个元素，以此类推。

参数

[arrays] (…Array) : 待处理的数组

返回

(Array) : 返回一个含有同组元素的新数组

示例

_.zip(["fred", "barney"], [30, 40], [true, false]);
// → [["fred", 30, true], ["barney", 40, false]]

作用与 _.pairs 相反。该方法返回一个由属性名数组和值数组组成的对象。需要提供一个长度只为 2 的数组，例如：[[key1, value1], [key2, value2]] 。或者一个为属性名的数组，另一个为属性值的数组。

别名

_.object

参数

props (Array) : 属性名组

[values=[]] (Array) : 属性值组

返回

(Object) : 返回一个新的对象。

示例

_.zipObject([["fred", 30], ["barney", 40]]);
// → { "fred": 30, "barney": 40 }

_.zipObject(["fred", "barney"], [30, 40]);
// → { "fred": 30, "barney": 40 }

该方法类似 _.zip，但其接受一个指定值应该如何结合的迭代器。iteratee 迭代器绑定 thisArg 并在执行时传入四个参数：accumulator, value, index, group。

参数

[arrays] (…Array) : 待处理的数组

[iteratee] (Function) : 处理重组值的函数

[thisArg] (*) : iteratee 绑定的 this

返回

(Array) : 返回含有重组的元素的新数组

示例

_.zipWith([1, 2], [10, 20], [100, 200], _.add);
// → [111, 222]