Swift之闭包

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

前面已经学习了全局函数和嵌套函数，今天重点学习闭包表达式

闭包表达式：简称为闭包，没有名字的函数式

一、闭包引入

普通函数写法

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

函数改成闭包的步骤：
1、删除关键字func和函数名称
2、把参数列表移到{ }
3、添加关键字 in

闭包写法

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

闭包表达式语法
1、由一对{}开始和结束；
2、in关键字把闭包分成两部分：参数与返回值、闭包体
3、调用闭包时不需要传参数名

思考1：demo是不是一个闭包

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

思考2：写一个闭包表达式，实现两数相加

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

第二部分：闭包缩写

需求：简写上面的sum闭包

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

省略1：能够推断出参数和返回值类型的情况下，可以省略参数和返回值类型。

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

省略2：单行表达式闭包可以省略 return 关键字来

let sum:(Int,Int)->Int = {
  (num1,num2) in num1+num2
}

省略3：省略参数列表定义，用$0,$1等等指代参数，同时省略in

let sum:(Int,Int)->Int = { $0+$1}

第三部分：尾随闭包

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

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+"~~~")}

第四部分：闭包的应用

4.1 数组的map方法

数组的map方法可以实现把每个成员拿出来做一些事情

var arr1 = [1,2,3,4,6,9]
arr1.map({(number:Int) in 
print(number)
})

let arr2 = arr1.map({(number:Int)->Int in 
return number+100
})

思考：如何简写？

let arr2 = arr1.map(){$0+100} //只有一个参数，可以省略(）
let arr2 = arr1.map{$0+100}

4.2 数组的filter方法

filter是过滤，筛选的意思，fiter()方法可以依次遍历数组中的每个成员，并把满足条件的筛选出来。

var arr3 = arr1.filter({
(number:Int)->Bool in
  return number%2==0
})

思考：
1、如何简写？
2、过滤大于5的成员

第五部分：拓展

值捕获

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

逃逸闭包在网络访问中会经常用到！

参考链接

https://www.jianshu.com/p/a3eed1c04a75
https://zhuanlan.zhihu.com/p/92464947
https://www.jianshu.com/p/4150fbee2571