Lodash工具庫
- 一、Lodash了解
- 二、Array方法學習
-
- 1_.chunk(array, [size=1])
- 2_.compact(array)
- 3_.difference(array, [values])
- 4_.differenceBy(array, [values], [iteratee=_.identity])
- 5_.differenceWith(array, [values], [comparator])
- 6_.drop(array, [n=1])
- 8_.take(array, [n=1])
- 9_.flatten(array)
- 10_.intersection([arrays])
- 11_.union([arrays])
- 12_.xor([arrays])
- 13_.nth(array, [n=0])
- 14_.remove(array, [predicate=_.identity])
- 15_.without(array, [values])
- 16_.uniq(array)
- 17_.zip([arrays])
- 18_.unzip(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)。
_.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 做等值比較。隻有第一次出現的元素才會被保留。
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方法相反，拆分數組