一.存储属性

• 存储属性是一个作为特定类和结构体实例一部分的常量或变量.存储属性要么是变量存储属性(由var关键字引入),要么是常量存储属性(由let关键字引入).

class Teacher {
  var age: Int
  var name: String
}

• 比如这里的age和name就是所谓的存储属性,这里需要加以区分的是let和var两者的区别:

• let:用来声明常量,常量的值一旦设置好就不能再被修改.

• var:用来声明变量,变量的值可以在将来设置成不同的值.

• 示例:

class Teacher {
    let age: Int
    var name: String
    init(_ age:Int, _ name:String) {
        self.age = age
        self.name = name
    }
}

struct Student {
    let age: Int
    var name: String
}

WechatIMG45.jpeg

• 23行,由于变量age是let修饰,所以不能对其进行修改

• 25行,由于t实例是let修饰,所以不能对其进行修改

• 28行,由于变量age是let修饰,所以不能对其进行修改

• 33行,由于s是值,又是通过let修饰,所以不能对其进行修改

• 34行,由于s是值,又是通过let修饰,所以不能对其进行修改

• 35行,s是值,又是let修饰,所以不能对其进行修改

• 38行,由于变量age是let修饰,所以不能对其进行修改

• 从SIL角度分析var和let的区别:

var age = 18
/**
* @_hasStorage: 存储属性
* @_hasInitialValue: 已初始化
* var age: Int : 变量名称,变量类型
* {get set} :get和set方法
*/
@_hasStorage @_hasInitialValue var age: Int { get set }

let x = 20
/**
* @_hasStorage: 存储属性
* @_hasInitialValue: 已初始化
* var age: Int : 变量名称,变量类型
* {get} :get方法
*/
@_hasStorage @_hasInitialValue let x: Int { get }

x = 30 // 此时编译器是报错的,因为找不到x的set方法.

/**
* let 和 var 本质上也可以看成是一种语法糖
*/

二.计算属性

• 存储属性是最常见的,除了存储属性, 类,结构体和枚举还能够定义计算属性,计算属性并不存储值,他们提供getter和setter来修改和获取值.对于存储属性来说可以是常量或者变量,但计算属性必须定义为变量.与此同时书写计算属性的时候必须包含类型,因为编译器需要知道期望返回值是什么.

// 函数调用方式为静态派发,不占用内存
struct square {
    var width: Double // 存储属性,实例是需要占据内存的. 8字节.
    
    var area: Double {// 计算属性,本质其实是方法,对于当前Struct来说,不存储方法.
        get {
            return width * width // 此处return可以省略,编译器能够推导出来
        }
        set {
            self.width = newValue // newValue是编译器生成的,查看sil可以看到
        }
    }
}

三.属性观察者

• 属性观察者用来观察属性值的变化,willSet当属性即将被更改时调用,即使这个值与原来的值相同.而didSet在属性已经改变之后调用.他们的语法类似getter和setter.

class SubjectName {
    var subjectName: String = "" {
        willSet {
            print("subjectName will set value \(newValue)")
        }
        didSet {
            print("subjectName has been changed \(oldValue)")
        }
    }
    
    init(subjectNmae: String) {
        self.subjectName = subjectNmae
    }
}

let s = SubjectName(subjectNmae: "Swift进阶")
s.subjectName = "LGQ"

• 注意:使用属性观察器的时候,初始化期间设置属性时不会调用willSet和didSet观察者.只有在为完全初始化的实例分配新值时才会调用它们.运行下面的代码, 你会发现不会有任何的输出.

class SubjectName {
    var subjectName: String = "" {
        willSet {
            print("subjectName will set value \(newValue)")
        }
        didSet {
            print("subjectName has been changed \(oldValue)")
        }
    }
    
    init(subjectNmae: String) {
        self.subjectName = subjectNmae
    }
}

let s = SubjectName(subjectNmae: "Swift进阶")

• 上面的属性观察者支只对存储属性起作用, 如果想对计算属性起作用应该怎么办?很简单,只需将相关代码添加到setter.

struct square {
    var width: Double = 30.0 // 存储属性,实例是需要占据内存的. 8字节.

    var area: Double {// 计算属性,本质其实是方法,对于当前Struct来说,不存储方法.
        get {
            return width * width // 此处return可以省略,编译器能够推导出来
        }
        set {
            // 在这里添加观察代码
            self.width = newValue
        }
    }
    
    init(width: Double) {
        self.width = width
    }

}

• 如下代码重载了age属性,注意age属性赋值顺序:

class Teacher {
    var age: Int {
        willSet {
            print("age will set value \(newValue)")
        }
        didSet {
            print("age has been changed \(oldValue)")
        }
    }
    var height: Double
    
    init(_ age: Int, _ height: Double) {
        self.age = age
        self.height = height
    }
}

class PartTimeTeacher : Teacher {
    override var age: Int {
        willSet {
            print("override age will set value \(newValue)")
        }
        didSet {
            print("override age has been changed \(oldValue)")
        }
    }
    
    var subjectName: String
    
    init(_ subjectName: String) {
        self.subjectName = subjectName
        super.init(18, 100.0) // 调用super方法, 此时已经初始化完成了, 第二次调用会走willSet,didSet方法.
        self.age = 20// 走到这句代码就是赋值操作
    }
}

let t = PartTimeTeacher("Swift")

• 代码运行结果:(此结果可通过sil文件验证)

  
  
  WechatIMG46.png

四.延迟存储属性

• 延迟存储属性的初始值在其第一次使用时才进行计算.
• 用关键字lazy来标识一个延迟存储属性.

class Subject {
    lazy var age: Int = 18
}

/**
* 下面是上面代码生成的sil文件
* 可以看到,age是一个Int?可选类型.这就是在其第一次使用之前没有值的本质
*/
class Subject {
  lazy var age: Int { get set }
  @_hasStorage @_hasInitialValue final var $__lazy_storage_$_age: Int? { get set }
  @objc deinit
  init()
}

五.类型属性

• 类型属性其实就是一个全局变量
• 类型属性只会被初始化一次

class Teacher {
    static var age: Int = 18 // static 关键字标识为 类型属性
}

// 类型属性可以通过类名直接访问
Teacher.age = 30

// 下面是sil中的代码,可以看到在变量age之前加了一个static
class Teacher {
  @_hasStorage @_hasInitialValue static var age: Int { get set }
  @objc deinit
  init()
}

// one-time initialization token for age
sil_global private @$s4main7TeacherC3age_Wz : $Builtin.Word

// static Teacher.age
sil_global hidden @$s4main7TeacherC3ageSivpZ : $Int

// 看一下main函数中调用age的方式
// main
sil @main : $@convention(c) (Int32, UnsafeMutablePointer<Optional<UnsafeMutablePointer<Int8>>>) -> Int32 {
bb0(%0 : $Int32, %1 : $UnsafeMutablePointer<Optional<UnsafeMutablePointer<Int8>>>):
  %2 = metatype $@thick Teacher.Type
  // function_ref Teacher.age.unsafeMutableAddressor
  %3 = function_ref @$s4main7TeacherC3ageSivau : $@convention(thin) () -> Builtin.RawPointer // user: %4
  
 // 全局搜索 s4main7TeacherC3ageSivau 
 // Teacher.age.unsafeMutableAddressor
sil hidden [global_init] @$s4main7TeacherC3ageSivau : $@convention(thin) () -> Builtin.RawPointer {
bb0:
  %0 = global_addr @$s4main7TeacherC3age_Wz : $*Builtin.Word // user: %1
  %1 = address_to_pointer %0 : $*Builtin.Word to $Builtin.RawPointer // user: %3
  // function_ref one-time initialization function for age
  %2 = function_ref @$s4main7TeacherC3age_WZ : $@convention(c) () -> () // user: %3
  %3 = builtin "once"(%1 : $Builtin.RawPointer, %2 : $@convention(c) () -> ()) : $()
  %4 = global_addr @$s4main7TeacherC3ageSivpZ : $*Int // user: %5
  %5 = address_to_pointer %4 : $*Int to $Builtin.RawPointer // user: %6
  return %5 : $Builtin.RawPointer                 // id: %6
} // end sil function '$s4main7TeacherC3ageSivau'
  
// 上面代码 %3 可以看到 builtin "once" , 也就意味着只执行一次.
  
// xcrun swift-demangle s4main7TeacherC3age_WZ 终端执行这句代码可以还原s4main7TeacherC3age_WZ,以便查看它的意义.

• 在Swift中实现单例:

class Teacher {
    static let sharedInstance = Teacher()// static只创建一次, let不可修改,
    
    private init() {}// 私有化初始化器. 外部只能通过sharedInstance访问.
}

六.属性在Macho-O文件的位置信息

• Metadata的元数据结构

struct Metadata{
    var kind: Int
    var superClass: Any.Type
    var cacheData: (Int, Int)
    var data: Int
    var classFlags: Int32
    var instanceAddressPoint: UInt32
    var instanceSize: UInt32
    var instanceAlignmentMask: UInt16
    var reserved: UInt16
    var classSize: UInt32
    var classAddressPoint: UInt32
    var typeDescriptor: UnsafeMutableRawPointer
    var iVarDestroyer: UnsafeRawPointer
}

• typeDescriptor 在Mach-中存在于 _TEXT,swift_types 的section里.
• typeDescriptor,里面记录了V-Table的相关信息,下面认识一下typeDescriptor中的fieldDescriptor

struct TargetClassDescriptor{
    var flags: UInt32
    var parent: UInt32
    var name: Int32 // name即为当前类/结构体/Enum的名称
    var accessFunctionPointer: Int32
    var fieldDescriptor: Int32
    var superClassType: Int32
    var metadataNegativeSizeInWords: UInt32
    var metadataPositiveSizeInWords: UInt32
    var numImmediateMembers: UInt32
    var numFields: UInt32
    var fieldOffsetVectorOffset: UInt32
    var Offset: UInt32
    // == 以下是补充的数据
    var size: UInt32
    // 下面就是函数表
    //V-Table (methods) 
}

• fieldDescriptor记录了当前的属性信息,其中fieldDescriptor在源码的结构如下:

struct FieldDescriptor {
  MangledTypeName int32 // 混写之后的类型名称
  Superclass            int32
  kind                      uint16 // 标识
  FieldRecordSize uint16 // 领域记录大小
  NumFields             uint32 // 属性个数
  FieldRecords      [FieldRecord] // 属性数组,记录每个属性的具体细节
}

• 其中NumFields是当前属性的数组,FieldRecords记录了每个属性的信息,FieldRecords的结构体如下:

struct FieldRecord {
  Flags                         uint32 // 标志位
  MangledTypeName   int32 // 属性的类型信息
  FieldName                 int32 // 属性的名称
}

• 找到typeDescriptor的地址:

  
  
  WechatIMG49.jpeg
• 上图, 0xFFFFFF58 + 0x3F2C = 0x100003E84
• 在减去虚拟地址 0x100000000 = 0x000003E84 就是typeDescriptor在Mach-O的地址.

• 接着定位到__TEXT,_const

  
  
  WechatIMG50.jpeg
• 0x3E84就是TargetClassDescriptor位置偏移信息,flags,parent,name,accessFunctionPointer占4个四字节,
• 所以FieldDescriptor的位置信息就是 0x00000070 + 0x3E94 = 0x3F04

• 注意: 此时0x3F04 在_TEXT,__swift_fieldmd 可以查看FieldDescriptor的相关地址信息

  
  
  WechatIMG51.jpeg
• 要找到FieldRecords , 所以需要偏移 MangledTypeName int32(4字节), Superclass int32(4字节), kind uint16 (2字节), FieldRecordSize uint16(2字节), NumFields uint32(4字节), 一共偏移(4+4+2+2+4) = 16个字节.即上图中0x00000002
• 0x00000002就第一个属性的Flags, 0xFFFFFFE0就是第一个属性的MangledTypeName, 0xFFFFFFDF就是第一个属性的FieldName.
• 0x00000002就是第二个属性的Flags,0xFFFFFFD4就是第二个属性的MangledTypeName,0xFFFFFFD7就是第二个属性的FieldName.
• 0x3F14 + 0x8 + 0xFFFFFFDF = 0x100003EFB , 得到fieldName在mach-O中的文件信息,减去虚拟内存地址 0x100000000 = 0x3EFB
• 此时定位到_TEXT, swift_reflstr文件中:
  
  WechatIMG53.jpeg
• 此时就定位到了属性.