摘要：參數待檢查的已整理過的數組待計算的值每次迭代執行的函數綁定的返回返回在中應該插入的索引位置示例使用迭代器函數使用回調函數簡稱該方法類似，但其返回的是插入的最大的索引位置。

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]