Swift进阶（三）--- 属性

Swift的属性

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

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

一：存储属性

存储属性分为两种
1、用let修饰的 --- 常量存储属性
2、用var修饰的 --- 变量存储属性
定义如下：

class SuperMan{
    var age: Int = 18
    var name: String = "Aaron"
}
let t = SuperMan()

代码中age、name都是变量存储属性，我们通过SIL来观察一下(对查看SIL文件有疑问的同学可以参考Swift进阶（一）--- 源码编译):

class SuperMan {
//_hasStorage 表示的是存储属性
  @_hasStorage @_hasInitialValue var age: Int { get set }
  @_hasStorage @_hasInitialValue var name: String { get set }
  @objc deinit
  init()
}

下面我们断点调试一下：

image11.png

• 最明显的可以看到age = 18存储在实例对象的内存空间里面
• 如果对此处x/8g打印出的其他值不明白，可以查看 Swift进阶（二）--- 类，对象，这里就不做过多赘述。

二：计算属性

计算属性：指不占用内存空间，本质是set/get方法的属性

• 定义计算属性只能用var，不能用 let
• 计算属性的值是可能发生变化的（即使是只读计算属性）
  下面我们来验证一下：

class SuperMan{
    var age: Double = 18
    var nominalAge: Double {
        get {
            return age + 1
        }
        set {
            age = sqrt(newValue) - 1
        }
    }
}
print(class_getInstanceSize(SuperMan.self))
/************* 输出结果 **************/
24

从上面的结果，可以看出来：SuperMan的内存大小是24。正好是 metadata + refCounts + age == 24。因此说明nominalAge属性没有占用内存空间

接着我们验证：为什么本质是set/get方法

• 下面我们通过SIL文件来观察一下：

class SuperMan {
  @_hasStorage @_hasInitialValue var age: Double { get set }
  var nominalAge: Double { get set }
  @objc deinit
  init()
}

可以看到，nominalAge没有我们上面提到的_hasStorage标识符。

计算属性中，可以给set定义参数名，表示新值

var age:Int {
        get {
            10
        }
        set (newAge) {
        }
    }

只读计算属性：只有get，没有set

var age:Int {
        get {
            10
        }
    }

三：属性观察器（Property Observer）

• willSet: 新值存储之前调用newValue
• didSet: 新值存储之后调用oldValue
  同样的我们来验证一下：

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

var man = SuperMan()
man.name = "Jarvis"
/*********** 打印结果 ************/
willSet newValue: Jarvis
didSet oldValue: Aaron

• 在这里需要注意一点：init函数不会触发属性观察器。如下文代码，在init函数里面去修改name，并没有触发属性观察器
  注意：init中主要是初始化当前变量，除了默认的前16个字节，其他属性会调用memset清理内存空间（因为有可能存在脏数据，内存地址被别人用过），然后才会赋值。

class SuperMan {
    var name: String = "Aaron" {
        //新值存储之前调用
        willSet {
            print("willSet newValue: \(newValue)")
        }
        //新值存储之后调用
        didSet {
            print("didSet oldValue: \(oldValue)")
        }
    }
    
    init() {
        name = "Jarvis"
    }
}

var man = SuperMan()
print(man.name)
/*********  输出结果 *********/
Jarvis

结论：
1：在初始化器init方法中设置属性，不会触发属性观察器。
另外，
2：在属性定义的时候设置初始值也不会触发属性观察器，有兴趣的同学可以自己尝试一下。
3：可以给非lazy的var存储属性设置属性观察器。如果给lazy修饰的属性添加属性观察器，则会在初始化的时候直接触发属性观察器。
4：计算属性不能添加属性观察器

• 属性观察器可以在那些地方使用呢？
  1、父类中定义的存储属性
  2、子类继承的存储属性
  3、子类继承的计算属性
  4、可以用在全局变量身上 或者 局部变量身上
  • 讲到这里，就有一个问题，既然子类继承的存储属性，可以添加属性观察器，那么，如果父类里面已经添加了属性观察器，此时属性观察器的调用顺序是什么？
    下面我们用代码来观察一下：

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

class SuperChild: SuperMan {
    override var name: String {
        willSet {
            print("SuperChild willSet newValue: \(newValue)")
        }
        didSet {
            print("SuperChild didSet oldValue: \(oldValue)")
        }
    }
    
}

var child = SuperChild()
child.name = "Jarvis"
/*****************  输出结果 ***************/
SuperChild willSet newValue: Jarvis
SuperMan willSet newValue: Jarvis
SuperMan didSet oldValue: Aaron
SuperChild didSet oldValue: Aaron

结论：当父类与子类同时对一个存储属性添加属性观察器的时候，则调用顺序是：子类(willSet) --> 父类(willSet) --> 父类(didSet) --> 子类(didSet)

• 子类调用父类的init方法，会不会触发属性观察器

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

class SuperChild: SuperMan {
    override var name: String {
        willSet {
            print("SuperChild willSet newValue: \(newValue)")
        }
        didSet {
            print("SuperChild didSet oldValue: \(oldValue)")
        }
    }
    override init() {
        super.init()
        self.name = "Jarvis"
    }
}

var child = SuperChild()
/*****************  输出结果 ***************/
SuperChild willSet newValue: Jarvis
SuperMan willSet newValue: Jarvis
SuperMan didSet oldValue: Aaron
SuperChild didSet oldValue: Aaron

结论：可以看到，子类调用父类的init方法后，再在初始化方法中给属性赋值，是可以触发属性观察器的。
因为子类调用父类的init方法后,就已经做了初始化，而初始化流程保证了所有的属性都要值，所以可以观察属性了。(注意：这里触发的观察的属性是父类里面的属性，子类自有的属性，并不会被观察)

四：延迟存储属性（Lazy Stored Property）

• lazy属性必须是var，不能是let
  

  image0.png

• let必须在实例的初始化方法完成之前就拥有值

• 如果多条线程同时第一次访问lazy属性，无法保证属性只被初始化一次

• 延迟存储属性必须有一个默认的初始值，否则就会报错。如下所示：

  
  
  image.png

• 使用lazy可以定义一个延迟存储属性，在第一次用到属性的时候才会进行初始化
  

  image1.png
  
  可以看到，在p.age = 30赋值之前，p.age == 0
  下面我们通过SIL文件来查看一下第一次调用延时属性，程序究竟做了什么？

class Person {
  lazy var age: Int { get set }
  @_hasStorage @_hasInitialValue final var $__lazy_storage_$_age: Int? { get set }
  @objc deinit
  init()
}

image2.png

结论：lazy修饰的属性，底层默认是optional，在没有被访问的时候，默认是nil,在内存中表现为0x0。当第一次访问的时候，调用属性的getter方法，其内部通过enum分支，进行一个赋值操作，赋的是初始值。

• 我们来打印一下可选型的内存大小会发现一个问题，其实际分配的大小跟非可选型不一样。
  • size: 实际大小
  • stride: 分配大小（会进行内存对齐）

print("非可选型")
print(MemoryLayout.stride)
print(MemoryLayout.size)
print("可选型")
print(MemoryLayout>.stride)
print(MemoryLayout>.size)
/********** 打印结果 **********/
非可选型
8
8
可选型
16
9

可以看出，可选型的实际大小比非可选型多了一个字节。多的这一个字节，存储的是case值。

• 延迟存储属性对实例对象大小的影响
  1、使用lazy修饰
  
  image3.png
  
  2、不使用lazy修饰
  
  image4.png

可以看出，lazy对实例对象的内存大小是有影响的，主要还是上面讲的，可选类型的属性多存储了一个case，内存对齐之后，内存大小就变化了。

• 当 结构体 中含有一个延迟存储属性时，只能用var才能访问延迟存储属性
  因为延迟存储属性初始化的时候，修改了结构体的内存
  
  image5.png

五：类型属性（Type Property）: 只能通过类型去访问

1、使用关键字static修饰，且是一个全局变量，整个程序运行过程中只有一份内存。
2、如果是class，也可以使用class关键字修饰。
3、不同于存储实例属性，你必须给存储类型属性设定初始值；因为类型没有像实例那样的init初始化器来初始化存储属性。
4、存储类型属性默认就是lazy，会在第一次使用的时候才初始化。
5、就算被多个线程同时访问，也能保证只会初始化一次。
6、存储类型属性可以是let。
7、枚举类型也可以定义类型属性(存储类型属性、计算类型属性)。

六：单例模式

/****** 样式1 *****/
public class FileManager {
    //1、使用 static + let 创建声明一个实例对象
    public static let sharedInstance = FileManager()
    //2、给当前init添加private访问权限
    private init(){}
}
/****** 样式2 *****/
public class FileManager {
    //1、使用 static + let 创建声明一个实例对象
    public static let sharedInstance = {
        ///可以添加一些必要的代码
        //....
        //....
        return FileManager()
    }
    //2、给当前init添加private访问权限
    private init(){}
}