// ## 尾隨閉包
func someFunctionThatTakesAClosure(closure: () -> Void) {
    // 函數(shù)體部分
}

someFunctionThatTakesAClosure(closure: {
    
})

someFunctionThatTakesAClosure {
    
}

// ## 值捕獲
func makeIncrementer(forIncrement amount: Int) -> () -> Int {
    var runningTotal = 0
    func incrementer() -> Int {
        runningTotal += amount
        return runningTotal
    }
    return incrementer
}
let incrementByTen = makeIncrementer(forIncrement: 10)
var d = incrementByTen() //10
d = incrementByTen() //20
d = incrementByTen() //30

let incrementBySeven = makeIncrementer(forIncrement: 7)
d = incrementBySeven() //7
d = incrementByTen() //40
let alsoIncrementByTen = incrementByTen
alsoIncrementByTen() //50


// ## 逃逸閉包
//一種能使閉包“逃逸”出函數(shù)的方法是，將這個閉包保存在一個函數(shù)外部定義的變量中
var completionHandlers: [ ()->Void ] = []
func someFunctionWithEscapingClosure(completionHandler: @escaping ()->Void) {
    completionHandlers.append(completionHandler)
}
//將一個閉包標記為 @escaping 意味著你必須在閉包中顯式地引用 self。
func someFunctionWithNonescapingClosure(closure: () -> Void) {
    closure()
}
class SomeClass {
    var x = 10
    func doSomething() {
        someFunctionWithEscapingClosure {
            self.x = 100
        }
        someFunctionWithNonescapingClosure { x = 200 }
    }
}
let instance = SomeClass()
instance.doSomething()
print(instance.x)
// 打印出“200”

completionHandlers.first?()
print(instance.x)
// 打印出“100”


// ## 自動閉包讓你能夠延遲求值，因為直到你調(diào)用這個閉包，代碼段才會被執(zhí)行
var customersInLine = ["Chris", "Alex", "Ewa", "Barry", "Daniella"]
print(customersInLine.count)
// 打印出“5”

let customerProvider = { customersInLine.remove(at: 0) }
print(customersInLine.count)
// 打印出“5”

print("現(xiàn)在才移除第一個元素 \(customerProvider())")
// 現(xiàn)在才移除第一個元素 Chris
print(customersInLine.count)
// 打印出“4”

//將閉包作為參數(shù)傳遞給函數(shù)時，你能獲得同樣的延時求值行為。
func serve(customer customerProvider: ()->String) {
    print("函數(shù)被調(diào)用時才移除第一個元素 \(customerProvider())")
}
serve(customer: { customersInLine.remove(at: 0) })

//通過將參數(shù)標記為 @autoclosure 來接收一個自動閉包
func serve(customer customerProvider: @autoclosure () -> String) {
    print("Now serving \(customerProvider())!")
}
serve(customer: customersInLine.remove(at: 0))
// 打印“Now serving Ewa!”

// ## 自動閉包和逃逸閉包
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.”
for customerProvider in customerProviders {
    print("Now serving \(customerProvider())!")
}
// 打印“Now serving Barry!”
// 打印“Now serving Daniella!”