我们经常会遇到这样的情况：我们需要找到一种方法，根据一些身份的概念来存储对象。无论是在缓存中，还是在磁盘上存储对象的表示，或者简单地使用字典——我们经常需要找到方法来唯一地识别我们所处理的对象。
本周，让我们来看看在Swift中我们所掌握的一些常见的身份概念，以及我们如何以不同的方式将它们用于值和对象。
Equatable ==
一个经常被用来比较对象和值的核心协议是Equatable。这是一个你们中的许多人可能已经熟悉的协议，因为无论何时你想使==操作符与一个类型一起使用，你都需要遵守它，这里有一个例子：
struct Book {
let title: String
let author: String
}
extension Book: Equatable {
static func ==(lhs: Book, rhs: Book) -> Bool {
guard lhs.title == rhs.title else {
return false
}
guard lhs.author == rhs.author else {
return false
}
return true
}
}请注意，上述
==的手动实现其实已经不需要了，因为编译器会自动为任何只有符合Equatable属性的类型合成为符合Equatable（比如我们上面的Book类型）。
实例的 Equatable ===
虽然Equatable非常适合处理值（如结构体或枚举），但对于对象/类，它可能不是你要找的。有时你想检查两个对象是否是同一个实例。要做到这一点，我们使用==的较少为人所知的同胞 ===，它让你根据两个对象的实例，而不是它们的值来比较。
让我们来看一个例子，我们想在每次给InventoryManager分配一个新的dataSource时重新加载它:
// 具有 "AnyObject "约束的协议只能由类来遵守，
// 使我们能够假设将使用一个对象。
protocol InventoryDataSource: AnyObject {
var numberOfItems: Int { get }
func item(at index: Int) -> Item
}
class InventoryManager {
var dataSource: InventoryDataSource? {
// 'oldValue'是一个神奇的变量，当一个新的属性被设置时，
// 它总是含有该属性的前一个值
didSet { dataSourceDidChange(from: oldValue) }
}
private func dataSourceDidChange(from previousDataSource: InventoryDataSource?) {
// 如果同一数据源被重新分配，我们不希望重新加载
guard previousDataSource !== dataSource else {
return
}
reload()
}
}正如你在上面看到的，使用===可以非常整洁，因为它使你能够执行检查，而不要求符合某个协议的类型也实现Equatable。
Hashable
就像Equatable一样，另一个在处理值类型时要遵守的协议是Hashable。当你在某种形式的基于哈希的集合中使用一个类型时，这是一个要求，比如Set，或者作为Dictionary中的一个键。
让我们把之前的Book类型扩展到也符合Hashable:
extension Book: Hashable {
func hash(into hasher: inout Hasher) {
hasher.combine(title)
hasher.combine(author)
}
}同样，如果一个类型的所有属性也符合
Hashable，编译器就能够自动合成上述内容。
例如，我们现在能够建立一个只有独特书籍的收藏：
代码语言：javascript复制class BookStore {
var inventory = [Book]()
var uniqueBooks = Set<Book>()
func add(_ book: Book) {
// 清单将包含所有的书籍，包括重复的。
inventory.append(book)
// 通过使用一个集合（我们可以这样做，因为'Book'符合'Hashable'的要求）
// 我们可以保证'uniqueBooks'只包含唯一的值
uniqueBooks.insert(book)
}
}Protocols 和 Hashable
虽然Hashable在处理具体类型时（比如上面的BookStore例子）很容易使用（尽管它的实现可能有点样板化），但在处理协议时就会变得有点棘手。
在使用哈希值时要记住的一点是，只有当你知道你的所有对象或值都是完全相同的类型时，你才能依赖它们。由于协议不是这种情况，我们必须依靠其他方法。
假设我们正在构建一个渲染API，不同的对象可以在屏幕下次绘制帧的时候请求被渲染。为了使用这个API，对象要符合一个Renderable协议，并在需要时使用一个Renderer来排队等待渲染（类似于UIView有一个setNeedsLayout方法），像这样:
class Circle {
var radius: CGFloat {
didSet { renderer?.enqueue(self) }
}
var strokeColor: UIColor {
didSet { renderer?.enqueue(self) }
}
weak var renderer: Renderer?
}
extension Circle: Renderable {
func render(in context: CGContext) {
context.drawCircle(withRadius: radius, strokeColor: strokeColor)
}
}作为一种优化，我们要确保每一帧只渲染一个对象，即使它可能在一帧绘制之前多次请求渲染。为了实现这一点，我们需要跟踪符合Renderable的独特实例，这些实例已经被排队了，但由于这些实例可能是完全不同的类型，我们不能只是把Equatable或Hashable作为一个要求。
对象标识符 ObjectIdentifier
解决上述问题的一个办法，是使用 Swift 的 ObjectIdentifier 类型来识别实例，并确保我们的渲染队列不会包含重复的实例。
func enqueue(_ renderable: Renderable) {
let identifier = ObjectIdentifier(renderable)
}ObjectIdentifier已经符合Equatable和Hashable，这使我们能够在Renderable周围写一个薄的包装类型，使用每个实例的标识符来为它提供身份。
class RenderableWrapper {
fileprivate let renderable: Renderable
init(renderable: Renderable) {
self.renderable = renderable
}
}
extension RenderableWrapper: Renderable {
func render(in context: CGContext) {
// 将调用转发到底层实例
renderable.render(in: context)
}
}
extension RenderableWrapper: Equatable {
static func ==(lhs: RenderableWrapper, rhs: RenderableWrapper) -> Bool {
// 比较底层实例
return lhs.renderable === rhs.renderable
}
}
extension RenderableWrapper: Hashable {
func hash(into hasher: inout Hasher) {
// U使用实例的唯一标识符进行散列
hasher.combine(ObjectIdentifier(renderable))
}
}现在我们可以简单地使用一个Set来跟踪需要在我们的渲染器Renderer中进行渲染的唯一实例:
class Renderer {
private var objectsNeedingRendering = Set<RenderableWrapper>()
func enqueue(_ renderable: Renderable) {
// 因为我们使用了一个 "Set"，所以重复的部分会自动被抛弃。
// 我们不需要为此编写任何代码
let wrapper = RenderableWrapper(renderable: renderable)
objectsNeedingRendering.insert(wrapper)
}
func screenDidDraw() {
// 首先清空队列
let objects = objectsNeedingRendering
objectsNeedingRendering = []
// Render each object
for object in objects {
let context = makeContext()
object.render(in: context)
}
}
}结论
当使用值时，Equatable和Hashable可能是身份识别方面的方法——因为你更多地是在比较一个值的规范化表示，而不是一个唯一的实例。然而，在处理对象时，使用这篇文章中的一些技术可以使你的API更容易使用，从而降低复杂性并提高稳定性。
你可以使用===操作符和ObjectIdentifier类型这样的技术来快速、唯一地识别对象，而不是要求实现者符合Equatable，或暴露某种形式的唯一标识符（如UUID），不需要太多的额外代码。
你怎么看？在处理Swift中的对象身份时，你还有其他喜欢的技术吗？
译自 John Sundell 的 Identifying objects in Swift
