Swift 中的 Hashable 协议是一个用于生成哈希值的核心协议，它使得遵循该协议的类型可以将实例转换为唯一的整数值（哈希值）。这个协议在集合类型（如 Set 和 Dictionary）的高效存储和查找中至关重要。

1. Hashable 协议的本质 #

1.1 哈希值的作用 #

• 核心目的：将任意大小的数据映射到固定大小的整数（哈希值），用于：
  • 快速查找：在集合（如 Set、Dictionary）中通过哈希值快速定位元素。
  • 唯一性判断：结合 Equatable 协议，确保两个哈希值相同的对象是否真正相等。
• 数据结构依赖：Set 和 Dictionary 的底层实现依赖哈希表（Hash Table），其性能（接近 O(1) 时间复杂度）直接依赖哈希值的质量。

1.2 Hashable 与 Equatable 的关系 #

• 继承关系：Hashable 继承自 Equatable，因此必须实现 == 运算符。
• 一致性要求：
  • 如果 a == b，则 a.hashValue == b.hashValue（这是 Hashable 的强制要求）。
  • 如果 a.hashValue != b.hashValue，则 a != b（这是上述规则的逻辑推论）。
  • 如果 a.hashValue == b.hashValue，a == b 可能为 true 或 false（哈希碰撞时需进一步判断）。

2. 何时必须使用 Hashable？ #

2.1 强制使用场景 #

以下场景中，自定义类型 必须 遵循 Hashable 协议：

1. 作为 Dictionary 的键（Key）

   struct User: Hashable { /* ... */ }
   var userScores: [User: Int] = [:]  // Key 必须 Hashable
   

2. 存入 Set

   let uniqueUsers = Set<User>()  // 元素必须 Hashable
   

3. 需要唯一性判断的集合操作
   例如 Array 的去重：

   let users = [user1, user2, user1]
   let uniqueUsers = Array(Set(users))  // 依赖 Hashable
   

4. 某些算法或库的强制要求
   例如 Swift 的 Identifiable 协议结合集合操作时，可能需要 Hashable。

2.2 推荐使用场景 #

• 高性能查找：当需要快速判断对象是否存在（如缓存、索引）。
• 自定义数据结构的实现：如实现自己的哈希表、布隆过滤器等。

3. 如何实现 Hashable？ #

3.1 自动合成（Swift 的默认支持） #

• 适用条件：

  • 结构体（Struct）：所有存储属性（Stored Properties）必须遵循 Hashable。
  • 枚举（Enum）：所有关联值（Associated Values）必须遵循 Hashable（无关联值的枚举自动支持）。
  • 类（Class）：不支持自动合成（因为类可能涉及继承和引用语义）。

• 示例 1：结构体自动合成

  struct Student: Hashable {
      let id: Int       // Int 是 Hashable 的
      let name: String  // String 是 Hashable 的
  }
  // Swift 自动生成 hash(into:) 和 ==
  

• 示例 2：枚举自动合成

  enum Device: Hashable {
      case phone(model: String)  // String 是 Hashable
      case laptop(weight: Double, brand: String)
  }
  

3.2 手动实现 Hashable #

当以下情况发生时，需要手动实现 hash(into:) 和 ==：

1. 需要忽略某些属性：例如不参与哈希计算的临时属性。
2. 自定义哈希逻辑：例如组合多个属性的哈希值。
3. 类的实现：类必须手动实现（因为不支持自动合成）。

手动实现步骤： #

1. 实现 func hash(into hasher: inout Hasher)，将关键属性通过 hasher.combine(_:) 合并。
2. 实现 static func == (lhs: Self, rhs: Self) -> Bool，确保与哈希逻辑一致。

4. 具体代码示例 #

示例 1：忽略某些属性的手动实现 #

struct Person: Hashable {
    let id: Int
    let name: String
    var age: Int  // age 不参与哈希
    
    func hash(into hasher: inout Hasher) {
        hasher.combine(id)
        hasher.combine(name)
        // 忽略 age
    }
    
    static func == (lhs: Person, rhs: Person) -> Bool {
        lhs.id == rhs.id && lhs.name == rhs.name
    }
}

示例 2：类的实现（必须手动） #

class User: Hashable {
    let id: UUID
    var name: String
    
    init(id: UUID, name: String) {
        self.id = id
        self.name = name
    }
    
    func hash(into hasher: inout Hasher) {
        hasher.combine(id)  // 仅用 id 作为哈希依据
    }
    
    static func == (lhs: User, rhs: User) -> Bool {
        lhs.id == rhs.id
    }
}

示例 3：组合属性的哈希（如坐标点） #

struct Point: Hashable {
    let x: Int
    let y: Int
    
    func hash(into hasher: inout Hasher) {
        hasher.combine(x)
        hasher.combine(y)
    }
    
    static func == (lhs: Point, rhs: Point) -> Bool {
        lhs.x == rhs.x && lhs.y == rhs.y
    }
}

示例 4：枚举的复杂关联值 #

enum Transaction: Hashable {
    case payment(amount: Double, currency: String)
    case refund(reason: String, amount: Double)
    
    // 无需手动实现，因为关联值类型均为 Hashable
}

5. 高级注意事项 #

5.1 哈希值的稳定性 #

• 单次运行稳定：同一对象在程序的一次运行中哈希值必须相同。
• 跨运行不稳定：出于安全考虑（防止哈希泛洪攻击），不同运行中同一对象的哈希值可能不同。

5.2 避免哈希冲突 #

• 设计原则：
  • 关键属性参与哈希：选择唯一性强的属性（如 id）。
  • 组合多个属性：例如同时哈希 name 和 id，减少碰撞概率。
  • 避免哈希质量差的属性：例如浮点数（精度问题）。

5.3 不可变性与哈希 #

• 禁止在哈希后修改属性：

  var user = User(id: 1, name: "Alice")
  let set = Set([user])
  user.name = "Bob"  // 修改后，集合中的哈希值失效，导致行为未定义！
  

6. 总结 #

必须使用 Hashable 的场景 #

• 类型作为 Dictionary 的键或 Set 的元素。
• 需要快速查找、去重的场景（如缓存、唯一性校验）。

实现方式 #

• 自动合成：优先用于结构体和枚举（确保所有属性满足条件）。
• 手动实现：用于类或需要自定义逻辑的情况，确保 hash(into:) 和 == 的一致性。

最佳实践 #

• 尽量使用不可变属性（let）参与哈希。
• 类的哈希应基于唯一标识（如 id），而非可变状态。
• 避免依赖哈希值的跨运行稳定性。

通过合理设计哈希逻辑，可以显著提升数据结构的性能和代码的健壮性。