JavaScript 数组元素动态分组策略：基于尺寸数组与最大尺寸规则的实现

/**
 * 根据指定的分组大小数组动态切分数组元素。
 * 当元素数组长度超出指定分组总和时，剩余元素将按照已定义的最大分组大小进行切分。
 *
 * @param {Array} array 待分组的原始数组。
 * @param {Array<number>} groups 包含一系列分组大小的数组。
 * @returns {Array<Array>} 包含分组后子数组的数组。
 */
function splitIntoGroups (array, groups) {
    var output = [];
    var maxLength = 1; // 初始化最大分组长度，至少为1，以防groups数组为空或元素过小。
    var offset = 0;    // 当前切片的起始偏移量。

    // 阶段1: 按照groups数组中指定的分组大小进行切分
    for (var i = 0; i < groups.length && offset < array.length; i++) {
        var currentGroupSize = groups[i];

        // 确保当前分组大小是正数，避免slice出现意外行为
        if (currentGroupSize <= 0) {
            continue; 
        }

        // 切片当前组，从offset开始，长度为currentGroupSize
        output.push(array.slice(offset, offset + currentGroupSize));

        // 更新偏移量
        offset += currentGroupSize;

        // 更新最大分组长度
        if (currentGroupSize > maxLength) {
            maxLength = currentGroupSize;
        }
    }

    // 阶段2: 处理剩余元素，使用已记录的最大分组长度
    while (offset < array.length) {
        // 切片剩余元素，从offset开始，长度为maxLength
        // 注意：slice会自动处理endIndex超出数组长度的情况，只取到数组末尾
        output.push(array.slice(offset, offset + maxLength));

        // 更新偏移量
        offset += maxLength;
    }

    return output;
}

// 示例数据
var elements = ['a','b','c','d','e','f','g','h','i','j','k','l','m','n','o','p'];
var groups = [1, 3, 5]; // 初始分组大小

console.log("--- 各种输入场景示例 ---");

// 场景1: 原始数组长度小于所有指定分组的总和 (例如：'a','b','c')
// 预期输出: [['a'], ['b','c']] (第二个组被截断)
console.log("输入: ['a','b','c'], 分组: [1, 3, 5]");
console.log("输出:", splitIntoGroups(elements.slice(0, 3), groups)); 
// 实际调用：splitIntoGroups(['a','b','c'], [1, 3, 5])

// 场景2: 原始数组长度等于或略大于部分指定分组的总和 (例如：'a','b','c','d','e')
// 预期输出: [['a'], ['b','c','d'], ['e']] (第三个组被截断)
console.log("\n输入: ['a','b','c','d','e'], 分组: [1, 3, 5]");
console.log("输出:", splitIntoGroups(elements.slice(0, 5), groups));
// 实际调用：splitIntoGroups(['a','b','c','d','e'], [1, 3, 5])

// 场景3: 原始数组长度刚好覆盖所有指定分组，并有剩余元素按最大组长分组 (例如：'a'...'l')
// 预期输出: [['a'], ['b','c','d'], ['e','f','g','h','i'], ['j','k','l']]
console.log("\n输入: ['a'...'l'], 分组: [1, 3, 5]");
console.log("输出:", splitIntoGroups(elements.slice(0, 12), groups));
// 实际调用：splitIntoGroups(['a'...'l'], [1, 3, 5])

// 场景4: 原始数组长度远大于所有指定分组的总和，大量剩余元素按最大组长分组 (例如：'a'...'p')
// 预期输出: [['a'], ['b','c','d'], ['e','f','g','h','i'], ['j','k','l','m','n'], ['o','p']]
console.log("\n输入: ['a'...'p'], 分组: [1, 3, 5]");
console.log("输出:", splitIntoGroups(elements, groups));
// 实际调用：splitIntoGroups(['a'...'p'], [1, 3, 5])

// 场景5: 指定分组数组包含更大的分组，且超出原始数组长度 (测试截断行为)
var largeGroups = [1, 3, 5, 5, 5, 1000];
console.log("\n输入: ['a'...'p'], 分组: [1, 3, 5, 5, 5, 1000]");
console.log("输出:", splitIntoGroups(elements, largeGroups));
// 预期输出会根据groups和elements的长度进行动态调整，最终结果与场景4类似，因为1000这个大组会被elements的长度截断。