本文深入探讨了JavaScript中将一维数组按照指定宽度转换为二维数组（即数组分块或Chunking）的技术。我们将解析这一常见操作的原理、应用场景，并通过分析流行的Lodash库中的`chunk`函数实现，以及提供一个简洁的纯JavaScript实现，帮助开发者理解并掌握高效、健壮的数组分块方法。
引言：数组分块（Chunking）的必要性
在前端或后端开发中，我们经常需要处理数据列表。有时，为了更好地展示、传输或处理这些数据，需要将一个线性的、一维的数组分割成多个较小的、固定大小的子数组。这种操作被称为“数组分块”（Array Chunking）。
例如，当我们需要在用户界面中实现分页功能时，每页显示固定数量的条目；或者在处理大量数据时，为了避免内存溢出或提高处理效率，需要将数据分批次（batch）处理。此时，数组分块就成为一项核心技术。
问题描述与目标
我们的目标是将一个给定的数组（例如 [1,2,3,4,5,6,7]）按照指定的宽度（例如 width = 3）进行分割，生成一个由子数组组成的二维数组。
立即学习“Java免费学习笔记（深入）”；
输入：
- 一个数组：array
- 一个整数：width (表示每个子数组的最大长度)
输出：
- 一个二维数组，其中每个子数组的长度不超过 width。
示例： 输入：array = [1,2,3,4,5,6,7], width = 3 输出：[[1,2,3],[4,5,6],[7]]
核心算法与实现思路
实现数组分块的基本思路是遍历原始数组，每次从当前位置开始，截取 width 个元素作为一个子数组，并将其添加到结果数组中。这个过程持续到原始数组的所有元素都被处理完毕。需要注意的是，最后一个子数组的元素数量可能不足 width。
参考实现：Lodash chunk 函数解析
Lodash 是一个广受欢迎的 JavaScript 工具库，提供了大量实用的功能函数，其中包括 chunk 函数，它专门用于数组分块。分析其实现有助于我们理解一个健壮的 chunk 函数应如何处理各种情况。
以下是 Lodash chunk 函数的核心代码片段：
function chunk(array, size = 1) {
// 1. 参数验证与处理
// 确保 size 是一个非负整数。toInteger 内部会将非数字转换为 0，并取整。
size = Math.max(toInteger(size), 0);
// 2. 获取数组长度，处理空数组或 null/undefined 情况
const length = array == null ? 0 : array.length;
// 3. 边界条件：如果数组为空或 size 无效，则返回空数组
if (!length || size < 1) {
return [];
}
// 4. 初始化变量
let index = 0; // 当前在原始数组中的读取位置
let resIndex = 0; // 当前在结果数组中的写入位置
// 5. 预分配结果数组空间，优化性能
// Math.ceil(length / size) 计算出总共会有多少个子数组
const result = new Array(Math.ceil(length / size));
// 6. 循环遍历原始数组并分块
while (index < length) {
// slice(array, index, (index += size))
// 从 array 中截取从 index 到 index + size 的部分作为一个子数组。
// (index += size) 在截取后更新 index 到下一个子数组的起始位置。
result[resIndex++] = slice(array, index, (index += size));
}
return result;
}
// 辅助函数（Lodash内部实现，这里简化概念）
// toInteger 负责将值转换为整数，非数字或NaN转换为0
function toInteger(value) {
const number = Number(value);
return isNaN(number) ? 0 : Math.trunc(number);
}
// slice 负责从数组中截取指定范围的元素
// 这里的 slice 并非 Array.prototype.slice，而是 Lodash 内部的优化版本
// 但其功能与 Array.prototype.slice(start, end) 类似
function slice(array, start, end) {
let length = array == null ? 0 : array.length;
if (!length) {
return [];
}
start = start == null ? 0 : start;
end = end === undefined ? length : end;
if (start < 0) {
start = -start > length ? 0 : (length + start);
}
end = end > length ? length : end;
if (end < 0) {
end += length;
}
start = start > end ? end : start;
let index = -1;
let subLength = end - start;
const result = new Array(subLength);
while (++index < subLength) {
result[index] = array[index + start];
}
return result;
}代码解析：
-
参数验证与处理 (size = Math.max(toInteger(size), 0)):
- toInteger(size)：这是一个内部辅助函数，用于将输入 size 转换为一个整数。如果 size 是 null、undefined、非数字字符串或 NaN，它会将其转换为 0。
- Math.max(..., 0)：确保 size 至少为 0。这意味着即使输入了负数，也会被视为 0。
-
获取数组长度并处理空数组 (length = array == null ? 0 : array.length):
- 检查 array 是否为 null 或 undefined，如果是，则其长度视为 0。
-
边界条件 (if (!length || size < 1)):
- 如果数组为空 (!length) 或者分块大小 size 小于 1（意味着无法有效分块），则直接返回一个空数组 []。
-
预分配结果数组 (new Array(Math.ceil(length / size))):
- Math.ceil(length / size) 计算出需要创建多少个子数组。例如，长度为 7，宽度为 3，则 Math.ceil(7 / 3) = Math.ceil(2.33) = 3。
- 预先创建具有正确长度的数组可以优化性能，避免在循环中频繁地进行数组扩容。
-
循环分块 (while (index < length)):
- index 跟踪原始数组中当前处理的起始位置。
- resIndex 跟踪结果数组中下一个子数组应该放置的位置。
- slice(array, index, (index += size))：这是核心操作。
- slice 函数（这里是Lodash内部的_slice，功能类似于 Array.prototype.slice）从 array 中截取一部分。
- index 是截取的起始位置。
- (index += size) 是截取的结束位置，并且在表达式求值后，index 会被更新为下一个子数组的起始位置。
- result[resIndex++] = ...：将截取到的子数组存入结果数组，并递增 resIndex。
自定义实现示例
对于大多数简单的应用场景，我们可以编写一个更简洁的纯 JavaScript 函数来实现数组分块，而无需引入整个 Lodash 库。
/**
* 将数组分块为指定大小的子数组集合。
* @param {Array} array 要分块的原始数组。
* @param {number} size 每个子数组的最大长度。
* @returns {Array<Array>} 包含子数组的二维数组。
*/
function chunkArray(array, size) {
if (!Array.isArray(array) || size <= 0) {
return [];
}
const result = [];
for (let i = 0; i < array.length; i += size) {
result.push(array.slice(i, i + size));
}
return result;
}
// 示例用法
const originalArray = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
const width = 3;
const chunkedResult = chunkArray(originalArray, width);
console.log(chunkedResult);
// 输出: [[1, 2, 3], [4, 5, 6], [7, 8, 9], [10]]
const emptyArray = [];
console.log(chunkArray(emptyArray, 5)); // 输出: []
const singleElementArray = [42];
console.log(chunkArray(singleElementArray, 1)); // 输出: [[42]]
console.log(chunkArray(singleElementArray, 5)); // 输出: [[42]]
const invalidSize = [1, 2, 3];
console.log(chunkArray(invalidSize, 0)); // 输出: []
console.log(chunkArray(invalidSize, -2)); // 输出: []
console.log(chunkArray(invalidSize, null)); // 输出: []这个自定义实现利用了 Array.prototype.slice() 方法，该方法能够从数组中提取一个部分并返回一个新数组。for 循环中的 i += size 确保了每次迭代都跳过已处理的元素。
注意事项与最佳实践
- 参数验证：在实际应用中，务必对 array 和 size 参数进行严格验证。确保 array 是一个数组，并且 size 是一个大于 0 的整数。自定义实现中已经加入了基本的验证。
- 空数组和无效 size：一个健壮的 chunk 函数应该能够正确处理空数组、size 为 0 或负数的情况，通常是返回一个空数组 []。
- 性能考虑：对于非常大的数组，频繁地创建子数组可能会带来一定的性能开销。Lodash 的实现通过预分配结果数组空间来优化，而 Array.prototype.slice 本身是高效的。在大多数情况下，上述两种实现方式的性能都足够满足需求。
- 可读性与维护性：选择清晰、易于理解的代码实现。如果项目中已经引入了 Lodash 或类似的工具库，直接使用其提供的 chunk 函数通常是最佳实践，因为它经过了充分测试且功能全面。
总结
数组分块是数据处理中一项基础且重要的操作。无论是通过像 Lodash 这样的成熟库，还是通过自定义的纯 JavaScript 函数，理解其背后的逻辑和实现细节都对开发者至关重要。通过本文的解析，您应该能够根据项目需求，选择或实现一个高效、健壮的数组分块方案，从而更好地管理和处理您的数据。
