如何计算循环数组索引与目标索引的距离并限制在N个位置内

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

  if (diff === 0) {
    return 0;
  } else if (diff < 0) { // 目标索引在当前索引之前
    // 检查是否在反向3个位置内
    if (diff > -3) { // 例如 diff = -1, -2
      return diff;
    } else { // 例如 diff = -4, -5, ... 或者通过循环从右侧过来
      // 计算循环距离，并限制在 3
      // length - currentIndex + index 实际上是计算从 currentIndex 到 length-1 再到 index 的距离
      // 例如 currentIndex=0, index=7, length=10 => 10 - 0 + 7 = 17 (不对)
      // 应该是 (index - currentIndex + length) % length 得到正向距离，然后判断
      // 这里的逻辑是想处理反向超出3个位置的情况，例如 currentIndex=0, index=7, length=10
      // diff = 7，但从左侧看是 -3。
      // 这里的 Math.min(length - currentIndex + index, 3) 似乎有误，且返回值是正数。
      // 它尝试处理的是类似 index=7 (对于 currentIndex=0, length=10) 应该返回 -3 的情况
      // 但实际返回值 Math.min(10 - 0 + 7, 3) = Math.min(17, 3) = 3，这不符合 -3 的预期。
      // 实际上，这个分支的目的应该是返回 -3。
      // 并且，如果 diff 是 -4，它应该返回 -3。
      return Math.min(diff, 3); // 这一行可能导致错误，因为 diff 是负数，min(负数, 3) 还是负数。
                               // 比如 diff = -4，返回 -4，与期望的 -3 不符。
    }
  } else { // 目标索引在当前索引之后
    // 检查是否在正向3个位置内
    if (diff < length - 3) { // 例如 diff = 1, 2, 3
      return Math.min(diff, 3); // 这一行实际上是返回 diff，或者 3。
                                // 例如 diff=1, 返回1；diff=3, 返回3；diff=4, 返回3。
    } else { // 例如 diff = 7, 8, 9 (对于 length=10)
      // 计算循环距离，并限制在 -3
      // 例如 currentIndex=0, index=7, length=10 => diff=7
      // diff - length = 7 - 10 = -3
      return Math.max(diff - length, -3); // 返回 -3。
    }
  }
}

getOffset(0, 0, 10) -> 0
getOffset(0, 1, 10) -> 1
getOffset(0, 9, 10) -> -1  // 预期 -1，实际 Math.min(-1, 3) = -1
getOffset(0, 6, 10) -> 3   // 预期 3，实际 Math.min(6, 3) = 3

function getOffset(currentIndex: number, index: number, length: number): number {
  // 1. 计算正向循环距离
  // (index - currentIndex + length) % length 确保结果始终为非负数，
  // 表示从 currentIndex 顺时针到 index 的距离。
  // 例如：currentIndex=0, index=9, length=10
  // diff = (9 - 0 + 10) % 10 = 19 % 10 = 9
  // 例如：currentIndex=5, index=2, length=10
  // diff = (2 - 5 + 10) % 10 = 7 % 10 = 7
  const diff = (index - currentIndex + length) % length;

  // 2. 根据正向循环距离判断最终偏移量
  const maxDistance = 3; // 可配置的最大距离

  if (diff <= maxDistance) {
    // 如果正向距离在允许范围内（0到maxDistance），直接返回该距离。
    // 例如：diff = 0, 1, 2, 3
    return diff;
  } else if (diff >= length - maxDistance) {
    // 如果正向距离非常大，说明目标索引在当前索引的“左侧”或“逆时针”方向，
    // 且距离在允许范围内。
    // 例如：currentIndex=0, index=9, length=10, maxDistance=3
    // diff = 9
    // length - maxDistance = 10 - 3 = 7
    // diff (9) >= (7) 为真
    // 此时，9 - 10 = -1，表示逆时针方向距离为1。
    // 例如：currentIndex=0, index=7, length=10, maxDistance=3
    // diff = 7
    // length - maxDistance = 7
    // diff (7) >= (7) 为真
    // 此时，7 - 10 = -3，表示逆时针方向距离为3。
    return diff - length;
  } else {
    // 其他情况：正向距离大于 maxDistance，且逆向距离也大于 maxDistance。
    // 根据需求，这些超出范围的索引应统一映射到 maxDistance。
    // 例如：currentIndex=0, index=4, length=10, maxDistance=3
    // diff = 4
    // diff <= 3 为假
    // diff >= 10 - 3 (即 7) 为假
    // 进入此分支，返回 3。
    return maxDistance;
  }
}

const length = 10;
const currentIndex = 0;

console.log(`getOffset(${currentIndex}, 0, ${length}) -> ${getOffset(currentIndex, 0, length)}`); // 0 (预期 0)
console.log(`getOffset(${currentIndex}, 1, ${length}) -> ${getOffset(currentIndex, 1, length)}`); // 1 (预期 1)
console.log(`getOffset(${currentIndex}, 2, ${length}) -> ${getOffset(currentIndex, 2, length)}`); // 2 (预期 2)
console.log(`getOffset(${currentIndex}, 3, ${length}) -> ${getOffset(currentIndex, 3, length)}`); // 3 (预期 3)
console.log(`getOffset(${currentIndex}, 4, ${length}) -> ${getOffset(currentIndex, 4, length)}`); // 3 (预期 3)
console.log(`getOffset(${currentIndex}, 5, ${length}) -> ${getOffset(currentIndex, 5, length)}`); // 3 (预期 3)
console.log(`getOffset(${currentIndex}, 6, ${length}) -> ${getOffset(currentIndex, 6, length)}`); // 3 (预期 3)
console.log(`getOffset(${currentIndex}, 7, ${length}) -> ${getOffset(currentIndex, 7, length)}`); // -3 (预期 -3)
console.log(`getOffset(${currentIndex}, 8, ${length}) -> ${getOffset(currentIndex, 8, length)}`); // -2 (预期 -2)
console.log(`getOffset(${currentIndex}, 9, ${length}) -> ${getOffset(currentIndex, 9, length)}`); // -1 (预期 -1)

// 针对其他 currentIndex 的测试
console.log(`getOffset(5, 2, ${length}) -> ${getOffset(5, 2, length)}`); // (2-5+10)%10 = 7. 7 >= 10-3=7 -> 7-10 = -3. (预期 -3)
console.log(`getOffset(5, 8, ${length}) -> ${getOffset(5, 8, length)}`); // (8-5+10)%10 = 3. 3 <= 3 -> 3. (预期 3)
console.log(`getOffset(5, 9, ${length}) -> ${getOffset(5, 9, length)}`); // (9-5+10)%10 = 4. 4 <= 3 为假，4 >= 7 为假 -> 3. (预期 3)