Hashable是最常见的协议之一。也许是由于它太常见了。以至于好多人都没法正确的实现它。下面总结一下实现它需要的原则。
基本原则
基本原则只有两条：
Hashable继承了Equatable。因此，要实现Hashable必须同时实现Equatable。- 当相同类型的
a与b相等时，它们的hashValue相等。反之不成立，即hashValue相等的两个相同类型的a与b，不一定相等。
class Fruit:Hashable {
let name:String
var hashValue: Int {
return name.hashValue
}
init(name:String) {
self.name = name
}
static func ==(lhs: Fruit, rhs: Fruit) -> Bool {
return lhs.name == rhs.name
}
}
注意
var hashValue: Int只要求返回值，因此如何实现都可以，设置只返回固定的值，比如var hashValue: Int { return 10 }也是可以的。
不能使用hashValue来判断是否相等。
不同的解读
上面的代码在涉及到子类时，不同的人会有不同的理解。比如：
class Apple:Fruit {
override var hashValue: Int {
return super.hashValue - "apple".characters.count
}
}
class Banana:Fruit {
override var hashValue: Int {
return super.hashValue - "banana".characters.count
}
}
let a = Apple(name: "")
let b = Banana(name: "")
print(a == b) // true
print(a.hashValue) // prints 4799450059485596700
print(b.hashValue) // prints 4799450059485596699
上面的代码，print(a == b) // true，但是hashValue却不相等。这违背了上面提到的基本原则2。这段代码需要修改。但是如何修改，不同的人有不同的看法。
判断类型
我认为最好的办法就是优先判断类型。因为，类型不同的类，就不应该相等。比如一个苹果就不应该和一个香蕉相等。
class Fruit:Hashable {
let name:String
var hashValue: Int {
return name.hashValue
}
init(name:String) {
self.name = name
}
static func ==(lhs: Fruit, rhs: Fruit) -> Bool {
return type(of:lhs) == type(of:rhs) && lhs.name == rhs.name
}
}
class Apple:Fruit {
override var hashValue: Int {
return super.hashValue - "apple".characters.count
}
}
class Banana:Fruit {
override var hashValue: Int {
return super.hashValue - "banana".characters.count
}
}
let a = Apple(name: "")
let b = Banana(name: "")
print(a == b) // false
print(a.hashValue) // prints 4799450059485596700
print(b.hashValue) // prints 4799450059485596699
即在非final的类的==里，总是先比较类型，类型相同的，再毕竟其它。这么做之后，就永远不会发生一个苹果等于一个香蕉的笑话了。但是这里还有一个问题，我们没有编写子类的==。这里暂时没有问题，但是如果遇到有其它属性的子类，就可能出现问题。
class Orange:Fruit {
let weight:Double
override var hashValue: Int {
return super.hashValue - "orange".characters.count + Int(weight)
}
init(name: String, weight: Double) {
self.weight = weight
super.init(name: name)
}
}
let o1 = Orange(name: "", weight: 0.4)
let o2 = Orange(name: "", weight: 1.2)
print(o1 == o2) // true
print(o1.hashValue) // prints 4799450059485596699
print(o2.hashValue) // prints 4799450059485596700
由于Orange没有重新定义==，比较时，直接调用了Fruit的==，导致了不符合基本原则2。补救办法就是在Orange重新定义==。
class Orange:Fruit {
let weight:Double
override var hashValue: Int {
return super.hashValue - "orange".characters.count + Int(weight)
}
static func ==(lhs: Orange, rhs: Orange) -> Bool {
return type(of:lhs) == type(of:rhs) && lhs.name == rhs.name && lhs.weight == rhs.weight
}
init(name: String, weight: Double) {
self.weight = weight
super.init(name: name)
}
}
let o1 = Orange(name: "", weight: 0.4)
let o2 = Orange(name: "", weight: 1.2)
print(o1 == o2) // false
print(o1.hashValue) // prints 4799450059485596699
print(o2.hashValue) // prints 4799450059485596700
不重写hashValue，仅重新定义==
一些特殊的情况下，也许你可以不重写hashValue，而仅重新定义==。
import Foundation
import Cocoa
class Fruit:Hashable {
let name:String
var hashValue: Int {
return name.hashValue
}
init(name:String) {
self.name = name
}
static func ==(lhs: Fruit, rhs: Fruit) -> Bool {
return lhs.name == rhs.name
}
}
class Apple:Fruit {
}
class ColoredApple:Apple {
let color:NSColor
init(name:String, color:NSColor) {
self.color = color
super.init(name: name)
}
static func ==(lhs: ColoredApple, rhs: ColoredApple) -> Bool {
return lhs.name == rhs.name && lhs.color == rhs.color
}
}
let greenApple = ColoredApple(name: "green apple", color: .green)
let apple = Apple(name: "green apple")
print(greenApple == apple) // true
print(greenApple.hashValue) // -2580839601755588497
print(apple.hashValue) //-2580839601755588497
var set:Set<Apple> = [greenApple, apple]
print(set.count) // 1
var d:Dictionary<Apple, Int> = [greenApple:10]
// eat one
d.updateValue(d[greenApple]! - 1, forKey: apple)
print(d[greenApple]!) // 9
这种做法不常见，一旦选择了不重写hashValue，就必须在该基类的所有子类都保持一致。
注意
由于Set和Dictionary使用hashValue进行判断，放入其中的元素的hashValue在没有从其中移出时，不能改变，否则会出现问题。
可以看到apple和greenApple因为hashValue相同，它们在Set和Dictionary里被当做是同一元素/键值。
