Swift 属性 & 属性观察者

前言

上一篇文章Swift编译流程 & Swift类中分析了swift类的底层结构和大小计算，接下来我们来看看属性。

一、Swift属性

在swift中，属性主要分为以下几种

1. 存储属性
2. 计算属性
3. 延迟存储属性
4. 类型属性

1.1 存储属性

存储属性，分两种：

1. let修饰的常量存储属性
2. var修饰的变量存储属性

代码验证

1. 输入以下代码👇

class LGPerson {
    var age: Int = 18
    var name: String = "luoji"
}

let t = LGPerson()

2. 打开终端，cd到Demo文件夹，输入swiftc -emit-sil xx.swift >> ./xx.sil生成.sil文件。使用VSCode打开，搜索class👇

class LGPerson {
  @_hasStorage @_hasInitialValue var age: Int { get set }
  @_hasStorage @_hasInitialValue var name: String { get set }
  @_hasStorage @_hasInitialValue final let occupation: String { get }
  @objc deinit
  init()
}

我们发现，age 和 name 都是变量存储属性，包含get set方法，而occupation是常量存储属性，只有get方法

3. 接着我们打断点，lldb看看地址是如何分配的👇

上图红框处，两个地址分别为 0x0000000000000012 和 0x000000696a6f756c，就是aged的值18和name的值luoji，而0x0072656863616554就是occupation的值Teacher。

不信，打开mach-O查看可执行文件SwiftTest，如下图👇

1.2 计算属性

计算属性：是指不占用内存空间，本质是set/get方法的属性。添加计算属性height，代码👇

    var height: Int{
        get{
            return age * 10
        }
        set{
            age = newValue/10
        }
    }

run👇

红框处可见，对象t中并没有计算属性height，所以计算属性不占用内存空间。接着，我们打开终端，和之前一样，生成sil文件👇

上图可见，计算属性height确实只包含get/set方法。

1.3 延迟存储属性

延迟属性主要有以下几点说明：

1. 使用lazy修饰的存储属性
2. 延迟属性必须有一个默认的初始值
3. 延迟存储在第一次访问的时候才被赋值
4. 延迟存储属性并不能保证线程安全
5. 延迟存储属性对实例对象大小有影响

下面来一一进行分析延迟存储属性的上述特点。

1.3.1 lazy修饰

lazy var weight : Int = 140

1.3.2 默认的初始值

不给默认值，直接出错！

1.3.3 赋值的时机

上图可知，给t.weight赋值之前，weight是没有值的，为nil，地址是0x0，接着我们给与赋值，再查看👇

懒加载存储属性只有在第一次访问时才会被赋值

接下来，我们看看中间层sil代码，看看底层是如何处理lazy赋值的过程的？
首先，打开终端，输入以下指令👇

swiftc -emit-sil xx.swift | xcrun swift-demangle >> ./xx.sil && vscode xx.sil

其中vscode是自定义的指令，具体操作请参考上一篇文章Swift编译流程 & Swift类，在.zshrc中做配置。

接着我们看看weight的setter和getter流程👇

setter

getter

以上sil代码分析，我们可以注意到以下几点：

1. 在getter方法中，读取lazy weight属性的值时，是Optional可选类型，在没有被访问时，默认是nil，在内存地址就是0x0。
2. 在第一次访问weight时，调用的是属性的getter方法，其内部实现是-->读取值后，对该值进行enum的分支判断，来进行一个赋值操作。

1.3.4 线程安全

继续分析sil代码，主要是查看weight的getter方法，想象以下，假如此时有两个线程：

1. 线程1访问weight，这时weight是没有值的，进入bb2流程；
2. 然后这时又来了个线程2，对于optional的weight来说，依然是none，同样也可以走到bb2流程；

那么在此时，线程1会走一遍赋值，线程2也会走一遍赋值，这样就不能保证weight属性只初始化有且仅有一次了。这就是线程不安全的原因。

1.3.5 对象的大小

我们可以通过class_getInstanceSize来获取对象的大小。现在我们来看看lazy修饰符对大小的影响有多少？👇

有lazy修饰

无lazy修饰

1.4 类型属性

类型属性主要有以下几个特点：

1. 使用关键字static修饰，且是一个全局变量
2. 类型属性必须有一个默认的初始值
3. 类型属性只会被初始化一次

class LGPerson{
    static var age: Int = 18
}
// 调用
var vAge = LGPerson.age

查看sil👇

接着我们看看unsafeMutableAddressor

然后来到@globalinit_029_12232F587A4C5CD8B1EEDF696793B2FC_func0

至此，其实var vAge = LGPerson.age底层的执行过程就是：找到LGPerson的全局类型属性age地址，然后做个初始化过程，再赋值给vAge全局变量。

最后，我们看看age类型属性的setter和getter方法👇

除了研究sil之外，我们也可以打断点查看汇编的执行流程👇

果然，有调用unsafeMutableAddressor，在这一步再打下断点，重新运行，按住control step into进入查看👇

我们发现了swift_once，我们去到swift源码查看👇

swift_once在Apple系统条件下调用的是dispatch_once_f，是否很熟悉，就是单例的底层调用，这也就验证了类型属性只会被初始化一次！

至于线程安全，既然在setter底层流程中调用的是dispatch_once_f，这个函数底层我们之前也研究过，详情可见GCD底层里的单例的底层子章节，dispatch_once_f中使用了_dispatch_once_gate_tryenter保证当前只允许一个线程进入，所以是线程安全的。

最后，我们验证一下不给类型属性初始化值，会怎么样？

编译器直接报错，都不用run运行，所以swift预编译阶段功能十分强大。

二、属性观察者

swift中的 属性观察者，就是willSet(新值存储前)和didSet(新值存储后)。

2.1 示例演示

class LGTeacher{
    var name: String = "luogi"{
        //新值存储之前调用
        willSet{
            print("willSet newValue \(newValue)")
        }
        //新值存储之后调用
        didSet{
            print("didSet oldValue \(oldValue)")
        }
    }
}
var t = LGTeacher()
t.name = "lg"

run👇

2.2 查看sil代码流程

还是和之前一样，先生成sil，然后用VSCode打开，重点看name的setter方法👇

2.3 相关面试题

1. init方法中是否会触发属性观察者？

其实，除了 init方法中不会触发意外，还有一个场景不会触发👇

在定义属性时，给了默认值，并且这个默认值调用了其它的属性。

大家可以自行验证。

2. 哪些地方可以添加属性观察者？

• 类中定义的存储属性
• 通过类继承的存储属性
• 通过类继承的计算属性
  第一种就是上面的示例，第二种是继承的存储属性，例如👇

class LGSeniorTeacher: LGTeacher{
    override var name: String {
        //新值存储之前调用
        willSet{
            print("willSet newValue \(newValue)")
        }
        //新值存储之后调用
        didSet{
            print("didSet oldValue \(oldValue)")
        }
    }
}

第三种继承的计算属性，示例如下👇

class LGTeacher {
    var height: Int = 180
    
    var weight: Int {
        get{
            return (height - 100) * 2
        }
        set{
            self.height = newValue
        }
    }
}

class LGSeniorTeacher: LGTeacher{
    override var height: Int {
        //新值存储之前调用
        willSet{
            print("willSet newValue \(newValue)")
        }
        //新值存储之后调用
        didSet{
            print("didSet oldValue \(oldValue)")
        }
    }
    
    override var weight: Int {
        //新值存储之前调用
        willSet{
            print("willSet newValue \(newValue)")
        }
        //新值存储之后调用
        didSet{
            print("didSet oldValue \(oldValue)")
        }
    }
}

3. 子类和父类的计算属性同时存在didset、willset时，他们的调用顺序是什么样？

上图可知，对于同一个属性，子类和父类都有属性观察者时，其调用顺序是 --> 先子类willset，后父类willset，在父类didset， 子类的didset，即：子父 父子。

4. 子类调用了父类的init，是否会触发观察属性？

class LGTeacher{
    var name: String = "luogi"{
        //新值存储之前调用
        willSet{
            print("父类 willSet newValue \(newValue)")
        }
        //新值存储之后调用
        didSet{
            print("父类 didSet oldValue \(oldValue)")
        }
    }
}

class LGSeniorTeacher: LGTeacher{
    override var name: String {
        //新值存储之前调用
        willSet{
            print("子类 willSet newValue \(newValue)")
        }
        //新值存储之后调用
        didSet{
            print("子类 didSet oldValue \(oldValue)")
        }
    }
    
    override init() {
        super.init()
        self.name = "LG init Senior Teacher"
    }
}

子类覆写了初始化方法，并给属性age赋新值，run👇

//****** 打印结果 ******
子类 willSet newValue LG init Senior Teacher
父类 willSet newValue LG init Senior Teacher
父类 didSet oldValue luogi
子类 didSet oldValue luogi

发现，会触发属性观察者，主要是因为子类调用了父类的init初始化，而初始化流程保证了所有属性都有值（即super.init确保变量初始化完成了），所以可以观察属性了。

总结

本篇文章主要讲解了swift中的4大类属性，从sil中间层代码探究了属性的getter和setter流程，然后结合几道常见的面试题，对属性观察者做了讲解。