Array对象2，lodash

参考：

https://www.lodashjs.com/docs/lodash.chunk

 

import { chunk, compact, concat, difference,differenceBy,differenceWith, drop, dropRight,dropRightWhile,dropWhile,fill,findIndex,findLastIndex,flatten,flattenDeep,flattenDepth,fromPairs,head,indexOf,initial,intersection,intersectionBy,join,nth,pull,pullAll,pullAllBy,pullAt,remove,reverse,sortedIndex,sortedUniq,sortedUniqBy,take,takeRight,union,uniq,zip,unzip,without,xor} from "lodash";

 

chunk(arr,size=1) 将数组拆分成多个size长度的区块成二维数组

let arr = [1, 2, 3, 4, 5, 6, 7];
console.log(chunk(arr,2))
// [Array(2), Array(2), Array(2), Array(1)]

compact(arr) 返回一个新数组，过滤掉arr中所有的非假值

let arr = [0, 1, false, 2, '', 3]
console.log(compact(arr))
// [1, 2, 3]

difference(arr1,arr2) 返回arr1所有数组元素过滤掉arr2的其他部分

let arr = [1, 2, 3, 4, 5, 6, 7];
console.log(difference(arr, [2, 3, 8, 9]));
// [1, 4, 5, 6, 7]

differenceBy(arr1,arr2,func) 同difference类似，第三个参数为迭代器

console.log(differenceBy([3.1, 2.2, 1.3], [4.4, 2.5], Math.floor));
// [3.1, 1.3] Math.floor(x) 返回的是整数，向下取整，得到[3,2,1]和[4,2],然后对比

differenceWith(arr1,arr2,func) 同differenceBy类似，第三个参数为比较器

var objects = [{ 'x': 1, 'y': 2 }, { 'x': 2, 'y': 1 }];
console.log(differenceWith(objects, [{ 'x': 1, 'y': 2 }], isEqual));
// [{x: 2, y: 1}]

flatten(arr) 减少一级arr嵌套深度，三维变二位，二维变一维

let arr = [[1, 2], [[[[3, 4], 5], 6], 7]];
arr = flatten(arr)
arr = flatten(arr)
arr = flatten(arr)
arr = flatten(arr)
console.log(arr)
// [1, 2, 3, 4, 5, 6, 7]

flattenDeep(arr) 直接变成一维

let arr = [[1, 2], [[[[3, 4], 5], 6], 7]];
console.log(flattenDeep(arr))
// [1, 2, 3, 4, 5, 6, 7]

flattenDepth(arr,num) 减少num级嵌套深度

let arr = [[1, 2], [[[[3, 4], 5], 6], 7]];
console.log(flattenDepth(arr,4))
// [1, 2, 3, 4, 5, 6, 7]

fromPairs(arr) 将特定的数组（pairs）[[key1,val1],[]] 转换成对象

console.log(fromPairs([['fred', 30], ['barney', 40]]))
// {fred: 30, barney: 40}

intersection(arr1,arr2,arr3...) 取多个数组的交集

console.log(intersection([2, 1], [4, 2], [1, 2]))
// [2]

intersectionBy(arr1,arr2,arr3...,func) 取多个数组处理后的交集，用第一个数组中的值，与differenceBy类似

console.log(intersectionBy([2.1, 1.2], [4.3, 2.4], Math.floor))
// [2.1]

intersectionWith(arr1,arr2,arr3...,func) 与differenceWith类似，第三个参数为比较器

nth(arr,[n=0]) 获取一个元素的位置，如果n是负数，则从后往前数
let arr = [1, 2, 3, 4, 5, 6, 7];
console.log(nth(arr,-2))
// 6

pull(arr,val1,val2) 移除数组中的元素，改变原数组

let arr = [1, 2, 3, 4, 5, 6, 7];
pull(arr,2,3,4)
console.log(arr)
// [1, 5, 6, 7]

pullAll(arr,arr1) 移除arr中包含arr1中的元素，改变元素组

let arr = [1, 2, 3, 4, 5, 6, 7];
pullAll(arr,[2,3,4])
console.log(arr)
// [1, 5, 6, 7]

pullAllBy(arr,values,[iteratee]) 迭代器，和differenceBy类似

// let arr = [1, 2, 3, 4, 5, 6, 7];
var array = [{ 'x': 1 }, { 'x': 2 }, { 'x': 3 }, { 'x': 1 }];
pullAllBy(array, [{ 'x': 1 }, { 'x': 3 }], 'x');
console.log(array);
// [{'x':2}]

pullAllWith(arr,val,[comparator])
pullAt(arr,index1,index2...) 根据index移除数组中的元素，返回被移除的元素，改变原数组

let arr = [1, 2, 3, 4, 5, 6, 7];
var arr1 = pullAt(arr,2,3,4)
console.log(arr,arr1);
// [1, 2, 6, 7] [3, 4, 5]

sortedIndex(arr,val) 检索val在arr中会排序到的位置

console.log(sortedIndex([30, 50], 40));
// 1

sortedIndexBy(arr,val,[iteratee])
sortedIndexOf()
sortedLastIndex()
sortedLastIndexBy()
sortedLastIndexOf()
sortedUniq(arr) 把一个已排序过的数组相邻的相同元素合并

let arr = [1,1,3,4,2,2]
console.log(sortedUniq(arr))

sortedUniqBy(arr,[iteratee])

sortedUniqBy([1.1, 1.2, 2.3, 2.4], Math.floor);
console.log(sortedUniqBy([1.1, 1.2, 2.3, 2.4], Math.floor))
// [1.1, 2.3]

union(arr1,arr2,...) 取数组元素并集

console.log(union([2], [1, 2]))
// [2, 1]

unionBy(arr,...,[iteratee])
unionWith()
uniq(arr) 数组元素去重

let arr = [1,2,4,6,3,4,2,1]
console.log(uniq(arr))
// [1, 2, 4, 6, 3]

uniqBy()
uniqWith()
zip(arr1,arr2,arr3,...) 打包多个数组成一个数组，数组第一个元素是所有要打包的数组的第一个元素的集合，以此类推

let zipped = zip(['fred', 'barney'], [30, 40], [true, false]);
// [["fred", 30, true],["barney", 40, false]]

unzip(arr1,arr2,arr3,...)

let zipped1 = unzip(zipped);
console.log(zipped1)

zipWith() 打包的时候可以合并处理

zipWith([1, 2], [10, 20], [100, 200], function(a, b, c) {
return a + b + c;
});
// [111, 222]

unzipWith() 解包的时候可以合并处理

var zipped = zip([1, 2], [10, 20], [100, 200]);
unzipWith(zipped, add);
// [3, 30, 300]

without(arr,val1,val2,...) 返回过滤后的新数组，与pull()一致，但是不改变原数组
xor(arr1,arr2,...) 数组取对称差，也就是 ！交集 与intersection()相反
xorBy()
xorWith()

 

 

// 重复部分，js1.6(es6)会不会是参考的lodash?
concat(arr1,val)，数组连接 与js 的 concat 重复， == arr1.concat(val)
drop(arr,num) 切除数组前num个元素，返回剩余数组，== arr.slice(num)
dropRight(arr,num) 切除数组尾部num个元素，返回剩余数组，== arr.slice(0,-num)
dropRightWith(arr,func) 过滤掉符合func条件的数据，返回剩余数组，== arr.filter(!func)
dropWhile(arr,func) 这个方法有个毛病，不知道是不是版本问题，复现不了
fill(arr,val,start,end) 替换填充，后两个参数可不传，== arr.fill(val,start,end)
findIndex(arr,func) 获取匹配的第一个元素的index，== arr.findIndex(func)
findLastIndex(arr,func) 获取匹配的最后一个元素的index ~= arr.lastIndexOf()
head(arr) 返回数组第一个元素，== arr[0]
indexOf(arr,val,[fromIndex=0]) 返回元素的index，== arr.indexOf(val,[fromIndex=0])
initial(arr) 返回除了最后一个元素的数组，== arr.slice(0,-1)
join(arr,[separator=',']) 把数组转换成字符串 == arr.join(arr,[separator=','])
last(arr) 返回数组最后一个元素，== arr[arr.length-1]
lastIndexOf(arr,val,[fromIndex=array.length-1]) 从右向左遍历arr的元素 == arr.lastIndexOf(val)
remove(arr,func) 根据方法移除元素，与filter相反 == arr.filter(!func)
reverse(arr) 数组倒序 == arr.reverse()
slice(arr,[start=0],[end=arr.length]) 裁剪数组 arr.slice(arr,[start=0],[end=arr.length])
tail(arr) 除了第一个元素以外的全部元素 == arr.slice(1)
take(arr,num) 提出num个元素 == arr.slice(0,num)
takeRight(arr,num) == arr.slice(-num)
takeRightWhile(arr,[predicate])
takeWhile(arr,[predicate])