Swift之闭包(Closure)

本文首发于个人我的博客

什么是闭包

• 一个函数和它所捕获的变量\常量环境组合起来，称为闭包
  • 通常指定义在函数内部的函数
  • 通常它捕获的是外层函数的局部变量\常量
• 能够把闭包想象成是一个类的实例对象
  • 内存在堆空间
  • 捕获的局部变量\常量就是对象的成员(存储属性)
  • 组成闭包的函数就是类内部定义的方法

eg: 咱们有一个函数 sum

// 函数
func sum(_ v1: Int, _ v2: Int) -> Int { v1 + v2 }
// 使用
sum(10, 20)
复制代码

若是用闭包表达式定义一个函数

var fn = {
    (v1: Int, v2: Int) -> Int in
    return v1 + v2
}

// 使用
fn(10, 20)
复制代码

固然了，也能够

{
    (v1: Int, v2: Int) -> Int in
    return v1 + v2
}(10, 20)

复制代码

总结起来就是

{
    (参数列表) -> 返回值类型 in 函数体代码
}
复制代码

闭包表达式的简写

咱们定义以下的函数 exec ，它接收三个参数，分别为两个Int 和一个函数，并且这个函数，接收两个Int 参数，返回一个Int结果，exec 的做用就是，把前两个参数传给第三个参数(也就是函数)去执行，而后结果打印出来

// 函数 咱们定义以下的函数 exec ，它接收三个参数，分别为两个Int 和一个函数，并且这个函数，接收两个Int 参数，返回一个Int结果，exec 的做用就是，把前两个参数传给第三个参数(也就是函数)去执行，而后结果打印出来
func exec(v1: Int, v2: Int, fn: (Int, Int) -> Int) {
    print(fn(v1, v2))
}
复制代码

若是用闭包表达式来定义的话

// 闭包表达式
exec(v1: 10, v2: 20, fn: {
    (v1: Int, v2: Int) -> Int in
    return v1 + v2
})
复制代码

固然了，咱们能够省略不少，以下

// 省略参数类型 由于swift能够本身推断类型
exec(v1: 10, v2: 20, fn: {
    v1, v2 in return v1 + v2
})

// return 也能够省略
exec(v1: 10, v2: 20, fn: {
    v1, v2 in v1 + v2
})

// 省略掉参数列表，用$0表明第0个参数，$1表明第1个参数
exec(v1: 10, v2: 20, fn: {
    $0 + $1
})

// 终极省略
exec(v1: 10, v2: 20, fn: +)
复制代码

尾随闭包

• 若是将一个很长的闭包表达式做为函数的最后一个实参，使用尾随闭包能够加强函数的可读性
  • 尾随闭包是一个被书写在函数调用括号外面(后面)的闭包表达式

有以下的函数 闭包表达式做为函数的最后一个实参

func exec(v1: Int, v2: Int, fn: (Int, Int) -> Int) {
    print(fn(v1, v2))
}
	
复制代码

使用尾随闭包为

exec(v1: 10, v2: 20) {
    $0 + $1
}
复制代码

• 若是闭包表达式是函数的惟一实参，并且使用了尾随闭包的语法，那就不须要在函数名后边写圆括号

// 这个闭包表达式表达式是函数的惟一实参
func exec(fn: (Int, Int) -> Int) { 
	print(fn(1, 2))
}

复制代码

可使用尾随闭包以下

// 使用尾随闭包以下三种均可以
exec(fn: { $0 + $1 })
exec() { $0 + $1 }
exec { $0 + $1 }

复制代码

尾随闭包实战

系统自带的排序

假设咱们有个包含Int元素的数组，想对立面的元素进行排序

func numberSort()  {
    var arr = [6, 8, 1, 10]
    arr.sort()
    print(arr) //[1, 6, 8, 10]
}

numberSort()

复制代码

打印结果为

[1, 6, 8, 10]

查看官方对sort的源码为

// 官方代码
func sort(by areInIncreasingOrder: (Element, Element) -> Bool)
复制代码

自定义排序

假如咱们想自定义排序

/// 返回true: i1排在i2前面
/// 返回false: i1排在i2后面
func cmp(i1: Int, i2: Int) -> Bool {
    // 大的排在前面
    return i1 > i2
}
复制代码

使用的时候

var nums = [6, 8, 1, 10]
nums.sort(by: cmp)
print(nums)
复制代码

打印结果为

[10, 8, 6, 1]

用尾随闭包书写

上面的代码

能够写成

nums.sort(by: {
    (i1: Int, i2: Int) -> Bool in
    return i1 > i2
})
复制代码

也能够等价于下面几种

nums.sort(by: { i1, i2 in return i1 > i2 })
nums.sort(by: { i1, i2 in i1 > i2 })
nums.sort(by: { $0 > $1 })
nums.sort(by: > )
nums.sort() { $0 > $1 }
nums.sort { $0 > $1 }
复制代码

忽略参数

Swift中，不少时候，若是咱们对于参数不作处理，能够用 下划线 _ 来代替

例以下面的闭包

func exec(fn: (Int, Int) -> Int) {
    print(fn(1, 2))
}

print(exec{_,_ in 100 })  // 100
复制代码

输出

100

自动闭包

函数

假设咱们定义一个这样的函数，要求 若是第1个数大于0，返回第一个数。不然返回第2个数

func getFirstPositive(_ v1: Int, _ v2:  Int) -> Int? {
    return v1 > 0 ? v1 : v2
    
}
    
//调用
getFirstPositive(10, 20) // 10
getFirstPositive(-2, 20) // 20
getFirstPositive(0, -4) // -4
复制代码

如今假如说，咱们这么传入的话

func getNum() -> Int {
	// 这里每次都执行
    let a = 100
    let b = 200
    return a + b
}

func getFirstPositive2(_ v1: Int, _ v2:  Int) -> Int? {
    return v1 > 0 ? v1 : v2
    
}

getFirstPositive2(10, getNum())

复制代码

改为函数类型的参数

由于第一个参数已是10 大于0了，第二个参数，也就是getNum() 根本不必去执行，浪费性能，因此，有没有什么办法能作到，当第一个参数不知足时候，才去执行getNum()呢？答案是有的

// 改为函数类型的参数，可让v2延迟加载
func getFirstPositive2(_ v1: Int, _ v2: () -> Int) -> Int? {
	// 这里判断 v1 > 0 不会调用 v2()
    return v1 > 0 ? v1 : v2()
}

getFirstPositive2(10, {
	// 第一个参数大于0的时候，这里不会执行
    let a = 100
    let b = 200
    return a + b
})

复制代码

改进

若是改为这样写就报错了

/ 改为函数类型的参数，可让v2延迟加载
func getFirstPositive2(_ v1: Int, _ v2: () -> Int) -> Int? {
	// 这里判断 v1 > 0 不会调用 v2()
    return v1 > 0 ? v1 : v2()
}

getFirstPositive2(10,  20) //报错 Cannot convert value of type 'Int' to expected argument type '() -> Int'
复制代码

由于须要的是() -> Int类型，给的是Int

咱们能够写成下面两种均可以

/ 改为函数类型的参数，可让v2延迟加载
func getFirstPositive2(_ v1: Int, _ v2: () -> Int) -> Int? {
	// 这里判断 v1 > 0 不会调用 v2()
    return v1 > 0 ? v1 : v2()
}

getFirstPositive2(10) { 20}

getFirstPositive2(10, {20})
复制代码

@autoclosure

上面的也能够用自动闭包技术

func getFirstPositive3(_ v1: Int, _ v2: @autoclosure () -> Int) -> Int? {
    return v1 > 0 ? v1 : v2()
}
getFirstPositive3(-4, 20)
复制代码

须要的注意点：

• 为了不与指望冲突，使用了@autoclosure的地方最好明确注释清楚:这个值会被推迟执行
• @autoclosure 会自动将 20 封装成闭包 { 20 }
• @autoclosure 只支持 () -> T 格式的参数 n@autoclosure 并不是只支持最后1个参数
• 空合并运算符 ?? 使用了 @autoclosure 技术
• 有@autoclosure、无@autoclosure，构成了函数重载

Swift官方源码

从入门到精通Swift编程

更多资料，欢迎关注我的公众号，不定时分享各类技术文章。