一、函數(shù)定義與調(diào)用

• 語法

func 函數(shù)名() -> 返回值 {
    函數(shù)體
    return 返回值
}

二俊扭、函數(shù)參數(shù)與返回值

• 函數(shù)參數(shù)與返回值在Swift中非常的靈活, 你可以定義任何類型的函數(shù)，包括從只帶一個未名參數(shù)的簡單函數(shù)到復(fù)雜的帶有表達性參數(shù)名和不同參數(shù)選項的復(fù)雜函數(shù)。

1祝旷、無參無返回值函數(shù)

func say() {
    print("hello world!")
}

2面殖、無參有返回值函數(shù)

func say() -> String {
    return "hello world!"
}

3竖哩、有參無返回值

func sum(x: Int, y: Int) {
    print(x + y)
}

4、有參有返回值

func sum(x: Int, y: Int) -> Int {
    return x + y
}

注意
沒有定義返回類型的函數(shù)會返回一個特殊的 Void 值脊僚。它其實是一個空的元組相叁，沒有任何元素遵绰，可以寫成()。

• 被調(diào)用時增淹，一個函數(shù)的返回值可以被忽略：

func printAndCount(string: String) -> Int {
    print(string)
    return string.count
}
func printWithoutCounting(string: String) {
    let _ = printAndCount(string: string)
}
printAndCount(string: "hello, world")
// 打印 "hello, world" 并且返回值 12
printWithoutCounting(string: "hello, world")
// 打印 "hello, world" 但是沒有返回任何值

5椿访、多重返回值函數(shù)

• 可以用元組（tuple）類型讓多個值作為一個復(fù)合值從函數(shù)中返回。

func minMax(array: [Int]) -> (min: Int, max: Int) {
    var currentMin = array[0]
    var currentMax = array[0]
    for value in array[1..<array.count] {
        if value < currentMin {
            currentMin = value
        } else if value > currentMax {
            currentMax = value
        }
    }
    return (currentMin, currentMax)
}

• 因為元組的成員值已被命名虑润，因此可以通過 . 語法來檢索找到的最小值與最大值：

let bounds = minMax(array: [8, -6, 2, 109, 3, 71])
print("min is \(bounds.min) and max is \(bounds.max)")
// 打印 "min is -6 and max is 109"

6成玫、可選元組返回類型

注意
可選元組類型如 (Int, Int)? 與元組包含可選類型如 (Int?, Int?) 是不同的∪鳎可選的元組類型哭当，整個元組是可選的，而不只是元組中的每個元素值冗澈。

func minMax(array: [Int]) -> (min: Int, max: Int)? {
    if array.isEmpty { return nil }
    var currentMin = array[0]
    var currentMax = array[0]
    for value in array[1..<array.count] {
        if value < currentMin {
            currentMin = value
        } else if value > currentMax {
            currentMax = value
        }
    }
    return (currentMin, currentMax)
}

• 你可以使用可選綁定來檢查 minMax(array:) 函數(shù)返回的是一個存在的元組值還是 nil：

if let bounds = minMax(array: [8, -6, 2, 109, 3, 71]) {
    print("min is \(bounds.min) and max is \(bounds.max)")
}
// 打印 "min is -6 and max is 109"

三钦勘、函數(shù)參數(shù)標簽和參數(shù)名稱

每個函數(shù)參數(shù)都有一個參數(shù)標簽（argument label）以及一個參數(shù)名稱（parameter name）。
參數(shù)標簽在調(diào)用函數(shù)的時候使用亚亲；
調(diào)用的時候需要將函數(shù)的參數(shù)標簽寫在對應(yīng)的參數(shù)前面彻采。
參數(shù)名稱在函數(shù)的實現(xiàn)中使用。
默認情況下朵栖，函數(shù)參數(shù)使用參數(shù)名稱來作為它們的參數(shù)標簽颊亮。

1、指定參數(shù)標簽

• 語法

func someFunction(argumentLabel parameterName: Int) {
    // 在函數(shù)體內(nèi)陨溅，parameterName 代表參數(shù)值
}

• 下面是 greet(person:) 函數(shù)终惑，接收一個人的名字和他的家鄉(xiāng)，并且返回一句問候：

func greet(person: String, from hometown: String) -> String {
    return "Hello \(person)!  Glad you could visit from \(hometown)."
}
print(greet(person: "Bill", from: "Cupertino"))
// 打印 "Hello Bill!  Glad you could visit from Cupertino."

• 參數(shù)標簽的使用能夠讓一個函數(shù)在調(diào)用時更有表達力门扇，更類似自然語言雹有，并且仍保持了函數(shù)內(nèi)部的可讀性以及清晰的意圖蜕窿。

2旬痹、忽略參數(shù)標簽

• 如果你不希望為某個參數(shù)添加一個標簽嚼蚀，可以使用一個下劃線（_）來代替一個明確的參數(shù)標簽闷沥。

func someFunction(_ firstParameterName: Int, secondParameterName: Int) {
     // 在函數(shù)體內(nèi)，firstParameterName 和 secondParameterName 代表參數(shù)中的第一個和第二個參數(shù)值
}
someFunction(1, secondParameterName: 2)

• 如果一個參數(shù)有一個標簽暮芭，那么在調(diào)用的時候必須使用標簽來標記這個參數(shù)朴肺。

3黔牵、默認參數(shù)值

• 你可以在函數(shù)體中通過給參數(shù)賦值來為任意一個參數(shù)定義默認值留攒。當默認值被定義后煤惩，調(diào)用這個函數(shù)時可以忽略這個參數(shù)。

func someFunction(parameterWithoutDefault: Int, parameterWithDefault: Int = 12) {
    // 如果你在調(diào)用時候不傳第二個參數(shù)炼邀，parameterWithDefault 會值為 12 傳入到函數(shù)體中魄揉。
}
someFunction(parameterWithoutDefault: 3, parameterWithDefault: 6) // parameterWithDefault = 6
someFunction(parameterWithoutDefault: 4) // parameterWithDefault = 12

• 將不帶有默認值的參數(shù)放在函數(shù)參數(shù)列表的最前。
• 一般來說拭宁，沒有默認值的參數(shù)更加的重要洛退，將不帶默認值的參數(shù)放在最前保證在函數(shù)調(diào)用時瓣俯，非默認參數(shù)的順序是一致的，同時也使得相同的函數(shù)在不同情況下調(diào)用時顯得更為清晰兵怯。

4彩匕、可變參數(shù)

• 一個可變參數(shù)（variadic parameter）可以接受零個或多個值。
• 函數(shù)調(diào)用時摇零，你可以用可變參數(shù)來指定函數(shù)參數(shù)可以被傳入不確定數(shù)量的輸入值推掸。
• 通過在變量類型名后面加入（...）的方式來定義可變參數(shù)桶蝎。

func arithmeticMean(_ numbers: Double...) -> Double {
    var total: Double = 0
    for number in numbers {
        total += number
    }
    return total / Double(numbers.count)
}
arithmeticMean(1, 2, 3, 4, 5)
// 返回 3.0, 是這 5 個數(shù)的平均數(shù)驻仅。
arithmeticMean(3, 8.25, 18.75)
// 返回 10.0, 是這 3 個數(shù)的平均數(shù)。

注意
一個函數(shù)最多只能擁有一個可變參數(shù)登渣。

5噪服、輸入輸出參數(shù)

* 函數(shù)參數(shù)默認是常量。
* 試圖在函數(shù)體中更改參數(shù)值將會導(dǎo)致編譯錯誤胜茧。
* 這意味著你不能錯誤地更改參數(shù)值粘优。

* 如果你想要一個函數(shù)可以修改參數(shù)的值，
* 并且想要在這些修改在函數(shù)調(diào)用結(jié)束后仍然存在呻顽，
* 那么就應(yīng)該把這個參數(shù)定義為輸入輸出參數(shù)

* 定義一個輸入輸出參數(shù)時雹顺，在參數(shù)定義前加 `inout` 關(guān)鍵字。

* 你只能傳遞變量給輸入輸出參數(shù)廊遍。
* 你不能傳入常量或者字面量嬉愧，因為這些量是不能被修改的。

* 當傳入的參數(shù)作為輸入輸出參數(shù)時喉前，
* 需要在參數(shù)名前加 & 符没酣，
* 表示這個值可* 以被函數(shù)修改。

注意
輸入輸出參數(shù)不能有默認值卵迂，而且可變參數(shù)不能用 inout 標記裕便。

• 下例中，swapTwoInts(_:_:) 函數(shù)有兩個分別叫做 a 和 b 的輸入輸出參數(shù)

func swapTwoInts(_ a: inout Int, _ b: inout Int) {
    let temporaryA = a
    a = b
    b = temporaryA
}
var someInt = 3
var anotherInt = 107
swapTwoInts(&someInt, &anotherInt)
print("someInt is now \(someInt), and anotherInt is now \(anotherInt)")
// 打印 "someInt is now 107, and anotherInt is now 3"

注意
輸入輸出參數(shù)和返回值是不一樣的见咒。上面的 swapTwoInts 函數(shù)并沒有定義任何返回值偿衰，但仍然修改了 someInt 和 anotherInt 的值。輸入輸出參數(shù)是函數(shù)對函數(shù)體外產(chǎn)生影響的另一種方式改览。

四下翎、函數(shù)類型

• 每個函數(shù)都有種特定的函數(shù)類型，函數(shù)的類型由函數(shù)的參數(shù)類型和返回類型組成恃疯。
• 例如下面兩個函數(shù)的類型是 (Int, Int) -> Int

func addTwoInts(_ a: Int, _ b: Int) -> Int {
    return a + b
}
func multiplyTwoInts(_ a: Int, _ b: Int) -> Int {
    return a * b
}

• 下面是另一個例子漏设，一個沒有參數(shù)，也沒有返回值的函數(shù)：

func printHelloWorld() {
    print("hello, world")
}

這個函數(shù)的類型是：() -> Void今妄，或者叫“沒有參數(shù)郑口，并返回 Void 類型的函數(shù)”鸳碧。

1、使用函數(shù)類型

• 在 Swift 中犬性，使用函數(shù)類型就像使用其他類型一樣瞻离。例如，你可以定義一個類型為函數(shù)的常量或變量乒裆，并將適當?shù)暮瘮?shù)賦值給它：

var mathFunction: (Int, Int) -> Int = addTwoInts

• 現(xiàn)在套利，你可以用 mathFunction 來調(diào)用被賦值的函數(shù)了：

print("Result: \(mathFunction(2, 3))")
// Prints "Result: 5"

• 有相同匹配類型的不同函數(shù)可以被賦值給同一個變量，就像非函數(shù)類型的變量一樣：

mathFunction = multiplyTwoInts
print("Result: \(mathFunction(2, 3))")
// Prints "Result: 6"

• 就像其他類型一樣鹤耍，當賦值一個函數(shù)給常量或變量時肉迫，你可以讓 Swift 來推斷其函數(shù)類型：

let anotherMathFunction = addTwoInts
// anotherMathFunction 被推斷為 (Int, Int) -> Int 類型

2、函數(shù)類型作為參數(shù)類型

• 你可以用 (Int, Int) -> Int 這樣的函數(shù)類型作為另一個函數(shù)的參數(shù)類型

func printMathResult(_ mathFunction: (Int, Int) -> Int, _ a: Int, _ b: Int) {
    print("Result: \(mathFunction(a, b))")
}
printMathResult(addTwoInts, 3, 5)
// 打印 "Result: 8"

3稿黄、函數(shù)類型作為返回類型

• 你可以用函數(shù)類型作為另一個函數(shù)的返回類型喊衫。你需要做的是在返回箭頭（->）后寫一個完整的函數(shù)類型。

func stepForward(_ input: Int) -> Int {
    return input + 1
}
func stepBackward(_ input: Int) -> Int {
    return input - 1
}

func chooseStepFunction(backward: Bool) -> (Int) -> Int {
    return backward ? stepBackward : stepForward
}

• 你現(xiàn)在可以用chooseStepFunction(backward:)來獲得兩個函數(shù)其中的一個：

var currentValue = 3
let moveNearerToZero = chooseStepFunction(backward: currentValue > 0)
// moveNearerToZero 現(xiàn)在指向 stepBackward() 函數(shù)杆怕。

• 現(xiàn)在族购，moveNearerToZero 指向了正確的函數(shù)，它可以被用來數(shù)到零：

print("Counting to zero:")
// Counting to zero:
while currentValue != 0 {
    print("\(currentValue)... ")
    currentValue = moveNearerToZero(currentValue)
}
print("zero!")
// 3...
// 2...
// 1...
// zero!

五陵珍、嵌套函數(shù)

• 到目前為止本章中你所見到的所有函數(shù)都叫全局函數(shù)寝杖，它們定義在全局域中。你也可以把函數(shù)定義在別的函數(shù)體中互纯，稱作 嵌套函數(shù)瑟幕。

• 默認情況下，嵌套函數(shù)是對外界不可見的伟姐，但是可以被它們的外圍函數(shù)調(diào)用收苏。一個外圍函數(shù)也可以返回它的某一個嵌套函數(shù)，使得這個函數(shù)可以在其他域中被使用愤兵。

func chooseStepFunction(backward: Bool) -> (Int) -> Int {
    func stepForward(input: Int) -> Int { return input + 1 }
    func stepBackward(input: Int) -> Int { return input - 1 }
    return backward ? stepBackward : stepForward
}
var currentValue = -4
let moveNearerToZero = chooseStepFunction(backward: currentValue > 0)
// moveNearerToZero now refers to the nested stepForward() function
while currentValue != 0 {
    print("\(currentValue)... ")
    currentValue = moveNearerToZero(currentValue)
}
print("zero!")
// -4...
// -3...
// -2...
// -1...
// zero!