Swift闭包

let arr = ["alex","tony","bob"]

内联闭包

let arr0 = arr.sorted(by: { (s1:String,s2:String) -> Bool in
    return s1 < s2
})
print("arr0 = ",arr0)       
//打印结果：arr0 =  ["alex", "bob", "tony"]

根据上下文推断类型 省略()、->、Bool，写成单行表达式：

let arr1 = arr.sorted(by: {s1,s2 in return s1 > s2})
print("arr1 = ",arr1)
//打印结果：arr1 =  ["tony", "bob", "alex"]

单行表达式省略return：

let arr2 = arr.sorted(by: {s1,s2 in s1 < s2})
print("arr2 = ",arr2)
//打印结果：arr2 =  ["alex", "bob", "tony"]

参数名称缩写：

let arr3 = arr.sorted(by: {$0 > $1})
print("arr3 = ",arr3)
//打印结果：arr3 =  ["tony", "bob", "alex"]

运算符方法：

let arr4 = arr.sorted(by: <)
print("arr4 = ",arr4)
//打印结果：arr4 =  ["alex", "bob", "tony"]

尾随闭包

尾随闭包是一个书写在函数括号之后的闭包表达式，函数支持将其作为最后一个参数调用，在使用尾随闭包时，你不用写出他的参数标签。

let arr5 = arr.sorted { (s1, s2) -> Bool in
    s1 > s2
}
print("arr5 = ",arr5)
//打印结果：arr5 =  ["tony", "bob", "alex"]

尾随闭包改写：

let arr6 = arr.sorted() {
    $0 < $1
}
print("arr6 = ",arr6)
//打印结果：arr6 =  ["alex", "bob", "tony"]

如果闭包是函数或者方法的唯一参数，则可以把()省略：

let arr7 = arr.sorted {
    $0 > $1
}
print("arr7 = ",arr7)
//打印结果：arr7 =  ["tony", "bob", "alex"]

捕获值

func makeIncrement(_ increment:Int) -> () -> Int {
    var runningTotal = 0
    func incrementer() -> Int {
        runningTotal += increment
        print(runningTotal)
        return runningTotal
    }
    return incrementer
}
let incrementByTen = makeIncrement(10)
incrementByTen()        //返回的值为10
incrementByTen()        //返回的值为20
incrementByTen()        //返回的值为30

闭包是引用类型：

let alsoIncrementByTen = incrementByTen
alsoIncrementByTen()        //返回的值为40

逃逸闭包

当一个闭包作为参数传到一个函数中，但是这个闭包在函数返回之后才被执行，称为该闭包从函数“逃逸”。当你定义接受闭包作为参数的函数时，你可以在参数名之前标注@escaping，用来指明这个闭包是允许“逃逸”出这个函数的。例如：

var completionHandlers : [() -> Void] = []
func someFunc(completionHandler:@escaping () -> Void) {
    completionHandlers.append(completionHandler)
}
func funcA() {
    print("abc")
}
someFunc(completionHandler: funcA)        //此时funcA还未执行
completionHandlers.first?()               //打印"abc"