Swift 属性 & 属性观察者

前言

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

一、Swift属性

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

存储属性
计算属性
延迟存储属性
类型属性

1.1 存储属性

存储属性，分两种：

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

代码验证

输入以下代码

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

let t = LGPerson()

打开终端，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方法

接着我们打断点，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 延迟存储属性

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

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

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

1.3.1 lazy修饰

lazy var weight : Int = 140

1.3.2 默认的初始值

不给默认值，直接出错！

1.3.3 赋值的时机

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

t.weight有值了，是120，地址对应的是0x78（16进制），转换成十进制也是120。由此可见

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

接下来，我们看看中间层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代码分析，我们可以注意到以下几点：

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

1.3.4 线程安全

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

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

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

1.3.5 对象的大小

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

有lazy修饰

无lazy修饰

1.4 类型属性

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

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

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方法中，是不会触发属性观察者的。init中主要是初始化当前变量，除了默认的前16个字节，其他属性会调用memset清理内存空间（因为有可能是脏数据，即之前可能被别人用过），然后才会赋值。

其实，除了 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流程，然后结合几道常见的面试题，对属性观察者做了讲解。