//閉包 這章有的地方不懂orz

//“閉包是自包含的函數(shù)代碼塊活玲，可以在代碼中被傳遞和使用阱当。Swift 中的閉包與 C 和 Objective-C 中的代碼塊（blocks）以及其他一些編程語(yǔ)言中的匿名函數(shù)比較相似”

//“閉包可以捕獲和存儲(chǔ)其所在上下文中任意常量和變量的引用欧募。被稱為包裹常量和變量艘绍。 Swift 會(huì)為你管理在捕獲過(guò)程中涉及到的所有內(nèi)存操作”

//“在函數(shù)章節(jié)中介紹的全局和嵌套函數(shù)實(shí)際上也是特殊的閉包，閉包采取如下三種形式之一：

    //全局函數(shù)是一個(gè)有名字但不會(huì)捕獲任何值的閉包
    //嵌套函數(shù)是一個(gè)有名字并可以捕獲其封閉函數(shù)域內(nèi)值的閉包
    //閉包表達(dá)式是一個(gè)利用輕量級(jí)語(yǔ)法所寫的可以捕獲其上下文中變量或常量值的匿名閉包

//“Swift 的閉包表達(dá)式擁有簡(jiǎn)潔的風(fēng)格架曹，并鼓勵(lì)在常見場(chǎng)景中進(jìn)行語(yǔ)法優(yōu)化，主要優(yōu)化如下：

    //利用上下文推斷參數(shù)和返回值類型
    //隱式返回單表達(dá)式閉包闹瞧，即單表達(dá)式閉包可以省略 return 關(guān)鍵字
    //參數(shù)名稱縮寫
    //尾隨閉包語(yǔ)法”

//1.閉包表達(dá)式

//1.1 閉包表達(dá)式示例
//“Swift 標(biāo)準(zhǔn)庫(kù)提供了名為 sorted(by:) 的方法绑雄，它會(huì)根據(jù)你所提供的用于排序的閉包函數(shù)將已知類型數(shù)組中的值進(jìn)行排序。一旦排序完成奥邮，sorted(by:) 方法會(huì)返回一個(gè)與原數(shù)組大小相同万牺，包含同類型元素且元素已正確排序的新數(shù)組。原數(shù)組不會(huì)被 sorted(by:) 方法修改漠烧⌒臃撸”

let names = ["chris","alex","ewa","barry","daniella"]
func backward(_ s1: String,_ s2: String)->Bool{
    return s1 > s2
}
var reversedNames = names.sorted(by: backward)
print(reversedNames)

//1.2.閉包表達(dá)式語(yǔ)法

//一般形式
/*
    {(parameters)-> returnType in
        statements
    }
*/

//“閉包表達(dá)式參數(shù) 可以是 in-out 參數(shù)，但不能設(shè)定默認(rèn)值已脓。也可以使用具名的可變參數(shù)（注：但是如果可變參數(shù)不放在參數(shù)列表的最后一位的話珊楼，調(diào)用閉包的時(shí)候編譯器將報(bào)錯(cuò),）。元組也可以作為參數(shù)和返回值度液。

//所以上邊的例子可以寫作內(nèi)聯(lián)閉包：
reversedNames = names.sorted(by: {(s1:String,s2:String)->Bool in
    return s1 > s2
})
print(reversedNames)

//“該例中 sorted(by:) 方法的整體調(diào)用保持不變厕宗，一對(duì)圓括號(hào)仍然包裹住了方法的整個(gè)參數(shù)。然而堕担，參數(shù)現(xiàn)在變成了內(nèi)聯(lián)閉包已慢。
//“ 內(nèi)聯(lián)閉包 參數(shù)和返回值類型聲明與 上個(gè)例子中backward(::) 函數(shù)類型聲明相同。在這兩種方式中霹购，都寫成了 (s1: String, s2: String) -> Bool佑惠。然而在內(nèi)聯(lián)閉包表達(dá)式中，函數(shù)和返回值類型都寫在大括號(hào)內(nèi)齐疙，而不是大括號(hào)外膜楷。”
//“閉包的函數(shù)體部分由關(guān)鍵字in引入贞奋。該關(guān)鍵字表示閉包的參數(shù)和返回值類型定義已經(jīng)完成赌厅，閉包函數(shù)體即將開始”

//1.3根據(jù)上下文推斷類型
//“因?yàn)榕判蜷]包函數(shù)是作為 sorted(by:) 方法的參數(shù)傳入的，Swift 可以推斷其參數(shù)和返回值的類型轿塔。sorted(by:) 方法被一個(gè)字符串?dāng)?shù)組調(diào)用特愿，因此其參數(shù)必須是 (String, String) -> Bool 類型的函數(shù)。這意味著 (String, String) 和 Bool 類型并不需要作為閉包表達(dá)式定義的一部分勾缭。因?yàn)樗械念愋投伎梢员徽_推斷揍障，返回箭頭（->）和圍繞在參數(shù)周圍的括號(hào)也可以被省略”
reversedNames = names.sorted(by: {s1,s2 in return s1 > s2})
print(reversedNames)
//“實(shí)際上，通過(guò)內(nèi)聯(lián)閉包表達(dá)式構(gòu)造的閉包作為參數(shù)傳遞給函數(shù)或方法時(shí)俩由，總是能夠推斷出閉包的參數(shù)和返回值類型毒嫡。這意味著閉包作為函數(shù)或者方法的參數(shù)時(shí)，你幾乎不需要利用完整格式構(gòu)造內(nèi)聯(lián)閉包采驻∩笈撸”
//“盡管如此，你仍然可以明確寫出有著完整格式的閉包礼旅。如果完整格式的閉包能夠提高代碼的可讀性膳叨，則我們更鼓勵(lì)采用完整格式的閉包”

//1.4 單表達(dá)式閉包隱式返回
//“單行表達(dá)式閉包可以通過(guò)省略 return 關(guān)鍵字來(lái)隱式返回單行表達(dá)式的結(jié)果”

reversedNames = names.sorted(by: {s1,s2 in s1 > s2})
print(reversedNames)

//“在這個(gè)例子中，sorted(by:) 方法的參數(shù)類型 明確了 閉包必須返回一個(gè) Bool 類型值痘系。因?yàn)殚]包函數(shù)體只包含了一個(gè)單一表達(dá)式（s1 > s2）菲嘴，該表達(dá)式返回 Bool 類型值，因此這里 沒有歧義 汰翠，return 關(guān)鍵字可以省略”

//1.5 參數(shù)名稱縮寫
//“Swift 自動(dòng)為 內(nèi)聯(lián)閉包 提供了參數(shù)名稱縮寫功能龄坪，你可以直接通過(guò) $0，$1复唤，$2 來(lái)順序調(diào)用閉包的參數(shù)健田，以此類推》鹑遥”
//“如果你在閉包表達(dá)式中使用參數(shù)名稱縮寫妓局，你可以在閉包定義中省略參數(shù)列表，并且對(duì)應(yīng)參數(shù)名稱縮寫的類型會(huì)通過(guò)函數(shù)類型進(jìn)行推斷呈宇。in關(guān)鍵字也同樣可以被省略”

reversedNames = names.sorted(by: {$0 > $1})
print(reversedNames)
//“這個(gè)例子中好爬，$0和$1表示閉包中第一個(gè)和第二個(gè) String 類型的參數(shù)∩模”

//2. 尾隨閉包
// “如果你需要將一個(gè)很長(zhǎng)的閉包表達(dá)式作為 最后一個(gè)參數(shù) 傳遞給函數(shù)存炮，可以使用尾隨閉包來(lái)增強(qiáng)函數(shù)的可讀性。尾隨閉包是一個(gè)書寫在函數(shù)括號(hào)之后的閉包表達(dá)式蜈漓，函數(shù)支持將其作為最后一個(gè)參數(shù)調(diào)用穆桂。在使用尾隨閉包時(shí)，你不用寫出它的參數(shù)標(biāo)簽”

func someFunctionThatTakesAclosure(closure:()->Void){
 //函數(shù)體部分
}

//不使用尾隨閉包進(jìn)行函數(shù)調(diào)用
someFunctionThatTakesAclosure(closure:{
    //閉包主體部分
})

//使用尾隨閉包進(jìn)行函數(shù)調(diào)用
someFunctionThatTakesAclosure() {
    //閉包主體部分
}

//上一節(jié)例子可以寫為
reversedNames = names.sorted(){$0 > $1}
//如果比表表達(dá)式是函數(shù)或者方法的唯一參數(shù)迎变，則可以把（）省略掉
reversedNames = names.sorted{$0 > $1}

//“當(dāng)閉包非常長(zhǎng)以至于不能在一行中進(jìn)行書寫時(shí)充尉，尾隨閉包變得非常有用”
//“Swift 的 Array 類型有一個(gè) map(_:) 方法，這個(gè)方法獲取一個(gè)閉包表達(dá)式作為其唯一參數(shù)衣形。該閉包函數(shù)會(huì)為數(shù)組中的每一個(gè)元素調(diào)用一次驼侠，并返回該元素所映射的值。具體的映射方式和返回值類型由閉包來(lái)指定”

let digitNames = [0:"zero",1:"one",2:"two",3:"three",4:"four",5:"five",6:"six",7:"seven",8:"eight",9:"nine"]
let numbers = [15,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
}
print(strings)

//“map(:) 為數(shù)組中每一個(gè)元素調(diào)用了一次閉包表達(dá)式谆吴。你不需要指定閉包的輸入?yún)?shù) number 的類型倒源，因?yàn)榭梢酝ㄟ^(guò)要映射的數(shù)組類型進(jìn)行推斷【淅牵”
//“局部變量 number 的值由閉包中的 number 參數(shù)獲得笋熬，因此可以在閉包函數(shù)體內(nèi)對(duì)其進(jìn)行修改，(閉包或者函數(shù)的參數(shù)總是常量)腻菇，閉包表達(dá)式指定了返回類型為 String胳螟，以表明存儲(chǔ)映射值的新數(shù)組類型為 String昔馋。”
//“注意：字典 digitNames 下標(biāo)后跟著一個(gè)嘆號(hào)（!）糖耸，因?yàn)樽值湎聵?biāo)返回一個(gè)可選值（optional value）秘遏，表明該鍵不存在時(shí)會(huì)查找失敗。在上例中嘉竟，由于可以確定 number % 10 總是 digitNames 字典的有效下標(biāo)邦危，因此嘆號(hào)可以用于強(qiáng)制解包 (force-unwrap) 存儲(chǔ)在下標(biāo)的可選類型的返回值中的String類型的值∩崛牛”
//“在上面的例子中倦蚪，通過(guò)尾隨閉包語(yǔ)法，優(yōu)雅地在函數(shù)后封裝了閉包的具體功能边苹，而不再需要將整個(gè)閉包包裹在 map(:) 方法的括號(hào)內(nèi)陵且。”

//3. 值捕獲
//“閉包可以在其被定義的上下文中捕獲常量或變量个束。即使定義這些常量和變量的原作用域已經(jīng)不存在滩报，閉包仍然可以在閉包函數(shù)體內(nèi)引用和修改這些值〔ゼ保”

//“Swift 中脓钾，可以捕獲值的閉包的最簡(jiǎn)單形式是嵌套函數(shù)，也就是定義在其他函數(shù)的函數(shù)體內(nèi)的函數(shù)桩警。嵌套函數(shù)可以捕獲其外部函數(shù)所有的參數(shù)以及定義的常量和變量可训。”

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

//“incrementer() 函數(shù)并沒有任何參數(shù)捶枢，但是在函數(shù)體內(nèi)訪問(wèn)了 runningTotal 和 amount 變量握截。這是因?yàn)樗鼜耐鈬瘮?shù)捕獲了 runningTotal 和 amount 變量的引用。捕獲引用保證了 runningTotal 和 amount 變量在調(diào)用完 makeIncrementer 后不會(huì)消失烂叔，并且保證了在下一次執(zhí)行 incrementer 函數(shù)時(shí)谨胞，runningTotal 依舊存在。
//注意:“為了優(yōu)化蒜鸡，如果一個(gè)值不會(huì)被閉包改變胯努，或者在閉包創(chuàng)建后不會(huì)改變，Swift 可能會(huì)改為捕獲并保存一份對(duì)值的拷貝逢防。 Swift 也會(huì)負(fù)責(zé)被捕獲變量的所有內(nèi)存管理工作叶沛，包括釋放不再需要的變量”

let incrementByTen = makeIncrementer(forIncrement: 10)
incrementByTen()  //返回值為10
incrementByTen()  //返回值為20
incrementByTen()  //返回值為30

//“如果你創(chuàng)建了另一個(gè) incrementor，它會(huì)有屬于自己的引用忘朝，指向一個(gè)全新灰署、獨(dú)立的 runningTotal 變量：”
let incrementBySeven = makeIncrementer(forIncrement: 7)
incrementBySeven()  //返回值為7

//“再次調(diào)用原來(lái)的 incrementByTen 會(huì)繼續(xù)增加它自己的 runningTotal 變量，該變量和 incrementBySeven 中捕獲的變量沒有任何聯(lián)系：”
incrementByTen() //返回值為40
//“如果你將閉包賦值給一個(gè)類實(shí)例的屬性，并且該閉包通過(guò)訪問(wèn)該實(shí)例或其成員而捕獲了該實(shí)例溉箕，你將在閉包和該實(shí)例間創(chuàng)建一個(gè)循環(huán)強(qiáng)引用晦墙。Swift 使用捕獲列表來(lái)打破這種循環(huán)強(qiáng)引用”

//4.閉包的引用類型
//“上面的例子中，incrementBySeven 和 incrementByTen 都是常量肴茄，但是這些常量指向的閉包仍然可以增加其捕獲的變量的值偎痛。這是因?yàn)楹瘮?shù)和閉包都是引用類型《览桑”
//“無(wú)論你將函數(shù)或閉包賦值給一個(gè)常量還是變量，你實(shí)際上都是將常量或變量的值設(shè)置為對(duì)應(yīng)函數(shù)或閉包的引用枚赡。上面的例子中氓癌，指向閉包的引用 incrementByTen 是一個(gè)常量，而并非閉包內(nèi)容本身贫橙√巴瘢”
//“這也意味著如果你將閉包賦值給了兩個(gè)不同的常量或變量，兩個(gè)值都會(huì)指向同一個(gè)閉包”

let alsoIncrementByTen = incrementByTen
alsoIncrementByTen()  // 返回50

//5.逃逸閉包
// “當(dāng)一個(gè)閉包作為參數(shù)傳到一個(gè)函數(shù)中卢肃，但是這個(gè)閉包在函數(shù)返回之后才被執(zhí)行疲迂，我們稱該閉包從函數(shù)中逃逸。當(dāng)你定義接受閉包作為參數(shù)的函數(shù)時(shí)莫湘，你可以在參數(shù)名之前標(biāo)注 @escaping尤蒿，用來(lái)指明這個(gè)閉包是允許“逃逸”出這個(gè)函數(shù)的》澹”
//“一種能使閉包“逃逸”出函數(shù)的方法是腰池，將這個(gè)閉包保存在一個(gè)函數(shù)外部定義的變量中。舉個(gè)例子忙芒，很多啟動(dòng)異步操作的函數(shù)接受一個(gè)閉包參數(shù)作為 completion handler示弓。這類函數(shù)會(huì)在異步操作開始之后立刻返回，但是閉包直到異步操作結(jié)束后才會(huì)被調(diào)用呵萨。在這種情況下奏属，閉包需要“逃逸”出函數(shù)，因?yàn)殚]包需要在函數(shù)返回之后被調(diào)用”

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

//“someFunctionWithEscapingClosure(_:) 函數(shù)接受一個(gè)閉包作為參數(shù)潮峦，該閉包被添加到一個(gè)函數(shù)外定義的數(shù)組中囱皿。如果你不將這個(gè)參數(shù)標(biāo)記為 @escaping，就會(huì)得到一個(gè)編譯錯(cuò)誤忱嘹∶保”

//“將一個(gè)閉包標(biāo)記為 @escaping 意味著你必須在閉包中顯式地引用 self。比如說(shuō)德谅，在下面的代碼中爹橱，傳遞到 someFunctionWithEscapingClosure(:) 中的閉包是一個(gè)逃逸閉包，這意味著它需要顯式地引用 self。相對(duì)的愧驱，傳遞到 someFunctionWithNonescapingClosure(:) 中的閉包是一個(gè)非逃逸閉包慰技，這意味著它可以隱式引用 self”

func someFunctionWithNonescapeingClosure(closure:()->Void){
closure()   //閉包類型的定義
}

class SomeClass{
    var x = 10
    func doSomething(){
        someFunctionWithNonescapeingClosure {
            x = 200                                        //閉包內(nèi)容的定義
        }
        someFunctionWithEscapingClosure {
            self.x = 100                                   //閉包內(nèi)容的定義
        }
    }
}

let instance = SomeClass()
instance.doSomething()   //閉包的調(diào)用
print(instance.x)

completionHandles.first?() //閉包的調(diào)用
print(instance.x) 

//6.自動(dòng)閉包
//“自動(dòng)閉包是一種自動(dòng)創(chuàng)建的閉包，用于包裝傳遞給函數(shù)作為參數(shù)的表達(dá)式组砚。這種閉包不接受任何參數(shù)吻商，當(dāng)它被調(diào)用的時(shí)候，會(huì)返回被包裝在其中的表達(dá)式的值糟红。這種便利語(yǔ)法讓你能夠省略閉包的花括號(hào)艾帐，用一個(gè)普通的表達(dá)式來(lái)代替顯式的閉包。

//“下面的代碼展示了閉包如何延時(shí)求值盆偿∑獍郑”
var customersInLine = ["Chris","Alex","Andi","Barry","Edward"]
print(customersInLine.count)
//打印5
let customerProvider = {customersInLine.remove(at: 0)}
print(customersInLine.count)
//打印5
print("Now seving \(customerProvider())")
//打印 Now seving Chris
print(customersInLine.count)
//打印4

//“盡管在閉包的代碼中，customersInLine 的第一個(gè)元素被移除了事扭，不過(guò)在閉包被調(diào)用之前捎稚，這個(gè)元素是不會(huì)被移除的。如果這個(gè)閉包永遠(yuǎn)不被調(diào)用求橄，那么在閉包里面的表達(dá)式將永遠(yuǎn)不會(huì)執(zhí)行今野，那意味著列表中的元素永遠(yuǎn)不會(huì)被移除。請(qǐng)注意罐农，customerProvider 的類型不是 String条霜，而是 () -> String，一個(gè)沒有參數(shù)且返回值為 String 的函數(shù)”

//“閉包作為參數(shù)傳遞給函數(shù)時(shí)涵亏，你能獲得同樣的延時(shí)求值行為蛔外。”
// customersInLine is ["Alex","Andi","Barry","Edward"]
func serve(customer customerProvider:()->String){
print("Now serving \(customerProvider())")
}
serve(customer: {customersInLine.remove(at: 0)})
//打印出 Now serving Alex

//customerInLine is ["Andi","Barry","Edward"]
func severAgain(customer customerProvider: @autoclosure ()->String){
print("Now seving \(customerProvider())")
}
severAgain(customer: customersInLine.remove(at: 0))
//打印 Now serving Andi
//“ 過(guò)度使用 autoclosures 會(huì)讓你的代碼變得難以理解溯乒。上下文和函數(shù)名應(yīng)該能夠清晰地表明求值是被延遲執(zhí)行的夹厌。

//“如果你想讓一個(gè)自動(dòng)閉包可以“逃逸”，則應(yīng)該同時(shí)使用 @autoclosure 和 @escaping 屬性”
//customerInline is ["Barry","Edward"]
var againCustomerProviders: [()->String] = []
func collectCustomerProviders(_ customerProvider: @autoclosure @escaping ()->String){
        againCustomerProviders.append(customerProvider)
}

collectCustomerProviders(customersInLine.remove(at: 0))
collectCustomerProviders(customersInLine.remove(at: 0))
print("collected \(againCustomerProviders.count) closures")
// 打印 collected 2 closures
print(customersInLine)
//打印 [“Barry”裆悄，“Edward”]
for mycustomerPrivider in againCustomerProviders {
print("Now serving \(mycustomerPrivider())")
}
//打印 Now swrving Barry
//打印 Now seving  Edward