Swift3之闭包

本篇简书地址

Swfit的学习大致有几个重点：
元组，可选型，函数，闭包
这些是较之OC有很大不同的地方，学会了这些swift也算是入门了。

闭包有三种形式：

全局函数 嵌套函数 闭包表达式 有名字但不能捕获任何值。 有名字，也能捕获封闭函数内的值。 无名闭包，使用轻量级语法，可以根据上下文环境捕获值。

捕获值

• 闭包可以在其定义的上下文中捕获常量或变量。 即使定义这些常量和变量的原域已经不存在，闭包仍然可以在闭包函数体内引用和修改这些值。我认为可以理解为捕获增加了原常量或变量的引用计数。
• Swift最简单的闭包形式是嵌套函数，也就是定义在其他函数的函数体内的函数。 嵌套函数可以捕获其外部函数所有的参数以及定义的常量和变量。
  不理解的可以看捕获值

全局函数

什么叫全局函数？全局函数不能捕获值？啥意思呢？一阵懵逼。

let value = 1;func testGlobalFunc(){//这不是捕获了外部的value吗？    print(value);}testGlobalFunc()

我的理解是这样的：
全局函数是定义在类之外的不属于任何类的函数。
写OC的时候常常会用到各种宏定义,但是Swift中没有宏,通常是通过全局常量或者全局函数来实现这一效果.我们只需要建一个文件(假设叫Global.swift),把想用的定义在里面,无须导入头文件什么的,就可以在全局用啦.
在类中实现的函数是成员函数，也就是我们一般说的函数

////  Global.swift////  Created by apple on 2017/6/15.//import Foundationimport UIKit/** *   替代oc中的#define,列举一些常用宏 */let kScreenWidth = UIScreen.main.bounds.size.width// 屏幕的物理宽度func kScreenWidthFun() ->CGFloat{    return kScreenWidth}func kScreenHeighFun() ->CGFloat{    return UIScreen.main.bounds.size.height}


现在就可以直接调用kScreenHeighFun了。这就是全局函数，不需要类或对象调用，就和全局变量kScreenWidth一样
有人会问kScreenWidthFun不是捕获了kScreenWidth吗？我认为全局变量是跟随项目的生命周期的，所以这里只是调用，不能算捕获／。


闭包表达式

语法：
{
(参数) -> 返回值 in
函数实现
}
*这里的参数，可以是inout(输入输出参数)，但不能设定默认值
*元组也可以作为参数或者返回值
*"in"关键字表示闭包的参数和返回值类型定义已经完成，闭包函数体即将开始。即由in引入函数

闭包是一种简化的函数，函数类型由参数和返回值组成
例如：(Int) -> Int就是一个函数类型
闭包类型和函数一样，闭包类型也是这个样子的。
所以:test : (Int) ->(Int);对于变量test可以赋值为一个函数，也可以赋值为一个闭包

//一般形式let add:(Int,Int)->(Int) = {    (a:Int,b:Int) -> Int in    return a + b}print(add(10,5))//Swift可以根据闭包上下文推断参数和返回值的类型，所以上面的例子可以简化如下let add2:(Int,Int)->(Int) = {    a,b in  //省略了返回箭头和参数及返回值类型，以及参数周围的括号。当然你也可以加括号，为了代码的可读性: (a,b) in    return a + b}print(add2(10,5))//Swift 自动为内联函数提供了参数名称缩写功能，您可以直接通过$0,$1,$2来顺序调用闭包的参数。//如果你在闭包表达式中使用参数名称缩写, 您可以在闭包参数列表中省略对其定义, 并且对应参数名称缩写的类型会通过函数类型进行推断。in 关键字同样也可以被省略//一般不建议这样写，可读性太差let add3:(Int,Int) -> Int = {    return $0+$1;//知道要传入两个Int值，所以$0代表第一个参数，$1代表第二个参数}print(add3(10,5));//单行表达式闭包可以隐式返回，如下，省略returnlet add4:(Int,Int)->(Int) = {(a,b) in a + b}print(add4(10,5))//如果闭包没有参数，可以直接省略“in”let add5:()->Int = {return 10 + 5}print(add5())//这个是既没有参数也没返回值，所以把return和in都省略了let add6:()->Void = {print("15")}add6()

//inout参数，不太常用，因为我们直接使用外部值就行，没必要再作为参数传递一下var addValue : Int = 10;let test:(inout Int,Int)->(Int) = {(a,b)  inreturn a + b}print(test(&addValue,5))let test2:(Int,Int)->(Int) = {    (a,b)  in    addValue +=(a + b);    return addValue//能够直接修改addValue没必要使用inout传入}print(test2(10,5))

闭包类型

可以用关键字“typealias”声明一个闭包数据类型。类似于OC中的typedef

typealias AddBlock = (Int, Int) -> (Int)//typedef int (^testBlock)(int,int);//OC中block类型的定义let Add:AddBlock = {    (c,d) in    return c + d}let Result = Add(10,5)print("Result = \(Result)")

尾随闭包

若将闭包作为函数最后一个参数，可以省略参数标签,然后将闭包表达式写在函数调用括号后面。尾随闭包让代码更简洁

func testFunction(testBlock: ()->Void){    //这里需要传进来的闭包类型是无参数和无返回值的    testBlock()}//正常写法testFunction(testBlock: {    print("正常写法")})//尾随闭包写法testFunction(){    print("尾随闭包写法")}//若只有一个闭包参数，也可以把括号去掉，也是尾随闭包写法。推荐写法testFunction {     print("去掉括号的尾随闭包写法")}

逃逸闭包

• 当一个闭包作为参数传到一个函数中，需要这个闭包在函数执行结束之后才被执行，我们就称该闭包从函数中逃逸。一般如果闭包在函数体内涉及到异步操作，但函数却是很快就会执行完毕并返回的，闭包必须要逃逸掉，以便异步操作的回调。
• 逃逸闭包一般用于异步函数的回调，比如网络请求成功的回调和失败的回调。语法：在函数的闭包行参前加关键字“@escaping”。

  //逃逸闭包  //一下函数模仿了网络请求，主线成刷新UI的功能，此时的闭包类似OC中的Block        var comletionHandle: ((String) -> Void) = {            str in            print("逃逸闭包执行完毕")        };        func loadData(completion:@escaping (String)->()) {            print("当前线程\(Thread.current))")            DispatchQueue.global().async {                //异步网络请求//开启一个异步线程                print("当前线程\(Thread.current))")                Thread.sleep(forTimeInterval: 3)                let json = "JSON"                DispatchQueue.main.async {                    //回到了主线程                    print("当前线程\(Thread.current)");                    completion(json)//函数结束后才去调用的闭包这个就是逃逸闭包                }                print("异步线程执行结束")            }            print("loadData函数return")        }//1.传入的闭包参数是定义好的闭包变量        loadData(completion: comletionHandle);/*2.传入的参数是尾随闭包 loadData{//这也是逃逸闭包   str in   print("逃逸闭包执行完毕") };*/

可以看到loadData先return了，此时comletionHandle还没有执行,所以comletionHandle就叫做逃逸闭包，它逃离了loadData的生命周期。

自动闭包

语言解释完全没有看代码理解的快，直接上代码

func test(_ closure: ()-> Bool){    if closure(){        print("the result is true")    }}//1直接调用方法test({ () -> Bool in    return 2 > 1})//2省略参数说明test({ return 2 > 1 })//3:使用尾部闭包方式，闭包体在圆括号之外test(){ return 2 > 1 }//4:在 Swift 中对闭包的用法可以进行一些简化，在这种情况下我们可以省略掉 return，写成：test({ 2 > 1})//5:还可以更近一步，因为这个闭包是最后一个参数，所以可以使用尾随闭包 (trailing closure) 的方式把大括号拿出来，然后省略括号，变成：test{2 > 1}

上面的代码是开始就讲过的，尾随闭包。但是test{2 > 1}总是看起来别扭，因为方法的调用不是 test()这种吗？自动闭包就是实现从{}到()的转变

//////自动闭包autoclosure 标记自动闭包func test(_ closure: @autoclosure ()-> Bool){    if closure(){        print("the result is true")    }}test(2>1)//Swift 将会把 2 > 1 这个表达式自动转换为 () -> Bool。这样我们就得到了一个写法简单，表意清楚的式子。

当闭包作为函数参数时，可以将参数标记 @autoclosure 来接收自动闭包。 @autoclosure 暗含了非逃逸闭包的特性，如果你想让这个自动闭包具有逃逸的特性需要更改标记为 @autoclosure(escaping)。