• 創(chuàng)建函數(shù)

// 創(chuàng)建函數(shù)，無參，無返回值，同 func func1() -> Void
func func1() {
    print("no params func")
}
func1()
// 創(chuàng)建函數(shù)，帶參，帶返回類型
func func2(param: Int) -> Bool {
    return param > 60
}

func2(param: 80)

// 創(chuàng)建函數(shù)，帶多個參數(shù)，返回類型為元組
func func3(param1: String, param2: Int) -> (result1: String, result2: Int) {
    return (param1 + "11", param2 + 20)
}

let tuple = func3(param1: "param", param2: 60)
if tuple.result1.starts(with: "param") {
    print(tuple.result2)
}

// 創(chuàng)建函數(shù)，帶參，返回類型為 Optional
func func4(param: Int) -> Int? {
    guard param > 2 else {
        return nil
    }
    return param + 2
}

if let result = func4(param: 3) {
    print(result)
}

• 函數(shù)內(nèi)外參數(shù)命名

// 函數(shù)參數(shù)指定外部名稱
func outerNameFunc(name1 param1: Int, name2 param2: Int, param3: Int) {
    print(param1, param2, param3)
}
// 函數(shù)參數(shù)使用外部名稱
outerNameFunc(name1: 1, name2: 2, param3: 3)

func normalFunc(param1: Int, param2: Int, param3: Int) {
    print(param1, param2, param3)
}
// 默認函數(shù)參數(shù)的內(nèi)部名稱和外部名稱一致，調(diào)用函數(shù)時需要指定參數(shù)名稱
normalFunc(param1: 1, param2: 2, param3: 3)

// 調(diào)用函數(shù)時省略參數(shù)名稱
func annoFunc(_ param1: Int, _ param2: Int, _ param3: Int) {
    print(param1, param2, param3)
}
annoFunc(1, 2, 3)

• 函數(shù)參數(shù)指定默認值

func func5(param1: Int, param2: Int = 2, param3: Int = 3) {
    print(param1, param2, param3)
}
// 調(diào)用時，可以只傳入沒有默認值的參數(shù)
func5(param1: 1)
// 調(diào)用時，參數(shù)位置要嚴(yán)格對應(yīng)
func5(param1: 1, param2: 22)


// 函數(shù)參數(shù)指定默認值
func func6(param1: Int, param2: Int = 2, param3: Int) {
    print(param1, param2, param3)
}
// 調(diào)用時，參數(shù)位置要嚴(yán)格對應(yīng)
func6(param1: 1, param3: 33)

• 可變參數(shù)

// 函數(shù)傳入多個可變數(shù)量的參數(shù)，類似于 Kotlin 的 vararg
func mutableParamFunc(param: Int...) {
    var sum = 0
    for ele in param {
        sum += ele
    }
    print(sum)
}
mutableParamFunc(param: 1, 2)
mutableParamFunc(param: 1, 2, 3, 4)

// swift 的函數(shù)參數(shù)值（除引用類型外）默認是不可修改的
func immutableParam(param: Int) {
//    param += 1 // 編譯失敗 error: left side of mutating operator isn't mutable: 'param' is a 'let' constant
}

// 為了可以在函數(shù)參數(shù)內(nèi)部修改參數(shù)值，可以使用 inout 修飾參數(shù)
func immutableParam(param:inout Int) {
    param += 1 // 編譯通過
    print(param) // 2
}
// 調(diào)用時需要使用 & 符號
var number = 1
immutableParam(param: &number)
print(number) // 2, number的值也被修改了

• 函數(shù)類型引用，函數(shù)嵌套

// 函數(shù)可以作為類型進行聲明，就像使用其他類型一樣
let func7Name: (Int, Int) -> Bool
// 將閉包賦值給函數(shù)變量
func7Name = {(param1: Int, param2: Int) in
    return param1 > param2
}
// 調(diào)用函數(shù)變量
func7Name(1, 2) // false

// 函數(shù)作為參數(shù)傳入
func func8(funParam: (Int, Int) -> Bool) {
    print(funParam(2, 1)) // true
}
// 將 func7 傳入 func8
func8(funParam: func7Name)

// 函數(shù)作為返回值類型
func func9() -> (Int, Int) -> Bool {
    return func7Name // 將 func7Name 返回
}

// 函數(shù)嵌套
func outerFunc() {
    let outerScope = "outer scope"
    func innerFunc() {
        print(outerScope, "in inner func")
    }
    // 在外部函數(shù)內(nèi)調(diào)用內(nèi)部嵌套函數(shù)，在外部函數(shù)以外無法調(diào)用它
    innerFunc()
}
// 調(diào)用外部函數(shù)
outerFunc()

• defer的用法

很簡單，用一句話概括，就是 defer block 里的代碼會在函數(shù) return 之前執(zhí)行，無論函數(shù)是從哪個分支 return 的，還是有 throw，還是自然而然走到最后一行。

func testDefer() {
    defer {
        print("方法中defer內(nèi)容")
    }
    if true {
        defer {
            print("if 中defer內(nèi)容")
        }
        print("if中最后的代碼")
    }
    print("方法中的代碼")
    if true {
        return
    }
    print("方法結(jié)束前最后一句代碼")
}
testDefer()