Swift高阶函数的使用

头等函数：可将函数当做参数传递给其他的函数，或从其他函数里返回出值，并且可以将他们设定为变量，或者将他们存储在数据结构中。

闭包：Swift使用简洁的头等函数(闭包语法)代替了复杂的 block 语法，我们可以将闭包作为参数传递给其他函数，也可以将其作为返回值。

Example

假设我们需要两个函数，其中一个计算两个数的平方的平均值，另一个计算两个数的立方的平均值。

下面是传统解决方法：

func square(a:Float) -> Float {
    return a * a
}
func cube(a:Float) -> Float {
    return a * a * a
}
func averageSumOfSquares(a:Float,b:Float) -> Float {
    return (square(a) + square(b)) / 2.0
}
func averageSumOfCubes(a:Float,b:Float) -> Float {
    return (cube(a) + cube(b)) / 2.0
}

我们注意到averageSumOfSquares和averageSumOfCubes的唯一不同只是分别调用平方函数或立方函数。

如果我能够定义一个通用函数，这个函数以两个数和一个使用这两个数的函数作为参数，来计算平均值而不是重复调用将会非常好，我们可以使用闭包作为函数参数

func square(a:Float) -> Float {
    return a * a
}
func cube(a:Float) -> Float {
    return a * a * a
}


func averageOfFunction(a:Float,b:Float,f:((Float) -> Float)) -> Float {
    return (f(a) + f(b)) / 2
}
averageOfFunction(3, b: 4, f: square)
averageOfFunction(3, b: 4, f: cube)

这里是使用命名闭包作为参数，我们还可以使用匿名闭包，代码将简化为：

1	let num = averageOfFunction(3, b: 4, f: {(x: Float) -> Float in return x * x})

就可以省略掉func square，由于(x: Float) -> Float是闭包类型，从averageOfFunction方法的声明中可以推断出来闭包类型，因此可以省略参数类型，返回值类型代码变成如下：

1	let num1 = averageOfFunction(3, b: 4, f: {x in return x * x})

就像你不用给3或者4标注 Float 一样，而单个语句的闭包可以省略return，并且把语句的值作为返回值。因此代码如下：

1	let num1 = averageOfFunction(3, b: 4, f: {x in x * x})

最后我们还可以忽略指定参数名，使用默认参数名$0（如果函数接收多个参数，使用$1作为第K个参数，使用$0作为第K-1个参数，如$0，$1）：

let numbers = [5, 3, 2, 6, 1]

let sortedNumbers = numbers.sort(){$0 < $1}

print(sortedNumbers)

因此，我们可以方法简写为：

1	averageOfFunction(3, 4, {$0 * $0})

把闭包作为参数传递而非重复代码，这个编程技术极大的提升了代码的表达性，避免了代码引用和拷贝粘贴所带来的错误。

Swift的标准数组支持三个高阶函数：map，filter和reduce。Objective-C的NSArray没有实现这些方法，但是开源社区弥补了这个不足

Map

map用于将每个数组元素通过某个方法进行转换。数学表达式如下：

1	[ x1, x2, ... , xn].map(f) ->[f(x1), f(x2), ... , f(xn)]

我们用一个Int类型数组存储商品金额，想把每个金额后面添加一个字符“?”，把数组转成字符串数组

[10,20,45,32] -> [“10?”,”20?”,”45?”,”32?”]

最笨的办法-创建一个空数组，遍历和转换原数组的每个元素，然后把转换结果添加到空数组里：

let moneyArray = [10, 20, 45, 32]

var stringsArray : Array<String> = [] //Note that we have to specify the type of the array or else we'll get an type error
for money in moneyArray {
    stringsArray += ["\(money)$"]
}

func map(transform: (T) -> U) -> U[]

这个方法以一个命名函数transform作为参数，transform负责把元素类型T转成类型U并返回一个类型U的数组。

map将序列每个元素取出，进行闭包处理后，将处理过的元素组成一个新的数组并返回

stringsArray = moneyArray.map({"\($0)$"})
print(stringsArray)

```  
一句话搞定。如果看不明白，带类型的如下：

```swift
stringsArray = moneyArray.map({ (x: Int) -> String in
    return "\(x)$"
})

print(stringsArray)

Filter

filter用于选择数组元素中满足某种条件的元素。

使用前面金额的例子，筛选出金额大于30元素，结果应该是[45,32]

如果是传统实现：

var filteredArray : [Int] = []
for money in moneyArray {
    if (money > 30) {
        filteredArray += [money]
    }
}

filter(includeElement: (T) -> Bool) -> T[]

以返回true或false的函数includeElement作为参数，对原数组元素调用includeElement时，只有返回true的元素会通过筛选

1	filteredArray = moneyArray.filter({$0 > 30})

一行搞定。

Reduce

reduce方法把数组元素组合计算为一个值。

我们使用上面例子计算数组元素的和，结果应该为107(10 + 20 + 45 + 32)

传统实现：

var sum = 0
for money in moneyArray {
    sum += money
}

再看看数字相乘：

var product = 1
for money in moneyArray {
    product = product * money
}

这两个惟一不同的是计算的初始值（sum为0，product为1）和计算操作符（sum为+，product为*）

Reduce便可用于快速完成这类操作，通过指定一个初始值和一个组合元素的方法

Swift中reduct在Array类中的定义为

reduce(initial: U, combine: (U, T) -> U) -> U

接收两个参数，一个为类型U的初始值，另一个为把类型为U的元素和类型为T的元素组合成一个类型为U的值的函数。最终结果整个数组就变成了一个类型为U的值。

在事例中U和T是Int，初始值是0，combine函数计算两个Int之和

sum = moneyArray.reduce(0, combine: { (sum1: Int, comb: Int) -> Int in
    return sum1 + comb
})
print(sum)

sum = moneyArray.reduce(0,{$0 + $1})

Swift中操作符可用于函数，简化为：

1	sum = moneyArray.reduce(0, combine: +)

需要注意的是combine函数的两参数类型不同，$0为计算结果类型，$1为数组元素类型。

另一点需要说明的是数据比较大的时候，高阶函数会比传统实现更快，因为它可以并行执行（如运行在多核上），除非真的需要更高定制版本的map，reduce和filter，否则可以一直使用它们以获得更快的执行速度。

下面这些闭包问题作为练习

1.编写一个方法applyTwice(f:(Float -> Float), x:Float) -> Float，以函数f和float值x作为参数，然后用x参数调用f两次。如f(f(x))

func applyTwice(f:(Float -> Float), x:Float) -> Float
{
    return f(f(x))
}

2.编写一个方法applyKTimes(f:(Float -> Float), x:Float) -> Float，以函数f和float值x作为参数，然后用x参数调用f k次。

func applyKTimes(f:(Float -> Float), x:Float, k: Int) -> Float
{
    return k > 0 ? applyKTimes(f, x: f(x), k: k - 1) : x
}

applyKTimes(-, x: 5, k: 3)

func applyKTimes1(f:(Float -> Float),x:Float,k:Int) -> Float {
    var y : Float = x
    for _ in 0..<k {
        y = f(y)
    }
    return y
}

applyKTimes1(-, x: 5, k: 3)

3.使用applyKTimes实现x的k次方

func getKthPower(x: Float, k: Int) -> Float {
    return applyKTimes({x * $0}, x: x, k: k)
}

let sum = getKthPower(5.0, k: 2)
print(sum)

4.给定一个User类数组，类包含属性name:String和age:Int，用map函数返回一个用户name组成的字符串数组


class User {
    var name: String?
    var age : Int?
    
    init (name: String, age:Int) {
        self.name = name
        self.age = age
    }
}

var user1 = User(name: "WHY1", age: 22)
var user2 = User(name: "WHY2", age: 23)
var user3 = User(name: "WHY3", age: 24)
var user4 = User(name: "WHY4", age: 25)
var users = [user1,user2,user3,user4]
var names: [String?] = []

names = users.map({user in user.name})

print(names)

5.给定一个Dictionary数组，Dictionary包含key值name和key值age，用map函数返回name字符串数组

var user1 = ["name": "WHY1", "age": 22]
var user2 = ["name": "WHY2", "age": 23]
var user3 = ["name": "WHY3", "age": 24]
var user4 = ["name": "WHY4", "age": 25]

var users = [user1, user2, user3, user4]

let usersName = users.map { user in
    return user["name"]!
}

print(usersName)

6.给定一个Number数组，用filter函数选出奇数

let number = [1,2,4,8,23,45,89,127]

let oddNumber = number.filter {$0 % 2 == 1}
print(oddNumber)

7.给定一个String数组，用filter函数选出能被转成Int的字符串

var strs = ["2333", "1223", "callmewhy", "callherhh"]

let intStr = strs.filter { (str: String) -> Bool in
    Int(str) != nil
}

print(intStr)

8.给定一个UIView数组，用filter函数选出UILabel的子类

var view1 = UIView()
var view2 = UIView()
var view3 = UILabel()
var view4 = UIView()
var views = [view1,view2,view3,view4]

let label = views.filter({$0.isKindOfClass(UILabel)})
print(label[0] == view3)
print(view3)

9.用reduce函数把String数组中元素连接一个字符串，以换行符分隔

var strs = ["str1","str2","str3","str4"]

let newStrs = strs.reduce("") { (new: String, combine: String) -> String in
    return new + combine + "\n"
}

let newStrs1 = strs.reduce("", combine: {$0 + $1 + "\n"})

print(newStrs1)

10.使用reduce函数找出整形数组中的最大元素

var ints = [1,2,3,4,5,6]

var maxi = ints.reduce(Int.min) { (m: Int, num: Int) -> Int in
    return max(m, num)
}

print(maxi)

11.为什么不能用reduce实现平均函数{$0 + $1 / Float(array.count)}

var array = [1,2,3,4,6]
var mean = array.reduce(0, combine: {$0 + Float($1) / Float(array.count)}) // make division 5 times

print(mean)

可以实现，但由于reduce的特性，会将所有的数都先除以5 再相加，会做5次除法，性能太差了。