Lodash - 数组

Lodash - 数组方法

Lodash 提供了一套全面的函数，专门用于数组操作。虽然原生 JavaScript Array 方法（.map、.filter、.reduce、.slice、.concat 等）涵盖了许多常见用例，但 Lodash 为诸如将数组分成块（chunks）、查找差异或交集（differences or intersections）、高级过滤以及处理已排序数组（sorted arrays）等任务提供了额外的工具。

本节重点介绍 Lodash 提供的一些独特而强大的数组方法。

主要数组方法（超越原生等效方法）

以下是一些 Lodash 数组函数，它们提供了标准 JavaScript Array 方法中不直接可用的功能：

方法与语法	描述
chunk _.chunk(array, [size=1])	创建一个数组，其中的元素按 size 大小分组。如果 array 不能被均分，最后一个块将包含剩余元素。
compact _.compact(array)	创建一个移除了所有 falsey 值的数组（false、null、0、""、undefined、NaN）。
difference _.difference(array, [values])	创建一个包含 array 中但不在其他给定数组中的值的数组。使用 SameValueZero 进行相等比较。
differenceBy .differenceBy(array, [values], [iteratee=.identity])	类似于 _.difference，但接受一个 iteratee，该 iteratee 对 array 和 values 的每个元素调用，以生成用于比较的标准。
differenceWith _.differenceWith(array, [values], [comparator])	类似于 _.difference，但接受一个 comparator，该 comparator 用于比较 array 的元素和 values。
drop _.drop(array, [n=1])	创建一个 array 的切片，移除开头的 n 个元素。
dropRight _.dropRight(array, [n=1])	创建一个 array 的切片，移除末尾的 n 个元素。
dropWhile .dropWhile(array, [predicate=.identity])	创建一个 array 的切片，从开头移除元素直到 predicate 返回 falsey。
flatten _.flatten(array)	将 array 展平一级深度。原生等效方法：Array.prototype.flat() 或 array.flat(1)。
flattenDeep _.flattenDeep(array)	递归地展平 array。原生等效方法：array.flat(Infinity)。
flattenDepth _.flattenDepth(array, [depth=1])	将 array 递归展平至指定 depth 深度。原生等效方法：array.flat(depth)。
fromPairs _.fromPairs(pairs)	从键值 pairs（一个数组的数组）创建一个对象。
intersection _.intersection([arrays])	创建一个包含所有给定数组中都存在的独有值的数组。使用 SameValueZero 进行相等比较。
intersectionBy / intersectionWith	类似于 _.intersection，但接受一个 iteratee 或 comparator。
nth _.nth(array, [n=0])	获取 array 中索引为 n 的元素。如果 n 为负数，则返回倒数第 n 个元素。原生等效方法：array.at(n)。
pull _.pull(array, [values])	从 array 中移除所有给定值。会修改 array（Mutates）。
pullAll _.pullAll(array, values)	类似于 _.pull，但接受一个要移除的值数组。会修改 array（Mutates）。
pullAllBy / pullAllWith	类似于 _.pullAll，但接受一个 iteratee 或 comparator。会修改 array（Mutates）。
pullAt _.pullAt(array, [indexes])	从 array 中移除对应 indexes 的元素，并返回一个包含被移除元素的数组。会修改 array（Mutates）。
remove .remove(array, [predicate=.identity])	从 array 中移除所有 predicate 返回 truthy 的元素，并返回一个包含被移除元素的数组。会修改 array（Mutates）。
sortedIndex _.sortedIndex(array, value)	使用二分查找（binary search）确定 value 应插入到 array 中的最低索引位置，以保持其排序顺序（sort order）。
sortedIndexBy / sortedIndexOf / sortedLastIndex / sortedLastIndexOf	基于 iteratees 或查找现有值的二分查找变体。
sortedUniq _.sortedUniq(array)	为已排序数组（sorted arrays）优化的 _.uniq 版本。
sortedUniqBy _.sortedUniqBy(array, [iteratee])	类似于 _.sortedUniq，但接受一个 iteratee。
take _.take(array, [n=1])	创建一个 array 的切片，获取开头的 n 个元素。
takeRight _.takeRight(array, [n=1])	创建一个 array 的切片，获取末尾的 n 个元素。
takeWhile / takeRightWhile	创建切片，获取元素直到 predicate 返回 falsey。
union _.union([arrays])	从所有给定数组中创建一个包含独有值的数组，按顺序排列。
unionBy / unionWith	类似于 _.union，但接受一个 iteratee 或 comparator。
uniq _.uniq(array)	创建一个移除重复元素的数组版本。使用 SameValueZero 进行相等比较。
uniqBy / uniqWith	类似于 _.uniq，但接受一个 iteratee 或 comparator。
unzip _.unzip(array)	_.zip 的反向操作；接受一个分组元素的数组，并创建一个将元素重新分组到其压缩（pre-zip）前配置的数组。
unzipWith	类似于 _.unzip，但接受一个 iteratee 来指定如何组合重新分组的值。
without _.without(array, [values])	创建一个排除所有给定值的数组。使用 SameValueZero 进行相等比较。
xor _.xor([arrays])	创建一个包含独有值的数组，该数组是给定数组的对称差集（symmetric difference）（出现在奇数个数组中的元素）。
xorBy / xorWith	类似于 _.xor，但接受一个 iteratee 或 comparator。
zip _.zip([arrays])	创建一个分组元素的数组，其中第一个组包含给定数组的第一个元素，第二个组包含第二个元素，依此类推。
zipObject _.zipObject([props=[]], [values=[]])	从属性标识符数组和值数组创建一个对象。
zipObjectDeep _.zipObjectDeep([props=[]], [values=[]])	类似于 _.zipObject，但支持属性路径（property paths）。
zipWith .zipWith([arrays], [iteratee=.identity])	类似于 _.zip，但接受一个 iteratee 来指定如何组合分组的值。

示例：分块和查找差异

import _ from 'lodash-es';

const numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
const primes = [2, 3, 5, 7];
const data = ['a', 'b', 'c', 'd', 'e'];

// 将 numbers 分成大小为 3 的块
const chunks = _.chunk(numbers, 3);
// chunks: [[1, 2, 3], [4, 5, 6], [7, 8, 9], [10]]

// 查找非质数
const nonPrimes = _.difference(numbers, primes);
// nonPrimes: [1, 4, 6, 8, 9, 10]

// 使用 zip 组合 data 和 numbers
const zippedData = _.zip(data, numbers);
// zippedData: [['a', 1], ['b', 2], ['c', 3], ['d', 4], ['e', 5]]
// 注意：zip 在最短数组耗尽时停止。

// 从多个数组创建独有值列表
const list1 = [1, 2, 3, 4];
const list2 = [3, 4, 5, 6];
const uniqueUnion = _.union(list1, list2);
// uniqueUnion: [1, 2, 3, 4, 5, 6]

console.log('Chunks:', chunks);
console.log('Non-Primes:', nonPrimes);
console.log('Zipped Data:', zippedData);
console.log('Union:', uniqueUnion);

这些专门的数组方法可以显著简化复杂的数组操作，与单独使用原生方法实现相同逻辑相比，使代码更易读、更易于维护。