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)。
