Swift學習筆記第四篇（函數）

函數

在 Swift 中，每個函數都有一種類型，包括函數的參數實值型別和傳回值類型。你可以把函數類型當做任何其他普通變數類型一樣處理，這樣就可以更簡單地把函數當做別的函數的參數，也可以從其他函數中返回函數。函數的定義可以寫在在其他函數定義中，這樣可以在嵌套函數範圍內實現功能封裝。 單參數

/// 單參數////// - Parameter personName: 參數1/// - Returns: 傳回型別func sayHello(personName:String) -> String{    let greeting = "Hellow," + personName + "!"    return greeting}print(sayHello(personName: "MKJ"))

多參數

/// 多參數////// - Parameters:///   - num1: 參數1///   - num2: 參數2/// - Returns: 傳回型別func delataTwoNumber(num1:Int, num2:Int) -> Int{    return num1 - num2}print(delataTwoNumber(num1: 10, num2: 1))let funcD = delataTwoNumberfuncD(11,111)

無參數

/// 無參數////// - Returns: 傳回型別func sayHelloWorld() -> String {    return "hello, world"}print(sayHelloWorld())func printSingleSlogan(slogan:String){    print("woca,"+slogan + "!")}printSingleSlogan(slogan: "CJJ")

預設參數

/// 預設參數名////// - Parameters:///   - string1: 參數1///   - string2: 參數2///   - joiner: 參數3/// - Returns: 傳回值func join(string1:String,string2:String,joiner:String = "+") -> String{    return string1 + joiner + string2}print(join(string1: "我", string2: "你")) // "我+你\n"print(join(string1: "他", string2: "她", joiner: "0")) // "他0她\n"

可變參數

一個可變參數（variadic parameter）可以接受一個或多個值。函數調用時，你可以用可變參數來傳入不確定數量的輸入參數。通過在變數類型名後面加入（…）的方式來定義可變參數。
傳入可變參數的值在函數體內當做這個類型的一個數組

/// 可變參數////// - Parameter numers: 參數數組/// - Returns: 傳回值func total(numers:Double...) -> Double{    var totalD  = 0.0    for numer in numers {        totalD += numer    }    return totalD / Double(numers.count)}print("total is " + "\(total(numers: 2,10,21))")

輸入輸出參數（inout）

變數參數，正如上面所述，僅僅能在函數體內被更改。如果你想要一個函數可以修改參數的值，並且想要在這些修改在函數調用結束後仍然存在，那麼就應該把這個參數定義為輸入輸出參數（In-Out Parameters）。

定義一個輸入輸出參數時，在參數定義前加 inout 關鍵字。一個輸入輸出參數有傳入函數的值，這個值被函數修改，然後被傳出函數，替換原來的值。

你只能將變數作為輸入輸出參數。你不能傳入常量或者字面量（literal value），因為這些量是不能被修改的。當傳入的參數作為輸入輸出參數時，需要在參數前加&符，表示這個值可以被函數修改。

注意： 輸入輸出參數不能有預設值，而且可變參數不能用 inout 標記。如果你用 inout 標記一個參數，這個參數不能被 var 或者 let 標記。

/// 輸入輸出參數////// - Parameters:///   - a: 外部變數地址a///   - b: 外部變數地址bfunc swapTwoInts( a: inout Int, b: inout Int) {    let temporaryA = a    a = b    b = temporaryA}var someInt = 3var anotherInt = 107//swapTwoInts(a: &someInt, b: &anotherInt)swapTwoInts(a: &someInt, b: &anotherInt)print("\(someInt)" + "\(anotherInt)")

函數類型使用

（參數1，參數2，參數3） -> (傳回值1，傳回值2)
可以理解為傳入三個需要類型的參數，返回一個有兩個指定類型的元祖

/// 使用函數類型////// - Parameters:///   - a: 參數1///   - b: 參數2/// - Returns: 傳回值func add(a:Int,b:Int)->Int{    return a+b}func mutiby(a:Int,b:Int)->Int{    return a*b}// 指定函數類型var mathFunction :(Int,Int) -> Int = addprint("Result:\(mathFunction(2,3))")mathFunction = mutibyprint("Result:\(mathFunction(3,5))")// 自動推斷函數類型let mathFunc = addprint("Result:\(mathFunc(2,5))")

我們申明變數指向函數的時候可以手動指定函數的類型，如果你不指定，swift會自動進行類型推斷 函數類型作為參數

/// 函數作為參數////// - Parameters:///   - a: <#a description#>///   - b: <#b description#>/// - Returns: <#return value description#>func mathAdd(a:Int,b:Int) -> Int{    return a+b}func printMathResult(mathFunc:(Int,Int)->Int,a:Int  ,b:Int){    print("Result-->\(mathFunc(a,b))")}printMathResult(mathFunc: mathAdd, a: 3, b: 14)

printMathResult 函數的作用就是輸出另一個合適類型的數學函數的調用結果。它不關心傳入函數是如何?的，它只關心這個傳入的函數類型是正確的。這使得 printMathResult 可以以一種型別安全（type-safe）的方式來保證傳入函數的調用是正確的。 函數作為類型返回

你可以用函數類型作為另一個函數的傳回型別。你需要做的是在返回箭頭（->）後寫一個完整的函數類型。

/// 函數作為傳回值////// - Parameter number: <#number description#>/// - Returns: <#return value description#>func goForward(number:Int)->Int{    return number + 1}func goBackward(number:Int)-> Int{    return number - 1}func chooseStepFunction(chooseFlag:Bool) -> (Int)->Int{    return chooseFlag ? goBackward : goForward}var countingNumber = 3let moveFunc = chooseStepFunction(chooseFlag:  countingNumber > 0)while countingNumber != 0 {    print(String(countingNumber))    countingNumber = moveFunc(countingNumber)}print("0!")/// 3 2 1 0!

嵌套函數

你所見到的所有函數都叫全域函數（global functions），它們定義在全域域中。你也可以把函數定義在別的函數體中，稱作嵌套函數（nested functions）。

/// 嵌套函數////// - Parameter chooseFlag: <#chooseFlag description#>/// - Returns: <#return value description#>func nestChooseStepFunction(chooseFlag:Bool) -> (Int)->Int{    func stepF(num:Int)->Int{return num + 1}    func stepB(num:Int)->Int{return num - 1}    return chooseFlag ? stepF : stepB}var countingNum = -5let resultFunc = nestChooseStepFunction(chooseFlag: countingNum < 0)while countingNum < 0 {    print("\(countingNum)" + "!")    countingNum = resultFunc(countingNum)}print("0!")/* -5! -4! -3! -2! -1! 0! */