js-Lodash數組

• _.chunk(array,[size=1]) 切割數組

作用: 講數組array拆分成多個size長度的區塊，並將這些區塊組成一個新的數組，如果array無法分割成等長的區塊，那麼最後的剩餘元素將組成一個區塊。

• 參數
• array :需要處理的數組
• size=1(number):每個數組區塊的長度
• 返回
• (Array):返回一個包含拆分區塊的新數組(相當於二維數組)
• demo

 let _ = require("lodash");
 let arr = [1, 2, 3, 4, 5, 6];
 let arr_result = _.chunk(arr, 2);
 console.log(arr_result);
//結果[[1,2],[3,4],[5,6]]
//如果第二個參數要是4則變成 [[1,2,3,4],[5,6]]

• _.compact(array) 刨去假值

作用: 創建一個新數組，包含原數組中所有的非假值元素。例如false,null,0,"",undefined,NaN都被認為假值

• 參數
• array(要處理的數組)
• 返回值
• array:返回過濾掉假值的新數組
• demo

 let _ = require("lodash");
 let arr = [0, 1, NaN, 2, null, 3, undefined];
 let arr_result = _.compact(arr);
 console.log(arr_result);
//結果 [1,2,3]

• _.concat(array,[values]) 兩個數組鏈接起來

創建一個新的數組將array與任何數組或值鏈接在一起

• 參數
• array:被鏈接的數組
• [values] (...*)連接的值
• 返回值
• (Array):返回連接後的新數組
• demo

 let _ = require("lodash");
 let arr = [1];
 let arr2 = _.concat(arr, 2, [3], [[4]], { name: "張三" });
 console.log(arr2);
 console.log(arr);

• _.difference(array,[values]) 找到不同的

創建一個具有唯一array值得數組, 每個值不包含在其他給定的數組中

• 參數
• array:要檢查的數組
• [values] :要排除的值
• 返回值
• (Array):返回一個過濾值後的新數組,他是以第一個數組為基準
• demo

let _ = require("lodash");
 let result = _.difference([3, 2, 100], [100, 2]);
 console.log(result);
//結果就是[3]

• _.differenceBy(array,[values],condition) 找到不同的帶條件

創建一個具有唯一array值得數組,

• 參數
• array:要檢查的數組
• [values] :要排除的值
• 條件 :他是先把2個數組裡面的所有值都執行一遍條件，然後篩選出來
• 返回值
• (Array):返回一個過濾值後的新數組
• demo

 let _ = require("lodash");
 let result = _.differenceBy(
 [{ name: "哈哈" }, { sex: "男" }],
 [{ name: "哈哈" }],
 "name"
 );
 console.log(result);
//結果[{sex:"男"}]
 let _ = require("lodash");
 let result = _.differenceBy([3.1, 4.2, 5.3], [4.6, 5.1], Math.floor);
 console.log(result);
//結果3.1
 let _ = require("lodash");
 let result = _.differenceBy([12, 3, 4], [3, 1], function(item) {
 return item - 4 > 0;
 });
 console.log(result);

• _.drop(array,[n=1]) 從左邊去掉

創建一個切片數組，去除array前面的n個元素,從左邊開始切割

• 參數
• array:要查詢的數組
• [values] :要去除的元素個數
• 返回值
• (Array):返回array剩餘的切片
• demo

 let _ = require("lodash");
 let arr = [1, 2, 3, 4, 5, 6];
 let arr_result = _.drop(arr, 3);
 console.log(arr_result);
//結果就是[4,5,6]
//如果要去除的元素個數比總長都大，那麼返回一個空數組，要是0就不切割了

• _.dropRight(array,[n=1]) 從右邊去掉

創建一個切片數組，去除array前面的n個元素,從右邊開始切割

• 參數
• array:要查詢的數組
• [values] :要去除的元素個數
• 返回值
• (Array):返回array剩餘的切片
• demo

 let _ = require("lodash");
 let arr = [1, 2, 3, 4, 5, 6];
 let arr_result = _.dropRight(arr, 3);
 console.log(arr_result);
//結果就是[1,2,3]
//如果要去除的元素個數比總長都大，那麼返回一個空數組

• _.dropwhile(array,方法或者條件) 去掉帶條件

創建一個切片數組，去除滿足方法或者條件的

• 參數
• array:要查詢的數組
• [condition] : 滿足方法或者條件的
• 返回值
• (Array):返回array剩餘的切片
• demo

 let _ = require("lodash");
 let arr = [1, 2, 3, 4, 5, 6];
 let arr_result = _.dropWhile(arr, function(item) {
 return item < 4;
 });
 console.log(arr_result);
//結果就是[4,5,6]
//如果都不滿足，那麼返回一個空數組

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

使用value值來替換(array裡面的值),從start位置開始到end位置結束

• 參數
• array:要填充改變的數組
• value(*): 填充給array的值
• start=0 :開始位置(默認0)
• end=array.length:結束位置(默認array.length)
• 返回值
• (Array):會改變原數組
• demo

 let _ = require("lodash");
 let array = [2, 3, 4];
 let result = _.fill(array, "a", 1, 2);
 console.log(result);
 //結果就是[2,"a",4]
//要是從0開始那麼改變的就是第一位

• _.findIndex(array,condition,[fromIndex=0]) 找到序號

返回第一個通過條件為真值得元素的索引(index)值,而不是元素本身

• 參數
• array:要搜索的數組
• condition: 條件
• [fromIndex=0]: 從第幾個開始找
• 返回值
• (number):返回找到元素的索引值(index) ,否則返回就是-1
• demo

 let _ = require("lodash");
 let user = [
 { user: "哈哈哈", active: true },
 { user: "呵呵呵", active: true },
 { user: "嘿嘿嘿", active: false },
 { user: "哦哦哦", active: false }
 ];
 let result = _.findIndex(user, function(item) {
 return !item.active;
 });
 console.log(result);
//返回的結果就是2因為從0開始

• _.head(array) 找到第一個元素 等價於 _.first(array)

獲取數組array的第一個元素

• 參數
• array:要搜索的數組
• 返回值
• (*):返回數組的第一個元素
• demo

 let _ = require("lodash");
 let user = [
 { user: "哈哈哈", active: true },
 { user: "呵呵呵", active: true },
 { user: "嘿嘿嘿", active: false },
 { user: "哦哦哦", active: false }
 ];
 let result = _.first(user);
 console.log(result);
 //結果就是{user:"哈哈哈",active:true}

• _.flattenDeep(array) 迴歸一維數組

將array遞歸為一維數組

• 參數
• array:要搜索的數組
• 返回值
• (*):返回一個新的一維數組
• demo

 let _ = require("lodash");
 let user = [1, [2, 3, 4, [6, 8, [9, 10]]]];
 let result = _.flattenDeep(user);
 console.log(result);
//結果就是[1,2,3,4,6,8,9,10];

• _.flattenDepth(array,[depth=1]) 去除數組指定的層數

依據depth遞歸減少array的嵌套層數

• 參數
• array:要減少嵌套層級的數組
• depth:最多減少的嵌套層級數
• 返回值
• (*):返回減少嵌套層級後的新數組
• demo

 let _ = require("lodash");
 let user = [1, [2, 3, 4, [6, 8, [9, 10]]]];
 let result = _.flattenDepth(user, 2);
 console.log(result);
 //結果[1,2,3,4,6,7,[9,10]]

• _.intersection([arrays]) 求交集

創建唯一值得數組，這個數組包含所有數組的共同元素

• 參數
• array:待檢查的數組
• 返回值
• (*):返回一個包含所有傳入數組交集元素的新數組
• demo

 let _ = require("lodash");
 let result = _.intersection([1, 2], [2, 3], [4, 2]);
 console.log(result);
 //結果[2]

• _.intersectionBy([arrays],condition) 求交集

創建唯一值得數組，這個數組包含所有數組的共同元素

• 參數
• array:待檢查的數組
• condition:條件
• 返回值
• (*):返回一個包含所有傳入數組交集元素的新數組
• demo

 let _ = require("lodash");
 let result = _.intersectionBy(
 [1.3, 2.2],
 [2.6, 3.9],
 [4.1, 2.1],
 Math.floor
 );
 console.log(result);
 //結果[2.2]
 let _ = require("lodash");
 let result = _.intersectionBy([{ x: 1 }], [{ x: 1 }, { name: 3 }], "x");
 console.log(result);
 //結果[{x:1}]

• _.join([arrays],分隔符) 把數組變成字符串

將array中的所有元素轉換為由分隔符分割的字符串

• 參數
• array:待檢查的數組
• 分隔符:分割元素
• 返回值
• (*):返回連接字符串
• demo

 let _ = require("lodash");
 let result = _.join([1, 2, 3, 4], "~");
 console.log(result);
//結果1~2~3~4

• _.last(array) 找到最後一個元素

獲取array中最後一個元素

• 參數
• array:待檢查的數組
• 返回值
• (*):返回array中的最後一個元素
• demo

 let _ = require("lodash");
 let result = _.last([1, 2, 3, 4]);
 console.log(result);
//結果就是4

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

獲取array中第N個元素，如果N為負數，則返回從數組結尾開始的第N個元素

• 參數
• array:待檢查的數組
• n=0 要返回的元素的索引值
• 返回值
• (*):返回array中的第N個元素
• demo

 let _ = require("lodash");
 let array = [1, 3, 3, 4, 5, 6];
 let result = _.nth(array, 0);
 console.log(result);
 //結果就是1

• _.pull(array,[values]) 刪除

移除數組array中所有和給定值相等的元素，這個方法會改變原數組。

• 參數
• array:待檢查的數組
• [values] 要刪除的值
• 返回值
• (*):返回array
• demo

 let _ = require("lodash");
 let array = [1, 3, 3, 4, 5, 3, 2, 6, 2];
 _.pull(array, 3, 2);
 console.log(array);
//結果就是[1,4,5,6]

• _.pullAll(array,values)

移除數組array中所有和給定值相等的元素，這個方法會改變原數組。這個元素必須是數組

• 參數
• array:待檢查的數組
• [values] 要刪除的值,必須是數組
• 返回值
• (*):返回array
• demo

 let _ = require("lodash");
 let array = [1, 3, 3, 4, 5, 3, 2, 6, 2];
 _.pullAll(array, [2, 3]);
 console.log(array);
//結果[1,4,5,6]

凡是後面有By都會有迭代器

• _.pullAllBy(array,values,迭代器)

移除數組array中所有和給定值相等的元素，這個方法會改變原數組。迭代器會優先過濾下數組

• 參數
• array:待檢查的數組
• [values] 要刪除的值,必須是數組
• 迭代器:每一個數組裡面的值都需要執行
• 返回值
• (*):返回array
• demo

 let _ = require("lodash");
 let array = [1.3, 3.2, 3.4, 4.4, 5.3, 3.2, 2.1, 6.7, 2.8];
 _.pullAllBy(array, [2, 3], Math.floor);
 console.log(array);
 //結果就是 [1.3, 4.4, 5.3, 6.7]

• _.pullAt(array,[indexes])

根據索引indexes,移除array中對應的元素，並返回被移除元素的數組,這個方法會改變原數組

• 參數
• array:待檢查的數組
• [indexes] 要移除元素的索引
• 返回值
• (*):返回array
• demo

 let _ = require("lodash");
 let array = [1.3, 3.2, 3.4, 4.4, 5.3, 3.2, 2.1, 6.7, 2.8];
 _.pullAt(array, 1);
 console.log(array);
 //結果就是[1.3,3.4, 4.4, 5.3, 3.2, 2.1, 6.7, 2.8];

• _.remove(array,迭代器)

移除迭代器中返回是真的元素

• 參數
• array:要修改的數組
• 迭代器:每次迭代調用的函數
• 返回值
• (*):返回array
• demo

 let _ = require("lodash");
 let result = _.remove([1, 2, 3, 4, 5, 6], function(item) {
 return item % 2 == 0 ? true : false;
 });
 console.log(result); 

• _.reverse(array)

反轉array使得第一個元素變成最後一個元素,這個方法會改變原數組

• 參數
• array:要修改的數組
• 返回值
• (*):返回array
• demo

 let _ = require("lodash");
 let array = [1, 2, 3, 4, 2, 5, 6];
 _.reverse(array);
 console.log(array);
 //結果[6,5,2,4,3,2,1]

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

裁剪數組array,從start位置開始到end結束(包前不包後) 不改變原數組

• 參數
• array:要裁剪的數組
• start=0:開始的位置
• [end=array.length]:結束的位置
• 返回值
• (*):返回array
• demo

 let _ = require("lodash");
 let array = [1, 2, 3, 4, 2, 5, 6];
 let result = _.slice(array, 0, 4); 
 console.log(array);
 console.log(result);
 //結果[1,2,3,4]

• _.uniq(array) 去重

創建一個去重後的array的數組副本，只有第一次出現的元素才能被保留,不會改變原數組

• 參數
• array:要裁剪的數組
• 返回值
• (*):返回array
• demo

 let _ = require("lodash");
 let array = [1, 2, 3, 4, 2, 5, 6];
 let result = _.uniq(array);
 console.log(array);
 console.log(result);
//結果[1,2,3,4,5,6]