swift 中的閉包和JS中的匿名函數(shù)很像，但是它還有一些其它的特性回右，其中包括一些看起來很怪異的語法糖斤蔓，寫法看起來特別的蛋疼植酥。。。
- 閉包表達(dá)式
- 尾隨閉包
- 閉包是引用類型
- 逃逸閉包友驮，使用
@escaping進(jìn)行裝飾 - 自動閉包漂羊，使用
@autoclosure進(jìn)行裝飾
函數(shù)和嵌套函數(shù)是特殊的閉包，這個(gè)和JS中的閉包一致卸留。閉包采用如下3種形式：
- 全局函數(shù)是一個(gè)有名字當(dāng)不會捕獲任何值的閉包
- 嵌套函數(shù)是一個(gè)有名字并可以捕獲其封閉函數(shù)域內(nèi)值的閉包
- 閉包表達(dá)式是簡寫形式走越，可以捕獲其上下文中變量或常量值的匿名函數(shù)
swift中閉包表達(dá)式的特點(diǎn)：
- 利用上下文推斷參數(shù)和返回值類型
- 隱式返回單表達(dá)式閉包，可以省略
return關(guān)鍵詞耻瑟，和JS中一樣 - 參數(shù)名稱縮寫旨指， 使用
$0,$1...依次對應(yīng)參數(shù)列表中的第1個(gè)參數(shù)，第二個(gè)參數(shù)... - 尾隨閉包語法喳整，當(dāng)函數(shù)A最后一個(gè)參數(shù)是一個(gè)函數(shù)B時(shí)(即
A(B))谆构，可以將這個(gè)函數(shù)B提取出來寫在外面，如果函數(shù)A參數(shù)只有一個(gè)參數(shù)B框都，則函數(shù)的括號甚至都可以省略搬素，個(gè)人感覺這個(gè)優(yōu)化得太過了，完全失去了可讀性
1.閉包表達(dá)式
編寫一些小喬的函數(shù)結(jié)構(gòu)體比較方便魏保，例如函數(shù)作為參數(shù)熬尺，其一般形式為：
// 使用 "in" 關(guān)鍵詞分割參數(shù)和表達(dá)式
{(parameters) -> return type in
// statements
}
關(guān)鍵詞 in 分割參數(shù)和表達(dá)式
例如使用 sorted(by:) 對[String]排序
let names = ["chris", "alex", "ewa"]
// sorted(by:) 這個(gè)函數(shù)需要傳入一個(gè)函數(shù)作為參數(shù)
// 普通寫法
function descending(_ s1: String, _ s2: String) -> Bool {
return s1 > s2
}
var descendingNames = names.sorted(by: descending)
// ["eva", "chris", "alex"]
使用閉包表達(dá)式：
var descendingNames = names.sorted(by:
{(s1: String, s2: String) -> Bool in
return s1 > s2
})
swift可以推斷傳入?yún)?shù)和返回類型的簽名，(String, String) -> Bool 因此簽名部分可以省略谓罗，由swift自行推斷
var descendingNames =
names.sorted(by: {(s1, s2) in
return s1 > s2
})
// 上面包裹參數(shù)的括號是可以省略的
var descendingNames =
names.sorted(by: {s1, s2 in
return s1 > s2
})
2.單表達(dá)式閉包隱式返回
只有一個(gè)表達(dá)式時(shí)粱哼，可以省略 return 關(guān)鍵詞
let names = ["chris", "alex", "ewa"]
// 可以省略return
var descendingNames =
names.sorted(by: { (s1, s2) in s1 > s2 })
js示例：
let names = ["chris", "alex", "ewa"]
names.map((name, index) => `${index + 1}. ${name}`)
3.參數(shù)名稱縮寫
swift會自動的根據(jù)簽名，可以將參數(shù)移除使用 $0, $1... 來表示檩咱，這個(gè)和JS中的正則表達(dá)式 RegExp.$1... 來表示分組是一個(gè)意思
let names = ["chris", "alex", "ewa"]
// 參數(shù)列表為 (s1, s2)
var descendingNames =
names.sorted(by: { (s1, s2) in s1 > s2 })
// 使用縮寫
var descendingNames =
names.sorted(by: { $0 > $1 })
// 另外 sorted方法實(shí)現(xiàn)了運(yùn)算符重載
// 可以縮寫為
var descendingNames =
names.sorted(by: > )
4.尾隨閉包
使用尾隨閉包是揭措，不用寫出它的參數(shù)標(biāo)簽：
// 這個(gè)函數(shù)接收closure函數(shù)作為最后一個(gè)參數(shù)
func someFunc(closure: () -> Void) {
// ...
}
// 不使用尾隨表調(diào)用
someFunc(closure: {
// ...
})
// 使用尾隨閉包
// 可以將其提取出來
someFunc() {
// ...
}
// 這個(gè)函數(shù)只有一個(gè)參數(shù)，可以將someFunc后面的括號省略
someFunc {
// ...
}
看著很簡潔税手，但是感覺可讀性太差了蜂筹，可能我需要一段時(shí)間適應(yīng)
let names = ["chris", "alex", "ewa"]
// 使用尾隨閉包
var descendingNames = names.sorted() { $0 > $1 }
// 或者省略括號
var descendingNames = names.sorted { $0 > $1 }
示例2：
let nums = [1, 2, 3, 4]
// 使用map給每個(gè)數(shù)字加1
newNums = nums.map({item in return item + 1})
// 或者
newNums = nums.map({$0 + 1})
// 或者
newNums = nums.map() { $0 + 1 }
// 或者
newNums = nums.map { $0 + 1 }
5.閉包是引用類型
使用值捕獲來解決這個(gè)問題
這個(gè)會出現(xiàn)js中的問題需纳，需要注意
var funcArray = []
for (var i = 0; i < 5; i++) {
funcArray.push(function() {
console.log(i)
})
}
// 打印的值都是5
funcArray[0]() // 5
funcArray[1]() // 5
...
funcArray[4]() // 5
swift中也有這個(gè)問題：
// 閉包數(shù)組
var closureArray: [() -> ()] = []
var i = 0
for _ in 1...5 {
// 將函數(shù)添加到數(shù)組中
closureArray.append {
print(i)
}
i += 1
}
// 同樣的問題
// 因?yàn)楹瘮?shù)執(zhí)行的時(shí)候 i = 5, 閉包是引用類型
closureArray[0]() // 5
closureArray[1]() // 5
closureArray[2]() // 5
closureArray[3]() // 5
closureArray[4]() // 5
swift中的解決辦法：不使用引用芦倒，而是去將值拷貝之后再使用
var closureArray: [() -> ()] = []
var i = 0
for _ in 1...5 {
// 將函數(shù)添加到數(shù)組中 也稱之為 capture list
// 使用數(shù)組作為參數(shù)
closureArray.append { [i] in
print(i)
}
i += 1
}
// 同樣的問題
// 因?yàn)楹瘮?shù)執(zhí)行的時(shí)候 i = 5, 閉包是引用類型
closureArray[0]() // 0
closureArray[1]() // 1
closureArray[2]() // 2
closureArray[3]() // 3
closureArray[4]() // 4
// 也可以用別名
for _ in 1...5 {
// 將i命名為num
closureArray.append { [num = i] in
print(num)
}
i += 1
}
示例2：
var c = 0
var d = 0
let smartClosure: () -> () = { () in
print(c, d)
}
smartClosure()
// 打印 0, 0
// 改變其值
c = 9
d = 9
smartClosure()
// 打印 9，9
// 使用 capture list
// 不使用引用 而是進(jìn)行拷貝
var c = 5
var d = 5
let captureList: () -> () = { [c, d] in
print(c, d)
}
captureList()
// 打印 5, 5
c = 20
d = 20
captureList()
// 打印 5, 5 這里值沒有發(fā)生變化
// 因?yàn)樯厦婧瘮?shù)對值進(jìn)行了捕獲不翩，即使后面再改變c,d
// 捕獲的值仍然是5兵扬， 5
6.逃逸閉包(escaping closure)
對學(xué)JS的我感覺有點(diǎn)懵逼，這有篇好文章：
簡單列舉一下其特點(diǎn)和作用：
- 使用
@escaping關(guān)鍵詞來修飾閉包的簽名 - 將一個(gè)閉包標(biāo)記為
@escaping意味著必須在閉包中顯式的使用sekf - 作用1： 異步調(diào)用 如果需要調(diào)度隊(duì)列中異步調(diào)用閉包口蝠，這個(gè)隊(duì)列會持有閉包的應(yīng)用
- 作用2：存儲器钟，需要存儲閉包作為屬性，全局變量或其他類型坐稍后使用
示例
// 普通閉包
func normalClosure(closure: () -> Void) {
// 直接調(diào)用 調(diào)用結(jié)束后閉包被銷毀
closure()
}
// 逃逸閉包
// 使用一個(gè)外部變量將其存儲下來
var completionHandlers: [() -> Void] = []
// 使用 @escaping 進(jìn)行修飾
func escapingClosure(completeHandler: @escaping () -> Void) {
// 將其存儲 留作稍后使用
completionHandlers.append(completeHandler)
}
class SomeClass {
var x = 10
func doSomething() {
// 使用尾隨閉包的形式調(diào)用
normalClosure { x = 200 } // 隱式的使用 self
// 逃逸閉包必須顯式的使用 self
escapingClosure { self.x = 100 }
}
}
let instance = SomeClass()
print(instance.x) // 10
instance.doSomething()
// escapingClosure 被存儲在completionHandlers 數(shù)組中
print(instance.x) // 200
// 稍后再使用
completionHandlers.first?()
print(instance.x) // 100
7.自動閉包 (@autoclosure )
這個(gè)用于自動創(chuàng)建閉包妙蔗，也是一種簡寫的語法套傲霸，用于包裝傳遞給函數(shù)作為參數(shù)的表達(dá)式。
這種閉包不接受任何參數(shù)，當(dāng)被調(diào)用的時(shí)候回返回被包裝在其中的表達(dá)式的值昙啄，能夠省略閉包的花括號穆役，感覺沒啥用，可讀性不友好
var customersInLine = ["Chris", "Alex", "Ewa", "Barry", "Daniella"]
print(customersInLine.count)
// 打印出 "5"
// 定義函數(shù)
let customerProvider = { custersInLint.remove(at: 0) }
print("Now serving \(customerProvider())!")
// Prints "Now serving Chris!"
print(customersInLine.count)
// 打印出 "4"
func serve(customer customerProvider: () -> String) {
print("Now serving \(customerProvider())!")
}
// 調(diào)用
serve(customer: { customersInLine.remove(at: 0) } )
// 可以看出 serve 函數(shù)的customer參數(shù)是一個(gè)不接受任何參數(shù)的閉包
// 因此可以寫成自動閉包的形式
// 使用 @autoclosure 關(guān)鍵詞
func serve(customer customerProvider: @autoclosure () -> String) {
print("Now serving \(customerProvider())!")
}
// 調(diào)用時(shí) 可以省略閉包的一對括號
serve(customer: customersInLine.remove(at: 0))
// 打印 "Now serving Ewa!"
可以將 自動閉包和逃逸閉包一起使用：
var customerProviders: [() -> String] = []
func collectCustomerProviders(_ customerProvider: @autoclosure @escaping () -> String) {
customerProviders.append(customerProvider)
}
// 將函數(shù)添加到數(shù)組中
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!"
說實(shí)話這語法看著很蛋疼梳凛。耿币。。
