优化循环数组中索引相对位置计算的简洁方法

function getOffset(currentIndex, index, length) {
  const diff = index - currentIndex;

  if (diff === 0) {
    return 0;
  } else if (diff < 0) {
    // 目标索引在当前索引之前
    if (diff < -3) {
      // 循环后距离仍超过3个位置（反向）
      // 计算正向距离，然后截断
      return Math.min(length + diff, 3);
    } else {
      // 距离在-1到-3之间
      return diff;
    }
  } else {
    // 目标索引在当前索引之后
    if (diff > 3 && diff < length - 3) {
      // 距离超过3个位置（正向），但未到反向的3个位置
      return 3; // 截断为3
    } else if (diff >= length - 3) {
      // 循环后距离在-1到-3之间
      return diff - length;
    } else {
      // 距离在1到3之间
      return diff;
    }
  }
}

/**
 * 计算循环数组中索引的相对偏移量，并限制最大绝对值为N。
 *
 * @param {number} currentIndex 当前索引。
 * @param {number} index 目标索引。
 * @param {number} length 数组总长度。
 * @param {number} maxOffset 允许的最大偏移量（例如 3）。
 * @returns {number} 目标索引相对于当前索引的偏移量，范围在 [-maxOffset, maxOffset] 之间，
 *                   超出范围的将被截断为 maxOffset 或 -maxOffset。
 */
function getOffset(currentIndex, index, length, maxOffset = 3) {
  // 1. 计算两个索引之间的“正向”循环距离。
  // (index - currentIndex + length) 确保结果为正，然后 % length 得到0到length-1的距离。
  const diff = (index - currentIndex + length) % length;

  // 2. 根据正向距离判断实际偏移量。
  if (diff <= maxOffset) {
    // 如果正向距离小于等于maxOffset，直接返回该距离。
    // 这涵盖了 currentIndex, currentIndex+1, ..., currentIndex+maxOffset 等情况。
    return diff;
  } else if (diff >= length - maxOffset) {
    // 如果正向距离大于等于 length - maxOffset，
    // 这意味着目标索引在循环方向上位于 currentIndex 之后，但实际是“负向”的较小距离。
    // 例如，length=10, maxOffset=3, currentIndex=0, index=7。
    // diff = 7。 length - maxOffset = 7。
    // 7 >= 7 成立。
    // 返回 diff - length = 7 - 10 = -3。
    // 这涵盖了 currentIndex-1, currentIndex-2, ..., currentIndex-maxOffset (循环后) 等情况。
    return diff - length;
  } else {
    // 其他所有情况，即正向距离大于 maxOffset 且小于 length - maxOffset。
    // 这些索引都超出了 maxOffset 的范围，无论正向还是反向，
    // 因此统一截断为 maxOffset。
    // 例如，length=10, maxOffset=3, currentIndex=0, index=4, 5, 6。
    // diff = 4, 5, 6。这些值都不满足前两个条件，因此返回 maxOffset (3)。
    return maxOffset;
  }
}

// 假设 currentIndex = 0, length = 10, maxOffset = 3

// 自身偏移量为0
console.log(getOffset(0, 0, 10, 3)); // 输出: 0

// 正向偏移量在限制内
console.log(getOffset(0, 1, 10, 3)); // 输出: 1
console.log(getOffset(0, 2, 10, 3)); // 输出: 2
console.log(getOffset(0, 3, 10, 3)); // 输出: 3

// 正向偏移量超出限制，截断为 maxOffset (3)
console.log(getOffset(0, 4, 10, 3)); // 输出: 3
console.log(getOffset(0, 5, 10, 3)); // 输出: 3
console.log(getOffset(0, 6, 10, 3)); // 输出: 3

// 反向偏移量在限制内（通过循环计算）
// index = 7 相当于 0 - 3 (循环)
console.log(getOffset(0, 7, 10, 3)); // 输出: -3
// index = 8 相当于 0 - 2 (循环)
console.log(getOffset(0, 8, 10, 3)); // 输出: -2
// index = 9 相当于 0 - 1 (循环)
console.log(getOffset(0, 9, 10, 3)); // 输出: -1

// 改变 currentIndex
console.log(getOffset(5, 8, 10, 3)); // currentIndex=5, index=8. diff = (8-5+10)%10 = 3. 输出: 3
console.log(getOffset(5, 2, 10, 3)); // currentIndex=5, index=2. diff = (2-5+10)%10 = 7. length-maxOffset = 7. 7 >= 7 成立. 返回 7-10 = -3. 输出: -3