闭包表达式(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
}
fn(10,29)
//
{
    (v1: Int,v2: Int) -> Int in
    return v1 + v2
}(11,22)

闭包表达式的简写

func exec(v1: Int,v2: Int,fn: (Int,Int) -> Int) {
    print(fn(v1,v2))
}
//函数调用时(闭包)简写
//fn为一个闭包,可按照闭包的定义格式书写
//{
//    (参数列表) -> 返回值类型 in
//    函数体代码
//}
exec(v1: 10, v2: 21, fn: {
    (v1: Int,v2: Int) -> Int in
    return v1 + v2
})
//fn为一个闭包,可按照闭包的定义格式书写
//在此基础上,因类型推倒,可将参数类型省略
//因为传进来的参数v1,v2,已经可以确定类型为Int
//编译器可以自动推倒出参数类型,顾客省略参数类型
exec(v1: 10, v2: 22, fn: {
    v1,v2 in return v1 + v2
})
//如果函数体只有一行代码,有作为函数返回值,可以省略return
exec(v1: 10, v2: 33, fn: {
    v1 ,v2 in v1 + v2
})
//也可以是用$加序号,来标识参数
exec(v1: 10, v2: 20, fn: {
    $0 + $1
})
//
exec(v1: 10, v2: 22, fn: +)

尾随闭包

如果将一个很长的闭包表达式作为函数的最后一个实参,使用尾随闭包可以增强函数的可读性
尾随闭包是一个被书写在函数调用括号外面(后面)的闭包表达式

func exec(v1: Int,v2: Int,fn: (Int,Int) -> Int) {
    print(fn(v1,v2))
}
//fn为函数exec的最后一个参数,且fn为函数类型(闭包).故可以使用未遂闭包的形式.将参数fn写在函数参数列表括号的外面.
exec(v1: 10, v2: 11) { (v1, v2) -> Int in
    v1 + v2
}

如果闭包表达式是函数唯一实参,而且使用了尾随闭包的语法,那就不需要在函数名后面谢圆括号

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

数组排序

func cmp(i1: Int,i2: Int) -> Bool {
    //大的排在前面
    return i1 > i2
}

var nums = [11,9,33,12,2,4,22]

nums.sort(by: cmp)

print(nums)//[33, 22, 12, 11, 9, 4, 2]
//传入闭包参数
nums.sort(by: {
    (s1: Int,s2: Int) -> Bool in
    return s1 < s2
})
print(nums)//[2, 4, 9, 11, 12, 22, 33]
//省略参数类型
nums.sort(by: {
    (s1,s2) -> Bool in
    return s1 < s2
})
//省略参数类型 及 返回值类型,编译器自动推断类型
nums.sort(by: {
    (s1,s2) in
    return s1 < s2
})
//省略return
nums.sort(by: {
    (s1,s2) -> Bool in
    s1 < s2
})

nums.sort(by: {$0 < $1})
nums.sort(by: <)
nums.sort(){$0 < $1}
nums.sort{$0 < $1}

闭包

一个函数和他所捕获的变量/常量环境组合起来,称为闭包
一般他捕获的是外层函数的局部变量/常量
可以把闭包想象成是一个类的实例对象
内存在堆空间
捕获的局部变量/常量就是对象的成员(存储属性)
组成闭包的函数就是类内部定义的方法

typealias Fn = (Int) -> Int
func getFn() -> Fn {
    var num = 0
    func plus(_ i: Int) -> Int{
        num += i
        return num
    }
    
    return plus
}
var fn1 = getFn()
var fn2 = getFn()
fn1(1)//1
fn2(2)//2
fn1(3)//4
fn2(4)//6
fn1(5)//9
fn2(6)//12

可以把闭包想象成一个类的实例对象

class Closure {
    var num = 0
    func plus(_ i: Int) -> Int {
        num += i
        return num
    }
}
var cs1 = getFn()
var cs2 = getFn()
cs1(1)//1
cs2(2)//2
cs1(3)//4
cs2(4)//6
cs1(5)//9
cs2(6)//12

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()
print(p(5))//(5,10)
print(m(4))//(1,2)
print(p(3))//(4,8)
print(m(2))//(2,4)

class Closure {
    var num1 = 0
    var num2 = 0
    func plus(_ i: Int) -> (Int,Int) {
        num1 += i
        num2 += i << 1// i * 2
        return (num1,num2)
    }
    func minus(_ i: Int) -> (Int,Int) {
        num1 -= i
        num2 -= i << 1// i * 2
        return(// (5,10),num2)
    }
}
var cs = Closure()
cs.plus(5)// (5,10)
cs.minus(4)// (1,2)
cs.plus(3)// (4,8)
cs.minus(2)// (2,4)

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 {
        return i
    }
}
var cls: [Closure] = []
for i in 1...3{
    cls.append(Closure(i))
}
for cls in cls {
    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

自动闭包

@autoclosure 会自动将20封装成闭包{ 20 }
@autoclosure只支持() -> T格式的参数
@autoclosure并非只支持最后一个参数
空合运算符??使用了@autoclosure技术
有@autoclosure和无@autoclosure构成函数重载

//如果第一个数大于零,返回第一个数,否则返回第二个数
func getFirstPositive(_ v1: Int,_ v2: Int) -> Int{
    return v1 > 0 ? v1 : v2
}
getFirstPositive(10, 3)//10
getFirstPositive(-10, 3)//3
getFirstPositive(0, -3)//-3

//改成函数类型的参数,可以让v2延迟加载
func getFirstPositive(_ v1: Int,_ v2: () -> Int) -> Int? {
    return v1 > 0 ? v1 : v2()
}

print(getFirstPositive(10) { () -> Int in
    20
})//Optional(10)
print(getFirstPositive(-10) { () -> Int in
    20
})//Optional(20)

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

print(getFirstPositive(-5, 1))//Optional(1)