KeyPath在Swift中的妙用

原文链接: The power of key paths in Swift

自从swift刚开始就被设计为是编译时安全和静态类型后，它就缺少了那种我么经常在运行时语言中的动态特性，比如Object-C, Ruby和JavaScript。举个例子，在Object-C中，我们可以很轻易的动态去获取一个对象的任意属性和方法 - 甚至可以在运行时交换他们的实现。

虽然缺乏动态性正是Swift如此强大的一个重要原因 - 它帮助我们编写更加可以预测的代码以及更大的保证了代码编写的准确性, 但是有的时候，能够编写具有动态特性的代码是非常有用的。

值得庆幸的是，Swift不断获取越来越多的更具动态性的功能，同时还一直把它的关注点放在代码的类型安全上。其中的一个特性就是KeyPath。这周，就让我们来看看KeyPath是如何在Swift中工作的，并且有哪些非常酷非常有用的事情可以让我们去做。

基础知识

Key paths实质上可以让我们将任意一个属性当做一个独立的值。因此，它们可以传递，可以在表达式中使用，启用一段代码去获取或者设置一个属性，而不用确切地知道它们使用哪个属性。

Key paths主要有三种变体:

• KeyPath: 提供对属性的只读访问
• WritableKeyPath: 提供对具有价值语义的可变属性提供可读可写的访问
• ReferenceWritableKeyPath: 只能对引用类型使用(比如一个类的实例), 对任意可变属性提供可读可写的访问

这里有一些额外的keypath类型，它们可以减少内部重复的代码，以及可以帮助我们做类型的擦除，但是我们在这篇文章中，会专注于上面的三种主要的类型。

让我们深入了解如何使用key paths吧，以及使它们变得有趣且非常强大的原因。

功能速记

我们这样说吧，我们正在构建一个可以让我们阅读从网络上获取到文章的app，以及我们已经有一个Article的模型用来表达这篇文章，就像下面这样:

struct Article {
    let id: UUID
    let source: URL
    let title: String
    let body: String
}
复制代码

无论什么时候，我们使用这个模型数组，通常需要从每个模型中提取单个数据以组成新的数组 - 就像下面这两个从文章数组中获取所有的IDs和sources的列子一样:

let articleIDs = articles.map { $0.id }
let articleSources = articles.map { $0.source }
复制代码

虽然上面的实现完全没有问题，但是我们只是想要从每个元素中提取单一的值，我们不是真的需要闭包的所有功能 - 所以使用keypath就可能非常合适。让我们看看它是如何工作的吧。

我们会通过在Sequence协议中重写map方法来处理key path，而不是通过闭包。既然我们只对这个使用例子的只读访问有兴趣，那么我们将会使用标准的KeyPath类型，并且为了实际的数据提取，我们将会使用给定的键值路径作为下标参数，如下所示：

extension Sequence {
	func map<T>(_ keyPath: KeyPath<Element, T>) -> [T] {
	  return map { $0[keyPath: keyPath] }
	}
}
复制代码

随着上述准备就绪，我们能够使用友好和简单的语法来从任意的序列元素中提取出单一的值，使将之前的列子转化成下面的样子成为可能：

let articleIDs = articles.map(\.id)
let articleSources = articles.map(\.source)
复制代码

这是非常酷的，但是键值路径真正开始闪光的时候，是当它们被用来组成更加灵活的表达式 - 比如当给序列的值 排序 的时候。

标准库可以给任意的包含可排序的元素的序列进行自动排序，但是对于其他不可排序的元素，我们必须提供自己的排序闭包。然而，使用关键路径，我们可以很简单的给任意的可比较的元素添加排序的支持。就像之前一样，我们给序列添加一个扩展，来将给定的关键路径在排序表达闭包中进行转化:

extension Sequence {
    func sorted<T: Comparable>(by keyPath: KeyPath<Element, T>) -> [Element] {
        return sorted { a, b in
            return a[keyPath: keyPath] < b[keyPath: keyPath]
        }
    }
}
复制代码

使用上述方法，我们可以非常快速的排序任意的序列，只用简单的提供一个我们期望被排序的关键路径。如果我们构建的app是用来处理任意的可排序的列表 - 举个例子，一个包含了播放列表的音乐app - 这将是非常有用的，我们现在可以随意排序基于可比较属性的列表（甚至是嵌套的属性）。

playlist.songs.sorted(by: \.name)
playlist.songs.sorted(by: \.dateAdded)
playlist.songs.sorted(by: \.ratings.worldWide)
复制代码

完成上述的事情看起来有点简单，就像添加了一个语法糖。但是既可以写出更加灵活的代码去处理序列，让他们更易读，也可以减少重复的代码。因此我们现在能够为任意属性重用相同的排序代码。

不需要实例

虽然适量的语法糖很好，但是关键路径的真正的威力来自于，它可以让我们引用属性而不必与任意的实例相关联。延续使用之前的音乐主题，假设我们正在开发一个展示歌曲列表的App - 并且在UI中为这个列表配置UITableViewCell，我们使用如下的配置类型:

struct SongCellConfigurator {
    func configure(_ cell: UITableViewCell, for song: Song) {
        cell.textLabel?.text = song.name
        cell.detailTextLabel?.text = song.artistName
        cell.imageView?.image = song.albumArtwork
    }
}
复制代码

再次声明，上面的代码没有一点问题，但是我们期望以这样的方式渲染其他的模型的概率非常的高（非常多的tableView的cells尝试着去渲染标题，副标题以及图片而不用去管他们代表的是什么模型）- 因此让我们看看，我们能否用关键路径的威力去创建一个共享的配置实现，让他可以被任意的模型使用。

让我们创建一个名叫CellConfigurator的泛型，然后因为我们想要用不同的模型去渲染不同的数据，所以我们将会给它提供一组基于关键路径的属性 - 我们先渲染其中的一个数据:

struct CellConfigurator<Model> {
    let titleKeyPath: KeyPath<Model, String>
    let subtitleKeyPath: KeyPath<Model, String>
    let imageKeyPath: KeyPath<Model, UIImage?>

    func configure(_ cell: UITableViewCell, for model: Model) {
        cell.textLabel?.text = model[keyPath: titleKeyPath]
        cell.detailTextLabel?.text = model[keyPath: subtitleKeyPath]
        cell.imageView?.image = model[keyPath: imageKeyPath]
    }
}
复制代码

上面的实现优雅的地方在于，我们现在可以为每个模型定制我们的CellConfigurator，使用相同的轻量的关键路径语法，如下所示:

let songCellConfigurator = CellConfigurator<Song>(
    titleKeyPath: \.name,
    subtitleKeyPath: \.artistName,
    imageKeyPath: \.albumArtwork
)

let playlistCellConfigurator = CellConfigurator<Playlist>(
    titleKeyPath: \.title,
    subtitleKeyPath: \.authorName,
    imageKeyPath: \.artwork
)
复制代码

就像标准库中的map和sorted等函数的操作一样，我们曾经可能会使用闭包去实现CellConfigurator。然而，通过关键路径，我们能够使用一个非常好的语法去实现它 - 并且我们也不需要任何的订制化的操作去不得不通过模型实例去处理 - 使它们变得更加的简单，更加的具有说服力。

转化为函数

目前为止，我们仅仅使用关键路径来读取值 - 现在让我们看看我们如何使用它们来动态的写值。在很多不同的代码中，我们常常可以见到一些像下面的代码一样的列子 - 我们通过这段代码来加载一系列的事项，然后在ListViewController中去渲染它们，然后当加载操作完成后，我们会简单的将加载的事项赋值给视图控制器中的属性。

class ListViewController {
    private var items = [Item]() { didSet { render() } }

    func loadItems() {
        loader.load { [weak self] items in
            self?.items = items
        }
    }
}
复制代码

让我们看看，通过关键路径赋值能否让上面的语法简单一点，并且能够移除我们经常使用的weak self的语法（如果我们忘记对self的引用前加上weak关键字的话，那么就会产生循环引用）。

既然所有上面我们做的事情都是获取传递给我们闭包的值，并将它赋值给视图控制器中的属性 - 那么如果我们真的能够将属性的setter作为函数传递，会不会很酷呢？这样我们就可以直接将函数作为完成闭包传递给我们的加载方法，然后所有的事情都会正常执行。

为了实现这一目标，首先我们先定义一个函数，让任意的可写的转化为一个闭包，然后为关键路径设置属性值。为此，我们将会使用ReferenceWritableKeyPath类型，因为我们只想把它限制为引用类型（否则的话，我们只会改变本地属性的值）。给定一个对象，以及给这个对象设置关键路径，我们将会自动将捕获的对象作为弱引用类型，一旦我们的函数被调用，我们就会给匹配关键路径的属性赋值。就像这样:

func setter<Object: AnyObject, Value>(
    for object: Object,
    keyPath: ReferenceWritableKeyPath<Object, Value>
) -> (Value) -> Void {
    return { [weak object] value in
        object?[keyPath: keyPath] = value
    }
}
复制代码

使用上面的代码，我们可以简化之前的代码，将弱引用的self去除，然后用看起来非常简洁的语法结尾：

class ListViewController {
    private var items = [Item]() { didSet { render() } }

    func loadItems() {
        loader.load(then: setter(for: self, keyPath: \.items))
    }
}
复制代码

非常酷有没有！或许它还能变得更加的酷，当上面的代码跟更加先进的函数式编程思想结合在一起的时候，如组合函数 - 因此我们现在可以将多个setter函数和其他的函数链接在一起使用。在接下来的文章中，我们将介绍函数式编程和组合函数。