Lodash學習--Array篇

Yeaseon_Zhang發表於2017-10-12

作者： Yeaseon
Blog：yeaseonzhang.github.io
原文連結

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]複製程式碼

Lodash學習-Collection篇
2017-10-12
webpack 學習筆記：使用 lodash
2020-10-05
Web筆記
lodash已死？radash最全使用介紹（附原始碼說明）—— Array方法篇（4）
2024-04-24
原始碼
lodash已死？radash最全使用介紹（附原始碼說明）—— Array方法篇（2）
2024-04-03
原始碼
lodash已死？radash最全使用介紹（附原始碼說明）—— Array方法篇（3）
2024-04-12
原始碼
lodash已死？radash最全使用介紹（附原始碼詳細說明）—— Array方法篇（1）
2024-03-30
原始碼
從lodash原始碼學習節流與防抖
2018-05-24
原始碼
【numpy學習筆記】 Array processing
2018-07-11
筆記
【C++學習筆記】vector和array
2017-04-04
C++筆記
sass學習篇
2018-04-04
Golang學習--開篇
2017-11-16
Golang
學習理解篇1
2024-05-07
Salesforce LWC學習(二十四) Array.sort 淺談
2020-09-08
Salesforce
學習一下Array.reduce函式的使用
2024-09-28
函式
ES6新增API：Array篇(二)
2021-11-30
API
ES6新增API：Array篇(一)
2021-11-25
API
Flutter學習篇(五)——路由剖析終篇
2019-10-15
Flutter路由
Java學習之反射篇
2020-08-13
Java反射
[學習篇] Swoole 協程
2020-01-03
【學習篇】Swoole 協程
2020-01-03
微服務學習系列篇
2019-05-20
微服務
JVM調優-學習篇
2019-03-04
JVM
JVM 調優（學習篇）
2020-12-13
JVM
測試學習SQL篇
2020-11-13
SQL
C++學習篇(2)
2021-01-02
C++
【學習筆記】HTML篇
2020-10-05
筆記HTML
學習篇一：Web API
2017-09-10
WebAPI
物化檢視-學習篇
2013-04-08
JavaScript 複習之 Array 物件
2019-02-26
JavaScript物件
Vue原始碼學習: 關於對Array的資料偵聽
2019-04-22
Vue原始碼
lodash入門
2018-10-18
Lodash筆記
2020-10-09
筆記
資料分析-學習篇-01
2020-08-19
Flutter學習篇(四)—— 尺寸解惑
2019-08-06
Flutter
Python基礎學習篇
2019-03-16
Python
Node.js學習——開篇
2019-02-16
Node.js
《springboot學習篇4》
2020-11-05
Spring Boot
NestJS學習總結篇
2022-05-27
JS

Lodash學習--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

相關文章