swift 闭包的学习

import UIKit
import os
import Foundation

var names = ["Chris", "Alex", "Ewa", "Barry", "Daniella"]

func backward(_ s1: String, _ s2: String) -> Bool {
    return s1 > s2
}
var reversedNames = names.sorted(by: backward)
// reversedNames 为 ["Ewa", "Daniella", "Chris", "Barry", "Alex"]

let funa = backward

var RRName = names.sorted(by: <)

/**
 { (parameters) -> return type in
     statements
 }
 原始结构
 */

let aaa = {(str1 :String,str2:String) -> Bool  in
    return str1 > str2
}
reversedNames = names.sorted(by: {(str1,str2) -> Bool in return str1 > str2})
reversedNames = names.sorted(by: aaa)

/**
根据上下文推断类型
因为排序闭包函数是作为 sorted(by:) 方法的参数传入的，Swift 可以推断其参数和返回值的类型。sorted(by:) 方法被一个字符串数组调用，因此其参数必须是 (String, String) -> Bool 类型的函数。这意味着 (String, String) 和 Bool 类型并不需要作为闭包表达式定义的一部分。因为所有的类型都可以被正确推断，返回箭头（->）和围绕在参数周围的括号也可以被省略：
*/

reversedNames = names.sorted(by: { str1, str2 in return str1 > str2})

/**
单表达式闭包的隐式返回
单行表达式闭包可以通过省略 return 关键字来隐式返回单行表达式的结果，如上版本的例子可以改写为：

*/

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

/**
参数名称缩写
Swift 自动为内联闭包提供了参数名称缩写功能，你可以直接通过 1，$2 来顺序调用闭包的参数，以此类推。
如果你在闭包表达式中使用参数名称缩写，你可以在闭包定义中省略参数列表，并且对应参数名称缩写的类型会通过函数类型进行推断。闭包接受的参数的数量取决于所使用的缩写参数的最大编号。in 关键字也同样可以被省略，因为此时闭包表达式完全由闭包函数体构成：

在这个例子中，1 表示闭包中第一个和第二个 String 类型的参数。因为 0 和 $1 的类型均为 String。
*/

reversedNames = names.sorted(by: { $0 < $1 } )

print(reversedNames)

/**
在这个例子中，1 表示闭包中第一个和第二个 String 类型的参数。因为 0 和 $1 的类型均为 String。
*/

reversedNames = names.sorted(by: >)

extension String{

    func ssss(str:String) -> (Int) {
        return str.count + 5
    }
}

reversedNames = names.sorted(){$0>$1}

/*
下例介绍了如何在 map(_:) 方法中使用尾随闭包将 Int 类型数组 [16, 58, 510] 转换为包含对应 String 类型的值的数组 ["OneSix", "FiveEight", "FiveOneZero"]：
**/

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 { numberin -> String in
    var number = numberin
    var output = ""
    repeat{
        output = digitNames[number%10]! + output
        number/=10
    }while number > 0
    return output
}
print(strings)


func someFunctionThatTakesAClosure(closure: () -> Void) {
    closure()
    print("someFunctionThatTakesAClosure 被调用")
    // 函数体部分
}


var name_val:String = "zs"

func fff() ->Void{
    name_val = "fff"
}
someFunctionThatTakesAClosure(closure: {() -> Void in })
someFunctionThatTakesAClosure(closure: {})
someFunctionThatTakesAClosure {
    name_val = "zlj"
}
print(name_val)
someFunctionThatTakesAClosure(closure: {})
print(name_val)
someFunctionThatTakesAClosure(closure: fff)
print(name_val)

names.sorted(){$1>$0}
names.sorted{$1>$0}

/**
如果一个函数接受多个闭包，您需要省略第一个尾随闭包的参数标签，并为其余尾随闭包添加标签。例如，以下函数将为图片库加载一张图片：

 func loadPicture(from server: Server, completion:(Picture) -> Void,
         onFailure: () -> Void) {
     if let picture = download("photo.jpg", from: server){
         completion(picture)
     }else{
         onFailure()
     }
 }

当您调用该函数以加载图片时，需要提供两个闭包。第一个闭包是一个完成处理程序，它在成功下载后加载图片；第二个闭包是一个错误处理程序，它向用户显示错误。

 loadPicture(from: someServer){    picture in
     someView.currentPicture = picture
 } onFailure: {
     print("Couldn't download the next picture.")
 }

在本例中，loadPicture(from:completion:onFailure:) 函数将它的网络任务分配到后台，并在网络任务完成时调用两个完成处理程序中的一个。通过这种方法编写函数，您将能够把负责处理网络故障的代码和成功下载后更新用户界面的代码干净地区分开，而不是只使用一个闭包处理两种情况。

注意
完成处理程序可能很难阅读，特别是您必须嵌套多个完成处理程序时。另一种方法是使用异步代码，如章节并发 中所述。

*/

//逃逸闭包

/*
当一个闭包作为参数传到一个函数中，但是这个闭包在函数返回之后才被执行，我们称该闭包从函数中逃逸。当你定义接受闭包作为参数的函数时，你可以在参数名之前标注 (‘@escaping’)，用来指明这个闭包是允许“逃逸”出这个函数的。
一种能使闭包“逃逸”出函数的方法是，将这个闭包保存在一个函数外部定义的变量中。举个例子，很多启动异步操作的函数接受一个闭包参数作为 completion handler。这类函数会在异步操作开始之后立刻返回，但是闭包直到异步操作结束后才会被调用。在这种情况下，闭包需要“逃逸”出函数，因为闭包需要在函数返回之后被调用。例如：
*/

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

/**
someFunctionWithEscapingClosure(:) 函数接受一个闭包作为参数，该闭包被添加到一个函数外定义的数组中。如果你不将这个参数标记为 @escaping，就会得到一个编译错误。
将一个闭包标记为 @escaping 意味着你必须在闭包中显式地引用 self。比如说，在下面的代码中，传递到 someFunctionWithEscapingClosure(:) 中的闭包是一个逃逸闭包，这意味着它需要显式地引用 self。相对的，传递到 someFunctionWithNonescapingClosure(_:) 中的闭包是一个非逃逸闭包，这意味着它可以隐式引用 self。
*/

func someFunctionWithNonescapingClosure(closure: () -> Void) {
    closure()
}

class SomeClass {
    var x = 10
    func doSomething() {
        someFunctionWithEscapingClosure { self.x = 100 } //逃逸闭包 需要 指定 self
        someFunctionWithNonescapingClosure { x = 200 } // 调用someFunctionWithNonescapingClosure 会执行closure() 实际执行了 { x = 200 }
    }
}

let instance = SomeClass()
instance.doSomething()
print(instance.x)
// 打印出“200”

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

/**
自动闭包是一种自动创建的闭包，用于包装传递给函数作为参数的表达式。这种闭包不接受任何参数，当它被调用的时候，会返回被包装在其中的表达式的值。这种便利语法让你能够省略闭包的花括号，用一个普通的表达式来代替显式的闭包。
*/

var customersInLine = ["Chris", "Alex", "Ewa", "Barry", "Daniella"]
print(customersInLine.count)
let customerProvider = {customersInLine.remove(at: 0)} //仅赋值 未执行 因为是闭包
print(customersInLine.count)

print(customerProvider()) //执行后 返回删除的值 Chris
print("Now serving \(customerProvider())!") //执行后返回删除的 Alex
// 打印出“Now serving Chris!”
print(customersInLine.count)
// 打印出“3”

/**。⬆️
尽管在闭包的代码中，customersInLine 的第一个元素被移除了，不过在闭包被调用之前，这个元素是不会被移除的。如果这个闭包永远不被调用，那么在闭包里面的表达式将永远不会执行，那意味着列表中的元素永远不会被移除。请注意，customerProvider 的类型不是 String，而是 () -> String，一个没有参数且返回值为 String 的函数。
将闭包作为参数传递给函数时，你能获得同样的延时求值行为。
*/

customersInLine = ["Chris", "Alex", "Ewa", "Barry", "Daniella"]
// customersInLine is ["Alex", "Ewa", "Barry", "Daniella"]
func serve(customer customerProvider: () -> String) {
    print("Now -  serving \(customerProvider())!")
}
serve(customer: { customersInLine.remove(at: 0) } )
// 打印出“Now serving Alex!”

/**
上面的 serve(customer:) 函数接受一个返回顾客名字的显式的闭包。下面这个版本的 serve(customer:) 完成了相同的操作，不过它并没有接受一个显式的闭包，而是通过将参数标记为 @autoclosure 来接收一个自动闭包。现在你可以将该函数当作接受 String 类型参数（而非闭包）的函数来调用。customerProvider 参数将自动转化为一个闭包，因为该参数被标记了 @autoclosure 特性。
*/

// customersInLine is ["Ewa", "Barry", "Daniella"]
func serve(customer customerProvider: @autoclosure () -> String) {
    print("Now serving \(customerProvider())!")
}
//serve(customer:{ customersInLine.remove(at: 0)})
serve(customer: customersInLine.remove(at: 0)) //自动闭包可以省略括号 '{}'
// 打印“Now serving Ewa!”

/**
注意 ❗️
过度使用 autoclosures 会让你的代码变得难以理解。上下文和函数名应该能够清晰地表明求值是被延迟执行的。
/
/*
如果你想让一个自动闭包可以“逃逸”，则应该同时使用 @autoclosure 和 @escaping 属性。@escaping 属性的讲解见上面的 逃逸闭包。
*/

// customersInLine i= ["Barry", "Daniella"]
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!”

/**
总结

在 函数 章节中介绍的全局和嵌套函数实际上也是特殊的闭包，闭包采用如下三种形式之一：
1全局函数是一个有名字但不会捕获任何值的闭包
2嵌套函数是一个有名字并可以捕获其封闭函数域内值的闭包
3闭包表达式是一个利用轻量级语法所写的可以捕获其上下文中变量或常量值的匿名闭包

Swift 的闭包表达式拥有简洁的风格，并鼓励在常见场景中进行语法优化，主要优化如下：
1利用上下文推断参数和返回值类型
2隐式返回单表达式闭包，即单表达式闭包可以省略 return 关键字
3参数名称缩写
4尾随闭包语法

闭包表达式语法
闭包表达式语法有如下的一般形式：
🌟🌟🌟🌟🌟🌟🌟🌟🌟🌟🌟
{ (parameters) -> returnType in
return statements
}
🌟🌟🌟🌟🌟🌟🌟🌟🌟🌟🌟

对照:
{ (s1: String, s2: String) -> Bool in
return s1 > s2
}

简写1:{ (s1: String, s2: String) -> Bool in return s1 > s2 }
简写2:{ (s1, s2) in return s1 > s2 } 根据上下文推断其参数 类型以及返回值类型
简写3:{ s1, s2 in return s1 > s2 } 省略括号
简写4:{ s1, s2 in s1 > s2 }省略 return
简写5: { 1 } 参数名称缩写 你可以直接通过 1，1代表有两个参数,需要按顺序写否则报错
简写6: { >} 或者 > 运算符方法
其实闭包的终结就是 --->{} 个人理解.

其他理解:

闭包是引用类型,闭包被赋值给多个变量他们都执行的是同一个闭包,闭包内的捕获的“值”也是“共用”的.

*/