1. 函数类型
之前在代码的书写过程中，我们已经或多或少的接触过函数，函数本身也有自己的类型，它由形式参数类型，返回类型组成。如果将函数传递给a变量，那么就可以借助a来调用方法,这里addTwoInts代表函数类型。如果出现了同名函数，但是返回值或者参数不一样，那么就需要指明函数类型。否则就会报 ambiguous user of *** 错误，因为这个时候编译器不知道要给a赋值哪一个参数。把函数赋值给a，那么a里面储存的是什么呢？
func addTwoInts(_ a: Int, _ b: Int) -> Int { return a + b
}
var a = addTwoInts
a(10,20)
func addTwoInts(_ a: Double, _ b: Double) -> Double { return a + b
}
func addTwoInts(_ a: Int, _ b: Int) -> Int { return a + b
}
var a: (Double, Double) -> Double = addTwoInts
a(10, 20)
var b = a
b(20 ,30)
运行后打印a，这里看懂存储的是函数类型.这里函数类型也是引用类型，当把函数赋值给a的时候，就把函数的metadata赋值给了a.
这里打印b，看到了存储的信息是一样的，证明了函数类型是引用类型。
到源码中查看函数的metadata，之前的学习中可以知道，直接搜索名字functiontype，就找到了函数在源码中的结构体。看到其继承自TargetMetadata，那么就会有kind，也就是oc中的isa。其次还有flags。
flags的类型点进去可以看到看到这里有enum，这些关键字标注了函数的类型。
函数类型里面还有一个ResultType，也就是返回值类型。最后就是参数了，这里看到是用连续的内存空间存放参数，读取参数是用getParameters方法读取。
模仿出function的结构体，这里flags与上掩码可以得到有多少个参数。
那么这里就可以使用unsafeBitCast将函数转换为TargetFunctionTypeMetadata结构体，然后调用numberArguments方法看到有几个参数了。
2. 闭包
闭包是一个捕获了上下文的常量或者是变量的函数，即使常量或者变量的作用域已经不在，闭包仍然可以修改他们。当每次修改捕获值的时候，其实是修改堆区的值。闭包中没有block哪有全局，堆，栈的概念了。
在函数makeIncrementer里面定一个函数incrementer，incrementer里面使用了外部函数的变量runningTotal。当调用makeIncrementer() 复制给a的时候
，明显的可以知道incrementer的生命周期比makeIncrementer要长，而runningTotal是属于外部函数的变量，外部函数返回之后，外部函数就消失了，而内部函数要想使用runningTotal，那么就必须把runningTotal捕获到incrementer的内部，这样才能在使用incrementer的使用，正确使用runningTotal的值，incrementer和匹配的runningTotal的变量，构成了闭包。
func makeIncrementer() -> () -> Int {
var runningTotal = 10
func incrementer() -> Int {
runningTotal += 1
return runningTotal
}
return incrementer
}
var a = makeIncrementer()
闭包表达式
{ (param) -> (returnType) in //do something
}
OC 中的 Block 其实是一个匿名函数，闭包也可以当成是匿名函数，而这个表达式要具备
- 作用域(也就是大括号)
- 参数和返回值
- 函数体(in)之后的代码
Swift 中的闭包即可以当做变量，也可以当做参数传递，这里我们来看一下下面的例子熟悉一 下:
var closure : (Int) -> Int = { (age: Int) in return age}
同样的我们也可以把我们的闭包声明一个可选类型:
//错误的写法
var closure : (Int) -> Int? closure = nil
//正确的写法
var closure : ((Int) -> Int)? closure = nil
还可以通过 let 关键字将闭包声明位一个常量(也就意味着一旦赋值之后就不能改变了)
let closure: (Int) -> Int
closure = {(age: Int) in return age
}
closure = {(age: Int) in return age
}
同时也可以作为函数的参数
unc test(param : () -> Int){ print(param())
}
var age = 10
test { () -> Int inage += 1
return age }
3. 尾随闭包
当我们把闭包表达式作为函数的最后一个参数，如果当前的闭包表达式很?，我们可以通过尾随闭包的书写方式来提高代码的可读性。
func test(_ a: Int, _ b: Int, _ c: Int, by: (_ item1: Int, _ item2: Int, _ item3: Int) -> Bool) -> Bool {
return by(a, b, c)
}
///原结构
test(10, 20, 30, by: {(_ item1: Int, _ item2: Int, _ item3: Int) -> Bool in
return (item1 + item2 < item3)
})
///后置闭包结构
test(10, 20, 30) {
}
其中闭包表达式是 Swift 语法。使用闭包表达式能更简洁的传达信息。当然闭包表达式的好处 有很多:
- 利用上下文推断参数和返回值类型
- 单表达式可以隐士返回，既省略 return 关键字
- 参数名称的简写(比如我们的 $0)
- 尾随闭包表达式
var array = [1, 2, 3]
array.sort(by: {(item1 : Int, item2: Int) -> Bool in return item1 < item2 } array.sort(by: {(item1, item2) -> Bool in return item1 < item2 }) array.sort(by: {(item1, item2) in return item1 < item2 }) array.sort{(item1, item2) in item1 < item2 }
array.sort{ return $0 < $1 }
array.sort{ $0 < $1 }
array.sort(by: <)
4. 捕获值
回顾一下oc中的捕获值,这里会打印2，1，2，对于block来说，这里会当作自己的变量，捕获i瞬时的值，这个时候外面对i进行改变，不会改变block中的值。如果用 __block修饰，那么就会改变block中变量的值了，这个时候就会打印2，2，2.
- (void)testBlock{
NSInteger i = 1;
void(^block)(void) = ^{
NSLog(@"block %ld:", i);
};
i += 1;
NSLog(@"before block %ld:", i);
block();
NSLog(@"after block %ld:", i);
}
而对于闭包来说，这里就会打印2，2，2了。这里闭包和block不一样，在闭包中遇到i变量，这里是全局变量，那么闭包就会直接去取i的地址，拿到i的值。如果是在函数中，也就是局部变量，那么就会把变量捕获到堆区中,并且变量会成为closure的一部分。而对于引用类型来说，就直接把其在堆区的地址存放到闭包的数据结构里面。
下面会打印11，12，13，这里相当于操作同一个对象。
func makeIncrementer() -> () -> Int {
var runningTotal = 10
func incrementer() -> Int {
runningTotal += 1
return runningTotal
}
return incrementer
}
let makeInc = makeIncrementer()
print(makeInc())
print(makeInc())
print(makeInc())
而这里打印的则都是11了，因为这里相当于每次创建一个新的实例对象。
func makeIncrementer() -> () -> Int {
var runningTotal = 10
func incrementer() -> Int {
runningTotal += 1
return runningTotal
}
return incrementer
}
let makeInc = makeIncrementer()
print(makeIncrementer()())
print(makeIncrementer()())
print(makeIncrementer()())
5. 闭包本质
- 1、捕获值原理：在堆上开辟内存空间，并将捕获的值放到这个内存空间里
- 2、修改捕获值时：实质是修改堆空间的值
- 3、闭包是一个引用类型（引用类型是地址传递），闭包的底层结构（是结构体：闭包执行地址 + 捕获变量堆空间的地址 == 闭包）
- 4、函数也是一个引用类型（本质是一个结构体，其中只保存了函数的地址）。
6. OC Block 和 Swift闭包相互调用
我们在OC中定义的Block，在Swift中是如何调用的呢？
typedef void(^ResultBlock)(NSError *error);
@interface LSTest : NSObject
+ (void)testBlockCall:(ResultBlock)block;
@end
@implementation LSTest
+ (void)testBlockCall:(ResultBlock)block {
NSError *error = [NSError errorWithDomain:NSURLErrorDomain code:400 userInfo:nil];
block(error);
}
@end
在 Swift 中我们可以这么使用
LSTest.testBlockCall { error in
let errorcast = error as NSError
print(errorcast)
}
func test(_ block: ResultBlock) {
let error = NSError.init(domain: NSURLErrorDomain, code: 400, userInfo: nil)
block(error)
}
比如我们在 Swift里这么定义，在OC中也是可以使用的
class LSTeacher: NSObject {
@objc static var closure: (() -> ())?
}
+ (void)test {
LSTeacher.closure = ^{
NSLog(@"end");
};
}
7. defer
defer {} 里的代码会在当前代码块返回之后执行，无论当前代码块是从哪个分支 return 的，即使程序抛出错误，也会执行。如果多个 defer 语句出现在同一作用域中，则它们出现的顺序与它们执行的顺序相反，也就是 先出现的后执行。那么defer有什么作用呢？defer一般用来关闭数据库/文件来使用，当打开了数据库或者文件，我们需要及时的关掉它，而等一个方法里面的逻辑代码太多，就需要用到defer来关闭数据库/文件。
有一点需要注意的是，如果有guard的话，应该将defer写在guard前面，否则defer不会执行。
8.逃逸闭包
逃逸闭包的定义:当闭包作为一个实际参数传递给一个函数的时候，并且是在函数返回之后调 用，我们就说这个闭包逃逸了。当我们声明一个接受闭包作为形式参数的函数时，你可以在形式 参数前写 @escaping 来明确闭包是允许逃逸的。逃逸闭包的三个条件
- 作为函数的参数传递
- 当前闭包在函数内部异步执行或者被存储
- 函数结束，闭包被调用，生命周期结束
一般逃逸闭包有2种情况
- 当闭包被当作属性存储，导致函数完成时闭包生命周期被延长
- 异步执行网络请求
非逃逸闭包优点 - 不会产生循环引用，函数作用域内释放
- 编译器更多性能优化 (retain， relsase)
- 上下文的内存保存再栈上，不是堆上
9. 自动闭包
自动闭包是一种用来把实际参数传递给函数表达式打包的闭包，不接受任何实际参数，当其调用时，返回内部表达式的值。用普通表达式代替闭包的写法，语法糖的一种。使用了自动闭包之后，那么就可以传入一个string或者是一个闭包。这里如果传入string就相当于把string用一个闭包包裹起来。
func debugOutPrint(_ condition: Bool , _ message: @autoclosure () -> String){
if condition {
print("debug:(message())")
}
}
debugOutPrint(true,getResult() )
debugOutPrint(true, getResult )
func getResult()->String{
return "Application Error Occured"
}