一致性哈希是什么？解决了什么问题？

                  0 / 2^32
                 ┌───●───┐
         节点 C ●          ● 节点 A
                │   环    │      key1 ──顺时针──> 节点 A
         节点 D ●          │      key2 ──顺时针──> 节点 B
                 └───●───┘
                   节点 B

新增节点 E 放在 A 和 B 之间：
  只有原本落在 (A, E] 区间的 key 从 B 移到 E，其他 key 不动
删除节点 B：
  原本属于 B 的 key 顺延给下一个节点 C，其他 key 不动

import { createHash } from 'node:crypto'

// 取 MD5 的前 4 个字节作为 32 位无符号整数，环的范围是 0 ~ 2^32-1
const hash = (key) => createHash('md5').update(key).digest().readUInt32BE(0)

class ConsistentHash {
  constructor(nodes = [], replicas = 160) {
    this.replicas = replicas // 每个物理节点对应的虚拟节点数
    this.ring = [] // 按 hash 升序排列的 { hash, node }
    nodes.forEach((n) => this.addNode(n))
  }

  addNode(node) {
    for (let i = 0; i < this.replicas; i++) {
      this.ring.push({ hash: hash(`${node}#${i}`), node })
    }
    this.ring.sort((a, b) => a.hash - b.hash)
  }

  removeNode(node) {
    this.ring = this.ring.filter((v) => v.node !== node)
  }

  getNode(key) {
    if (this.ring.length === 0) return null
    const h = hash(key)
    // 二分查找第一个 hash >= h 的虚拟节点
    let lo = 0
    let hi = this.ring.length
    while (lo < hi) {
      const mid = (lo + hi) >>> 1
      if (this.ring[mid].hash < h) lo = mid + 1
      else hi = mid
    }
    // 超过最后一个节点就回到环的起点（顺时针绕一圈）
    return this.ring[lo % this.ring.length].node
  }
}

// 验证：加一个节点后，有多少 key 换了位置
const keys = Array.from({ length: 100000 }, (_, i) => `user:${i}`)
const ch = new ConsistentHash(['cache-a', 'cache-b', 'cache-c', 'cache-d'])
const before = keys.map((k) => ch.getNode(k))
ch.addNode('cache-e')
const moved = keys.filter((k, i) => ch.getNode(k) !== before[i]).length
console.log(`一致性哈希迁移比例：${(moved / keys.length * 100).toFixed(1)}%`) // 接近 1/5

const modMoved = keys.filter((k) => hash(k) % 4 !== hash(k) % 5).length
console.log(`取模迁移比例：${(modMoved / keys.length * 100).toFixed(1)}%`) // 约 80%