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

swift进阶 学习大纲

  1. 闭包
  2. Runtime
  3. Any、AnyObject 、 AnyClass、self、Type 、type(of)

1. 闭包

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

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

测试代码：

  1. 自动捕获变量，会影响外部变量
var age = 10
let closure = {
   age += 1
}
closure()
print(age)
  • 打印结果：
    image.png

    自动捕获了外部变量age，闭包内修改age值，影响了外部age的值
  1. 手动捕获外界变量，值类型对象，会被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

总结

  1. swift闭包会自动捕获外界变量，并影响引用计数，有循环引用风险。
  2. 手动声明捕获变量(写在[ ]内):
    值类型：数据会被copy一份，为只读属性，不受该值的后续变化影响，也不会影响该值。
    引用类型：copy的是对象地址，操作对象地址，会影响对象引用计数，也会影响该对象的内容。有循环引用风险。
  3. 打断循环引用有两种方式：
    [weak弱引用]： 将对象变为可空类型，不强引用对象，对象为nil时，不执行后续语句，很安全。（生命周期跟对象一致）

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

2. Runtime

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

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

  • dynamic在编译时就已完成函数的替换操作，在运行前就处理好了。
  • Mirror反射可以动态获取类型和成员信息，在程序运行时调用方法、属性等行为特性。但没有OCRuntime那么强大
  • 创建一个oc项目：
  1. 创建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!")
            }
        }
    }
}

  1. OC调用的文件中，必须导入XXX-Swift.h头文件。确保桥接文件中，已自动生成OC类、属性和函数。

    image.png

    image.png

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

    image.png

  3. 当我们调用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的原因，是结构相互兼容。

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类型的详细介绍。
最后编辑于 ：
©著作权归作者所有,转载或内容合作请联系作者
【社区内容提示】社区部分内容疑似由AI辅助生成，浏览时请结合常识与多方信息审慎甄别。
平台声明：文章内容（如有图片或视频亦包括在内）由作者上传并发布，文章内容仅代表作者本人观点，简书系信息发布平台，仅提供信息存储服务。

相关阅读更多精彩内容

友情链接更多精彩内容