从零学习Swift 05:闭包表达式和闭包

作者: 小心韩国人 | 来源:发表于2020-04-21 18:25 被阅读0次

一:闭包表达式的定义

在 Swfit 中,可以通过func定义一个函数,也可以通过闭包表达式定义一个函数.闭包表达式的格式为:

{
(参数列表) -> 返回值类型 in
方法体
}

比如说我们使用func定义一个add方法:


func add(a: Int, b: Int) -> Int{
    a + b
}

print(add(a: 10, b: 20))

用闭包表达式也可以定义:


let fn = {
    (a: Int , b: Int) -> Int in
    a + b
}

print(fn(10,20))

二:闭包表达式的简写

定义一个函数如下:

// 接受两个 Int 类型的参数 , 和一个函数类型的参数
func exec(a: Int, b: Int, fn: (Int, Int) -> Int){
    print(fn(a,b))
}

使用闭包表达式完整调用如下:

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

另外还有4中简写方式:

省略参数类型和返回值类型
因为闭包表达式已经明确定义了参数类型和返回值类型都是 Int 类型,所以在调用闭包表达式的时候,编译器能自动类型推断,知道具体的类型.所以类型可以省略

exec(a: 10, b: 20) {
    v1, v2 in
    return v1 + v2
}

省略 return
因为函数体代码是一个单一表达式,所以我们可以省略 return

exec(a: 10, b: 20) {
    v1, v2 in v1 + v2
}

省略参数,$0 $1分别代表第一个,第二个参数

exec(a: 10, b: 20) {
    $0 + $1
}

直接 +
如果直接写一个运算符,编译器也知道是拿两个参数直接参与运算

exec(a: 10, b: 20, fn: +)

三:尾随闭包

如果一个函数的最后一个实参是一个闭包表达式,并且这个闭包表达式的函数体代码很长,为了增强函数的可读性,这个闭包表达式可以采用尾随闭包.

尾随闭包:尾随闭包是一个书写在函数调用括号外面的闭包表达式.

像上面的exec函数,它的最后一个参数是一个闭包表达式,那我们我们可以使用尾随闭包来增强可读性:(事实上,编译器自动敲出来的就是尾随闭包)

func exec(a: Int, b: Int, fn: (Int, Int) -> Int){
    print(fn(a,b))
}

// 尾随闭包
exec(a: 10, b: 20) { (v1, v2) -> Int in
    return v1 + v2
}

如果函数只有一个参数,而且这个参数是个闭包表达式,并且使用了尾随闭包的写法,那么在调用的时候可以省略小括号():

func add(fn: (Int, Int) -> Int){
    print(fn(20,10))
}

//正常写法
add(fn: {$0 - $1})

//尾随闭包写法
add(){$0 - $1}

//省略小括号()
add{$0 - $1}

示例:
Swift 中的Array有一个排序方法:

func sort(by areInIncreasingOrder: (Self.Element, Self.Element) throws -> Bool)

接收两个参数,返回一个布尔值.假设第一个参数是v1,第二个参数是v2,它的意思是:如果返回true,v1排在v2前面;如果返回false,v1排在v2后面.

常规写法是传入一个函数:

func arraySort(){
    //排序规则函数
    func comp(v1: Int, v2: Int) -> Bool{
        //从大到小排序
        v1 > v2
    }
    
    var array = [4,2,10,19,13,8,22]
    //传入 comp 函数
    array.sort(by: comp(v1:v2:))
    print(array)
}

也可以使用尾随闭包:

//闭包表达式示例  数组排序
func arraySort(){
    var array = [4,2,10,19,13,8,22]
    
    //闭包表达式常规写法
    array.sort(by: {
        (v1: Int, v2: Int) -> Bool in
        return v1 > v2
    })
    
    //因为是最后一个参数,可以采用尾随闭包写法
    array.sort(){
        v1,v2 in v1 > v2
    }
    
    //因为是最后一个参数,并且是唯一一个参数,可以省略小括号
    array.sort{
        v1,v2 in v1 > v2
    }
    
    //使用 $ 替代参数
    array.sort{
        $0 > $1
    }
    
    //直接使用 >
    array.sort(by: >)
    
    print(array)
}

四:闭包

闭包和闭包表达式完全是两个概念:

闭包表达式: 闭包表达式是定义函数的一种方式;
闭包: 闭包是一个函数和它所捕获的变量/常量环境组合起来,称作闭包.
一般指定义在函数内部的函数
一般它捕获的是外部函数的局部变量/常量

思考一下以下代码的打印结果是什么:

typealias Fn = (Int) -> Int
func getFn() -> Fn{
    
    var num = 0
    
    func sum(_ v1: Int) -> Int{
        num += v1
        return num
    }
    
    return sum
}

var fn = getFn()
print(fn(1))
print(fn(2))
print(fn(3))
print(fn(4))

结果如下: