JavaScript 数组高级转换：实现特定元素动态子数组封装

问题描述

在javascript中，有时我们需要对数组进行非标准的结构转换。例如，给定一个包含 0 和 1 的数组，我们希望将所有单独的 0 或连续的 0 组合成一个子数组，而 1 则保持为独立的元素。

原始数组示例：

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];

可以看到，单个 0 被转换为 [0]，连续的 0 被转换为包含这些 0 的子数组，而 1 保持不变。

解决方案概述

为了实现这种转换，我们可以采用迭代遍历的方式，并维护一个状态变量来记录上一个被处理并添加到结果数组中的元素。这样，当遇到一个 0 时，我们可以判断它是应该开始一个新的子数组，还是应该添加到之前已经创建的子数组中。

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

代码实现

以下是实现上述转换的JavaScript函数：

怪兽AI数字人

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

44

查看详情

/**
 * 根据特定规则将数组元素转换为子数组。
 * - 1 保持为独立元素。
 * - 0 如果是第一个或跟在 1 后面，则开始一个新的子数组 [0]。
 * - 0 如果跟在另一个 0 后面（即前一个元素已是一个子数组），则添加到该子数组中。
 *
 * @param {Array<number>} a 待转换的数字数组，包含 0 和 1。
 * @returns {Array<number|Array<number>>} 转换后的数组。
 */
function groupZeroElements(a) {
    let lastProcessedElement = null; // 用于跟踪结果数组中上一个被操作的元素引用
    let resultArray = []; // 存储转换后的结果

    for (let currentElement of a) {
        if (currentElement === 1) {
            // 如果当前元素是 1，直接将其推入结果数组
            // 并更新 lastProcessedElement 为 1
            resultArray.push(currentElement);
            lastProcessedElement = currentElement;
        } else { // currentElement === 0
            // 如果当前元素是 0
            if (Array.isArray(lastProcessedElement)) {
                // 如果 lastProcessedElement 已经是一个数组（意味着前一个元素也是 0，
                // 并且已经创建了一个子数组），则将当前 0 推入该子数组
                lastProcessedElement.push(currentElement);
            } else {
                // 否则（lastProcessedElement 是 1 或 null），
                // 说明当前 0 是一个新的连续 0 序列的开始，
                // 创建一个新的子数组 [0] 并推入结果数组，
                // 同时更新 lastProcessedElement 为这个新的子数组的引用
                resultArray.push(lastProcessedElement = [currentElement]);
            }
        }
    }
    return resultArray;
}

// 示例用法
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]

let anotherTest = [0, 0, 1, 0, 0, 0, 1, 1, 0];
console.log(groupZeroElements(anotherTest));
// 预期输出: [[0, 0], 1, [0, 0, 0], 1, 1, [0]]

代码详解

1. groupZeroElements(a) 函数定义：

   • 接受一个数组 a 作为输入。
   • lastProcessedElement = null：这是一个关键的状态变量。它存储了 resultArray 中上一个被处理的元素（或其引用）。当遇到 0 时，我们需要知道它是否应该加入到前一个 0 形成的子数组中。
   • resultArray = []：这是最终输出的结果数组。

2. for (let currentElement of a) 循环：

   • 遍历输入数组 a 中的每一个元素 currentElement。

3. if (currentElement === 1) 条件块：

   • 如果当前元素是 1，根据需求，1 应该保持独立。
   • resultArray.push(currentElement)：直接将 1 推入 resultArray。
   • lastProcessedElement = currentElement：更新 lastProcessedElement 为 1。这很重要，因为下一个元素如果是 0，它将知道前一个不是一个子数组，需要开始一个新的 [0]。

4. else { // currentElement === 0 } 条件块：

   • 当当前元素是 0 时，我们需要进行更复杂的判断。
   • if (Array.isArray(lastProcessedElement))：
     • 这个条件检查 lastProcessedElement 是否是一个数组。
     • 如果为真，说明上一个被处理并添加到 resultArray 的元素是一个子数组（即它是一个 [0] 或 [0, 0] 等，并且它是由一个或多个 0 组成的）。
     • 在这种情况下，当前的 0 应该被添加到这个现有的子数组中，形成一个更长的连续 0 序列。
     • lastProcessedElement.push(currentElement)：将当前的 0 推入 lastProcessedElement 所引用的数组中。
   • else：
     • 如果 lastProcessedElement 不是一个数组（这意味着它要么是 null，要么是 1）。
     • 这表示当前的 0 是一个新的连续 0 序列的开始。
     • resultArray.push(lastProcessedElement = [currentElement])：
       • 创建一个新的子数组 [currentElement]（即 [0]）。
       • 将这个新创建的子数组推入 resultArray。
       • 同时，将 lastProcessedElement 更新为这个新创建的子数组的引用。这样，如果下一个元素也是 0，Array.isArray(lastProcessedElement) 就会为真，从而将 0 添加到这个子数组中。

注意事项

• 状态变量 lastProcessedElement 的作用：这个变量是实现连续 0 聚合的关键。它不仅仅记录了上一个值，更重要的是，当它指向一个数组时，它提供了对 resultArray 中某个子数组的直接引用，允许我们原地修改该子数组。
• 特定性：这个解决方案是高度针对 0 和 1 这种特定转换规则设计的。如果规则发生变化（例如，需要聚合 2 而不是 0，或者聚合的是连续相同的任意数字），则需要相应地调整 if/else 逻辑。
• 性能：该方法通过单次遍历数组完成转换，时间复杂度为 O(n)，其中 n 是数组的长度，具有良好的性能。

总结

通过使用一个简单的迭代过程和巧妙地利用一个状态变量来跟踪上一个处理的元素，我们成功地实现了一个JavaScript函数，能够根据特定规则将数组中的 0 元素动态地封装成子数组，而 1 元素则保持不变。这种模式在处理需要根据元素值或序列进行条件性分组和重构的数组时非常有用，展示了JavaScript在数据结构转换方面的灵活性和强大功能。

以上就是JavaScript 数组高级转换：实现特定元素动态子数组封装的详细内容，更多请关注php中文网其它相关文章！