Swift-06-闭包

闭包是自包含的函数代码块,可以被传递和使用,类似OC中的代码块。闭包可以捕获和存储其所在上下文中任意的常量和变量的引用，就是所谓的闭合并包裹着这些常量和变量。

• 全局函数和嵌套函数也是特殊的闭包，闭包常见的有三种
  • 1.全局函数是有名字，不能捕获任何值的闭包
  • 2.嵌套函数是有名字，可以捕获封闭函数域范围内的闭包
  • 3.闭包表达式没有名字，可以捕获对应上下文中变量或者常量。
• 闭包可以通过语法优化，拥有一个简洁的风格
• 1.利用上下文推断参数和返回值类型
• 2.隐式返回单表达式闭包，可以省略return关键字
• 3.参数名称缩写
• 4.尾随闭包语法

---

1.闭包表达式

闭包表达式是一种利用简洁语法构建内联包的方式。下面通过多次迭代优化来简化闭包表达式

1.1sort方法

Swift的sort方法可以用来怼数组进行排序，返回一个与原大小数组大小相同，正确排序的新数组，原数组不会被修改

let names = ["zhangsang","lisi","wangwu","zhaoliu"]

// sort方法接受一个闭包，该闭包函数需要传入与数组元素相同的连个值，根据布尔值，来选择排序顺序.
// 类型为(String, String) -> Bool

// 写一个符合该类型的闭包函数，按照逆序排列数组
func backwards(s1: String, s2: String) -> Bool{
    
    return s1 > s2
}
var reversed = names.sort(backwards)
// 排序完的数组如下
["zhaoliu"，"zhangsang","wangwu","lisi"]

1.2闭包表达式语法

闭包表达式的一般形式

{(参数)-> 返回值 in
     闭包语句
}

闭包表达式的参数

• 常量、变量、inout类型，不可提供默认值

• 可在参数列表的后面使用可变参数

• 元祖可以作为参数和返回值

• 内联闭包参数和返回值类型声明与backwards函数类型声明相同，两种都可以写为(s1: String, s2: String) -> Bool

• 内联闭包表达式中，函数和返回值都写在大括号内

• 函数的关键部分通过in引入。in前面是闭包的参数和返回值，in后面为闭包函数体

reversed = names.sort({(s1: String, s2: String) -> Bool in return s1 > s2 })

上述代码完全可以写在一行，这样闭包也就变成了内联闭包

1.3根据上下文推断类型

reversed = names.sort（{(s1: String, s2: String) -> Bool in return s1 > s2 }）

- 该闭包是sort方法的参数，由于该方法的参数必然为（String,String）->Bool 类型的函数，这就意味着闭包的参数和返回值不需要特别指出，Swift可以自动推断出正确的类型。那么，参数和返回值可以继续简写

- ~~~Swift
reversed = names.sort（{s1, s2 in return s1 > s2 }）

• 通过内联表达式构造的闭包作为参数传递给函数或者方法时，都可以正确的推倒出闭包的参数和返回值

• 当闭包作为函数或者方法的参数时，不需要完整格式的闭包表达

• 为了代码的可读性，适度的选择简写

1.4单表达式闭包隐式返回

• 单行表达式闭包可以省略return来隐式地返回当行表达式的结果，sort方法的第二个参数表示，闭包必须返回一个Bool值，由于该闭包只有一个单一表达式 s1 > s2,而且返回Bool类型，所以下面的简写不会有歧义：

reversed = names.sort（{s1, s2 in  s1 > s2 }）

1.5参数名称缩写

• Swift系统为内联闭包提供参数缩写功能，通过$0,$1,$2来顺序调用闭包的参数

• 通过参数名称缩写，可以在闭包参数列表中，省略相应参数的定义

• 通过参数名称缩写，相应参数的类型会进行类型推断

• in也能被省略

reversed = names.sort（{ $0 > $1 }）

####1.6运算函数
- Swift的Sring类型，(>)接受两个String类型的参数，返回Bool值。这样的类型刚好匹配Sort方法所需的参数类型，因此可以进一步简写
- ~~~Swift
reversed = names.sort（>）

---

2.尾随闭包

• 当一个很长的闭包表达式作为最后一个参数传递个函数时，可以使用尾随闭包来增强函数的可读性

• 尾随闭包是一个写在函数括号之后的闭包表达式，函数支持它作为最后一个参数调用

// 一个普通的函数
func oneFunction( closure:()->Void){

    // 函数体
}

// 不用尾随闭包调用
oneFunction { () -> Void in

    // 闭包内容
}
// 使用尾随闭包调用
oneFunction(){
    // 闭包内容
}

• 上面关于排序的闭包也写简写

reversed = names.sort（）{ $1 > $2 }

• 如果函数只需要一个闭包作为参数，尾随闭包可以省略括号

reversed = names.sort{ $1 > $2 }

- Array有个map(_:)方法，只接受一个闭包作为参数，该方法会返回一个新的数组，数组中的元素与原数组一一映射
- 下面通过该方法，使用尾随闭包，讲Int类型数组[16,58,510]转换为对应的String类型的数组["OneSix","FiveEight","FiveOneZero"]
-
~~~Swift
let digitNames = [
    0: "Zero", 1: "One", 2: "Two",   3: "Three", 4: "Four",
    5: "Five", 6: "Six", 7: "Seven", 8: "Eight", 9: "Nine"
]
//
let numbers = [16, 58, 510]
//  目标字符串
let strings = numbers.map { (var number) -> String in
    var output = ""
    while number > 0 {
        output = digitNames[number % 10]! + output
        number /= 10
    }
   return output
}

• 上述过程，闭包参数number被声明为一个可变参数，因此可以在闭包函数体中修改。

• 闭包表达式指定了返回类型为String

• 闭包表达式每次被调用时，创建一个Output的字符串并且返回

• 从digitNames字典中取出的字符串被拼接早output的前段，逆序简历了一个字符串版本的数字

• 当number /= 10 为0时，out字符串被返回

• map方法讲字符串添加到所映射的数组中

• 尾随闭包让代码变得更优雅

---

3.捕获值

• 闭包在其对应的上下文中捕获常量或者变量，即使被捕获的常量或者变量作用域已经不在，闭包仍然可以正确地引用和修改这些值。

• 嵌套函数是最简单的可以捕获值的闭包，捕获范围是其外部函数范围

下面举个例子来说明：

• makeIncrementor函数包含一个incrementor的嵌套函数，incrementor从上下文中捕获了两个值，一个amount，一个runningTotal

• 成功捕获该值后，makeIncrementor将incrementor作为闭包返回

• 每次调用incrementor时，runningTotal会增加amount

• makeIncrementor函数的返回值是一个无参数返回值为Int的函数,() ->Int

• makeIncrementor有一个runningTotal的初始值，该值通过incrementor函数返回

• makeIncrementor函数有个Int类型的参数，其外部参数为forIncrement，内部参数为amount

func makeIncrementor(forIncrement amount: Int) -> () ->Int {

    var runningTotal = 0

    func  incrementor() -> Int{

        runningTotal += amount

        return runningTotal
    }
    return incrementor
}

• incrementor函数没用参数，但是捕获了amount，runningTotal两个参数，并且可以进行正确的修改

• 注意：

  • 当一个值步变的时候，Swift可能会改为捕获并且保存一份对值的拷贝
  • Swift会自我管理捕获变量的内存

• 下面，来调用上面的函数

//
let run = makeIncrementor(forIncrement: 5)
run() // 5
run() // 10
//
let run2 = makeIncrementor(forIncrement: 7)
run2() // 7
//
run() // 15

• 当创建incrementor时，会得到了个独立全新的变量，因此上述run1,run互不干扰

---

4.闭包是引用类型

• 上面的例子，run,run1都是常量，但是这些常量指向的闭包依然可以增加其捕获变量的值，因为闭包是引用类型

• 将一个函数或者闭包赋值给一个常量或者变量，实际都是讲常量或者变量的值设置为对应函数或者闭包的引用

• 将闭包赋值给两个不同的变量或者常量，两个值都会指向一个闭包

let run3 = run
run3() // 20

5.非逃逸闭包

5.1什么是非逃逸闭包

• 当一个闭包作为参数传递给函数时，如果闭包在函数返回之后才执行，则成这样的闭包从函数中逃逸

• 当定义接受闭包作为参数的函数时，可以在参数前面添加@noescape，用来表示该闭包是不可以逃逸的

• 闭包标注@noescape后，闭包只能在函数体中执行，不能脱离函数体

// 非逃逸闭包
func someFunction(@noescape closure: ()->Void){
    closure()
}

• sort方法就可以用非逃逸闭包，因为它在排序完成的时候，就已经没用了
• 常用的闭包往往都是逃逸的，比如网络异步请求后，我们获得返回数据使用，这些闭包要脱离函数体使用