JavaScript数组重塑：将特定元素动态分组为子数组

引言：数组重塑的需求

在数据处理和前端开发中，我们经常需要根据特定规则重塑数组结构。一个常见的场景是将数组中某些特定值（如 0）进行分组，使其成为子数组，而其他值（如 1）则保持独立。例如，给定一个javascript数组：

var test = [0, 1, 0, 1, 1, 1, 0, 0, 1, 0, 0, 0, 0, 1];

我们的目标是将其转换为以下结构：

test = [[0], 1, [0], 1, 1, 1, [0, 0], 1, [0, 0, 0, 0], 1];

从这个例子中，我们可以观察到以下规则：

1. 数字 1 始终作为独立的元素存在于结果数组中。
2. 数字 0 总是被包裹在一个子数组中。
3. 连续出现的 0 会被聚合到同一个子数组中。例如，[0, 0] 变为 [0, 0]，而不是 [[0], [0]]。
4. 当 0 出现在 1 之后，它会开启一个新的 [0] 子数组。

核心思路：状态跟踪与迭代

要实现这种复杂的重构，我们需要一种机制来“记住”上一个处理过的元素的状态。具体来说，我们需要知道：

• 上一个添加到结果数组的元素是什么类型？是独立的 1 还是一个 0 的子数组？
• 如果上一个是一个 0 的子数组，我们是否应该将当前的 0 添加到它里面，还是创建一个新的子数组？

为此，我们可以引入一个“状态变量”或“引用变量”，在遍历原始数组时，它会跟踪最后一次操作的结果。

立即学习“Java免费学习笔记（深入）”；

实现代码

以下是实现上述逻辑的JavaScript函数：

怪兽AI数字人

数字人短视频创作，数字人直播，实时驱动数字人

44

查看详情

/**
 * 将数组中的特定元素（如0）动态分组为子数组。
 *
 * @param {Array<number>} arr - 待处理的原始数组，包含0和1。
 * @returns {Array<number | number[]>} - 重塑后的数组，其中0被分组到子数组中。
 */
function groupZeroElements(arr) {
    let lastProcessedItem = null; // 用于跟踪最后添加到结果数组的元素或其引用
    const result = [];            // 存储最终结果的数组

    for (const element of arr) {
        if (element === 1) {
            // 如果当前元素是1，直接将其添加到结果数组
            // 并更新lastProcessedItem为1，表示上一个处理的是独立元素1
            result.push(element);
            lastProcessedItem = element;
        } else { // element === 0
            // 如果当前元素是0
            if (Array.isArray(lastProcessedItem)) {
                // 如果lastProcessedItem是一个数组（意味着上一个元素也是0，并已开始一个子数组）
                // 则将当前的0添加到该子数组中
                lastProcessedItem.push(element);
            } else {
                // 如果lastProcessedItem不是数组（意味着上一个元素是1，或者这是数组的第一个元素且为0）
                // 则创建一个新的包含0的子数组，并将其添加到结果数组
                // 同时更新lastProcessedItem为这个新创建的子数组的引用
                const newSubArray = [element];
                result.push(newSubArray);
                lastProcessedItem = newSubArray;
            }
        }
    }
    return result;
}

// 示例用法
let testArray = [0, 1, 0, 1, 1, 1, 0, 0, 1, 0, 0, 0, 0, 1];
let transformedArray = groupZeroElements(testArray);
console.log(transformedArray);
// 预期输出: [[0], 1, [0], 1, 1, 1, [0, 0], 1, [0, 0, 0, 0], 1]

代码解析

1. lastProcessedItem = null;: 这个变量是实现状态跟踪的关键。它在每次循环中都会被更新，以记录最后添加到 result 数组的元素。

   • 如果 lastProcessedItem 的值是 1，说明上一个处理的是一个独立的 1。
   • 如果 lastProcessedItem 的值是一个数组的引用，说明上一个处理的是一个 0 元素，并且它已经在一个子数组中。
   • 初始值为 null，用于处理数组的第一个元素是 0 的情况。

2. for (const element of arr): 遍历输入数组 arr 中的每一个元素。

3. if (element === 1):

   • 如果当前元素是 1，根据规则，它应该独立存在。
   • result.push(element);: 将 1 直接添加到 result 数组。
   • lastProcessedItem = element;: 更新 lastProcessedItem 为 1。这样，如果下一个元素是 0，我们就会知道它需要开启一个新的子数组。

4. else { // element === 0 }:

   • 如果当前元素是 0，我们需要判断它应该加入到现有的 0 子数组中，还是创建一个新的。
   • if (Array.isArray(lastProcessedItem)): 检查 lastProcessedItem 是否是一个数组。
     • 如果是，这表明上一个处理的元素是 0，并且它已经在一个子数组中（lastProcessedItem 此时就是那个子数组的引用）。
     • lastProcessedItem.push(element);: 将当前的 0 添加到这个已存在的子数组中。result 数组本身不需要修改，因为我们正在修改它内部的一个子数组的引用。
   • else: 如果 lastProcessedItem 不是一个数组（即它是 1 或 null）。
     • 这意味着当前的 0 是一个新的 0 序列的开始（或者它是数组的第一个元素）。
     • const newSubArray = [element];: 创建一个新的子数组，包含当前的 0。
     • result.push(newSubArray);: 将这个新的子数组添加到 result 数组。
     • lastProcessedItem = newSubArray;: 更新 lastProcessedItem 为这个新创建的子数组的引用。这是至关重要的一步，它确保了后续连续的 0 能够被添加到这个子数组中。

注意事项与扩展

• 通用性： 尽管此函数是为 0 和 1 设计的，但其核心逻辑可以推广。如果您需要分组其他特定值，只需修改 if (element === 1) 和 else { // element === 0 } 中的条件即可。例如，可以传入一个 targetValue 参数来指定需要分组的元素。
• 性能： 该算法通过单次遍历数组（O(n) 时间复杂度）完成任务，对于大多数实际应用来说是高效的。
• 可读性： lastProcessedItem 变量的命名清晰地表达了其意图，即跟踪最后处理的项。这种状态机模式在处理序列数据时非常有用。
• 其他数据类型： 当前函数假设数组只包含 0 和 1。如果数组中包含其他数字、字符串、布尔值或对象，则需要调整逻辑来明确如何处理这些额外的类型。
• 空数组处理： 如果输入是空数组 []，函数将返回一个空数组 []，这是符合预期的。

总结

通过巧妙地使用一个 lastProcessedItem 变量来跟踪前一个处理元素的状态，我们能够有效地将JavaScript数组中的特定元素（如 0）动态地分组到子数组中，同时保持其他元素（如 1）的独立性。这种基于状态跟踪的迭代方法提供了一种灵活且高效的解决方案，适用于各种数组重构场景，是JavaScript开发者工具箱中的一个实用技巧。

以上就是JavaScript数组重塑：将特定元素动态分组为子数组的详细内容，更多请关注php中文网其它相关文章！