JavaScript中基于优先级动态管理对象数组的策略

beforeSaveCell: (oldValue, newValue, row, column) => {
  let aux = stateLinhas
  aux.forEach((item, index) => {
    if (parseInt(newValue) === parseInt(item.prioridade)) {
      item.prioridade = parseInt(newValue) + 1
    }
  })
  setStateLinhas(() => aux)
}

const rules = [];

function addRule() {
    const priority = document.getElementById('priority').value;
    const newRule = {priority: parseInt(priority)};

    const index = rules.findIndex(rule => rule.priority === newRule.priority);
  if (index !== -1) {
    rules.splice(index, 0, newRule);
    let currentPriority = newRule.priority;
    rules.map((rule, i) => {
        if (i > index) {
        if (rule.priority === currentPriority) {
            rule.priority++;
          currentPriority = rule.priority;
        }
      }
    });
  } else {
    rules.push(newRule);
  }

  console.log(rules);
}

/**
 * 管理对象数组中的优先级，确保唯一性和递增顺序。
 * 当插入或更新规则时，如果发生优先级冲突，将自动进行级联调整。
 *
 * @param {Array<Object>} rules - 原始规则数组，每个对象需包含 'id' 和 'priority' 属性。
 * @param {Object} newOrUpdatedRule - 要添加或更新的规则对象。
 * @returns {Array<Object>} - 经过优先级调整后的新规则数组。
 */
function manageRulePriority(rules, newOrUpdatedRule) {
    // 1. 创建数组的副本以避免直接修改原始状态（对于React等框架尤其重要）
    let updatedRules = [...rules];

    // 确保优先级是整数
    newOrUpdatedRule.priority = parseInt(newOrUpdatedRule.priority);

    // 2. 检查是更新现有规则还是添加新规则
    const existingRuleIndex = updatedRules.findIndex(r => r.id === newOrUpdatedRule.id);

    if (existingRuleIndex !== -1) {
        // 如果是更新现有规则，先将其从数组中移除
        updatedRules.splice(existingRuleIndex, 1);
    }

    // 3. 找到新规则的逻辑插入位置
    // 数组需要先按优先级排序，以便正确找到插入点
    // 注意：如果数组在外部始终保持排序，此步骤可以优化
    updatedRules.sort((a, b) => a.priority - b.priority);

    let insertIndex = updatedRules.findIndex(r => r.priority >= newOrUpdatedRule.priority);
    if (insertIndex === -1) {
        // 如果新规则的优先级最高，则插入到末尾
        insertIndex = updatedRules.length;
    }

    // 4. 插入新规则
    updatedRules.splice(insertIndex, 0, newOrUpdatedRule);

    // 5. 执行级联优先级调整
    // 从插入点开始（或从前一个规则开始，以防插入点是0）
    // 确保每个规则的优先级至少比前一个规则高1
    for (let i = 1; i < updatedRules.length; i++) {
        const prevRule = updatedRules[i - 1];
        const currentRule = updatedRules[i];

        // 如果当前规则的优先级小于或等于前一个规则的优先级
        if (currentRule.priority <= prevRule.priority) {
            // 将当前规则的优先级设置为前一个规则优先级 + 1
            currentRule.priority = prevRule.priority + 1;
        }
    }

    // 6. 最终排序以确保所有规则按优先级升序排列（即使经过调整）
    updatedRules.sort((a, b) => a.priority - b.priority);

    return updatedRules;
}

// --- 示例用法 ---
let myRules = [
    { id: 1, priority: 1 },
    { id: 2, priority: 2 },
    { id: 3, priority: 5 },
    { id: 4, priority: 6 }
];

console.log("原始规则:", JSON.parse(JSON.stringify(myRules)));

// 示例 1: 插入一个新规则，优先级与现有规则冲突 (priority 2)
let newRule1 = { id: 5, priority: 2 };
myRules = manageRulePriority(myRules, newRule1);
console.log("插入新规则 (id:5, priority:2) 后:", JSON.parse(JSON.stringify(myRules)));
// 预期结果: [ {id:1, priority:1}, {id:5, priority:2}, {id:2, priority:3}, {id:3, priority:5}, {id:4, priority:6} ]

// 示例 2: 插入一个新规则，优先级导致级联调整 (priority 3)
let newRule2 = { id: 6, priority: 3 };
myRules = manageRulePriority(myRules, newRule2);
console.log("插入新规则 (id:6, priority:3) 后:", JSON.parse(JSON.stringify(myRules)));
// 预期结果: [ {id:1, priority:1}, {id:5, priority:2}, {id:6, priority:3}, {id:2, priority:4}, {id:3, priority:5