Lodash Array数组方法
Lodash扩展了JavaScript内置对象方法的工具库，
它对 Array、Function、Oject、String、Number、Math 等等内置对象进行很丰富的扩展，添加了以及重置了很多很多方法，这些方法能帮我们快速的解决一些重复的、复杂的问题，就是帮助我们的工作的。
Lodash和jQuery一样封装了一个全局的对象，jQuery全局对象是$符号，Lodash全局对象是 _ 下划线
官网
英文 https://lodash.com/
中文 lodashjs.com
CDN
https://www.jsdelivr.com/package/npm/lodash
<script src="https://cdn.jsdelivr.net/npm/lodash@4.17.21/lodash.min.js"></script>
https://www.bootcdn.cn/lodash.js/
<script src="https://cdn.bootcdn.net/ajax/libs/lodash.js/4.17.21/lodash.min.js"></script>
一、拆分组合
_.chunk(array, [size=1])
将数组拆分成多个 size 长度的区块，并将这些区块组成一个新数组。如果array无法被分割成全部等长的区块，那么最后剩余的元素将组成一个区块
_.chunk(['a', 'b', 'c', 'd'], 2); // [['a', 'b'], ['c', 'd' ]] _.chunk(['a', 'b', 'c', 'd'], 3); // [['a', 'b', 'c'], [ 'd' ]]
_.concat()
作用：合并数组，与Array对象的方法一样
返回：连接后的新数组
三、过滤
_.compact()
过滤掉原数组里的非真（转布尔值后为false）数据，
例如 false, null, 0, "", undefined, NaN 都是被认为是假值（compact，n是协议契约合约，adj紧凑的意思）
_.compact([0, 1, false, 2, '', 3, null, NaN, undefined]); // [1, 2, 3]
_.difference(array, [values])
去除不同的数据，
例如干掉第一个数组中，和第二个数组重复的数据
_.difference([1, 3, 5, 7, 9], [3, 7]); // [1, 5, 9]
By 接收一个迭代器参数，这个迭代器参数会把每一个数据都进行遍历，按照迭代器的功能处理
_.differenceBy()
跟上面 difference 是一样的，只不过再接收一个参数（迭代器参数）
var arrFirst = [3.1, 2.2, 1.3]; var arrSecond = [4.4, 2.5]; _.differenceBy(arrFirst, arrSecond, Math.floor); // [3.1, 1.3]
Math.floor向下取整
1. 把所有的数据都迭代一次，向下取整 [3, 2, 1], [4, 2]
2. 取整后再去做 difference 的事件干掉2 [3, 1]
3. 返回的数据还是原来的数据 [3.1, 1.3]
With 也是接收一个参数，但是不是迭代器是一个比较器。意思是把一个参数的数据，都跟第二个参数进行对比
_.differenceWith()
与上面的方法一样，只不过它可以接收一个比较器的函数做为参数，对每个数据都要比较一下
var objects = [{'x':1, 'y':2}, {'x':2, 'y':1}];
_.differenceWith(objects, [{'x':1, 'y':2}], _.isEqual); // [{x: 2, y: 1}]_.isEqual方法用来比较两个数据是否相等，也是lodash中的一个方法
1. {'x':1, 'y':2} 跟 objects[0] 比，数据相等，把 objects[0] 干掉
2 .{'x':1, 'y':2} 跟 objects[1] 比，数据不一样，objects[1] 留下来
3. 返回过滤后的新数组 [{x: 2, y: 1}]
Ps：isEqual是比较相等，还可以比较大于、小于…
四、切割提取
1、切割
_.drop()
切掉数组的前n（第二个参数，默认为1）位
console.log(_.drop(['a', 'b', 'c', 'd', 'e'], 2)); // ['c', 'd', 'e']
Right 默认是切前2个，reght是切后面两个
_.dropRight()
切掉数组的后n位
console.log( _.dropRight( ['a', 'b', 'c', 'd', 'e'], 2 )); // ['a', 'b', 'c']
_.dropWhile()
去掉数组中，从起点到第二个方法返回假的数据。与Array对象身上的filter()方法一样
var users = [
{ 'user':'barney', 'active':false },
{ 'user':'fred', 'active':false },
{ 'user':'pebbles', 'active':true }
];
console.log( _.dropWhile(users, function(o) { return !o.active; }) ); // [{user: 'pebbles', active: true}]函数function(o) { return !o.active; }会在每一次遍历调用
1). 形参o，表示把每一条数据传进来，
return !o.active 表示把acive的布尔值取反
2). 从起始点开始 到 function(o)方法返回一个假false的数据为止，
返回第三条数据{ 'user': 'pebbles', 'active': true } ，因为active:true取反变成active:false
3). 把假前面两条active为真数据干掉，最后结果仅仅剩第三条{ 'user': 'pebbles', 'active': true } 一条数据
总结，这个迭代器就是遇到假的，就把假的返回
_.dropRightWhile()
与上面一样，不过它是从右边开始查，查到返回假的那个数据都去除
2、提取
_.take()
提取数组的前n（第二个参数，默认为1）位。与drop方法相反
var arr = ['a', 'b', 'c', 'd', 'e']; console.log(_.take(arr, 2 )); // ['a', 'b'] console.log(_.drop(arr, 2 )); // ["c", "d", "e"] console.log(arr); // ['a', 'b', 'c', 'd', 'e']
和drop方法是相反的，drop是删除掉前n位，take是提取前n位。不影响原数组
_.takeRight()
_.takeRightWhile()
_.takeWhile()
五、填充
_.fill()
填充数组，与Array对象身上的fill()方法一样
六、查找
_.findIndex()
原生数组对象有这个方法一模一样的，查满足条件的数据对应的索引值
_.findLastIndex()
从后往前找，与findIndex是相反的
七、降维
_.flatten()
减少一级数组嵌套深度，与Array的flat()这个方法相似
console.log( _.flatten( ['a', ['b', ['c', ['d']]]] ) ); // ['a', 'b', ['c', ['d']]]
_.flattenDeep()
把数组递归为一维数组。相当于[].flat(Infinity)
console.log( _.flattenDeep( ['a', ['b', ['c', ['d']]]] ) ); // ['a', 'b', 'c', 'd'] // 相当于 // console.log( ['a', ['b', ['c', ['d']]]].flat(Infinity) ); // ['a', 'b', 'c', 'd']
_.flattenDepth(array, n)
减少n（第二个参数）层数组的嵌套。相当于[].flat(2)
console.log( _.flattenDepth( ['a', ['b', ['c', ['d']]]], 2) ); // ['a', 'b', 'c', ['d']]
减少3层
console.log( _.flattenDepth( ['a', ['b', ['c', ['d']]]], 3) ); // ['a', 'b', 'c', 'd']
JS数组扁平化(flat)方法总结详解
https://www.jb51.net/article/163767.htm
七、转对象
fromPairs()
把数组转换为一个对象，与Object.fromEntries()方法一样
八、获取
1、获取第一位/最后一位
_.head()
head()/first()获取数组里第一个元素，就是取下标为0的那个数据
console.log( _.head([1, 2, 3]) ); // 1 console.log( _.head([]) ); // undefined
_.first()
取数组里的最后一位数据，取下标为length-1的那个数据
console.log( _.first([1, 2, 3]) ); // 1
_.last()
取数组里的最后一位数据，相当于用原生JS取下标为length-1的那个数据
console.log( _.last([1, 2, 3]) ); // 3
2、找索引值
_.indexOf()
查找数据，并返回数据对应的索引值，与Array对象身上的indexOf()方法一样
console.log( _.indexOf( ['a', 'b', 'c', 'd'], 'c') ); // 返回数据c索引值 2 console.log( _.indexOf( ['a', 'b', 'c', 'd'], 3) ); // 没找到返回 -1
lastIndexOf()
查找数据，并返回数据对应的索引值，与Array对象身上的lastIndexOf()方法一样
3、获取除第一位剩下的部分/最后一位剩下的部分
_.initial()
获取数组除了最后一位的所有数据
console.log( _.initial([1, 2, 3]) ); // [1, 2]
相当于删除数组里的最后一个数据，与Array对象身上的pop()方法一样，区别在于pop方法会改变原数组，而这个方法不会改变原数组
_.tail()
获取除了数组第一个元素以外的全部元素，想当于Array对象身上的shift()，与initial()相反
console.log( _.tail([1, 2, 3]) ); // [2, 3]
4、获取交集
_.intersection()
取数组的交集
console.log(_.intersection(['a', 'b'], ['b', 'c'], ['e', 'b'])); // ['b']
_.intersectionBy()
By形式接收一个遍历器（iteratee）
console.log(_.intersectionWith([2.1, 1.2], [4.3, 2.4], Math.floor)); // [2.1]
_.intersectionWith()
接收一个_.isEqual比较器
var objects = [{ 'x': 1, 'y': 2 }, { 'x': 2, 'y': 1 }];
var others = [{ 'x': 1, 'y': 1 }, { 'x': 1, 'y': 2 }];
console.log( _.intersectionWith(objects, others, _.isEqual) ); // [{ 'x': 1, 'y': 2 }]5、获取并集
_.union()
取数组的并集（把数据全部合并起来，然后去掉重复的）
console.log(_.union([2], [1, 2])); // [2, 1]
_.unionBy()
console.log( _.unionBy([2.1], [1.2, 2.3], Math.floor) ); // [2.1, 1.2]
_.nuionWith()
6、删除交集
_.xor()
删除数组的交集，留下非交集的部分（intersection是取交集的部分，xor是取非交集的部分）
console.log(_.xor(['a', 'b'], ['b', 'c'], ['e', 'b'])); // ["a", "c", "e"]
_.xorBy()
_.xorWith()
6、获取数组中某一个数据
_.nth()
取数组里的某个数据，就是通过下标取到某个数据。只不过它的数字（下标）可以为负。表示倒着找
var array = ['a', 'b', 'c', 'd']; console.log( _.nth(array, 1), //b _.nth(array, -2), //c );
十、转字符串
_.join()
把数组转成字符串，原生的Array对象也有这个方法
十一、删除
_.pull()
根据给的参数（参数为数据）删除原数组里的对应数据
返回原生数组
var array = [1, 2, 3, 1, 2, 3]; _.pull(array, 2, 3); // [1, 1] console.log(array); // [1, 1]
删除掉2和3，数组里就剩下 1
_.pullAll()
与上面的方法一样，就是参数为数组（好比call, apply这两个方法的区别）
var array = [1, 2, 3, 1, 2, 3]; _.pullAll(array, [2, 3]) console.log(array); // [1, 1]
pull和pullAll 和 call, apply这两个方法比较像
_.pullAllBy()
_.pullAllWith()
_.pullAt()
根据给的参数（参数为索引）删除原数组里的对应的数据
var array = [5, 10, 15, 20];
var evens = _.pullAt(array, 1, 3);
console.log('原数组变成：' + array); // [5, 15]
console.log('返回的数组：' + evens); // [10, 20]总结
pull、pullAll 参数是要删除的数据
pullAt 参数是要删除的索引
_.remove()
根据函数删除原数组里的数据（pull系列那些方法都通过rmove来实现）
var arr = ['a', 'b', 'c', 'd', 'e'];
// 参数是forEach、map..方法的形式
// 删除索引值大于2的位
_.remove(arr, function (value, index, array) {
return index > 2;
});
console.log('原数组：' + arr); // ["a", "b", "c"]_.without()
根据我们给的参数（参数为数据）删除原数组里的对应数据，与_.remove区别是不改变原数组
var arr = ['a', 'b', 'c', 'd', 'e']; console.log(_.without(arr, 'b', 'c')); // ['a', 'd', 'e'] console.log(arr); // ["a", "b", "c", "d", "e"]
十二、颠倒
_.reverse()
颠倒数组，比原生原生Array对象的方法好用
var arr = [10, 2, 3, 0.5, 1.2]; console.log( _.reverse(arr) ); // [1.2, 0.5, 3, 2, 10]
十三、截取
_.slice()
截取数组，这个方法原生的Array对象也有
从start开始到end结束，不包括end本身的位置
十四、排序
不是我们想的那种排序，是往数组里插入一些数据进行排序，意义不大
_.sortedIndex
_.sortedIndexBy
_.sortedIndexOf
_.sortedLastIndex
_.sortedLastIndexBy
_.sortedLastIndexOf
_.sortedUniq
_.sortedUniqBy
十五、去重
_.uniq()
console.log(_.uniq([1, 2, 2, 1])); // [1, 2]
uniqBy()/uniqWith() 与前面的一样
十六、zip
_.zip()
把各数组中索引值相同的数据放到一起，组成一个新的二维数组
var arr1 = ['小明', '小红', '小刚']; var arr2 = ['男', '女', '男']; var arr3 = [12, 13, 14]; console.log(_.zip(arr1, arr2, arr3)); // [ ["小明", "男", 12], ["小红", "女", 13], ["小刚", "男", 14] ]
_.zipObject()
与zip方法一样，区别是它输出的是对象，对象的形式是key: value，所以最后一组数据不能加了
var arr1 = ['小明', '小红', '小刚'];
var arr2 = ['男', '女', '男'];
var arr3 = [12, 13, 14];
console.log(_.zipObject(arr1, arr2, arr3)); // {小明: "男", 小红: "女", 小刚: "男"}_.zipObjecDeep() 有一些严格，我们用不到
_.zipWith()
with结尾跟之前稍微有一些不同，也是遍历每个数据，但是这里是索引相同的数据进行累加
var serult = _.zipWith([1, 2], [10, 20], [100, 200], function(a, b, c) {
return a + b + c;
});
console.log(serult); // [111, 222]_.unzip()
这个方法与zip相反，把每个数组里索引值一样的数据放在一起
console.log(_.unzip([["小明", "男", 12],["小红", "女", 13],["小刚", "男", 14]])); // [['小明', '小红', '小刚'], ['男', '女', '男'], [12, 13, 14]]
unzipWith()与zipWidth()跟之前一样，接收了一个迭代器的函数