Swift中的closure类型与func的关系

Swift中的closure是一个类型，关于closure，可以把它与函数做类比

closure在Swift是一个无名函数，类似地，block也是一个匿名函数

注：本篇文章学习自泊学(boxueio.com)

func函数

1.  通过参数处理数据

1）带两个以上参数时

func mul( /*outName*/a:Int, /*outName*/b:Int)
{
    print("\(a) * \(b) = \(a*b)")
}

mul(a: 5, b: 10)

如果不想用outName，则用 “_” 代替

func mul( _ a:Int,  _ /*outName*/b:Int) -> (Int)
{
    print("\(a) * \(b) = \(a*b)") 
    return a*b
}

//mul(a: 5, b: 10)
mul(5, 10)                // 50

2）参数数量可变时

func arraySum(num:Double...)
{
    var sum: Double = 0.0
    for i in num
    {
        sum+=i
    }
    print("sum:\(sum)")
}

arraySum(num: 1,2,3,4,5,6)

类似于  num: [Double]      接收了一数组

func testSum(num:[Double])
{
    var sum: Double = 0.0
    for i in num
    {
        sum+=i
    }
    print("sum:\(sum)")
}

testSum(num: [1,2,3,4,5,6])

3）当需要对传入的参数做修改时

①  即需要对函数内的参数的修改，要在函数外生效：---> 使用 inout 关键字

func increment( value:inout Int)
{
    value += 1
}

var m = 10;
increment(value: &m)  // 注意：1️⃣
m                     // 11

注意：1️⃣  此处要传的是一变量值的引用 即传址，而不是它本身 不是传值

②  感觉看起来是不是有点像__block关键字？

typedef void (^myBlock)(void);

int main(int argc, const char * argv[]) {
    @autoreleasepool {
        
        // block
        __block int b = 20;
        
        myBlock block;
        block = ^(void){
            b++;
        };
        
        block();
        printf("b = %d\n",b);   // b = 21
    }
    return 0;
}

4）函数类型做参数

①  函数类型

//var f1: (Int, Int) -> (Int) = mul
// 或者
var f1 = mul
var f2 = table
var f3 = strToInt

然后可以直接用f1调用函数

f1(5, 4)                // 20

② 函数类型做参数

func myTest( fn: ((String) -> Int?), str: String)
{
    fn(str)             // 20
}
myTest(fn: f3, str: "20")

2.  通过返回值处理数据

1）返回一个值

func multiple(a:Int, andB:Int) ->Int
{
    return a * andB
}
var r = multiple(a: 5, andB: 10)

2）返回多个值，用tuple

func tableInfo() ->(row:Int, colun:Int)
{
    return (4,5)
}

var table = tableInfo()
table.row       // 4
table.colun     // 5

3）返回值可能为空时，用optional

func strToInt(str:String) ->Int?
{
    return Int(str)
}
var n = strToInt(str: "12")     // 12
type(of: n)                     // Optional<Int>.Type
n = strToInt(str: "sd ")        // nil

4）函数类型做返回值

func fun_1(n:Int)->Int
{
    return n+1
}
func test() -> (Int) -> Int
{
    return fun_1(n:)
}
test()

5）内嵌函数

直接把刚刚的fun_1剪切到test函数里面

上面的代码可改成

func test() -> (Int) -> Int
{
    func fun_1(n:Int)->Int
    {
        return n+1
    }
    
    return fun_1(n:)
}
test()

closure

closure与函数func的关系，类似于： let ten = 10

ten为有名常量，10是无名的

closure就类似为一个无名函数

1. closure的使用及简化

1）使用

var addClosure:(Int,Int)->Int = {(a:Int, b:Int) -> Int in
    return a+b
}

addClosure(5,10)

2）简化

1  ∵ 函数类型已经声明过， ∴ 可省略

addClosure = {a, b in return a + b}

2  如果closure的功能可以写成单一表达式，则上式可再简化成

addClosure = {a, b in a - b}

3  甚至可以用符号代替参数

addClosure = {$0 + $1}

2. closure做参数

1）closure做参数时，可以与函数做函数的参数时的情况做比较

2）函数类型做参数：

func execute(_ a:Int, _ b:Int, operation:(Int, Int) -> Int) ->Int
{
    return operation(a ,b)
}

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

execute(10, 15, operation: addFunc)       // 25

3）closure类型做参数时：

①  可以直接把之前定义的addClosure传给函数：

execute(10, 15, operation: addClosure)     // 25

②  也可以再参数的位置再写一个closure：

execute(10, 15, operation: { (a:Int, b:Int) -> Int in
    return a + b                           // 25
})

tips:  直接在函数参数的位置敲回车 即是一个closure  （是不是和block很像）

此时的closure同样可以简化：

execute(6, 8, operation: {a, b in a + b})
execute(6, 8, operation: {$0 + $1})

特别地：如果closure做参数的最后一个参数时，可以把closure放在参数列表()外：

execute(6, 8){$0 + $1}