swift 中的闭包和JS中的匿名函数很像，但是它还有一些其它的特性，其中包括一些看起来很怪异的语法糖，写法看起来特别的蛋疼。。。
- 闭包表达式
- 尾随闭包
- 闭包是引用类型
- 逃逸闭包，使用
@escaping进行装饰 - 自动闭包，使用
@autoclosure进行装饰
函数和嵌套函数是特殊的闭包，这个和JS中的闭包一致。闭包采用如下3种形式：
- 全局函数是一个有名字当不会捕获任何值的闭包
- 嵌套函数是一个有名字并可以捕获其封闭函数域内值的闭包
- 闭包表达式是简写形式，可以捕获其上下文中变量或常量值的匿名函数
swift中闭包表达式的特点：
- 利用上下文推断参数和返回值类型
- 隐式返回单表达式闭包，可以省略
return关键词，和JS中一样 - 参数名称缩写， 使用
$0,$1...依次对应参数列表中的第1个参数，第二个参数... - 尾随闭包语法，当函数A最后一个参数是一个函数B时(即
A(B))，可以将这个函数B提取出来写在外面，如果函数A参数只有一个参数B，则函数的括号甚至都可以省略，个人感觉这个优化得太过了，完全失去了可读性
1.闭包表达式
编写一些小乔的函数结构体比较方便，例如函数作为参数，其一般形式为：
// 使用 "in" 关键词分割参数和表达式
{(parameters) -> return type in
// statements
}
关键词 in 分割参数和表达式
例如使用 sorted(by:) 对[String]排序
let names = ["chris", "alex", "ewa"]
// sorted(by:) 这个函数需要传入一个函数作为参数
// 普通写法
function descending(_ s1: String, _ s2: String) -> Bool {
return s1 > s2
}
var descendingNames = names.sorted(by: descending)
// ["eva", "chris", "alex"]
使用闭包表达式：
var descendingNames = names.sorted(by:
{(s1: String, s2: String) -> Bool in
return s1 > s2
})
swift可以推断传入参数和返回类型的签名，(String, String) -> Bool 因此签名部分可以省略，由swift自行推断
var descendingNames =
names.sorted(by: {(s1, s2) in
return s1 > s2
})
// 上面包裹参数的括号是可以省略的
var descendingNames =
names.sorted(by: {s1, s2 in
return s1 > s2
})
2.单表达式闭包隐式返回
只有一个表达式时，可以省略 return 关键词
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.参数名称缩写
swift会自动的根据签名，可以将参数移除使用 $0, $1... 来表示，这个和JS中的正则表达式 RegExp.$1... 来表示分组是一个意思
let names = ["chris", "alex", "ewa"]
// 参数列表为 (s1, s2)
var descendingNames =
names.sorted(by: { (s1, s2) in s1 > s2 })
// 使用缩写
var descendingNames =
names.sorted(by: { $0 > $1 })
// 另外 sorted方法实现了运算符重载
// 可以缩写为
var descendingNames =
names.sorted(by: > )
4.尾随闭包
使用尾随闭包是，不用写出它的参数标签：
// 这个函数接收closure函数作为最后一个参数
func someFunc(closure: () -> Void) {
// ...
}
// 不使用尾随表调用
someFunc(closure: {
// ...
})
// 使用尾随闭包
// 可以将其提取出来
someFunc() {
// ...
}
// 这个函数只有一个参数，可以将someFunc后面的括号省略
someFunc {
// ...
}
看着很简洁，但是感觉可读性太差了，可能我需要一段时间适应
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给每个数字加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.闭包是引用类型
使用值捕获来解决这个问题
这个会出现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中也有这个问题：
// 闭包数组
var closureArray: [() -> ()] = []
var i = 0
for _ in 1...5 {
// 将函数添加到数组中
closureArray.append {
print(i)
}
i += 1
}
// 同样的问题
// 因为函数执行的时候 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 {
// 将函数添加到数组中 也称之为 capture list
// 使用数组作为参数
closureArray.append { [i] in
print(i)
}
i += 1
}
// 同样的问题
// 因为函数执行的时候 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
// 不使用引用 而是进行拷贝
var c = 5
var d = 5
let captureList: () -> () = { [c, d] in
print(c, d)
}
captureList()
// 打印 5, 5
c = 20
d = 20
captureList()
// 打印 5, 5 这里值没有发生变化
// 因为上面函数对值进行了捕获，即使后面再改变c,d
// 捕获的值仍然是5， 5
6.逃逸闭包(escaping closure)
对学JS的我感觉有点懵逼，这有篇好文章：
简单列举一下其特点和作用：
- 使用
@escaping关键词来修饰闭包的签名 - 将一个闭包标记为
@escaping意味着必须在闭包中显式的使用sekf - 作用1： 异步调用 如果需要调度队列中异步调用闭包，这个队列会持有闭包的应用
- 作用2：存储，需要存储闭包作为属性，全局变量或其他类型坐稍后使用
示例
// 普通闭包
func normalClosure(closure: () -> Void) {
// 直接调用 调用结束后闭包被销毁
closure()
}
// 逃逸闭包
// 使用一个外部变量将其存储下来
var completionHandlers: [() -> Void] = []
// 使用 @escaping 进行修饰
func escapingClosure(completeHandler: @escaping () -> Void) {
// 将其存储 留作稍后使用
completionHandlers.append(completeHandler)
}
class SomeClass {
var x = 10
func doSomething() {
// 使用尾随闭包的形式调用
normalClosure { x = 200 } // 隐式的使用 self
// 逃逸闭包必须显式的使用 self
escapingClosure { self.x = 100 }
}
}
let instance = SomeClass()
print(instance.x) // 10
instance.doSomething()
// escapingClosure 被存储在completionHandlers 数组中
print(instance.x) // 200
// 稍后再使用
completionHandlers.first?()
print(instance.x) // 100
7.自动闭包 (@autoclosure )
这个用于自动创建闭包，也是一种简写的语法套，用于包装传递给函数作为参数的表达式。
这种闭包不接受任何参数，当被调用的时候回返回被包装在其中的表达式的值，能够省略闭包的花括号，感觉没啥用，可读性不友好
var customersInLine = ["Chris", "Alex", "Ewa", "Barry", "Daniella"]
print(customersInLine.count)
// 打印出 "5"
// 定义函数
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())!")
}
// 调用
serve(customer: { customersInLine.remove(at: 0) } )
// 可以看出 serve 函数的customer参数是一个不接受任何参数的闭包
// 因此可以写成自动闭包的形式
// 使用 @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!"
说实话这语法看着很蛋疼。。。
