Swift 4.1 新特性 (3) 合成 Equatable 和 Hashable

96
面试官小健
1.2 2018.04.05 14:43* 字数 1439

编译器合成 (synthesize) 是十分重要的功能,它把开发者从简单重复的劳动中解放出来。在Swift 4.0 中,我们知道 Codable 可以合成相关函数,于是 Codable 的实现者在大部分情况下不需要实现相关函数。 到了 Swift 4.1,Equatable 和 Hashable 也支持了合成。触发合成的一个重要的必要非充分条件是:包含的存储属性或相关值全都是 Codable / Equatable / Hashable,编译器才有可能推导出这个类型的相关函数实现。

我们先复习一下相关概念:

  1. 如果对象相等,则这两个对象的 hash 值一定相等。

  2. 如果两个对象 hash 值相等,这两个对象不一定相等。

  3. Swift 中 Hashable 一定是 Equatable,因为前者继承了后者。

  4. 修改 == 函数的时候需要考虑是否同步修改 hashValue,反之亦然。

  5. Dictionary 和 Set 的中的 Key 类型都要求是 Hashable

1. 合成 Equatable

我们以前得手写如下代码。缺点:1. 实现很冗长无聊。2. 增删改一个属性还得记得改这个函数。

struct Person: Equatable {
  static func == (lhs: Person, rhs: Person) -> Bool {
    return 
    lhs.firstName == rhs.firstName &&
    lhs.lastName == rhs.lastName &&
    lhs.birthDate == rhs.birthDate &&
...
  }
}

现在舒服了,声明下 : Equatable即可,编译器帮你合成 == 函数的实现。

struct Person: Equatable { ... }

这样是否意味着可以无脑申明 Equatable 了呢?并不是这样。在某些属性不参与相等比较时,必须自己实现,让编译器不要合成。举个例子,假如 Person 有一个属性叫 createdTime,记录了它被创建的时间,如果我们不希望这个属性参与相等比较,就需要自己实现 == 函数。

我们回顾一下 enum 在 Swift 4.1 版本前的情况,以下三种情况哪些可以编译通过呢?

// eg1
enum SSS {
    case a
    case b
}
SSS.a == SSS.b

// eg2
enum KKK : String {
    case a
    case b
}
KKK.a == KKK.b

// eg3
enum Token {
    case string(String)
    case number(Int)
    case lparen
    case rparen
}
Token.string("123") == Token.string("456")

答案是:例子1、2能编译过,例子 3编译不过。SSS 是最简单的 enum,KKK是带有 rawType 的 enum,这两个在 Swift 4.1 之前就自动是 Equatable 和 Hashable,即便不显式声明
例子3是带 associated value 的 enum,在 Swift 4.1 之前需要实现 Equatable,不仅要声明 :Equatable,还得自己写 == 方法,你还记得怎么写吗?,不妨不要看下面的答案,练习一下 Pattern Matching。

  static func == (lhs: Token, rhs: Token) -> Bool {
    switch (lhs, rhs) {
    case (.string(let lhsString), .string(let rhsString)):
      return lhsString == rhsString
    case (.number(let lhsNumber), .number(let rhsNumber)):
      return lhsNumber == rhsNumber
    case (.lparen, .lparen), (.rparen, .rparen):
      return true
    default:
      return false
    }
  }

在 Swift 4.1 中,例子 3 我们仅仅需要声明 :Equatable 就能让编译器帮我们合成==方法,太方便了。

2. 合成 Hashable

试想一下,上面那个带 associated value 的 enum,如何实现它的 hashValue方法呢?有可能你已经有了答案,但这里同样可以声明 :Hashable让编译器合成。

接下来我们来回顾下什么是 hash 函数。这个函数目的是:将原来对象的域映射到 Int 的值域。笔者认为 hash 函数设计的难点有两个:

  1. 如何将一个输入的域(对象的可取值范围),映射到一个一般来说更小的域(Int),同时又尽可能防止不同的对象得到同一个 Int,(这种情况叫“冲突”,冲突不可避免,但大规模冲突会大幅降低对象检索效率,最简单的hash函数实现是 return 1,但却是最糟糕的hash函数)
  2. hash 函数效率非常重要,它可能会被非常频繁地调用。除了 hash 函数算法本身,我们可以设计缓存策略,特别是在不可变情况比较多的 struct 和 enum 的时候。

基于以上两点:编译器合成的 hash 函数能保证高质量,但很有可能不是最优的。因为编译器无法得到一些只有你知道的信息:比如属性的实际值域:var age: Int(不可能是负数;如果是 Person 结构,取值范围在0-200等),又比如属性之间的关系特性,而往往你可以利用这些信息设计出更优的 hash 函数。

合成 Hashable 跟 Equatable 一样,声明 :Hashable 之后,可以自己实现,来压制编译器的合成行为。

Hashable 和 Equatable 还有一些编译器不合成的情况需要特别指出:

  1. class 不合成,原因是继承情况下比较复杂,合成出来也不一定是你要的。
  2. extension 声明实现 Hashable 或 Equatable 时也不合成。

其他:标准库 Index 类型支持 Hashable

除了同样是 Swift 4.1 的新特性并且同样跟 Hashable 相关,跟本文主题没太多关系,这里增强的是:标准库将 Index 类型都实现了 Hashable。

我们知道 Swift 有个特性叫强类型的 Key Path。如果 Key Path 中用下标表达式的话,下标类型必须是 Hashable 的,Int 原本就是,而String.Index原来不是,所以下面例子中第二段的代码只在 Swift 4.1 中是合法的。

let numbers = [10, 20, 30, 40, 50]
let firstValue = \[Int].[0]
print(numbers[keyPath: firstValue])     // 10

let string = "Helloooo!"
let firstChar = \String.[string.startIndex] // valid in Swift 4.1 or later

小结

在本文中,我们探讨了:

  • 合成 Hashable和 Equatable 的价值。
  • 合成的局限性,需要自己书写函数的情况和注意点。
  • 编译器不合成的情况。
  • 标准库 Index 类型支持 Hashable,增强Key Path表达式能力。

Swift 4.1 新特性系列文章

Swift 4.1 新特性 (1) Conditional Conformance
Swift 4.1 新特性 (2) Sequence.compactMap
Swift 4.1 新特性 (3) 合成 Equatable 和 Hashable
Swift 4.1 新特性 (4) Codable的改进

Swift