闭包
闭包是自包含的函数代码块，可以在代码中被传递和使用。
闭包可以捕获和存储其所在上下文中任意常量和变量的引用。被称为包裹常量和变量。 Swift 会为你管理在捕获过程中涉及到的所有内存操作。
在 函数 章节中介绍的全局和嵌套函数实际上也是特殊的闭包，闭包采用如下三种形式之一：
1.全局函数是一个有名字但不会捕获任何值的闭包
2.嵌套函数是一个有名字并可以捕获其封闭函数域内值的闭包
3.闭包表达式是一个利用轻量级语法所写的可以捕获其上下文中变量或常量值的匿名闭包
闭包表达式：匿名闭包
一、闭包引入
普通函数写法
func square(num:Int)->Int{
return num*num
}
print(square(num:3))
闭包写法
let functio = {
(num:Int)->Int in
return num*num
}
print(type(of:functio))//functio类型：(Int) -> Int
print(functio(4))
闭包表达式语法
闭包表达式语法有如下的一般形式：
{ (parameters) -> return type in
statements
}
闭包表达式参数 可以是 in-out 参数，但不能设定默认值。如果你命名了可变参数，也可以使用此可变参数。元组也可以作为参数和返回值。
闭包缩写
需求：把我们的java成绩放到了一个数组里，定义一个函数，把大于某个阈值的成绩返回给我
func getScore(score:[Int],con:(Int)->Bool)->[Int]{
var newScore = [Int]()
for item in score{
if con(item){
newScore.append(item)
}
}
return newScore
}
var score = [66,89,80,33,100]
print(getScore(score:score,con:{(s:Int)->Bool in return s>40}))
省略1：省略->返回类型(自动推断出返回值是一个Bool)
print(getScore(score:score,con:{(s:Int) in return s>40}))
省略2：省略参数类型和括号(自动推断出参数类型是Int)
print(getScore(score:score,con:{s in return s>40}))
省略3：单行表达式闭包可以省略 return 关键字来
print(getScore(score:score,con:{s in s>40}))
省略4：省略参数列表定义，用1等等指代参数，同时省略in
print(getScore(score:score,con:{$0>40}))
尾随闭包
尾随闭包是一个书写在函数圆括号之后的闭包表达式，函数支持将其作为最后一个参数调用。
使用情景：当闭包表达式作为最后一个参数传递给函数时，可以单独提出来
func printInfo(info:String,printFun:(String)->Void){
printFun(info)
}
//普通调用方式
printInfo(info:"hello world",printFun:{s in print(s+"~~~")})
//使用尾随闭包进行调用
printInfo(info:"hello world"){s in print(s+"~~~")}
值捕获
闭包可以在其被定义的上下文中捕获常量或变量。即使定义这些常量和变量的原作用域已经不存在，闭包仍然可以在闭包函数体内引用和修改这些值。
Swift 中，可以捕获值的闭包的最简单形式是嵌套函数，也就是定义在其他函数的函数体内的函数。嵌套函数可以捕获其外部函数所有的参数以及定义的常量和变量。
值捕获：也就是空手套白狼，把别人的变量或常量拿过来用
从案例中可以看出，incrementer内嵌函数自己没有定义任何的变量或常量，但可以捕获上下文中的常量和变量，拿过来自己使用。
func makeIncrementer(forIncrement amount: Int) -> () -> Int {
var runningTotal = 0
func incrementer() -> Int {
runningTotal += amount
return runningTotal
}
return incrementer
}
let a = makeIncrementer(forIncrement:10)
print(a())
注意:
如果你将闭包赋值给一个类实例的属性，并且该闭包通过访问该实例或其成员而捕获了该实例，你将在闭包和该实例间创建一个循环强引用。Swift 使用捕获列表来打破这种循环强引用。
闭包是引用类型
函数和闭包都是引用类型,无论你将函数或闭包赋值给一个常量还是变量，你实际上都是将常量或变量的值设置为对应函数或闭包的引用。
let b = a
print(b()) //输出结果为20
let c = makeIncrementer(forIncrement:10)
print(c())
逃逸闭包
当一个闭包作为参数传到一个函数中，但是这个闭包在函数返回之后才被执行，我们称该闭包从函数中逃逸。
需求：闭包作为一个参数传递一个函数，但是这个闭包我不立马使用，先把这个闭包存起来，过会再用
var recv:()->Void = {print("")}
var x = 10
//方案一：定义一个函数，接受一个普通闭包为参数
func test1(closure:()->Void){
recv = closure //此段代码报错，原因是普通闭包作为参数，会在函数结束之后被销毁，无法在函数外使用。
}
test1{
x=100
}
recv()
// 方案二：逃逸闭包
/*
逃逸闭包特点如下：
1、可以在函数结束后使用；
2、寿命长！逃逸闭包声明周期长于函数，只要它的引用被其他对象持有，就不会随着函数结束而释放掉
3、通过@escaping 指定一个闭包是逃逸闭包
*/
func test2(closure:@escaping ()->Void){
recv = closure
}
test2{
x = 200
}
recv()
print(x)
Swift 的闭包表达式拥有简洁的风格，并鼓励在常见场景中进行语法优化，主要优化如下：
1.利用上下文推断参数和返回值类型
2.隐式返回单表达式闭包，即单表达式闭包可以省略 return 关键字
3.参数名称缩写
4.尾随闭包语法
