swift

Swift进阶（三）--- 属性

2020-12-14  本文已影响0人  Jax_YD

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()
}

\color{red}{**存储属性的特征：会占用分配实力对象的内存空间**}
下面我们断点调试一下：

image11.png

二：计算属性

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

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方法

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）

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

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：计算属性不能添加属性观察器

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)

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）

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分支，进行一个赋值操作，赋的是初始值。

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值。

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

五：类型属性（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(){}
}
上一篇下一篇

猜你喜欢

热点阅读