Swift學習（9）- 閉包（程式碼完善版）

let names = ["Chris", "Alex", "Ewa", "Barry", "Jensen"]

func backward(_ s1: String, _ s2: String) -> Bool {
        return s1 > s2
}
var reversedNames = names.sorted(by: backward)  // reversedNames為["Jensen", "Ewa", "Chris", "Barry", "Alex"]
print("複雜閉包逆序：\(reversedNames).")
---
output: 複雜閉包逆序：["Jensen", "Ewa", "Chris", "Barry", "Alex"].

/*
 { (parameters) -> return type in
         statements
 }
 */

reversedNames = names.sorted(by: { (s1: String, s2: String) -> Bool in
        return s1 > s2
})
print("內嵌閉包運算式逆序：\(reversedNames).")
---
output: 內嵌閉包運算式逆序：["Jensen", "Ewa", "Chris", "Barry", "Alex"].

reversedNames = names.sorted(by: {(s1: String, s2: String) -> Bool in return s1 > s2})
print("簡潔內嵌閉包運算式逆序：\(reversedNames).")
---
output: 簡潔內嵌閉包運算式逆序：["Jensen", "Ewa", "Chris", "Barry", "Alex"].

reversedNames = names.sorted(by: {s1, s2 in return s1 > s2})
print("隱式推斷型別閉包運算式逆序：\(reversedNames).")
---
output: 隱式推斷型別閉包運算式逆序：["Jensen", "Ewa", "Chris", "Barry", "Alex"].

reversedNames = names.sorted(by: {s1, s2 in s1 > s2})
print("極致省略閉包逆序： \(reversedNames).")
---
output: 極致省略閉包逆序： ["Jensen", "Ewa", "Chris", "Barry", "Alex"].

reversedNames = names.sorted(by: { $0 > $1 })
print("省略參數名稱閉包逆序：\(reversedNames).")
---
output: 省略參數名稱閉包逆序：["Jensen", "Ewa", "Chris", "Barry", "Alex"].

reversedNames = names.sorted(by: >)

/*
 func someFunctionThatTakesAClosure(closure: () -> Void) {
         // 函式主體
 }
 // 不使用尾隨閉包
 someFunctionThatTakesAClosure(closure: {
         // 閉包主體
 })
 // 使用尾隨閉包
 someFunctionThatTakesAClosure {
         // 閉包主體
 }
 */

reversedNames = names.sorted() { $0 > $1 }
print("尾隨閉包：\(reversedNames).")
---
output: 尾隨閉包：["Jensen", "Ewa", "Chris", "Barry", "Alex"].

reversedNames = names.sorted { $0 > $1 }
print("尾隨閉包省略（）： \(reversedNames).")
---
output: 尾隨閉包省略（）： ["Jensen", "Ewa", "Chris", "Barry", "Alex"].

let digitNames = [
        0: "Zero", 1: "One", 2: "Two", 3: "Three", 4: "Four",
        5: "Five", 6: "Six", 7: "Seven", 8: "Eight", 9: "Nine"
]
let numbers = [16, 58, 510]

let strings = numbers.map {
        (number) -> String in
        var number = number
        var output = ""
        repeat {
                output = digitNames[number % 10]! + output
                number /= 10
        } while number > 0
        return output
}
// `strings`常數會被推斷為[String]
// 其值為["OneSix", "FiveEight", "FiveOneZero"]

func makeIncrementer(forIncrement amount: Int) -> () -> Int {
        var runningTotal = 0
        func incrementer() -> Int {
                runningTotal += amount
                return runningTotal
        }
        return incrementer
}

var testIncrementer = makeIncrementer(forIncrement: 10)
testIncrementer()  // 此時testIncrementer()的值為10
print(testIncrementer())  // 輸出20，10 + 10
---
output: 20

/*
func incrementer() -> Int {
        runningTotal += amount
        return runningTotal
}
 */

let incrementByTen = makeIncrementer(forIncrement: 10)

incrementByTen()  // 回傳10
incrementByTen()  // 回傳20
var result = incrementByTen()  // 回傳30
print("三次呼叫IncrementByTen()回傳結果為：\(result)。")
---
output: 三次呼叫IncrementByTen()回傳結果為：30。

let incrementBySeven = makeIncrementer(forIncrement: 7)
result = incrementBySeven()  // 回傳7
print("Result：\(result).")
---
output: Result：7.

incrementByTen()  // 回傳40

let alsoIncrementByTen = incrementByTen
print("alsoIncrementByTen的值是：\(alsoIncrementByTen()).")
---
output: alsoIncrementByTen的值是：50.

var completionHandlers: [() -> Void] = []
func someFunctionWithEscapingClosure(completionHandler: @escaping () -> Void) {
        completionHandlers.append(completionHandler)
}

func someFunctionWithNoneEscapingClosure(closure: () -> Void) {
        closure()
}
class someClass {
        var x = 10
        func doSometing() {
                someFunctionWithEscapingClosure {
                        self.x = 100
                }
                someFunctionWithNoneEscapingClosure {
                        x = 200
                }
        }
}
let instance = someClass()
instance.doSometing()
print(instance.x)  // 輸出“200”
completionHandlers.first?()  // someFunctionWithEscapingClosure的閉包已逃逸到外部，函式回傳後可呼叫  // xxx.first?() 可選鏈式呼叫
print(instance.x)  // 輸出“100”
---
output: 200
100

var customersInLine = ["Chris", "Jensen", "Ewa", "Alex", "Barry"]
print(customersInLine.count)  // 輸出“5”
let customerProvider = { customersInLine.remove(at: 0) }
print(customersInLine.count)  // 輸出“5”
print("NOW SERVING \(customerProvider())!")  // 輸出“NOW SERVING Chris!”
print(customersInLine.count)  // 輸出“4”
---
output: 5
5
NOW SERVING Chris!
4

// customersInLine is ["Jensen", "Ewa", "Alex", "Barry"]
func server(customer customerProvider: () -> String) {
        print("Now serving \(customerProvider())!")
}
server(customer: { customersInLine.remove(at: 0) })  // 輸出“Now serving Jensen!”
---
output: Now serving Jensen!

// customersInLine is ["Ewa", "Alex", "Barry"]
func server(customer customerProvider: @autoclosure () -> String) {
        print("Now Serving \(customerProvider())!")
}
server(customer: customersInLine.remove(at: 0))  // 輸出“Now Serving Ewa!”
---
output: Now Serving Ewa!

// customersInLine is ["Alex", "Barry"]
var customerProviders: [() -> String] = []
func collectCustomerProviders(_ customerProvider: @autoclosure @escaping () -> String) {
        customerProviders.append(customerProvider)
}
collectCustomerProviders(customersInLine.remove(at: 0))
collectCustomerProviders(customersInLine.remove(at: 0))
print("Collected \(customerProviders.count) closures.")  // 輸出“Collected 2 closures.” 現在有兩個閉包被加入外部customerProviders陣列
print(customersInLine)  // customersInLine 仍為 ["Alex", "Barry"]
for customerProvider in customerProviders {
        print("Now serving \(customerProvider())!")
}  // 輸出“Now serving Alex!”、“Now serving Barry!”
//print(customersInLine)  // 此時customersInLine陣列為空
---
output: Collected 2 closures.
["Alex", "Barry"]
Now serving Alex!
Now serving Barry!