在介绍闭包之前需要介绍下闭包表达式，很多人都会把闭包与闭包表达式混为一谈，这其实是两个概念。
闭包表达式（Closure Expression）
在Swift中，可以通过func定义一个函数，也可以通过闭包表达式定义一个函数
{
(参数列表) -> 返回值类型
in
函数体代码
}
func sum(_ v1: Int, _ v2: Int) -> Int {
v1 + v2
}
var fn = {
(v1: Int, v2: Int) -> Int in
return v1 + v2
}
闭包表达式的简写
// 写法1
exec(v1: 10, v2: 20, fn: {
(v1: Int, v2: Int) -> Int in
return v1 + v2
})
// 写法2
exec(v1: 10, v2: 20, fn: {
v1, v2 in
return v1 + v2
})
// 写法3
exec(v1: 10, v2: 20, fn: {
v1, v2 in v1 + v2
})
// 写法4
exec(v1: 10, v2: 20, fn: {
$0 + $1
})
// 写法4
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))
}
// 写法1
exec(fn: {$0 + $1})
// 写法2
exec(){$0 + $1}
// 写法3
exec{$0 + $1}
示例-数组的排序
@inlinable public mutating func sort(by areInIncreasingOrder: (Element, Element) throws -> Bool) rethrows
/// 返回true：i1在i2前面
/// 返回false： i1在i2后面
func cmp(i1:Int,i2:Int) -> Bool {
return i1 > i2
}
var nums = [11,2,18,6,5,68,45]
// 写法1
nums.sort(by: { (i1: Int, i2: Int) -> Bool in
return i1 < i2
})
// 写法2
nums.sort(by: { i1, i2 in return i1 < i2 })
// 写法3
nums.sort(by: { i1, i2 in i1 < i2 })
// 写法4
nums.sort(by: { $0 < $1 })
// 写法5
nums.sort(by: <)
// 写法6
nums.sort(){ $0 < $1 }
// 写法7
nums.sort{ $0 < $1 }
忽略参数
func exec(fn: (Int,Int)->Int) {
print(fn(1,2))
}
exec { _, _ in 10 }
闭包（Closure）
- 一个函数和它所捕获的变量\常量组合起来，称为闭包
- 一般指定义在函数内部的函数
- 一般它捕获的是外层函数的局部变量\常量
typealias Fn = (Int) -> Int
func getFn() -> Fn {
var num = 0
func plus(_ i: Int)->Int {
num += i
return num
}
return plus
}//返回的plus与num形成了闭包
// 等价写法
func getFn2() -> Fn {
var num = 0
return {
num += $0
return num
}
}
var fn1 = getFn()
var fn2 = getFn()
print(fn1(1)) //1
print(fn2(2)) //2
print(fn1(3)) //4
print(fn2(4)) //5
print(fn1(5)) //9
print(fn2(6)) //9
- 可以把闭包想象成是一个类的实例对象
- 内存在堆空间
- 捕获的局部变量\常量就是对象的成员（存储属性）
- 组成闭包的函数就是内内部定义的方法
class Closure {
var num = 0
func plus(_ i: Int) -> Int {
num += i
return num
}
}
var cs1 = Closure()
var cs2 = Closure()
cs1.plus(1) //1
cs2.plus(2) //2
cs1.plus(3) //4
cs2.plus(4) //6
cs1.plus(5) //9
cs2.plus(6) //12
示例-练习1
typealias Fn = (Int) -> (Int, Int)
func getFns() -> (Fn, Fn) {
var num1 = 0
var num2 = 0
func plus(_ i: Int) -> (Int, Int) {
num1 += i
num2 += i << 1
return (num1, num2)
}
func minus(_ i: Int) -> (Int, Int) {
num1 -= i
num2 -= i << 1
return (num1, num2)
}
return (plus, minus)
}
let (p, m) = getFns()
p(5) // (5, 10)
m(4) // (1, 2)
p(3) // (4, 8)
m(2) // (2, 4)
等价于
class Closure {
var num1 = 0
var num2 = 0
func plus(_ i: Int) -> (Int,Int) {
num1 += i
num2 += i << 1
return (num1,num2)
}
func minus(_ i: Int) -> (Int,Int) {
num1 -= i
num2 -= i << 1
return (num1,num2)
}
}
var cs = Closure()
print(cs.plus(5)) // (5, 10)
print(cs.minus(4)) //(1, 2)
print(cs.plus(3)) // (4, 8)
print(cs.minus(2)) //(2, 4)
示例-练习2
var functions: [()->Int] = []
for i in 1...3 {
functions.append{ i }
}
for f in functions {
print(f())
}
// 1
// 2
// 3
等价于
class Closure {
var i : Int
init(_ i : Int) {
self.i = i
}
func get() -> Int {
i
}
}
var clses: [Closure] = []
for i in 1...3 {
clses.append(Closure(i))
}
for cls in clses {
print(cls.get())
}
注意
如果返回值是函数类型，那么参数的修饰要保持统一
func add(_ num:Int) -> (inout Int) -> Void {
func plus(v: inout Int) {
v += num
}
return plus
}
var num = 5
add(20)(&num)
print(num) // 25
自动闭包
常规代码
// 如果第1个数大于0，返回第一个数。f否则返回第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 getFirstPositive(_ v1: Int, _ v2: ()->Int) -> Int? {
return v1 > 0 ? v1 : v2()
}
getFirstPositive(-4) {20}
使用自动闭包
func getFirstPositive(_ v1: Int, _ v2: @autoclosure ()->Int) -> Int? {
return v1 > 0 ? v1 : v2()
}
getFirstPositive(-4,20)
- 为了避免与期望冲突，使用了
@autoclosure的地方最好是明确注释清楚：这个值会被推迟执行 -
@autoclosure会自动将20封装成闭包{20} -
@autoclosure只支持()->T格式的参数 -
@autoclosure并非只支持最后一个参数 - 空合并预算符?? 使用了
@autoclosure技术 - 有
@autoclosure、无@autoclosure，构成了函数重载
