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,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,operation: addClosure)     // 25

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

execute(10,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,operation: {$0 + $1})

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

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