函数的灵活性函数的灵活性

学习目的： Swift 如何将函数作为参数使用，并且将函数当作数据，以完全类型安全的方式复制同样的OC功能
例子：Objective-C & Swift 的排序方式
1. ”素材“：

@objcMembers（@objcMembers，这样它的所有成员都将在 Objective-C 中可见）

final class Person: NSObject {
let first: String
let last: String
let yearOfBirth: Int
init(first: String, last: String, yearOfBirth: Int) {
self.first = first
self.last = last self.yearOfBirth = yearOfBirth // super.init() 在这里被隐式调用
} }
接下来我们定义一个数组，其中包含了不同名字和出生年份的人:
let people = [
Person(first: "Emily", last: "Young", yearOfBirth: 2002), Person(first: "David", last: "Gray", yearOfBirth: 1991), Person(first: "Robert", last: "Barnes", yearOfBirth: 1985),Person(first: "Ava", last: "Barnes", yearOfBirth: 2000), Person(first: "Joanne", last: "Miller", yearOfBirth: 1994), Person(first: "Ava", last: "Barnes", yearOfBirth: 1998),
]

2.排序规则： 先按照姓（last name）排序，再按照名（first name）排序，最后是出生年（yearOfBirth）。
Objective-C：运行时的工作方式；selector；一个 NSSortDescriptor 数组来定义如何排序；
(作为一门动态编程语言，Objective-C 会尽可能的将编译和链接时要做的事情推迟到运行时。只要有可能,Objective-C 总是使用动态的方式来解决问题。)
方法： 使用 NSSortDescriptor 对象来描述如何排序对象，通过它可以表达出各个排序标准 (使用 localizedStandardCompare 来进行遵循区域设置的排序): （localizedStandardCompare 字符串比较不区分大小写）
ascending： true 生序， false 降序

let lastDescriptor = NSSortDescriptor(key: #keyPath(Person.last), ascending: true,
selector: #selector(NSString.localizedStandardCompare(_:)))
let firstDescriptor = NSSortDescriptor(key: #keyPath(Person.first), ascending: true,
selector: #selector(NSString.localizedStandardCompare(_:)))
let yearDescriptor = NSSortDescriptor(key: #keyPath(Person.yearOfBirth), ascending: true)

使用 NSArray 的 sortedArray(using:) 方法，对数组进行排序

let descriptors = [lastDescriptor, firstDescriptor, yearDescriptor] (people as NSArray).sortedArray(using: descriptors)
/*
[Ava Barnes (1998), Ava Barnes (2000), Robert Barnes (1985),
David Gray (1991), Joanne Miller (1994), Emily Young (2002)]
*/

排序描述符用到了Objective-C 的两个运行时特性:首先，key 是 Objective-C 的键路径，它其实是一个包含属性名字的链表。不要把它和 Swift 4 引入的原生的 (强类型的) 键路径搞混。我们会在稍后再对它进行更多讨论。
其次是键值编程(key-value-coding)，它可以在运行时通过键查找一个对象上的对应值。 selector 参数接受一个 selector (实际上也是一个用来描述方法名字的字符串)，在运行时，这个 selector 将被用来查找比较函数，当对两个对象进行比较时，这个函数将使用指定键对应的值进行比较。
这是运行时编程的一个很酷的用例，排序描述符的数组可以在运行时构建，这一点在实现比如用户点击某一列时按照该列进行排序这种需求时会特别有用。
我们要怎么用 Swift 的 sort 来复制这个功能呢?
Swift: 将函数作为参数使用，并且将函数当作数据
1: 复制部分功能简单

var strings = ["Hello", "hallo", "Hallo", "hello"]
strings.sort { $0.localizedStandardCompare($1) == .orderedAscending} strings // ["hallo", "Hallo", "hello", "Hello"]

如果只是想用对象的某一个属性进行排序的话，也非常简单:

people.sorted { $0.yearOfBirth < $1.yearOfBirth }

不过，可选值属性和localizedStandardCompare方法结合，代码会丑陋不堪。例如，我们想用在可选值中定义的 fileExtension 属性来对一个包含文件名的数组进行排序:

var files = ["one", "file.h", "file.c", "test.h"] files.sort { l, r in r.fileExtension.flatMap {
l.fileExtension?.localizedStandardCompare($0)
} == .orderedAscending }
files // ["one", "file.c", "file.h", "test.h"]

改进：让可选值的排序稍微容易一些，对多个属性进行排序。要同时排序姓和名。
方法：用标准库的 lexicographicallyPrecedes 方法来进行实现。这个方法接受两个序列，并对它们执行一个电话簿方式的比较，也就是说，这个比较将顺次从两个序列中各取一个元素来进行比较，直到发现不相等的元素。所以，我们可以用姓和名构建两个数组，然后使用 lexicographicallyPrecedes 来比较它们。我们还需要一个函数来执行这个比较，这里我们把使用了 localizedStandardCompare 的比较代码放到这个函数中:

people.sorted { p0, p1 in
let left = [p0.last, p0.first]
let right = [p1.last, p1.first]
return left.lexicographicallyPrecedes(right) {
$0.localizedStandardCompare($1) == .orderedAscending }
}
/*
[Ava Barnes (2000), Ava Barnes (1998), Robert Barnes (1985),
David Gray (1991), Joanne Miller (1994), Emily Young (2002)] */

不过还有很大的改进空间。在每次比较的时候都构建一个数组是非常没有效率的，比较操作也是被写死的，通过这种方法我们将无法实现对 yearOfBirth 的排序。
函数作为数据
方法：定义一个描述对象顺序的函数
其中，最简单的一种实现就是接受两个对象作为参数，并在它们顺序正确的时候，返回 true。这个函数的类型正是标准库中 sort(by:) 和 sorted(by:) 的参数类型。接下来，让我们先定义一个泛型别名来表达这种函数形式的排序描述符:
/// 一个排序断言，当第一个值应当排在第二个值之前时，返回 `true`
typealias SortDescriptor = (Root, Root) -> Bool
现在，就可以用这个别名定义比较 Person 对象的排序描述符了。它可以比较出生年份，也可以比较姓的字符串:
let sortByYear: SortDescriptor = { $0.yearOfBirth < $1.yearOfBirth }
let sortByLastName: SortDescriptor = {
$0.last.localizedStandardCompare($1.last) == .orderedAscending
}
除了手写这些排序描述符外，我们也可以创建一个函数来生成它们。将相同的属性写两次并不太好，比如在 sortByLastName 中，我们很容易就会不小心弄成 $0.last 和 $1.first 进行比较。而且写排序描述符本身也挺无聊的:想要通过名来排序的时候，很可能你就把姓排序的 sortByLastName 复制粘贴一下，然后再进行修改。
为了避免复制粘贴，我们可以定义一个函数，它和 NSSortDescriptor 大体相似，但不涉及运行时编程。这个函数的第一个参数是一个名为 key 的函数，此函数接受一个正在排序的数组的元素，并返回这个排序描述符所处理的属性的值。然后，我们使用第二个参数 areInIncreasingOrder 比较 key 返回的结果。最后，用 SortDescriptor 把这两个参数包装一下，就是要返回的排序描述符了:

/// `key` 函数，根据输入的参数返回要进行比较的元素
/// `by` 进行比较的断言
/// 通过用 `by` 比较 `key` 返回值的方式构建 `SortDescriptor` 函数 func sortDescriptor(
key: @escaping (Root) -> Value,
by areInIncreasingOrder: @escaping (Value, Value) -> Bool) -> SortDescriptor
{
return { areInIncreasingOrder(key($0), key($1)) }
}

key 函数描述了如何深入一个 Root 类型的元素，并提取出一个和特定排序步骤相关的 Value 类型的值。因为借鉴了泛型参数名字 Root 和 Value，所以它和 Swift 4 引入的 Swift 原生键路径有很多相同之处。我们会在下面讨论怎么用 Swift 的键路径重写这个方法。
有了这个函数，我们就可以用另外一种方式来定义 sortByYear 了:

let sortByYearAlt: SortDescriptor = sortDescriptor(key: { $0.yearOfBirth }, by: <)
people.sorted(by: sortByYearAlt)
//[Robert Barnes (1985), David Gray (1991), Joanne Miller (1994), Ava Barnes (1998), Ava Barnes (2000), Emily Young (2002)]

甚至，我们还可以为所有实现了 Comparable 的类型定义一个重载版本:

func sortDescriptor(key: @escaping (Root) -> Value) -> SortDescriptor where Value: Comparable
{
return { key($0) < key($1) }
}
let sortByYearAlt2: SortDescriptor =
sortDescriptor(key: { $0.yearOfBirth })

这两个 sortDescriptor 都使用了返回布尔值的排序函数，因为这是标准库中对于比较断言的约定。但另一方面，Foundation 中像是 localizedStandardCompare 这样的 API，返回的却是一个包含 (升序，降序，相等) 三种值的 ComparisonResult。给 sortDescriptor 增加这种支持也很简单:

func sortDescriptor(
key: @escaping (Root) -> Value,
ascending: Bool = true,
by comparator: @escaping (Value) -> (Value) -> ComparisonResult) -> SortDescriptor
{
return { lhs, rhs in
let order: ComparisonResult = ascending ? .orderedAscending
: .orderedDescending
return comparator(key(lhs))(key(rhs)) == order }
}

这样，我们就可以用简短清晰得多的方式来写 sortByFirstName 了:

let sortByFirstName: SortDescriptor =
sortDescriptor(key: { $0.first }, by: String.localizedStandardCompare)
people.sorted(by: sortByFirstName)
/*
[Ava Barnes (2000), Ava Barnes (1998), David Gray (1991),
Emily Young (2002), Joanne Miller (1994), Robert Barnes (1985)] */

现在，SortDescriptor 和 NSSortDescriptor 就拥有了同样地表达能力，不过它是类型安全的，而且不依赖于运行时编程。
OC的例子中，我们曾经用 NSArray.sortedArray(using:) 方法指定了多个比较运算符对数组进行排序。
现在我们将使用一种不同的实现方式: 我们定义一个把多个排序描述符合并为一个的函数。它的工作方式和 sortedArray(using:) 类似:首先它会使用第一个描述符，并检查比较的结果。如果相等，再使用第二个，第三个，直到全部用完:
func combine
(sortDescriptors: [SortDescriptor]) -> SortDescriptor { return { lhs, rhs in
for areInIncreasingOrder in sortDescriptors {
if areInIncreasingOrder(lhs, rhs) { return true } if areInIncreasingOrder(rhs, lhs) { return false }
}
return false
} }
最终把一开始的例子重写为这样:
et combined: SortDescriptor = combine(
sortDescriptors: [sortByLastName, sortByFirstName, sortByYear] )
people.sorted(by: combined)
/*
[Ava Barnes (1998), Ava Barnes (2000), Robert Barnes (1985),
David Gray (1991), Joanne Miller (1994), Emily Young (2002)] */
最终，我们得到了一个与 Foundation 中的版本在行为和功能上等价的实现方法，但是我们的 方式要更安全，也更符合 Swift 的语言习惯。因为 Swift 的版本不依赖于运行时编程，所以编译器有机会对它进行更好的优化。另外，我们也可以使用它排序结构体或非 Objective-C 的对象。
基于函数的方式有一个不足，那就是函数是不透明的。我们可以获取一个 NSSortDescriptor 并将它打印到控制台，我们也能从排序描述符中获得一些信息，比如键路径，selector 的名字，以及排序顺序等。但是在基于函数的方式中，这些都无法做到。（一些信息取不到）如果这些信息很重要的话，我们可以将函数封装到一个结构体或类中，然后在其中存储一些额外的调试信息。
把函数作为数据使用的这种方式 (例如:在运行时构建包含排序函数的数组)，把语言的动态行为带到了一个新的高度。这使得像 Swift 这种需要编译的静态语言也可以实现诸如 Objective-C 或 Ruby 中的一部分动态特性。
我们也看到了合并其他函数的函数的用武之地，它也是函数式编程的构建模块之一。例如， combine(sortDescriptors:) 函数接受一个排序描述符的数组，并将它们合并成了单个的排序描述符。在很多不同的应用场景下，这项技术都非常强大。
除此之外，我们甚至还可以写一个自定义的运算符，来合并两个排序函数:

infix operator <||> : LogicalDisjunctionPrecedence
func <||>(lhs: @escaping (A,A) -> Bool, rhs: @escaping (A,A) -> Bool)
-> (A,A) -> Bool {
return{x,yin
if lhs(x, y) { return true } if lhs(y, x) { return false }
// 否则，它们就是一样的，所以我们检查第二个条件 if rhs(x, y) { return true }
return false
} }

大部分时候，自定义运算符不是什么好主意。因为自定义运算符的名字无法描述行为，所以它
们通常都比函数更难理解。不过，当使用得当的时候，它们也会非常强大。有了上面的运算符，
我们可以重写合并排序的例子:

let combinedAlt = sortByLastName <||> sortByFirstName <||> sortByYear people.sorted(by: combinedAlt)
/*
[Ava Barnes (1998), Ava Barnes (2000), Robert Barnes (1985),
David Gray (1991), Joanne Miller (1994), Emily Young (2002)]

这样的代码读起来非常清晰，而且可能比原来调用函数进行合并的做法更简洁一些。不过这有一个前提，那就是你 (和这段代码的读者) 都已经习惯了该操作符的意义。相比自定义操作符的版本，我们还是倾向于选择 combine(sortDescriptors:) 函数。它在调用方看来更加清晰，而且显然增强了代码的可读性。除非你正在写一些面向特定领域的代码，否则自定义的操作符很可能都是在用牛刀杀鸡。
再写一个接受函数作为参数，并返回函数的函数。这个函数可以把类似 localizedStandardCompare 这种接受两个字符串并进行比较的普通函数，提升成比较两个字符串可选值的函数。如果两个比较值都是nil，那么它们相等。如果左侧的值是 nil，而右侧不是的话，返回升序，相反的时候返回降序。最后，如果它们都不是 nil 的话，我们使用 compare 函数来对它们进行比较:

func lift(_ compare: @escaping (A) -> (A) -> ComparisonResult) -> (A?) -> (A?)

-> ComparisonResult {
return{lhsin{rhsin
switch (lhs, rhs) {
case (nil, nil): return .orderedSame case (nil, _): return .orderedAscending case (_, nil): return .orderedDescending case let (l?, r?): return compare(l)(r)
}
}} }

这让我们能够将一个普通的比较函数 “提升” (lift) 到可选值的作用域中，这样它就能够和我们的 sortDescriptor 函数一起使用了。如果你还记得之前的 files 数组，你会知道因为需要处理可选值的问题，按照 fileExtension 对它进行排序的代码十分难看。不过现在有了新的 lift 函数，它就又变得很清晰了:

let compare = lift(String.localizedStandardCompare)
let result = files.sorted(by: sortDescriptor(key: { $0.fileExtension },
by: compare))
result // ["one", "file.c", "file.h", "test.h"]

【函数的灵活性】我们可以为返回 Bool 的函数写一个类似的 lift。在可选值一章中我们提到过，标准库现在不再为可选值提供像是 > 这样的运算符了。因为如果你使用的不小心，可能会产生预想之外的结果，因此它们被删除了。Bool 版本的 lift 函数可以让你轻而易举地将现有的运算符提升为可选值也能使用的函数，以满足你的需求。