我们经常会遇到这样的情况：我们需要找到一种方法，根据一些身份的概念来存储对象。无论是在缓存中，还是在磁盘上存储对象的表示，或者简单地使用字典——我们经常需要找到方法来唯一地识别我们所处理的对象。

本周，让我们来看看在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，编译器就能够自动合成上述内容。

例如，我们现在能够建立一个只有独特书籍的收藏：

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