SWift之闭包
/*全局函数是一个有名字但不会捕获任何值的闭包
嵌套函数是一个有名字并可以捕获其封闭函数域内值的闭包
闭包表达式是一个利用轻量级语法所写的可以捕获其上下文中变量或常量值的匿名闭包
前面已经学习了全局函数和嵌套函数，今天重点学习闭包表达式
闭包表达式：匿名闭包
*/

一.闭包引入
普通函数写法

func square(num:Int)->Int{
    return num*num
}
print(square(num:5))

闭包写法

let fun1={
    (num:Int)->Int in
    return num*num
}
print(type(of:fun1))//fun1类型:(Int)->Int
print(fun1(3))

/*闭包表达式语法
1）由一对{}开始和结束
2)in关键字把闭包分成两个部分:参数与返回值 闭包体
*/
案例一:是不是一个闭包

let demo = {print("duck")}
print(type(of:demo))//()->()

案例二:写一个闭包表达式，实现两数相减

let sum = {
    (num1:Int,num2:Int)->Int in
    return num1-num2
}
print(sum(4,5))

二:闭包缩写

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=[55,66,77,88,99]
print(getScore(score:score,con:{(s:Int)->Bool in return s>60}))

省略1:省略->返回类型(自动推断出返回值是一个Bool)

print(getScore(score:score,con:{(s:Int)in return s>45}))

省略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>60}))

三:尾随闭包
/*使用情景:当闭包表达式作为最后一个参数传递给函数时,可以单独提出来
问题1:尾随指的是跟在别人后面 闭包到底跟在谁后面？——函数后面
问题2:用尾随的好处？提升代码的可读性
*/

func printInfo(info:String,printFun:(String)->Void){
    printFun(info)
}

普通调用方式

printInfo(info:"hi,duck",printFun:{s in print(s+"~~~")})

使用尾随闭包进行调用

printInfo(info:"hi,duck"){s in print(s+"~~~")}

四、值捕获
/*
值捕获:也就是空手套白狼,把别人的变量或者常量拿过来用
从案例中可以看出来,incrementer内嵌套函数自己没有任何意义的变量或常量,
但可以铺垫上下文中的常量和变量,拿过来自己用
*/

func makeIncrementer(forIncrement amount: Int)-> () -> Int{
    var runningTotal = 0
    func increment() ->Int {
        runningTotal += amount
        return runningTotal
    }
    return increment
}
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)