Swift闭包

Swift闭包

闭包(Closures)是自包含的功能代码块，可以在代码中使用或者用来作为参数传值。

Swift 中的闭包与 C 和 Objective-C 中的代码块（blocks）以及其他一些编程语言中的 匿名函数比较相似。

全局函数和嵌套函数其实就是特殊的闭包。

根据官方文档，闭包通常下三种形式之一：

1. 全局函数：有名字但不能捕获任何值。
2. 嵌套函数：有名字，也能捕获封闭函数内的值。
3. 闭包表达式：无名闭包，使用轻量级语法，可以根据上下文环境捕获值。

一、闭包引入

• 普通函数写法

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

• 闭包写法

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

闭包表达式

闭包表达式是一种利用简洁语法构建内联闭包的方式。
闭包表达式提供了一些语法优化，使得撰写闭包变得简单明了。
实例

let names = ["AT", "AE", "D", "S", "BE"]
// 使用普通函数(或内嵌函数)提供排序功能,闭包函数类型需为(String, String) -> Bool。
func backwards(s1: String, s2: String) -> Bool {
    return s1 > s2
}
var sum = names.sorted(by: backwards)
print(sum)

以上程序执行输出结果为：

["S", "D", "BE", "AT", "AE"]

如果第一个字符串 (s1) 大于第二个字符串 (s2)，backwards函数返回true，表示在新的数组中s1应该出现在s2前。 对于字符串中的字符来说，“大于” 表示 “按照字母顺序较晚出现”。 这意味着字母"B"大于字母"A"，字符串"S"大于字符串"D"。 其将进行字母逆序排序，"AT"将会排在"AE"之前。

参数名称缩写

Swift 自动为内联函数提供了参数名称缩写功能，您可以直接通过$0,$1,$2来顺序调用闭包的参数。

实例：

let names = ["AT", "AE", "D", "S", "BE"]

var sum = names.sorted( by: { $0 > $1 } )
print(sum)

$0和$1表示闭包中第一个和第二个String类型的参数。

以上程序执行输出结果为：

["S", "D", "BE", "AT", "AE"]

如果你在闭包表达式中使用参数名称缩写, 您可以在闭包参数列表中省略对其定义, 并且对应参数名称缩写的类型会通过函数类型进行推断。in 关键字同样也可以被省略.

尾随闭包

尾随闭包是一个书写在函数括号之后的闭包表达式，函数支持将其作为最后一个参数调用。

func sum(closure: () -> Void) {
    // 函数体部分
}

// 以下是不使用尾随闭包进行函数调用
sum({
    // 闭包主体部分
})

// 以下是使用尾随闭包进行函数调用
sum() {
  // 闭包主体部分
}

实例

func sum(closure:String,printFun:(String)->Void){
    printFun(closure)
}

//普通调用方式
sum(closure:"hello world",printFun:{s in print(s+"~~~")})

//使用尾随闭包进行调用
sum(closure:"hello world"){s in print(s+"~~~")}

注意： 如果函数只需要闭包表达式一个参数，当您使用尾随闭包时，您甚至可以把()省略掉。

捕获值

闭包可以在其定义的上下文中捕获常量或变量。

即使定义这些常量和变量的原域已经不存在，闭包仍然可以在闭包函数体内引用和修改这些值。

Swift最简单的闭包形式是嵌套函数，也就是定义在其他函数的函数体内的函数。

嵌套函数可以捕获其外部函数所有的参数以及定义的常量和变量。

func makeIncrementer(forIncrement amount: Int) -> () -> Int {
    var runningTotal = 0
    func incrementer() -> Int {
        runningTotal += amount
        return runningTotal
    }
    return incrementer
}

let a = makeIncrementer(forIncrement:10)
// 返回的值为10
print(a())
// 返回的值为20
print(a())
// 返回的值为30
print(a())

闭包是引用类型

得到的一个闭包常量，这个闭包常量在内存里作为一个实例对象，此对象存储了捕获到的参数，调用三次就得到三个不同的结果:

func makeIncrementor(forIncrement amount: Int) -> () -> Int {
    var runningTotal = 0
    func incrementor() -> Int {
        runningTotal += amount
        return runningTotal
    }
    return incrementor
}

let a = makeIncrementor(forIncrement: 10)

// 返回的值为10
a()

// 返回的值为20
a()

// 返回的值为30
a()

// 返回的值为40
a()

let sum = a

// 返回的值也为50
print(sum())

以上程序执行输出结果为：

50

得到的一个闭包常量，这个闭包常量在内存里作为一个实例对象，此对象存储了捕获到的参数，调用三次就得到三个不同的结果

逃逸闭包

逃逸闭包
当一个闭包作为参数传到一个函数中，需要这个闭包在函数返回之后才被执行，我们就称该闭包从函数种逃逸。一般如果闭包在函数体内涉及到异步操作，但函数却是很快就会执行完毕并返回的，闭包必须要逃逸掉，以便异步操作的回调。

逃逸闭包一般用于异步函数的回调，比如网络请求成功的回调和失败的回调。语法：在函数的闭包行参前加关键字“@escaping”。

逃逸闭包的条件：

1、闭包作为一个参数传到函数中。

2、闭包在函数返回之后才执行。

需求：闭包作为一个参数传递一个函数，但是这个闭包我不立马使用，先把这个闭包存起来，过会再用

var nums:()->Void = {print("")}
var x = 10
//方案一：定义一个函数，接受一个普通闭包为参数
func sum1(closure:()->Void){
    nums = closure //此段代码报错，原因是普通闭包作为参数，会在函数结束之后被销毁，无法在函数外使用。
}
sum1{
    x=100
}
nums()

// 方案二：逃逸闭包
/*
逃逸闭包特点如下：
1、可以在函数结束后使用；
2、寿命长！逃逸闭包声明周期长于函数，只要它的引用被其他对象持有，就不会随着函数结束而释放掉
3、通过@escaping 指定一个闭包是逃逸闭包
*/
func sum2(closure:@escaping ()->Void){
    nums = closure 
}
sum2{
    x = 200
}
nums()
print(x)