Swift 学习笔记(闭包)

 1let fruits = ["Apple", "Pear", "Banana"]
 2
 3func sorter(s1: String, s2: String) -> Bool {
 4    return s1 > s2
 5}
 6
 7fruits.sort(sorter)  //通过函数名，传入已定义的函数
 8
 9let sorterRef = sorter
10fruits.sort(sorterRef) //传入函数(闭包) 类型变量
11
12//以下是闭包
13let a = fruits.sort({(s1: String, s2: String) -> Bool in return s1 < s2}) //完整而冗余的格式
14fruits.sort({(s1: String, s2: String) in return s1 < s2}) //带有参数类型和 return 关键字
15fruits.sort({(s1, s2) in return s1 < s2}) //***** 标准格式 *****
16fruits.sort({s1, s2 in return s1 < s2}) //省去参数列表两边的括号，仍然有 return 关键字
17fruits.sort({(s1, s2) in s1 < s2})   //只省去了 return 关键字
18fruits.sort({s1, s2 in s1 < s2})     //同时省去了参数列表两边的括号和 return 关键字
19fruits.sort({$0 < $1})       //省略了参数列表，默认用 $0, $1, $2 ... 依次代表各参数
20fruits.sort(>)               //操作数都省了，这是一个二元操作符，所以相当于 $0 > $1
21
22let numbers = [1, 4, 2, 3]
23numbers.sort(<)              //整数数组的排序也可以这么省

 1fruits.sort(){ $0 < $1 }
 2fruits.sort { $0 < $1 }
 3
 4func op(n1: Int, _ n2: Int, _ fn: (Int, Int) -> Int) -> Int {
 5    return fn(n1, n2)
 6}
 7
 8op(2, 5) {
 9    var tmp = $0 + $1
10    tmp = tmp * 3
11    return tmp + ($0 * $1)
12}

 1func increase(step: Int) -> (Int -> Int){
 2    let localValue = 10
 3    return { $0 + step + localValue } //这其实是一个嵌套函数，捕获了外部函数的参数和局部变量
 4}
 5
 6increase(10)(5)        //25
 7
 8var base = 20
 9let foo: (Int -> Int) = {
10  base = base + 3      //闭包中可以修改外部变量的值，这比函数的参数还强悍
11  return base + $0     //让它捕获外部变量 base, 所以 base 要先于 foo 声明
12}
13
14foo(7)                //30
15foo(7)                //33
16base = 30             //改变外部变量，影响闭包的调用
17foo(7)                //40

 1func withNoescapeClosure(@noescape closure: () -> Void) {
 2    x = 200    //加了 @noescape, 使得隐式的访问 self 的变量 x，相当于 self.x = 200
 3    closure()  //函数返回后便不能调用 closure() 了，所以 closure 是 noescape 的
 4}
 5
 6
 7var op: ()->Void
 8func withEscapingClosure(@noescape closure: () -> Void) {   //需要去掉这里的 @noescape
 9    op = closure //函数赋给了外部变量，别人还有机会在函数外部调用，所以就不是 noescape；编译错误
10}