swift闭包-备

我给Swift 中的闭包一个定义：闭包是自包含的匿名函数代码块，可以作为表达式、函数参数和函数返回值，闭包表达式的运算结果是一种函数类型。

Swift中的闭包类似于Objective-C中的代码块、Java中的匿名内部类。

 

使用闭包表达式

Swift中的闭包表达式很灵活，其标准语法格式如下：

{ (参数列表) ->返回值类型 in

    语句组

}

其中，参数列表与函数中的参数列表形式一样，返回值类型类似于函数中的返回值类型，但不同的是后面有in关键字。

Swift提供了多种闭包简化写法，我来介绍下面几种不同形式：

 

1、类型推断简化

类型推断是Swift的强项，Swift可以根据上下文环境推断出参数类型和返回值类型。以下代码是标准形式的闭包：

{(a:Int, b:Int) -> Intin

    return a + b

}

Swift能推断出参数a和b是Int类型，返回值也是Int类型。简化形式如下：

{(a, b) in return a + b }

{a, b in return a + b }  //参数列表括号也可以省略

 

2、隐藏return关键字

在闭包内部语句组只有一条语句，如return a + b等，那么这种语句都是返回语句。前面的关键字return可以省略，省略形式如下：

{a, b in a + b }

使用这种简化方式修改后的示例代码如下：

 

[html]  view plain  copy

 print?

1. func calculate(opr :String)-> (Int,Int)-> Int {  
2.   
3.   
4.   
5.   
6.     var result : (Int,Int)-> Int  
7.   
8.       
9.   
10.     switch (opr) {  
11.   
12.     case "+" :  
13.   
14.         result = {a, b in a + b }　//return关键字省略了  
15.   
16.     default:  
17.   
18.         result = {a, b in a - b }　//return关键字省略了  
19.   
20.     }  
21.   
22.     return result  
23.   
24. }  

 

 

 

 

省略的前提是闭包中只有一条return语句。

 

3、省略参数名称

Swift提供了参数名省略功能，我们可以用$0、$1、$2…来指定闭包中参数，$0指代第一个参数，$1指代第二个参数，$2指代第三个参数，以此类推$n+1指代第n个参数。

使用参数名省略功能，在闭包中必须省略参数列表定义，Swift能够推断出这些缩写参数的类型。参数列表省略了，in关键字也需要省略。参数名省略之后如下所示：

{$0 + $1}

使用参数名省略后的示例代码如下：

 

[html]  view plain  copy

 print?

1. func calculate(opr :String)-> (Int,Int)-> Int {  
2.   
3.    
4.   
5.     var result : (Int,Int)-> Int  
6.   
7.       
8.   
9.     switch (opr) {  
10.   
11.     case "+" :  
12.   
13.         result = {$0 + $1} //采用了参数名省略  
14.   
15.     default:  
16.   
17.         result = {$0 - $1} //采用了参数名省略  
18.   
19.     }  
20.   
21.     return result  
22.   
23. }  
24.   
25.    
26.   
27. let f1:(Int,Int)-> Int = calculate("+")  
28.   
29. print("10 + 5 = \(f1(10,5))")  
30.   
31.    
32.   
33. let f2:(Int,Int)-> Int = calculate("-")  
34.   
35. print("10 - 5 = \(f2(10,5))")  

 

 

 

 

 

4、使用闭包返回值

闭包表达本质上是函数类型，是有返回值的，我们可以直接在表达式中使用闭包的返回值。重新修改add和sub闭包，示例代码如下：

 

[html]  view plain  copy

 print?

1. let c1:Int = {(a:Int, b:Int) -> Int in  
2.   
3.                  return a + b  
4.   
5.                }(10,5)     
6.   
7.    
8.   
9. print("10 + 5 = \(c1)")  
10.   
11.    

 

 

 

 

解释：给c1赋值，后面是一个闭包表达式。但是闭包表达式不能直接赋值给c1，因为c1是Int类型，需要闭包的返回值。这就需要在闭包结尾的大括号后面接一对小括号(10,5)，通过小括号(10,5)为闭包传递参数。

 

闭包表达式可以作为函数的参数传递，如果闭包表达式很长，就会影响程序的可读性。尾随闭包是一个书写在函数括号之后的闭包表达式，函数支持将其作为最后一个参数调用。

下面我们来看一个示例代码：

 

[html]  view plain  copy

 print?

1. func calculate(opr: String, funN:(Int, Int) -> Int) {　  
2.   
3.   
4.   
5.   
6. //最后一个参数funN是(Int,Int)-> Int函数类型，funN可以接收闭包表达式  
7.   
8.   
9.   
10.   
11.     switch (opr) {  
12.   
13.   
14.   
15.   
16.     case "+" :  
17.   
18.   
19.   
20.   
21.         print("10 + 5 = \(funN(10,5))")  
22.   
23.   
24.   
25.   
26.     default:  
27.   
28.   
29.   
30.   
31.         print("10 - 5 = \(funN(10,5))")  
32.   
33.   
34.   
35.   
36.     }  
37.   
38.   
39.   
40.   
41. }   
42.   
43.   
44.   
45.   
46. calculate("+", funN: {(a: Int, b: Int) -> Int in return a + b })  //调用  
47.   
48.   
49.   
50.   
51. calculate("+"){(a: Int, b: Int) -> Int in return a + b } //调用，这种形式就是尾随闭包  
52.   
53.   
54.   
55.   
56. calculate("+") { $0 + $1 }  //调用，这种形式就是尾随闭包  

 

 

 

 

       需要注意的是，闭包必须是参数列表的最后一个参数，如果calculate函数采用如下形式定义：

 

func calculate(funN:(Int, Int) ->Int, opr:String) {

 

...

 

}

 

由于闭包表达式不是最后一个参数，那么调用calculate函数就不能使用尾随闭包写法的。