Hashable

This article is extracted from the chat log with AI. Please identify it with caution.

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 协议：

作为 Dictionary 的键（Key）

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

存入 Set

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

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

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

某些算法或库的强制要求
例如 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:) 和 ==：

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

手动实现步骤：#

实现 func hash(into hasher: inout Hasher)，将关键属性通过 hasher.combine(_:) 合并。
实现 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），而非可变状态。
避免依赖哈希值的跨运行稳定性。

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