初学swift笔记 函数（六）

  1 import Foundation
  2 /*
  3 func 函数名 (参数名:参数类型) {
  4 
  5 }
  6 func 函数名 (参数名:参数类型) ->Void{
  7 
  8 }
  9 func 函数名 (参数名:参数类型) ->返回类型{
 10 
 11 }
 12 */
 13 func show_Array(tempArray: [Int]){
 14     for a in tempArray {
 15         println("\(a)")
 16     }
 17     
 18 }
 19 func show_Arrays(tempArray:Array<Any>){
 20     for a in tempArray {
 21         println("\(a)")
 22     }
 23     
 24 }
 25 //show_Array([2,3,4,5,6,2,1,3,2])
 26 //show_Arrays([2,3,"abc"])
 27 func maxOfValue(start : Int ,end : Int)->Int {
 28     if start>end {
 29         return start
 30     }
 31     return end
 32 }
 33 var temp = maxOfValue(9,2)
 34 println(temp)
 35 
 36 func showHello(){
 37     println("Hello World")
 38 }
 39 showHello()
 40 
 41 //返回多个值 即返回一个元组类型
 42 func returnMoreValue(t1:(Double,Double),t2:(Double,Double)) ->(width:Double,height:Double) {
 43     return (abs(t1.0-t2.1),abs(t1.1-t2.0))
 44 }
 45 
 46 func returnMoreValue_1(t1:(Double,Double),t2:(Double,Double)) ->(Double,Double) {
 47     return (abs(t1.0-t2.1),abs(t1.1-t2.0))
 48 }
 49 //函数的内部参数和外部参数
 50 func returnMoreValue_2(t1 a: Double,t2 b: Double) ->Double {
 51     //使用时只能用内部参数
 52     return a/b
 53 }
 54 //函数的内部参数和外部参数 与 returnMoreValue_2相同
 55 func returnMoreValue_3(#t1: Double,#t2: Double) ->Double {
 56     //使用时只能用内部参数
 57     return t1/t2
 58 }
 59 
 60 let p0 : (Double,Double) = (0,0)
 61 let p1 : (Double,Double) = (4,4)
 62 let p_v=returnMoreValue(p0,p1)
 63 println(p_v.width)
 64 //调用 函数传递外部参数
 65 println(returnMoreValue_2(t1: 3.3, t2: 2.3))
 66 println(returnMoreValue_3(t1: 4, t2: 6.6))
 67 
 68 //默认参数
 69 func joinString(s1: String ,toString s2: String ,joiner s3: String = " && ")->String {
 70     
 71     return s1+s3+s2
 72 }
 73 func joinString1(s1: String ,toString s2: String ,joiner: String = " && ")->String {
 74     
 75     return s1+joiner+s2
 76 }
 77 
 78 let str=joinString("hello", toString: "world", joiner: "#")
 79 println(str)
 80 
 81 let stra=joinString("hello", toString: "world")
 82 println(stra)
 83 joinString1("lsq", toString: "Liu", joiner: "#")
 84 joinString1("lsq", toString: "Liu")
 85 
 86 //参数的常量和变量
 87 //传递给函数的参数默认是常量，不可以修改 如果想修改参数的值，需要在参数定义的时候指定参数变量形式 var
 88 func swap(a: Int ,var b: Int) {
 89     let t=b
 90     b=a
 91 }
 92 //输入输出 函数inout 类似于c#中的值类型与引用类型
 93 func swap1(inout a : Int ,inout b : Int){
 94     let t=a
 95     a=b
 96     b=t
 97 }
 98 
 99 var x=10
100 var y=11
101 swap1(&x, &y) //& 表示传递变量地址
102 println("\(x),\(y)")
103 
104 //变参函数
105 //不确定参数的个数
106 //通常写法
107 func add(array: [Int])->Int{
108     var sum=0
109     for i in array {
110         sum+=i
111     }
112     return sum
113 }
114 //标准写法 参数个数不确定多时候 变量名: 类型...
115 func add1(array: Int...)->Int{
116     var sum=0
117     for i in array {
118         sum+=i
119     }
120     return sum
121 }
122 var temp_t = add([2,1,3,4,12,3])
123 println(temp_t)
124 
125 var temp1=add1(2,3,3,4,1,23,1,44)
126 println(temp1)
127 
128 //函数的类型
129 //给函数总结一下类型 (Int,Int)->Int
130 func m_add(a: Int ,b: Int)->Int{
131     return a+b
132 }
133 func m_sum(a: Int,b: Int)->Int{
134     return a-b
135 }
136 //定义函数类型的变量
137 var calFunc:(Int,Int)->Int = m_add;
138 //定义了参数 那么调用函数
139 println(calFunc(3,2))
140 calFunc = m_sum
141 println(calFunc(4,6))
142 
143 //闭包 可以理解为匿名函数 有参数有返回值 没有函数名称
144 //嵌套函数
145 /*
146 闭包表达式语法
147 {
148     (参数) -> 返回值类型 in
149         执行语句
150 }
151 
152 in 用来分割类型及执行语句
153 
154 */
155 //定义一个闭包表达式常量
156 let sayHello = {
157         println("无参数无返回值的匿名函数，即闭包表达式")
158 }
159 //调用
160 sayHello()
161 
162 //定义一个闭包表达式的常量 ，add_b类型是(Int,Int)->Int
163 let add_b = {(a: Int,b: Int)-> Int in
164     return a+b
165 }
166 //调用
167 println(add_b(4,6))
168 
169 //闭包表达式 回调用法 常用用法 将闭包作为一个函数的回调
170 
171 
172 func showArray(array : [Int]) {
173     for a in array {
174         //print("\(a) ")
175     }
176     println(array)
177 }
178 
179 //普通的 冒泡排序
180 func bubbleSort(inout array: [Int]){
181     let cnt=array.count
182     for var i = 1; i < cnt; i++ {
183         for var j = 0; j < cnt-i; j++ {
184             if (array[j] > array[j+1]) {
185                 var t = array[j]
186                 array[j] = array[j+1]
187                 array[j+1] = t
188             }
189         }
190     }
191 }
192 var array: Array<Int>=[9,8,7,6,5,10,4,2,1]
193 show_Array(array)
194 bubbleSort(&array)
195 println(array)
196 
197 //用闭包改造
198 func bubbleSort1(inout array: [Int],cmp:(Int,Int) -> Int){
199     let cnt=array.count
200     for var i = 1; i < cnt; i++ {
201         for var j = 0; j < cnt-i; j++ {
202             if (cmp(array[j],array[j+1]) == -1) {
203                 var t = array[j]
204                 array[j] = array[j+1]
205                 array[j+1] = t
206             }
207         }
208     }
209 }
210 var array_b1=[9,8,7,6,5,10,4,2,1]
211 //定义一个比较 闭包
212 let intCmp = {
213     (a: Int,b: Int) -> Int in
214     if a>b{
215         return -1
216     }else if a<b {
217         return 1
218     }else {
219         return 0
220     }
221 }
222 //可以这么调用
223 bubbleSort1(&array_b1,intCmp)
224 //也可以这么调用 这种方式较多人用
225 bubbleSort1(&array_b1,{
226     (a: Int,b: Int) -> Int in
227     if a>b{
228         return -1
229     }else if a<b {
230         return 1
231     }else {
232         return 0
233     }
234 })
235 println(array_b1)
236 
237 /*
238 闭包表达式的优化
239 1.类型 返回值 让编译器去推断
240 */
241 bubbleSort1(&array_b1,{
242     (a,b) in
243     if a>b{
244         return -1
245     }else if a<b {
246         return 1
247     }else {
248         return 0
249     }
250 })
251 println(array_b1)
252 /*
253 2.变量名称优化缩写
254 第一个参数 $0 后面的参数以此类推 $1 $2 $3 ...
255 */
256 bubbleSort1(&array_b1,{
257     let a = $0 , b = $1
258     if a>b{
259         return -1
260     }else if a<b {
261         return 1
262     }else {
263         return 0
264     }
265 })
266 println(array_b1)
267 //3.简单的闭包表达式代码可以更简洁
268 
269 /*
270 {
271   (a: Int,b: Int) -> Bool in
272     return a > b
273 }
274 优化：
275 {
276     return $0 > $1
277 }
278 
279 优化:
280 {
281     $0 > $1
282 }
283 
284 */
285 
286 //尾随闭包
287 //当闭包表达式是函数的最后一个参数时可以用尾随闭包的书写方式，即将闭包表达式写在函数后面，如
288 bubbleSort1(&array_b1){
289     let a = $0 , b = $1
290     if a>b{
291         return -1
292     }else if a<b {
293         return 1
294     }else {
295         return 0
296     }
297 }
298 println(array_b1)
299 //优化尾随闭包
300 bubbleSort1(&array_b1){
301     if $0>$1{
302         return -1
303     }else if $0<$1 {
304         return 1
305     }
306     return 0
307 }
308 println(array_b1)
309 
310 
311 //嵌套函数  值捕获
312 
313 //定义一个函数，范围值是一个闭包类型  函数中定义一个函数，函数中返回一个函数
314 func get_value(inc: Int) -> (Int)->Int {
315     func incFunc(v: Int) -> Int{
316         return inc+v
317     }
318     return incFunc
319 }
320 
321 func get_value1(inc: Int) -> (Int)->Int {
322     var mt = 0
323     func incFunc(v: Int) -> Int{
324         mt++
325         return inc+v+mt
326     }
327     return incFunc
328 }
329 let incFunc1=get_value(7)//声明一个变量，调用get_value函数，得到闭包 即该变量是一个闭包
330 println(incFunc1(10))//调用闭包
331 
332 let incFunc2=get_value1(7)
333 println(incFunc2(10))
334 println(incFunc2(10))