filter函数适用于过滤操作, 方法体是一个返回值为bool的闭包
map 函数适用于遍历的操作
reduce 函数适用于对原来的数据进行给定一个初始值, 进行修改, 并返回修改后的值
假如我们需要写一个函数，它接受一个给定的整型数组，通过计算得到并返回一个新数组，新 数组各项为原数组中对应的整型数据加一。这一切，仅仅只需要使用一个 for 循环就能非常容 易地实现:
func incrementArray(xs:[Int]) -> [Int] {
var result: [Int] = []
for x in xs {
result.append(x + 1)
}
return result
}
现在假设我们还需要一个函数，用于生成一个每项都为参数数组对应项两倍的新数组。这同样 能很容易地使用一个 for 循环来实现:
func doubleArray(xs:[Int]) -> [Int] {
var result: [Int] = []
for x in xs {
result.append(x * 2)
}
return result
}
这两个函数有大量相同的代码，我们能不能将没有区别的地方抽象出来，并单独写一个体现这
种模式且更通用的函数呢?像这样的函数需要追加一个新参数来接受一个函数，这个参数能根据各个数组项计算得到新的整型数值:
func computeIntArray(xs: [Int], transform: (Int) -> Int ) -> [ Int ] {
var result: [Int] = []
for x in xs {
result.append(transform(x))
}
return result
}
现在，取决于我们想如何根据原数组得到一个新数组，我们可以向函数传递不同的参数。 doubleArray 函数和 incrementArray 函数都精简为了一行调用 computeIntArray 的语句:
func doubleArray2(xs:[Int]) -> [Int] {
return computeIntArray(xs:xs) {
x in x * 2
}
}
代码仍然不像想象中的那么灵活。假设我们想要得到一个布尔型的新数组，用于表示原数组中
对应的数字是否是偶数。我们可能会尝试编写一些像下面这样的代码:
func isEvenArray(xs: [Int ]) -> [ Bool] {
computeIntArray(xs:xs) {
x in x % 2 == 0
}
}
不幸的是，这段代码导致了一个类型错误。问题在于，我们的 computeIntArray 函数接受一个 Int -> Int 类型的参数，也就是说，该参数是一个返回整型值的函数。而在 isEvenArray 函数的 定义中，我们传递了一个 Int -> Bool 类型的参数，于是导致了类型错误。
我们应该如何解决这个问题呢?一种可行方案是定义新版本的 computeIntArray 函数，接受一 个 Int -> Bool 类型的函数作为参数。类似下面这样:
func computeBoolArray(xs: [Int], transform: (Int) -> Bool) -> [Bool] {
var result: [Bool] = []
for x in xs {
result.append(transform(x))
}
return result
}
但是，这个方案的扩展性并不好。如果接下来需要计算 String 类型呢?我们是否还需要定义另 一个高阶函数来接受 Int -> String 类型的参数?
幸运的是，该问题有一个解决方案:我们可以使用泛型。computeBoolArray 和
computeIntArray 的定义是相同的;唯一的区别在于类型签名 (type signature)。假如我们定 义一个相似的函数 computeStringArray 来支持 String 类型，其函数体将会与先前两个函数完
全一致。事实上，相同部分的代码可以用于任何类型。我们真正想做的是写一个能够适用于每
种可能类型的泛型函数:
func genericComputeArray1<T>(xs: [Int], transform: (Int) -> T) -> [T] {
var result: [T] = []
for x in xs {
result.append(transform(x))
}
return result
}
关于这段代码，最有意思的是它的类型签名。理解这个类型签名有助于你将 genericComputeArray<T> 理解为一个函数族。类型参数 T 的每个选择都会确定一个新函数。 该函数接受一个整型数组和一个 Int -> T 类型的函数作为参数，并返回一个 [T] 类型的数组。
我们仍能进一步将这个函数一般化。没有理由让它仅能对类型为 [Int] 的输入数组进行处理。 将数组类型进行抽象，能得到下面这样的类型签名:
func map<Element, T>(xs: [Element], transform: (Element) -> T) -> [T] {
var result: [T] = []
for x in xs {
result.append(transform(x))
}
return result
}
这里我们写了一个 map 函数，它在两个维度都是通用的:对于任何 Element 的数组和 transform: Element -> T 函数，它都会生成一个 T 的新数组。这个 map 函数甚至比我们之前 看到的 genericComputeArray 函数更通用。事实上，我们可以通过 map 来定义 genericComputeArray:
func genericComputeArray2<T>(xs: [Int], transform: (Int) -> T) -> [T] {
return map(xs, transform: transform)
}
同样的，上述函数的定义并没有什么太过特别之处:函数接受 xs 和 transform 两个参数之后， 将它们传递给 map 函数，然后返回结果。关于这个定义，最有意思非类型莫属。 genericComputeArray(_:transform:) 是 map 函数的一个实例，只是它有一个更具体的类型。
实际上，比起定义一个顶层 map 函数，按照 Swift 的惯例将 map 定义为 Array 的扩展会更合 适:
extension Array {
func map<T>(transform: (Element) -> T) -> [T] {
var result: [T] = []
for x in self {
result.append(transform(x))
}
return result }
}
我们在函数的 transform 参数中所使用的 Element 类型源自于 Swift 的 Array 中对 Element
所进行的泛型定义。
作为 map(xs, transform) 的替代，我们现在可以通过 xs.map(transform) 来调用 Array 的
map 函数:
func genericComputeArray<T>(xs: [Int], transform: (Int) -> T) -> [T] {
return xs.map(transform)
}
想必你会很乐意听到其实并不需要自己像这样来定义 map 函数，因为它已经是 Swift 标准库的 一部分了
网友评论