Swift函數與閉包

標籤：

1.Swfit文法中使用func關鍵字來申明函數

func sayHi(){    println("Hi !")}

結果顯示：Hi !

2.帶參數和傳回值函數，參數為String，傳回值為String的函數

func sayHiToPerson(personName:String) ->String{    return "Hi ! " + personName;}println(sayHiToPerson("Girl"))

結果顯示：Hi ! Girl

3.外部參數名，在使用的時候會有相應的提示，若外部參數名跟局部參數一樣的話只要加個#就可以了

func area(寬 a:Double , 高 b:Double) -> Double{    return a * b;}println(area(寬: 3.0, 高: 3.0))func area(#a:Double , #b:Double) -> Double{    return a * b;}println(area(a: 3.0, b: 3.0))

結果顯示：9.0
結果顯示：9.0

4.可變參數，可變參數就是表示如果參數比較多的情況下可以使用 "類型..." 來表示多個參數
a.個函數只能接納一個可變參數
b.一個可變參數必須位於函數的最後

func sum(x:Int...) -> Int{    var t:Int = 0    for v in x{        t+=v    }    return t}println(sum(1,2,3,4,5,6))

結果顯示：21

5.預設參數，就是當參數未填入時，該參數會傳入一個預設參數為ta的值

func sayWhat( who:String = "Lucy" , what:String){    println("\(who) say \(what)")}sayWhat(who: "Tom", "Hello")

結果顯示：Tom say Hello

6.變數形參，預設的參數都是為常量，這裡也可以定義一個變數形參

func fac(var x:Int) -> Int{    var s:Int = 1    while x > 1{        s*=x--    }    return s}println(fac(5))

結果顯示：120

7.In-Out形參，來交換兩個數

func swap(inout a:Int ,  inout b:Int){    a = a^b;    b = a^b;    a = a^b;}var a:Int = 1var b:Int = 3swap(&a,&b)//傳入的實際是a和b的地址println("交換之後結果為：a=\(a) b=\(b)")

結果顯示：交換之後結果為：a=3 b=1

8.元群組類型，沒有傳回值的函數總返回Void，在swift中，Void表示一個元組，無傳回值即是一個空元組

func areaWithCircum(#width:Int ,#height:Int) -> (Int , Int){    return (width*height , (width+height)<<1)}println(areaWithCircum(width: 4, height: 4))

結果顯示：(16, 16)

9.函數類型，冒號後面是個函數 (Double ,Double) -> Double
a.函數類型可以定義一個常量或者變數

var areaFunc:(Double ,Double) -> Double = areaprintln(areaFunc(3.0,3.0))

結果顯示：9.0

b.函數類型可以做為參數類型

func printlnArea(area:(Double,Double)->Double,width:Double,height:Double){    println("\(area(width , height))")}printlnArea(areaFunc,3,3)

結果顯示：9.0

c.函數類型做為傳回型別，因為getMathFunc返回的是一個函數........這個函數的參數又是Int，所以需要傳入一個參數......

當然也可以寫成getMathFunc(type:"squre")(10)

func squre(a:Int) -> Int{    return a*a}func cube(a:Int) -> Int{    return a*a*a}func getMathFunc(#type:String) -> (Int) -> Int{    if type == "squre"{        return  squre    }    else{        return cube    }}var mathFunc = getMathFunc(type:"squre")println(mathFunc(10))

結果顯示：100

10.函數嵌套，函數嵌套就是一個函數中包含另一個函數

func getArea(type:String) -> (Int) -> Int{    func squre(a:Int) -> Int{        return a * a    }    func cube(a:Int) -> Int{        return a * a * a    }    switch type{    case "squre":        return squre    default:        return cube    }}var getAreaInstance = getArea("squre")println(getAreaInstance(4))

結果顯示：16

在getArea中的squre函數離開getArea就會被銷毀，所以squre和cube的函數名沒有任何的意義！所以可以使用閉包來簡化嵌套函數的寫法～

//閉包運算式
//{
//    (形參列表) -> 傳回值類型 in
//        可執行運算式
//}

func getArea1(type:String) -> (Int) -> Int{    switch type{    case "squre":return {            (Int) -> Int in            return a * a    }    default:        return{            (Int) -> Int in            return a * a * a        }    }}

仔細觀察上面的代碼，其實就是 " { xxx  in  xxx  } " 的形式， 前面的xxx 就是" 參數列表 -> 傳回型別 " ，後面的xxx 就是運算式...

另外~swift閉包可以通過上下文分析出參數列表，參數列表可以使用$0$1....$n這種方式表示。於是新的寫法又出現了~

var result: Int  = {    var result = 1    for i in 1...$1{        result *= $0    }    return result}(3 , 4)println(result)

結果顯示：81

11.尾隨閉包，指函數的參數類型為閉包類型

func someFunction (num : Int ,  fn: (Int)-> (Int)){    //執行代碼    println(num * fn(10))}someFunction(20,{ $0 * $0 })

結果顯示：2000

捕獲上下文中的變數或者常量，總之閉包這個東西很靈活！慢慢分析都是能夠弄清楚的～

func makeArr (ele: String) -> ()->[String]{    var arr : [String] = []    func addElement() -> [String]{        arr.append(ele)        return arr    }    return addElement}println(makeArr("Lucy")())

結果顯示：[Lucy]

 

 

Swift函數與閉包