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 Foundation
import 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));

//单行表达式闭包可以隐式返回，如下，省略return
let 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)  in
return 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()这种吗？自动闭包就是实现把test{}转变成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)。