你真的懂闭包么？

在介绍闭包之前需要介绍下闭包表达式，很多人都会把闭包与闭包表达式混为一谈，这其实是两个概念。

闭包表达式（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，构成了函数重载