Swift 函式與閉包

1. 創建函式

// 創建函式，無參，無回傳值，同 func func1() -> Void
func func1() {
    print("no params func")
}

func1()

// 創建函式，帶參，帶回傳型別
func func2(param: Int) -> Bool {
    return param > 60
}

func2(param: 80)

// 創建函式，帶多個引數，回傳型別為元組
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)
}

// 創建函式，帶參，回傳型別為 Optional
func func4(param: Int) -> Int? {
    guard param > 2 else {
        return nil
    }
    return param + 2
}

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

2. 函式內外引數命名

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

func normalFunc(param1: Int, param2: Int, param3: Int) {
    print(param1, param2, param3)
}
// 默認函式引數的內部名稱和外部名稱一致，呼叫函式時需要指定引數名稱
normalFunc(param1: 1, param2: 2, param3: 3)

// 呼叫函式時省略引數名稱
func annoFunc(_ param1: Int, _ param2: Int, _ param3: Int) {
    print(param1, param2, param3)
}
annoFunc(1, 2, 3)

3. 函式引數指定默認值

func func5(param1: Int, param2: Int = 2, param3: Int = 3) {
    print(param1, param2, param3)
}
// 呼叫時，可以只傳入沒有默認值的引數
func5(param1: 1)
// 呼叫時，引數位置要嚴格對應
func5(param1: 1, param2: 22)


// 函式引數指定默認值
func func6(param1: Int, param2: Int = 2, param3: Int) {
    print(param1, param2, param3)
}
// 呼叫時，引數位置要嚴格對應
func6(param1: 1, param3: 33)

4. 可變引數

// 函式傳入多個可變數量的引數，類似于 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 的函式引數值（除參考型別外）默認是不可修改的
func immutableParam(param: Int) {
//    param += 1 // 編譯失敗 error: left side of mutating operator isn't mutable: 'param' is a 'let' constant
}

// 為了可以在函式引數內部修改引數值，可以使用 inout 修飾引數
func immutableParam(param:inout Int) {
    param += 1 // 編譯通過
    print(param) // 2
}
// 呼叫時需要使用 & 符號
var number = 1
immutableParam(param: &number)
print(number) // 2, number的值也被修改了

5. 函式型別參考，函式嵌套

// 函式可以作為型別進行宣告，就像使用其他型別一樣
let func7Name: (Int, Int) -> Bool
// 將閉包賦值給函式變數
func7Name = {(param1: Int, param2: Int) in
    return param1 > param2
}
// 呼叫函式變數
func7Name(1, 2) // false

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

// 函式作為回傳值型別
func func9() -> (Int, Int) -> Bool {
    return func7Name // 將 func7Name 回傳
}

// 函式嵌套
func outerFunc() {
    let outerScope = "outer scope"
    func innerFunc() {
        print(outerScope, "in inner func")
    }
    // 在外部函式內呼叫內部嵌套函式，在外部函式以外無法呼叫它
    innerFunc()
}
// 呼叫外部函式
outerFunc()

6. 閉包：后置閉包、逃逸閉包與自動閉包

// 定義閉包，類似于 Kotlin 的 lambda 運算式，
// 閉包一般是為了處理回呼，傳遞功能代碼塊
// 閉包標準語法結構：{(param list) -> valueType in block}
let closureFunc1 = {(param1: Int, param2: Int) -> Int in
    return param1 + param2
}

// 呼叫閉包
closureFunc1(1, 2) // 3

// 閉包可省略回傳值
let closureFunc2 = {(param1: Int, param2: Int) in
    return param1 + param2
}
closureFunc2(1, 3) // 4


// 如果閉包只有一行代碼，可以省略 return
let closureFunc3 = {(param1: Int, param2: Int) in
    return param1 < param2
}
closureFunc3(1, 2) // true


// 入參為閉包
func func10(closureParam: (Int, Int) -> Bool) {
   closureParam(2, 1)
}
// 使用默認引數名
func10(closureParam: { $0 > $1 }) // true

// 后置閉包，當最后一個引數為閉包時，簡化寫法：
func10() {
    $0 > $1
}

// 非逃逸閉包：函式的生命周期結束后，閉包也將被銷毀
// 定義的閉包默認都是非逃逸的


// 逃逸閉包：函式的執行結束后，閉包在函式外仍可使用
// 定義逃逸閉包使用 @escaping ，一般用于異步回呼
func func11(closureParam: @escaping (Int, Int) -> Bool) {
   
}

// 定義自動閉包使用 @autoclosure，對簡單閉包的自動生成，
// 自動閉包默認非逃逸，自動閉包不能夠有引數，單運算式
func autoCloseFunc(closureParam: @autoclosure () -> Int) {
    print(closureParam()) // 6
}
autoCloseFunc(closureParam: 1 + 2 + 3)

GitHub 原始碼：Function.playground