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 = mulvar f2 = tablevar 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       // 4table.colun     // 5

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

func strToInt(str:String) ->Int?{    return Int(str)}var n = strToInt(str: "12")     // 12type(of: n)                     // Optional<Int>.Typen = 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}