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()
}
下面我们断点调试一下：
- 最明显的可以看到
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()
}
结论：
lazy修饰的属性，底层默认是optional，在没有被访问的时候，默认是nil,在内存中表现为0x0。当第一次访问的时候，调用属性的getter方法，其内部通过enum分支，进行一个赋值操作，赋的是初始值。
-
我们来打印一下
可选型的内存大小会发现一个问题，其实际分配的大小跟非可选型不一样。- size: 实际大小
- stride: 分配大小（会进行内存对齐）
print("非可选型")
print(MemoryLayout<Int>.stride)
print(MemoryLayout<Int>.size)
print("可选型")
print(MemoryLayout<Optional<Int>>.stride)
print(MemoryLayout<Optional<Int>>.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(){}
}
