Swift3.0－闭包、运算符重载

http://blog.csdn.net/minggeqingchun/article/details/54615722

闭包（Closure）

  自包含的函数代码块，可以在代码中被传递和调用

  闭包可以捕获和存储其所在上下文中任意常量和变量的引用

  闭包表达式：

    {  

        (parameters) -> returnType in

            statements

    }

  闭包可以使用常量、变量、inout类型作为参数，不提供默认值；元祖也可以作为参数和返回值

  全局和嵌套函数实际上也是特殊的闭包

 （1）全局函数是一个  有名字但不会捕获任何值 的闭包

 （2）嵌套函数是一个  有名字可以捕获其封闭函数域内值的闭包

 （3）闭包表达式是一个  捕获上下文变量和常量的匿名闭包

//！！！闭包的函数体部分由关键字in引入，该关键字表示闭包的参数和返回值类型定义已经完成，闭包函数体即将开始

[objc]  view plain  copy

1. /* 
2.  * 闭包（Closure） 
3.   自包含的函数代码块，可以在代码中被传递和调用 
4.   闭包可以捕获和存储其所在上下文中任意常量和变量的引用 
5.   闭包表达式： 
6.     {   
7.         (parameters) -> returnType in 
8.             statements 
9.     } 
10.   闭包可以使用常量、变量、inout类型作为参数，不提供默认值；元祖也可以作为参数和返回值 
11.   全局和嵌套函数实际上也是特殊的闭包 
12.  （1）全局函数是一个  有名字但不会捕获任何值 的闭包 
13.  （2）嵌套函数是一个  有名字可以捕获其封闭函数域内值的闭包 
14.  （3）闭包表达式是一个  捕获上下文变量和常量的匿名闭包 
15.  */  
16. //！！！闭包的函数体部分由关键字in引入，该关键字表示闭包的参数和返回值类型定义已经完成，闭包函数体即将开始  
17. //sorted函数  
18. let names:Array<String> = ["China","Alex","Ewa","Draw","Bob"]  
19. let i = names.sorted {  
20.     (s1, s2) -> Bool in  
21.     return s1 > s2  
22. }  
23. print(i)  
24.   
25. //尾部闭包  
26. func someFunction(closure:() -> ()){  
27.     //函数体部分  
28. }  
29. //以下是不使用尾随闭包进行函数调用  
30. someFunction (closure: {  
31.     //闭包主体部分  
32. })  
33. //使用尾随闭包进行函数调用  
34. someFunction() {  
35.     //闭包主体部分  
36. }  
37.   
38. let digitNames = [  
39.     0:"Zero",1:"One",2:"Two",3:"Three",4:"Four",  
40.     5:"Five",6:"Six",7:"Seven",8:"Eight",9:"Nine"  
41. ]  
42. let numbers = [16,58,510]  
43. func printOut() -> Void {  
44.     let strings = numbers.map {  
45.         (number) -> String in  
46.         var number = number  
47.         var output = ""  
48.         while number > 0{  
49.             output = digitNames[number % 10]! + output  
50.             number /= 10  
51.         }  
52.         return output  
53.     }  
54.     print(strings)  
55. }  
56. printOut()  
57.   
58.   
59. /* 
60.  * 运算符重载 
61.   让已有的运算符可以对自定义的类和结构进行运算 
62.  */  
63. struct Point {  
64.     var x = 0.0,y = 0.0  
65. }  
66. func + (left:Point,right:Point) -> Point{  
67.     return Point(x:left.x+right.x,y:left.y+right.y)  
68. }  
69. let p1 = Point(x:3.0,y:1.0)  
70. let p2 = Point(x:2.0,y:4.0)  
71. let p3 = p1 + p2  
72. print("p1=\(p1),p2=\(p2),p3=\(p3)")  
73.   
74. //前置、后置运算符(prefix、postfix)  
75. prefix func - (vector:Point) -> Point{  
76.     return Point(x:-vector.x,y:-vector.y)  
77. }  
78. let post = Point(x:3.0,y:4.0)  
79. let nag = -post  
80. let alp = -nag  
81. print("post=\(post),nag=\(nag),alp=\(alp)")  
82.   
83. //组合赋值运算符  
84. func += (left:inout Point,right:Point){  
85.     left = left + right  
86. }  
87. var p5 = Point(x:1.0,y:2.0)  
88. let p6 = Point(x:3.0,y:4.0)  
89. p5 += p6  
90. print("p5=\(p5)")  
91.   
92. //自定义运算符  
93. prefix operator +++  
94. prefix func +++ (vector:inout Point) -> Point{  
95.     vector += vector  
96.     return vector  
97. }  
98. var beDou = Point(x:1.0,y:4.0)  
99. let afterDou = +++beDou  
100. print("beDou=\(beDou),afterDou=\(afterDou)")  
101.   
102. /* 
103.  * 泛型函数:作用于任何类型 
104.   泛型使用了占位类型名字（通常用字母T来表示）来代替实际类型名字（如：Int、String等），占位类型名没有提示T必须是什么类型，但是它提示两个参数必须是同一类型T，不管T是什么类型，每次调用所传入实际类型才能决定T所代表类型 
105.  */  
106. print("\n泛型函数")  
107. func swapTwoValues<T>(a:inout T,b:inout T){//要求两参数类型值一致  
108.     let c = a  
109.     a = b  
110.     b = c  
111. }  
112. var beA = "测试"  
113. var beB = "test"  
114. swapTwoValues(a: &beA,b:&beB)  
115. print("a=\(beA),b=\(beB)")  
116.   
117. //栈操作  
118. print("\n栈操作")  
119. struct Stack<T>{  
120.     var items = [T]()  
121.     mutating func push(item:T){  
122.         items.append(item)  
123.     }  
124.     mutating func pop() -> T{  
125.         return items.removeLast()  
126.     }  
127. }  
128. var stackString = Stack<String>()  
129. stackString.push(item: "ni")  
130. stackString.push(item: "wo")  
131. stackString.push(item: "ta")  
132. print(stackString.items)  
133.   
134. extension Stack{  
135.     var topItem:T? {  
136.         return items.isEmpty ? nil : items[items.count - 1]  
137.     }  
138. }  
139. if let topItem = stackString.topItem{  
140.     print("The top item on the stack is \(topItem)")  
141. }