JavaScript中基于优先级属性管理对象数组的动态插入与更新策略

/**
 * 管理规则数组的优先级，处理插入和更新时的优先级冲突。
 *
 * @param {Array<Object>} rulesArray - 当前的规则对象数组，每个对象需包含 'id' 和 'priority' 属性。
 * @param {Object} newRule - 待插入或更新的新规则对象，需包含 'id' 和 'priority' 属性。
 * @returns {Array<Object>} 更新后的规则数组。
 */
function manageRulePriorities(rulesArray, newRule) {
    // 1. 创建数组的浅拷贝以避免直接修改原始数组，这在React等状态管理中很重要。
    let updatedRules = [...rulesArray];

    // 2. 如果是更新现有规则，则先移除旧版本的规则。
    // 假设每个规则都有一个唯一的 'id' 属性。
    const existingRuleIndex = updatedRules.findIndex(rule => rule.id === newRule.id);
    if (existingRuleIndex !== -1) {
        updatedRules.splice(existingRuleIndex, 1); // 从数组中移除旧规则
    }

    // 3. 确保新规则的优先级是整数类型。
    const targetPriority = parseInt(newRule.priority);
    newRule.priority = targetPriority;

    // 4. 查找新规则的插入点。
    // 寻找第一个与新规则优先级相同的规则，或者第一个优先级大于新规则的规则。
    let insertionIndex = updatedRules.findIndex(rule => rule.priority >= targetPriority);

    if (insertionIndex === -1) {
        // 如果没有规则的优先级大于或等于目标优先级，则将新规则添加到数组末尾。
        updatedRules.push(newRule);
    } else {
        // 在找到的位置插入新规则。
        updatedRules.splice(insertionIndex, 0, newRule);

        // 5. 执行优先级平移：处理新规则插入后可能导致的优先级冲突。
        let currentPriorityToShift = targetPriority; // 从新规则的优先级开始检查
        // 从新规则插入位置的下一个元素开始遍历
        for (let i = insertionIndex + 1; i < updatedRules.length; i++) {
            // 如果当前元素的优先级与期望的优先级（即上一个被调整或新插入元素的优先级）相同
            if (updatedRules[i].priority === currentPriorityToShift) {
                updatedRules[i].priority++; // 递增当前元素的优先级
                currentPriorityToShift = updatedRules[i].priority; // 更新期望的优先级，以应对连续冲突
            } else if (updatedRules[i].priority > currentPriorityToShift) {
                // 如果当前元素的优先级已经大于期望的优先级，说明存在一个优先级间隔，
                // 此时不需要再进行平移，可以提前结束循环。
                break;
            }
            // 如果 updatedRules[i].priority < currentPriorityToShift，
            // 这表示数组在插入前可能未完全排序，或者逻辑有误。
            // 鉴于我们会在最后进行一次排序，这里可以暂时忽略此情况。
        }
    }

    // 6. 最后，确保整个数组按优先级属性进行排序。
    // 尽管平移逻辑会尽量保持顺序，但最终的排序是确保一致性的最佳实践。
    updatedRules.sort((a, b) => a.priority - b.priority);

    return updatedRules;
}

let rules = [
    { id: 1, priority: 1, name: "规则A" },
    { id: 2, priority: 3, name: "规则B" },
    { id: 3, priority: 4, name: "规则C" }
];

console.log("初始规则:", JSON.stringify(rules));
// 初始规则: [{"id":1,"priority":1,"name":"规则A"},{"id":2,"priority":3,"name":"规则B"},{"id":3,"priority":4,"name":"规则C"}]

// 案例1: 添加一个优先级不冲突的新规则
rules = manageRulePriorities(rules, { id: 4, priority: 2, name: "规则D" });
console.log("添加规则D (优先级2):", JSON.stringify(rules));
// 结果: [{"id":1,"priority":1,"name":"规则A"},{"id":4,"priority":2,"name":"规则D"},{"id":2,"priority":3,"name":"规则B"},{"id":3,"priority":4,"name":"规则C"}]

// 案例2: 添加一个优先级与现有规则冲突的新规则
rules = manageRulePriorities(rules, { id: 5, priority: 3, name: "规则E" });
console.log("添加规则E (优先级3):", JSON.stringify(rules));
// 结果: [{"id":1,"priority":1,"name":"规则A"},{"id":4,"priority":2,"name":"规则D"},{"id":5,"priority":3,"name":"规则E"},{"id":2,"priority":4,"name":"规则B"},{"id":3,"priority":5,"name":"规则C"}]
// 注意：原优先级为3的规则B变为4，原优先级为4的规则C变为5。

// 案例3: 更新一个现有规则的优先级，使其与另一个规则冲突
rules = manageRulePriorities(rules, { id: 4, priority: 3, name: "规则D (更新)" });
console.log("更新规则D (id 4) 为优先级3:", JSON.stringify(rules));
// 结果: [{"id":1,"priority":1,"name":"规则A"},{"id":5,"priority":3,"name":"规则E"},{"id":4,"priority":4,"name":"规则D (更新)"},{"id":2,"priority":5,"name":"规则B"},{"id":3,"priority":6,"name":"规则C"}]
// 注意：原规则D被移除，新版本以优先级3插入，导致规则E变为4，规则B变为5，规则C变为6。