Swift-闭包

• 闭包是自包含的功能代码块，可以在代码中使用或者用来作为参数传值。
• 在Swift中的闭包与OC中的block类似。

 //闭包的表达式语法
/*
{(parameters) ->(return type) in
    statements
}
*/

//对整数进行排序 sorted 后面就是闭包
let numbers = [1, 5, 9, 6, 2, 3, 4]
let newNumbers = numbers.sorted { (a, b) -> Bool in
    return a > b
}
print(newNumbers)  //结果是 [9, 6, 5, 4, 3, 2, 1]

• 全局函数和嵌套函数其实就是特殊的闭包。

//设置全局方法获取某些值
func kNaviBarHeight() -> Float {
    return 44
}

print(kNaviBarHeight())

• 闭包的形式有：
• （1）全局函数都是闭包，有名字但不能捕获任何值。
• （2）嵌套函数都是闭包，且有名字，也能捕获封闭函数内的值。
• （3）闭包表达式都是无名闭包，使用轻量级语法，可以根据上下文环境捕获值。
• Swift中的闭包有很多优化的地方:
• (1)根据上下文推断参数和返回值类型
• (2)从单行表达式闭包中隐式返回（也就是闭包体只有一行代码，可以省略return）
• (3)可以使用简化参数名，如$0, $1(从0开始，表示第i个参数...)
• (4)提供了尾随闭包语法(Trailing closure syntax)
  */

// 以下闭包以Array的sorted函数为例
let names = ["Chris", "Alex", "Ewa", "Barry", "Daniella"]
func backward(_ str1: String, _ str2: String) -> Bool {
    return str1 > str2
}

// sorted函数的参数是一个闭包，下面传了一个方法名，由此说明：嵌套函数是一个有名字但并可以捕获其封闭函数域内值的闭包
var reversedNames = names.sorted(by: backward)

// 普通闭包格式：(参数: 参数类型,...) -> 返回值类型 in ...
reversedNames = names.sorted(by: { (str1: String, str2: String) -> Bool in
    return str1 > str2
})

// 根据Swift的类型推断，参数类型及参数括号可以去掉，返回值类型可以去掉
reversedNames = names.sorted(by: { str1, str2 in
    return str1 > str2
})

// 单行表达式：可以去掉return
reversedNames = names.sorted(by: {str1, str2 in
    str1 > str2
})

// 使用参数名缩写：参数和in也可以去掉
reversedNames = names.sorted(by: {
    $0 > $1     //$0代表第1个参数， $1 代表第二个参数
})

// 使用运算符：因为Swift中为字符串重载了大于号小于号
reversedNames = names.sorted(by: >)

// 使用尾随闭包：前提是闭包必须是函数的最后一个参数
reversedNames = names.sorted() {$0 < $1}

// 使用尾随闭包：闭包是函数唯一参数时，可以省掉参数括号
reversedNames = names.sorted {$0 < $1}

print(reversedNames)

• 闭包值捕获，闭包是引用类型

//sum 返回值是一个闭包 () -> Int
func sum(amount: Int) -> () -> Int {
    var runningTotal = 0
    func incrementer() -> Int {
        print("runningTotal = \(runningTotal)")
        runningTotal += amount
        return runningTotal
    }
    return incrementer
}

let addByTen = sum(amount: 10)

print("结果 \(addByTen())")
print("结果 \(addByTen())")

//打印结果
/*
runningTotal = 0
结果 10
runningTotal = 10
结果 20
*/
//两次调用incrementer闭包是同一个 runningTotal 被保留下来，所以闭包是引用类型的

• 逃逸闭包和非逃逸闭包
  如果这个闭包是在这个函数结束前内被调用，就是非逃逸的即noescape。
  如果这个闭包是在函数执行完后才被调用，调用的地方超过了这函数的范围，所以叫逃逸闭包。

例如：snapkit的添加约束的方法就是非逃逸的。因为这闭包马上就执行了

public func makeConstraints(_ closure: (_ make: ConstraintMaker) -> Void) {
        ConstraintMaker.makeConstraints(item: self.view, closure: closure)
    }

网络请求请求结束后的回调的闭包则是逃逸的，因为发起请求后过了一段时间后这个闭包才执行。比如这个Alamofire里的处理返回json的completionHandler闭包，就是逃逸的。

 public func response(queue: DispatchQueue? = nil, completionHandler: @escaping (DefaultDataResponse) -> Void) -> Self {
        delegate.queue.addOperation {
            (queue ?? DispatchQueue.main).async {
                var dataResponse = DefaultDataResponse(
                    request: self.request,
                    response: self.response,
                    data: self.delegate.data,
                    error: self.delegate.error,
                    timeline: self.timeline
                )

                dataResponse.add(self.delegate.metrics)

                completionHandler(dataResponse)
            }
        }

        return self
    }

举个例子，写一个模拟一个网络请求，1秒才执行，所以是逃逸闭包。

//此处编译不通过
 func loadRequest(callBack: () -> Void) -> Void {
        DispatchQueue.global().asyncAfter(deadline: DispatchTime.now() + 1) {
            callBack()
        }
    }

//下面是正确的写法
func loadRequest(callBack: @escaping () -> Void) -> Void {
        DispatchQueue.global().asyncAfter(deadline: DispatchTime.now() + 1) {
            callBack()
        }
    }

这样就需要显示的声明@escaping才能编译通过。

AD743289-18E8-43BC-8131-9B0C5D4A50C6.png