1.闭包的概念：闭包（Closures）是自包括的功能代码块，能够在代码中使用或者用来作为参数传值。在Swift中的闭包与C，OC中的block相似。闭包能够捕获和存储上下文中定义的不论什么常量和变量的应用，这就是所谓的变量和变量的自封闭，因此闭包还会处理全部捕获的引用的内存管理。全局函数和嵌套函数事实上就是特殊的闭包。
2.闭包的形式（分类）：
（1）全局函数是一个有名字但不会捕获任何值得闭包
（2）嵌套函数是一个有名字并且可以捕获其封闭函数域内值的闭包
（3）闭包表达式是一个利用轻量级语法所写的可以捕获其上下文中变量或常量值的匿名闭包
swift的闭包表达式拥有简洁的风格，并鼓励在常见场景中进行语法优化，主要优化如下：
- 利用上下文腿短参数和返回值类型
- 隐式返回单表达式闭包，即单表达式闭包可以省略
return关键字 - 参数名称缩写
- 尾随闭包语法
3.闭包表达式语法
闭包表达式语法有如下的一般形式
{（参数）-> 返回类型 in
函数实现方法
}
闭包表达式回调函数
func getMax( value1 : Int, value2 : Int, cmp : () -> String) -> Int{
if cmp() == "1" {
return max(value1, value2);
}else if cmp() == "2"{
return min(value1, value2);
}
}
let cmp = {
() -> String in
return "2";
}
let s = getMax(value1: 20, value2: 30, cmp: cmp);
//类似OC block回调
func likeBlock(num1 : Int, num2 : Int, cmp : (Int) -> Int) -> Int{
return cmp(num2 + num1);//将相加的值回调
}
likeBlock(num1: 12, num2: 13) { (allnum) -> Int in
return allnum;//返回值为12 + 13 = 50；
}
我们可通过修改闭包cmp的策略，来改变函数getMax的作用。当我们修改闭包cmp返回值为1时，getMax函数功能为获取两个参数的最大值。修改闭包cmp返回值为2时，getMax函数功能为获取两个参数的最小值。
或者将闭包表达式作为参数嵌入
let y = getMax(value1: 30, value2: 50) { () -> String in
return "1";
}//y的返回值为50
闭包表达式语法优化
var numbers = [23, 132, 61, 43, 53];
func com (n1 : Int, n2 : Int) -> Bool{
return n1 > n2;
}
//默认为升序 修改为降序
numbers.sorted(by: com(n1:n2:));
//精简写法1
numbers.sorted(by: {
(n1 : Int, n2 : Int) -> Bool in
return n1 > n2;
})
//精简写法2 根据上下文推断参数和返回值的类型 省略return
numbers.sorted(by: {n1, n2 in n1 > n2});
//精简写法3 参数名称缩写
numbers.sorted(by: {$0 > $1});
//精简写法4 运算符方法
numbers.sorted(by: >);
尾随闭包
//若你需要将一个很长的闭包表达式作为一个参数传递给函数，可以使用尾随闭包来增强函数的可读性
func testFunction(testBlock : () -> Void){
//这里需要传进来的闭包类型是无参数和无返回值的
testBlock();
}
//正常写法
testFunction(testBlock: {
print("正常写法");
});
//尾随闭包写法
testFunction(){
print("尾随闭包写法");
};
//也可以把括号去掉，也是尾随闭包写法 推荐写法
testFunction {
print("去掉括号的尾随闭包写法");
}
值捕获
闭包可以在其被定义的上下文中捕获常量或变量，即使定义这些常量和变量的原作用域已经不存在，闭包仍然可以在闭包函数体内引用和修改这些值
swift中，可以捕获值的闭包的最简单形式是嵌套函数，也就是定义在其他函数的函数体内的函数，嵌套函数可以捕获其外部函数所有参数以及定义的常量和变量
//makeIncrementerf返回类型为（）->int ，表示其返回的是一个函数，即返回嵌套函数incrementer。
//incrementer的作用是访问makeIncrementerf函数体内的 runningTotal 和 amount 变量。即从外围函数捕获了它们的引用。
//捕获引用保证了 runningTotal 和 amount 变量在 调用完 makeIncrementer 后不会消失，并且保证了在下一次执行 incrementer 函数时，runningTotal 依旧存在。
func makeIncrementer(forIncrement amount: Int) -> () -> Int {
var runningTotal = 0
func incrementer() -> Int {
runningTotal += amount
return runningTotal
}
return incrementer
}
//我们调用makeIncrementor，并定义了一个叫做 byTen 的常量，该常量指向一个每次调用会将其 runningTotal 变量增加 1 0 的 incrementor 函数。
let byTen = makeIncrementor(forIncrement: 10);
byTen() // 返回的值为10
byTen() // 返回的值为20
byTen() // 返回的值为30
//我们另定义一个bySeven
let bySeven = makeIncrementor(forIncrement: 10);
bySeven();//返回的值为7
//我们在此调用原来的byTen，会继续增加自己的runningTotal 变量，该变量和 bySeven 中 捕获的变量没有任何联系:
byTen();//返回的值为40
闭包是引用类型
上面的例子中，bySeven 和 byTen 都是常量，但是这些常量指向的闭包仍然可以增加其捕 获的变量的值,这是因为函数和闭包都是引用类型。
无论你将函数或闭包赋值给一个常量还是变量，你实际上都是将常量或变量的值设置为对应函数或闭包的引 用。上面的例子中，指向闭包的引用byTen 是一个常量，而并非闭包内容本身。
这也意味着如果你将闭包赋值给了两个不同的常量或变量，两个值都会指向同一个闭包:
let alsoIncrementByTen = byTen;
alsoIncrementByTen();// 返回的值为50
逃逸闭包
当一个闭包作为参数传到一个函数中，但是这个闭包在函数返回之后才被执行，我们称该闭包从函数中逃逸。当你定义接受闭包作为参数的函数时，你可以在参数名之前标注@escaping，用来指明这个闭包是允许逃逸出这个函数的
一种能使闭包逃逸出函数的方法是，将这个闭包保存在一个函数外部定义的变量中，举个例子，很多启动异步操作的函数接受一个闭包参数作为handler。这类函数会在异步操作开始之后立刻返回，但是闭包知道异步操作结束后才被调用，在这种情况下，闭包需要逃逸，因为闭包需要在函数返回之后被调用。
//定义一个数组
var handlers: [() -> Void] = [];
//逃逸闭包
func Escapingfunc(handler: @escaping () -> Void) {
handlers.append(handler);
}
Escapingfunc函数接受了一个闭包作为参数，该闭包被添加到一个函数外定义的数组中，如果你不将这个参数标记为@escaping，就会得到一个编译错误。
将一个闭包标记为@escaping意味着你必须在闭包中显示的引用self。比如说，在下面的代码中，传递到Escapingfunc中的闭包是一个逃逸闭包，这以为着它需要显示的引用self。相对的床底到NoEscapingfunc中的闭包是一个非逃逸闭包，这意味着它可以隐式引用self
func NoEscapingfunc(closure: () -> Void) {
closure()
}
class SomeClass {
var x = 10
func doSomething() {
Escapingfunc { self.x = 100 }
NoEscapingfunc { x = 200 }
}
}
let instance = SomeClass() instance.doSomething()
print(instance.x)// 打印出 "200"
handlers.first?()
print(instance.x)// 打印出 "100"
