根据官方文档，闭包通常下三种形式之一：
全局函数:是一个有名字但不会捕获任何值的闭包
嵌套函数:是一个有名字并可以捕获其封闭函数域内值的闭包
闭包表达式:是一个利用轻量级语法所写的可以捕获其上下文中变量或常量值的匿名闭包

闭包表达式：匿名闭包

一、闭包引入

//普通函数定义：
func square(num:Int)->Int{
    return num*num 
}
print(square(num:4))

闭包表达式语法：
由一堆{}开始和结束；in关键字把闭包分为两部分：
参数与返回值、闭包体

let func2 = {
    (num:Int)->Int in 
    return num*num 
}
print(type(of:func2))//fun2类型：(Int)->Int
print(func2(5))

//思考1:demo是不是一个闭包
let demo = {print("hello")}
print(type(of:demo))//()->()

//思考2：写一个闭包表达式，实现两数相加
let sum = {
    (num1:Int,num2:Int)->Int in 
    return num1+num2
}
print(sum(5,10))

第二部分：闭包缩写

需求：把我们的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 = [60,90,80,99,100]
print(getScore(score:score,con:{(s:Int)->Bool in return s>40}))

/*省略1：省略->返回类型（系统自动推断）
print(getScore(score:score,con:{(s:Int) in return s>40}))
*/

/*省略2：省略参数类型和括号
print(getScore(score:score,con:{ s in return s>40}))
*/

/*省略3：单行表达式闭包可以省略 reture 关键字来
print(getScore(score:score,con:{ s in s>40}))
*/

//省略4：省略参数列表的定义，用$0,$1..只带参数，同时省略in
print(getScore(score:score,con:{$0>60}))

第三部分：尾随闭包

使用情景：当闭包作为i最后一个参数传递给函数的时候，可以单独提出来
问题1：尾随闭包跟在谁后面？ ——函数后面
问题2：尾随闭包的好处 ——提升代码的可读性

func printInfo(info:String,printFun:(String)->Void){
    printFun(info)
}
//普通调用方式
printInfo(info:"hello,word",printFun:{s in print(s+"@@@@@@")})

//尾随闭包调用
printInfo(info:"你叫啥"){s in print(s+"啊？")}

*值捕获
值捕获：也就是空手套白狼，把别人的变量或常量拿过来用
从案例中可以看出，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())
闭包是引用类型
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)