swift进阶八：闭包 & Runtime & Any等类型

2020-12-17 本文已影响0人 markhetao

swift进阶学习大纲

上一节，我们分析了swfit的引用计数（strong、unwoned、weak）。本节，我们分析:

闭包
Runtime
Any、AnyObject 、 AnyClass、self、Type 、type(of)

1. 闭包

闭包，swift中强大的存在，它类似于OC中的Block。

闭包默认自动捕获外部变量，可直接对捕获变量进行操作，影响捕获变量的值

测试代码：

自动捕获变量，会影响外部变量
var age = 10
let closure = {
   age += 1
}
closure()
print(age)
打印结果：
image.png
自动捕获了外部变量age，闭包内修改age值，影响了外部age的值

手动捕获外界变量，值类型对象，会被copy一份，不可修改，也不影响外部值。
image.png

如果闭包直接持有外部变量，容易造成循环引用。

例如：
class HTPerson {
  var age = 18
  var completion: (()->Void)?
  deinit {
      print("HTPerson deinit")
  }
}

func test() {
   var person = HTPerson()
   person.completion = {
      person.age += 1
   }
}

test()

print("end")
打印结果：

image.png

person 持有completion属性，completion闭包中捕获person这个外部变量，造成循环引用。

swift提供两种方式打破循环:
【方式一】 weak弱引用
weak修饰的对象，不影响强引用计数，不影响对象的释放。对象允许为nil，nil时不执行后续语句。

image.png

【方式二】unowned无主引用

unowned修饰的对象，不影响强引用计数，不影响对象的释放。假定对象一直存在，不能为nil，必须确保捕获对象的生命周期可控（当对象已被释放时，会存在产生野指针，会有crash风险）

image.png

总结

swift闭包会自动捕获外界变量，并影响引用计数，有循环引用风险。

手动声明捕获变量(写在[ ]内):
值类型：数据会被copy一份，为只读属性，不受该值的后续变化影响，也不会影响该值。
引用类型：copy的是对象地址，操作对象地址，会影响对象引用计数，也会影响该对象的内容。有循环引用风险。

打断循环引用有两种方式：
[weak弱引用]：将对象变为可空类型，不强引用对象，对象为nil时，不执行后续语句，很安全。（生命周期跟对象一致）

[unowned无主引用]：假定对象一直存在，不强引用对象，对象不能为nil。必须确保捕获对象的生命周期可控（当对象已被释放时，会存在产生野指针，会有crash风险）

2. Runtime

swift是一门静态语言，本身不具备动态性，不像OC有Runtime运行时的机制（此处指OC提供运行时API供程序员操作）。但由于swift兼容OC，所以可以转成OC类和函数，利用OC的运行时机制，来实现动态性。

与运行时靠边的内容，swift只有dynamic修饰词和Mirror反射机制。

dynamic在编译时就已完成函数的替换操作，在运行前就处理好了。

Mirror反射可以动态获取类型和成员信息，在程序运行时调用方法、属性等行为特性。但没有OCRuntime那么强大

创建一个oc项目：

创建swift类，自动生成桥接文件。class类必须继承自NSObject，所有需要OC调用的函数和方法，都必须使用@objc声明。
class HTPerson: NSObject {
    @objc var age  = 10
    @objc func sayHello() {
        print("sayHello")
    }
}

class HTTool: NSObject {
    
    @objc static func test() {
        
        var methodCount: UInt32 = 0
        let methodList = class_copyMethodList(HTPerson.self, &methodCount)
        for i in 0..<numericCast(methodCount) {
            if let method = methodList?[i] {
                let methodName = method_getName(method)
                print("方法列表：\(String(methodName.description))")
            } else {
                print("not found method!")
            }
        }
       
        var count: UInt32 = 0
        let propertyList = class_copyPropertyList(HTPerson.self, &count)
        for i in 0..<numericCast(count) {
            if let property = propertyList?[i] {
                let propertyName = property_getName(property)
                print("属性列表：\(String(utf8String: propertyName)!)")
            } else {
                print("not found property!")
            }
        }
    }
}
OC调用的文件中，必须导入XXX-Swift.h头文件。确保桥接文件中，已自动生成OC类、属性和函数。

image.png
image.png

被调用时，可以看到我们动态获取到了@objc声明的属性和函数：

image.png

当我们调用swift函数时，打开汇编模式，可以看到已经是使用objc_msgSend进行消息发送了。此时这些@objc修饰的函数和变量，可具备OC的运行时特性。

image.png
image.png

至此，我们已知道swift借助OC实现运行时机制。

进一步探究（ 👉 objc4源码）

我们在objc4源码中搜索class_copyMethodList(，可以把上述案例代码复制在oc源码中，打断点，可以发现cls是Swift类。

image.png

如果进入data()里面，打印superClass，会发现是Swift._SwiftObject

image.png

在OC源码中，有针对swift一一对应的结构关系：

image.png

在Swift源码中，针对Runtime,有专门遵循NSObject协议的SwiftObject基类：

image.png

所以本质上swift能实现OC Runtime的原因，是结构相互兼容。

关于dynamic的介绍，在👉 方法调度 & @objc & 指针有介绍。

3. Any、AnyObject 、 AnyClass、self、Type 、type(of)

AnyObjetc: 代表任意类的Instance、类的类型(class)、仅类遵守的协议。（struct不行）
Any: 代表任意类型，包括function类型或Optional类型
AnyClass: 仅代表实例或类的类型( AnyObject.Type)
T.self: 如果T是实例对象，就返回实例本身。如果T是类，就返回metadata
T.Type: 一种类型，T.self是T.Type类型
type(of:)：用于获取一个值的动态类型

我们通过案例，来深刻理解他们的作用与区别：

3.1 AnyObject

可代表类的Instance实例、类的类型、类遵守的协议。（struct不行）
在开发过程中，如果不确定具体对象类，可使用AnyObject。

class HTPerson {
   var age = 18
}

// 1. 类实例
var p1: AnyObject =  HTPerson()

// 2. 类的类型
var p2: AnyObject = HTPerson.self

// 3. 类遵守的协议 (继承AnyObjec)
protocol JSONMap: AnyObject { }

// 4. struct不是AnyObject类型
// struct报错: [Non-class type 'HTJSON' cannot conform to class protocol 'JSONMap']
// struct HTJSON: JSONMap { }

// 5. 基础类型强转为Class,就属于AnyObject
var age: AnyObject = 10 as NSNumber  // Int不属于AnyObject，强转NSNumber就属于AnyObject

3.2 Any

Any比AnyObject代表的范围更广，不仅支持类实例对象、类类型、类协议。还支持struct、函数以及Optioanl可选类型。

class HTPerson {
   var age = 18
}

// 1. 类实例
var p1: Any =  HTPerson()

// 2. 类的类型
var p2: Any = HTPerson.self

// 3. 类遵守的协议 (继承AnyObjec)
protocol JSONMap: Any { }

// 4. struct
struct HTJSON: JSONMap { }

// 5. 函数
func test() {}

// 6. struct对象
let s = HTJSON()

// 7. 可选类型
let option: HTPerson? = nil

// Any类型的数组
var array: [Any] = [1,                // Int
                   "2",              // String
                   HTPerson.self,    // class类型
                   p1,               // 类的实例对象
                   JSONMap.self,     // 协议本身
                   HTJSON.self,      // struct类型
                   s,                // struct实例对象
                   option,           // 可选值
                   test()            // 函数
                   ]
print(array) 
// 打印结果: [1, "2", Demo.HTPerson, Demo.HTPerson, Demo.JSONMap, Demo.HTJSON, >Demo.HTJSON(), nil, ()]

通过[Any]数组，我们可以看到Any可指代范围有多广。

3.3 AnyClass

AnyClass仅代表类的类型。
虽可接受AnyObject所有对象，但实际只存储了类的类型(通过下面[AnyObject]数组可以观察到这一现象)

class HTPerson {
    var age = 18
}

// 1. 类实例
var p1: AnyObject =  HTPerson()

// 2. 类的类型
var p2: AnyObject = HTPerson.self

// 3. 类遵守的协议 (继承AnyObjec)
protocol JSONMap: AnyObject { }

// 4. struct 不支持
//struct HTJSON: JSONMap { }

class HTTest: JSONMap { }
var p3: JSONMap = HTTest()

// 7. 可选类型
let option: HTPerson? = nil

// Any类型的数组
var array: [AnyObject] = [ HTPerson.self,    // class类型
                           p1,               // 类的实例对象
                           p3                // 遵守AnyObject协议的类对象也符合(类对象本身符合)
                         ]
print(array) // 打印结果:  [Demo.HTPerson, Demo.HTPerson, Demo.HTTest]

3.4 T.self

如果T是实例对象，就返回实例本身。如果T是类，就返回metadata（首地址：类的类型）

class HTPerson {
    var age = 18
}

struct HTTest {
    var name = "ht"
}

// 1. class实例对象，返回对象本身
var p =  HTPerson().self
print(type(of: p))        // 打印： HTPerson（实例对象类型）

// 2. class类型， 返回class类型
var pClass = HTPerson.self
print(type(of: pClass))   // 打印： HTPerson.Type（class类型）

// 3. struct实例对象，返回对象本身
var t = HTTest().self
print(type(of: t))       // 打印： HTTest （实例对象类型）

// 4. struct类型，返回struct类型
var tStruct = HTTest.self
print(type(of: tStruct))  // 打印： HTTest.Type（struct类型）

3.5 T.Type

一种类型，T.self是T.Type类型。(使用type(of:)读取)

class类型的Type

image.png

struct类型的Type

image.png

3.6 type(of:)

用于获取一个值的动态类型

var age = 10

// 编译器任务value接收Any类型
func test(_ value: Any) {
   
   // type(of:)可获取真实类型
   print(type(of: value))    // 打印Int
   
}

test(age)

编译期：value是Any类型，运行时：type(of:)可获取真实类型

image.png
1. 父子类的调用，type(of:)是读取真实调用的对象：

class HTPerson { }

class HTStudent: HTPerson { }

func test(_ value: HTPerson) {
   print(type(of: value)) // 当前真实调用对象
}

var person = HTPerson()
var student = HTStudent()

test(person)  // 打印：HTPerson
test(student)  // 打印：HTStudent

1. 遵循协议的类调用，，type(of:)也是读取真实调用的对象，而不是协议：

protocol TestProtocol { }

class HTPerson: TestProtocol { }

func test(_ value: TestProtocol) {
   print(type(of: value)) // 当前真实调用对象（不是协议）
}

var p = HTPerson()
var p1: TestProtocol = HTPerson()

test(p)   // 打印： HTPerson
test(p1)  // 打印： HTPerson  （注意，不是协议）

补充：当使用泛型T时，调用时，可确定T类型。type(of:)读取的就是T类型：

protocol TestProtocol { }

class HTPerson: TestProtocol { }

func test<T>(_ value: T) {
   print(type(of: value)) // （是协议）   如果需要取到类，可将value强转为Any类型 (value as Any)
}

var p = HTPerson()
var p1: TestProtocol = HTPerson()

test(p)   // 打印： HTPerson
test(p1)  // 打印： TestProtocol  （是协议）

以上，就是swift的闭包、Runtime、Any & AnyObject & AnyClass & Type类型的详细介绍。