swift探索2: swift属性

最新推荐文章于 2024-07-19 20:43:59 发布
最新推荐文章于 2024-07-19 20:43:59 发布
阅读量203 收藏
点赞数
分类专栏： swift探索 文章标签： swift c#
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/changcongcong_ios/article/details/120001439
版权

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

  • 存储属性

  • 计算属性

  • 延迟存储属性

  • 类型属性

存储属性

存储属性，又分两种：

  • 要么是常量存储属性，即let修饰

  • 要么是变量存储属性，即var修饰

定义如下代码

class CJLTeacher{
    var age: Int = 18
    var name: String = "CJL"
}

let t = CJLTeacher()

其中代码中的age、name来说，都是变量存储属性，这一点可以在SIL中体现

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

存储属性特征：会占用占用分配实例对象的内存空间

下面我们同断点调试来验证

  • po t

  • x/8g 内存地址，即HeapObject存储的地址

    图片

    属性-1

    图片

    属性-2

计算属性

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

我们通过一个demo来说明，以下写法正确吗？

class CJLTeacher{
    var age: Int{
        get{
            return 18
        }
        set{
            age = newValue
        }
    }
}

在实际编程中，编译器会报以下警告，其意思是在age的set方法中又调用了age.set

图片

属性-3
然后运行发现崩溃了，原因是age的set方法中调用age.set导致了循环引用，即递归

图片

属性-4

验证：不占内存
对于其不占用内存空间这一特征，我们可以通过以下案例来验证，打印以下类的内存大小

class Square{
    var width: Double = 8.0
    var area: Double{
        get{
            //这里的return可以省略，编译器会自动推导
            return width * width
        }
        set{
            width = sqrt(newValue)
        }
    }
}

print(class_getInstanceSize(Square.self))

//********* 打印结果 *********
24

从结果可以看出类Square的内存大小是24，等于 （metadata + refCounts）类自带16字节 + width（8字节） = 24，是没有加上area的。从这里可以证明 area属性没有占有内存空间。

验证：本质是set/get方法

  • 将main.swift转换为SIL文件：swiftc -emit-sil main.swift >> ./main.sil

  • 查看SIL文件，对于存储属性，有_hasStorage的标识符

class Square {
  @_hasStorage @_hasInitialValue var width: Double { get set }
  var area: Double { get set }
  @objc deinit
  init()
}

  • 对于计算属性，SIL中只有setter、getter方法

    图片

    属性-5

属性观察者（didSet、willSet）

  • willSet：新值存储之前调用 newValue

  • didSet：新值存储之后调用 oldValue

验证

  • 可以通过demo来验证

class CJLTeacher{
    var name: String = "测试"{
        //新值存储之前调用
        willSet{
            print("willSet newValue \(newValue)")
        }
        //新值存储之后调用
        didSet{
            print("didSet oldValue \(oldValue)")
        }
    }
}
var t = CJLTeacher()
t.name = "CJL"

//**********打印结果*********
willSet newValue CJL
didSet oldValue 测试

  • 也可以通过编译来验证，将main.swift编译成mail.sil，在sil文件中找name的set方法

    图片

    属性-6

问题1：init方法中是否会触发属性观察者？
以下代码中，init方法中设置name，是否会触发属性观察者？

class CJLTeacher{
    var name: String = "测试"{
        //新值存储之前调用
        willSet{
            print("willSet newValue \(newValue)")
        }
        //新值存储之后调用
        didSet{
            print("didSet oldValue \(oldValue)")
        }
    }
    
    init() {
        self.name = "CJL"
    }
}

运行结果发现，并没有走willSet、didSet中的打印方法，所以有以下结论：

  • 在init方法中，如果调用属性，是不会触发属性观察者的

  • init中主要是初始化当前变量，除了默认的前16个字节，其他属性会调用memset清理内存空间（因为有可能是脏数据，即被别人用过），然后才会赋值

【总结】：初始化器（即init方法设置）和定义时设置默认值（即在didSet中调用其他属性值）都不会触发

问题2：哪里可以添加属性观察者？

主要有以下三个地方可以添加：

  • 1、类中定义的存储属性

  • 2、通过类继承的存储属性

class CJLMediumTeacher: CJLTeacher{
    override var age: Int{
        //新值存储之前调用
        willSet{
            print("willSet newValue \(newValue)")
        }
        //新值存储之后调用
        didSet{
            print("didSet oldValue \(oldValue)")
        }
    }
}

  • 3、通过类继承的计算属性

class CJLTeacher{
    var age: Int = 18
    
    var age2: Int {
        get{
            return age
        }
        set{
            self.age = newValue
        }
    }
}
var t = CJLTeacher()


class CJLMediumTeacher: CJLTeacher{
    override var age: Int{
        //新值存储之前调用
        willSet{
            print("willSet newValue \(newValue)")
        }
        //新值存储之后调用
        didSet{
            print("didSet oldValue \(oldValue)")
        }
    }
    
    override var age2: Int{
        //新值存储之前调用
        willSet{
            print("willSet newValue \(newValue)")
        }
        //新值存储之后调用
        didSet{
            print("didSet oldValue \(oldValue)")
        }
    }
}

问题3：子类和父类的计算属性同时存在didset、willset时，其调用顺序是什么？

有以下代码，其调用顺序是什么？

class CJLTeacher{
    var age: Int = 18{
        //新值存储之前调用
        willSet{
            print("父类 willSet newValue \(newValue)")
        }
        //新值存储之后调用
        didSet{
            print("父类 didSet oldValue \(oldValue)")
        }
    }
    
    var age2: Int {
        get{
            return age
        }
        set{
            self.age = newValue
        }
    }
}


class CJLMediumTeacher: CJLTeacher{
    override var age: Int{
        //新值存储之前调用
        willSet{
            print("子类 newValue \(newValue)")
        }
        //新值存储之后调用
        didSet{
            print("子类 didSet oldValue \(oldValue)")
        }
    }
    
}

var t = CJLMediumTeacher()
t.age = 20

运行结果如下：

图片

属性-7

结论：对于同一个属性，子类和父类都有属性观察者，其顺序是：先子类willset，后父类willset，在父类didset， 子类的didset，即：子父 父子

问题4：子类调用了父类的init，是否会触发观察属性？

在问题3的基础，修改CJLMediumTeacher类

class CJLMediumTeacher: CJLTeacher{
    override var age: Int{
        //新值存储之前调用
        willSet{
            print("子类 willSet newValue \(newValue)")
        }
        //新值存储之后调用
        didSet{
            print("子类 didSet oldValue \(oldValue)")
        }
    }
    
    override init() {
        super.init()
        self.age = 20
    }
}

//****** 打印结果 ******
子类 willSet newValue 20
父类 willSet newValue 20
父类 didSet oldValue 18
子类 didSet oldValue 18

从打印结果发现，会触发属性观察者，主要是因为子类调用了父类的init，已经初始化过了，而初始化流程保证了所有属性都有值（即super.init确保变量初始化完成了），所以可以观察属性了

延迟属性

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

  • 1、使用lazy修饰的存储属性

  • 2、延迟属性必须有一个默认的初始值

  • 3、延迟存储在第一次访问的时候才被赋值

  • 4、延迟存储属性并不能保证线程安全

  • 5、延迟存储属性对实例对象大小的影响

下面来一一进行分析

1、使用lazy修饰的存储属性

class CJLTeacher{
    lazy var age: Int = 18
}

2、延迟属性必须有一个默认的初始值

如果定义为可选类型，则会报错，如下所示

图片

属性-8

3、延迟存储在第一次访问的时候才被赋值
可以通过调试，来查看实例变量的内存变化

  • age第一次访问前的内存情况：此时的age是没值的，为0x0

    图片

    属性-9

  • age第一次访问后的内存情况：此时age是有值的，为30

    图片

    属性-10


    从而可以验证，懒加载存储属性只有在第一次访问时才会被赋值

我们也可以通过sil文件来查看，这里可以在生成sil文件时，加上还原swift中混淆名称的命令(即xcrun swift-demangle)：swiftc -emit-sil main.swift | xcrun swift-demangle >> ./main.sil && code main.sil，demo代码如下

class CJLTeacher{
    lazy var age: Int = 18
}

var t = CJLTeacher()
t.age = 30

  • 类+main：lazy修饰的存储属性在底层是一个optional类型

    图片

    属性-11

  • setter+getter：从getter方法中可以验证，在第一次访问时，就从没值变成了有值的操作

    图片

    属性-12

通过sil，有以下两点说明：

  • 1、lazy修饰的属性，在底层默认是optional，在没有被访问时，默认是nil，在内存中的表现就是0x0。在第一次访问过程中，调用的是属性的getter方法，其内部实现是通过当前enum的分支，来进行一个赋值操作

  • 2、可选类型是16字节吗？可以通过MemoryLayout打印

    • size：实际大小

    • stride：分配大小（主要是由于内存对齐）

print(MemoryLayout<Optional<Int>>.stride)
print(MemoryLayout<Optional<Int>>.size)

//*********** 打印结果 ***********
16
9

为什么实际大小是9？Optional其本质是一个enum，其中Int占8字节，另一个字节主要用于存储case值（这个后续会详细讲解）

4、延迟存储属性并不能保证线程安全

继续分析3中sil文件，主要是查看age的getter方法，如果此时有两个线程：

  • 线程1此时访问age，其age是没有值的，进入bb2流程

  • 然后时间片将CPU分配给了线程2，对于optional来说，依然是none，同样可以走到bb2流程

  • 所以，在此时，线程1会走一遍赋值，线程2也会走一遍赋值，并不能保证属性只初始化了一次

5、延迟存储属性对实例对象大小的影响
下面来继续看下不使用lazy的内存与使用lazy的内存是否有变化？

  • 不使用lazy修饰的情况，类的内存大小是24

    图片

  • 使用lazy修饰的情况下，类的内存大小是32

从而可以证明，使用lazy和不使用lazy，其实例对象的内存大小是不一样的

类型属性

类型属性，主要有以下几点说明：

  • 1、使用关键字static修饰，且是一个全局变量

  • 2、类型属性必须有一个默认的初始值

  • 3、类型属性只会被初始化一次

1、使用关键字static修饰

class CJLTeacher{
    static var age: Int = 18
}

// **** 使用 ****
var age = CJLTeacher.age

生成SIL文件

  • 查看定义，发现多了一个全局变量，说以，类型属性是一个全局变量

    图片

    属性-15

  • 查看入口函数中age的获取

    图片

    属性-16

  • 查看age的getter方法

    图片

    • 其中 globalinit_029_12232F587A4C5CD8B1EEDF696793B2FC_func0是全局变量初始化函数

    • builtin "once" ，通过断点调试，发现调用的是swift_once，表示属性只初始化一次

  • 源码中搜索swift_once，其内部是通过GCD的dispatch_once_f 单例实现。从这里可以验证上面的第3点

void swift::swift_once(swift_once_t *predicate, void (*fn)(void *),
                       void *context) {
#if defined(__APPLE__)
  dispatch_once_f(predicate, context, fn);
#elif defined(__CYGWIN__)
  _swift_once_f(predicate, context, fn);
#else
  std::call_once(*predicate, [fn, context]() { fn(context); });
#endif
}

2、类型属性必须有一个默认的初始值

如下图所示，如果没有给默认的初始值，会报错

图片

属性-20

所以对于类型属性来说，一是全局变量，只初始化一次，二是线程安全的

单例的创建

//****** Swift单例 ******
class CJLTeacher{
    //1、使用 static + let 创建声明一个实例对象
    static let shareInstance = CJLTeacher.init()
    //2、给当前init添加private访问权限
    private init(){ }
}
//使用(只能通过单例，不能通过init)
var t = CJLTeacher.shareInstance

//****** OC单例 ******
@implementation CJLTeacher
+ (instancetype)shareInstance{
    static CJLTeacher *shareInstance = nil;
    dispatch_once_t onceToken;
    dispatch_once(&onceToken, ^{
        shareInstance = [[CJLTeacher alloc] init];
    });
    return shareInstance;
}
@end

总结

  • 存储属性会占用实例变量的内存空间，且

  • 计算属性不会占用内存空间，其本质是set/get方法

  • 属性观察者

    • willset:新值存储之前调用，先通知子类，再通知父类（因为父类中可能需要做一些额外的操作），即子父

    • didSet：新值存储完成后，先告诉父类，再通知子类（父类的操作优先于子类），即父子

    • 类中的init方法赋值不会触发属性观察

    • 属性可以添加在 类定义的存储属性、继承的存储属性、继承的计算属性中

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

  • 延迟存储属性

    • 使用lazy修饰存储属性，且必须有一个默认值

    • 只有在第一次被访问时才会被赋值，且是线程不安全的

    • 使用lazy和不使用lazy，会对实例对象的内存大小有影响，主要是因为lazy在底层是optional类型，optional的本质是enum，除了存储属性本身的内存大小，还需要一个字节用于存储case

  • 类型属性

    • 使用static + let创建实例变量

    • init方法的访问权限为private

    • 使用static 修饰，且必须有一个默认初始值

    • 是一个全局变量，只会被初始化一次，是线程安全的

    • 用于创建单例对象：

changcongcong_ios
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Swift-DispatchQueue.once
提着裤衩找拖鞋的博客
01-31 742
// https://stackoverflow.com/a/39983813/235297 extension DispatchQueue { private static var _onceTracker = [String]() public class func once(file: String = #file, function: String = #function
Swift 代码调试－善用XCode工具（UI调试，五种断点，预览UIImage...）
Leo的专栏
11-29 7659
原创Blog，转载请注明出处 http://blog.csdn.net/hello_hwc?viewmode=list 我的stackoverflow 工欲善其事，必先利其器，强烈建议新手同学好好研究下XCode这个工具。比如Build Settings，Build Info Rules，Build Parse, Edit Scheme… 前言：这个Swift调试系列分为四篇 图形化界面
Once:Swift 中 Dispatch Once 的替代品
05-29
一次 用于 Swift 的 Dispatch Once 和 pthread_once 的简单线程安全替代品。 Swift 包管理器 更新您的Package.swift以包含以下适当的依赖项： 斯威夫特 5.2+ . package ( name : " Once " , " https://github.com/bscothern/Once.git " , from : " 1.4.0 " ) 斯威夫特 4.0-5.1 . package ( url : " https://github.com/bscothern/Once.git " , from : " 1.3.2 " ) 迦太基用法 将此行包含在您的Cartfile ： github "bscothern/Once" 用法 import Once let once = Once () func foo () {
Swift-总结单例实现的几种方法
ClayGuitar的专栏
04-14 745
Swift实现代理的几种方法1. class AppManager { private static let _sharedInstance = AppManager() class func getSharedInstance() -> AppManager { return _sharedInstance } private
Swift中的dispatch_once 单例模式
weixin_34195364的博客
09-23 96
以下有三种方法实现单例模式，支持懒初始化和线程安全 全局变量 结构 dispatch_once 全局变量: 这里使用了全局变量而非类变量，是因为不支持类变量 private let _SingletonSharedInstance = Singleton() class Singleton { class var sharedInstance : Sing...
Swift中如何安全的创建一个单例
a2025131311的博客
12-12 452
Talk is cheap. Show me the code. class TestShareInstance{ var age:Int static let shareInstane:TestShareInstance = TestShareInstance(age: 3); private init(age:Int){ self.age = age; }; } 说说原理 1. swift在类中，类变量是能够保证线程安全，swift底层，...
Swift-Playgrounds:斯威夫特游乐场
05-26
2. **类型系统**：Swift有强大的类型系统，包括基本类型如整型（Int）、浮点型（Double/Float）、布尔型（Bool）和字符串（String）等。类型推断使得变量在声明时可省略类型。 3. **结构体与枚举**：Swift支持...
swift-experiments:斯威夫特的乐趣
05-25
在Swift编程语言的世界里，"swift-experiments"项目是一个充满乐趣和探索的平台，它源自typedarray.org，旨在展示Swift语言的各种特性和可能性。通过这个项目，开发者可以深入理解Swift的强大之处，同时享受编程带来...
BouncyBall:在Swift探索中发展
03-29
《BouncyBall:在Swift探索中发展》 Swift是一种由Apple公司推出的编程语言，自2014年发布以来，已经迅速成为iOS、macOS、watchOS和tvOS开发的首选语言。它以其简洁的语法、强大的功能和高度的安全性赢得了开发者们...
swift-reflection:Swift 中的简单类反射
06-20
总的来说，Swift的反射功能虽然不如其他动态语言那样强大，但它仍然为开发者提供了探索和操作代码结构的能力。在开发过程中，合理运用反射可以解决一些复杂的问题，但同时也需要注意其潜在的性能影响。在学习和使用...
Swift-Project：尝试新的xcode
02-16
在探索这个项目时，开发者可以学习如何组织Swift代码，理解模块化设计，以及如何使用Swift的协议和扩展来实现多态。此外，还要了解如何使用Xcode的调试工具，如Breakpoint、Console和Profiler，来定位和解决代码中的...
Swift3中dispatch_once废弃的解决办法
热门推荐
享受开发，颠倒银河
09-23 1万+
在Swift中如果想搞类的单例模式,那么在初始化的时候一般会使用just one time执行的方式,我们使用dispatch_once_t配合调用dispatch_once方法,一般的代码如下:static var token: dispatch_once_t = 0 func whatDoYouHear() { print("All of this has happened before
Swift3.0 单例模式实现的几种方法-Dispatch_Once
kidd风的博客
12-26 4978
今天在写项目时，需要使用单例模式，正常我们的思路是使用GCD的dispatch_once这个API来写，然而在swift3.0中，苹果已经废弃了这个方法，不过不用担心，我们可以用别的方式来实现。结合swift语言的特性，总结了以下几种写法: 普通创建法静态创建法struct创建法通过给DIspatchQueue添加扩展实现 注意这里我希望大家除了使用还要会调用该对应的方法
在Swift中使用dispatch_once单例模型
xfxf996的博客
04-22 2047
I'm trying to work out an appropriate singleton model for usage in Swift. 我正在尝试制定一个合适的单例模型以在Swift中使
Swift类型属性底层研究
lcl130的专栏
08-29 1080
类型属性本质上是全局变量;类型属性是懒加载的，通过`dispatch_once_f`进行, 确保只会初始化一次，并且是线程安全的;编译器对类型属性和全局变量添加了内存安全的控制，避免了访问的读写冲突，使代码更加安全......
Swift进阶(一)：类和属性
正在注销账号的博客
12-12 673
1、类 SIL 在底层流程中，OC代码和SWift代码时通过不同的编译器进行编译，然后通过LLVM，生成.o可执行文件，如下所示 OC中通过clang编译器，编译成IR，然后再生成可执行文件.o（即机器码） swift中通过swiftc编译器，编译成IR，然后再生成可执行文件 下面是Swift中的编译流程，其中SIL（Swift Intermediate Language），是Swift编译过程中的中间代码，主要用于进一步分析和优化Swift代码。如下图所示，SIL位于在AST和LLVM IR之间
Swift底层原理探索----属性 & 方法
RUNNING-NIUER的博客
04-13 671
目录 【返回目录】 Swift语言基础----属性属性存储属性计算属性枚举rawValue原理延迟存储属性（Lazy Stored Property）延迟存储属性注意点属性观察器（Property Observer）全局变量、局部变量`inout`的再次研究`inout`的本质总结类型属性（Type Property）类型属性细节单例模式 属性 Swift中跟实例相关的属性可以分为2大类 存储...
Swift中的dispatch_once
iOS开发者-Ziank的总结
03-29 1518
我们都知道，从swift3.0开始，dispatch_once被废弃了，而是开始推荐大家使用全局let变量，懒加载的全局变量或者静态成员来完成，但是在extension中，这些方法都会不太合适，因为extension中不支持添加存储类型的属性。首先尝试的方法，就是使用let增加一个属性，然后发现会报错；接着就想到使用懒加载来进行返回，结果还是报同样的错误...
鸿蒙仓颉语言【泛型generic】
最新发布
m0_70748845的博客
07-19 179
与Java的泛型相比： Java也有泛型特性，它允许在类、接口和方法中使用类型参数来实现代码的重用性和类型安全性。与Swift类似，Java的泛型也可以用于定义参数的类型。例如，Java中的ArrayList可以接受不同类型的元素。泛型特性： 在给定的代码中，泛型被用于定义参数的类型。举例来说，Array和ArrayEvent)>中的Array都是泛型类型，它们可以接受不同类型的参数。
Swift开发进阶：探索iOS SDK
2. **Chapter 2: CoreData: What, Why, and How** - Core Data是苹果提供的一个强大的数据管理框架，本章深入讲解了Core Data的概念、用途和工作原理，让开发者了解如何在iOS应用中有效地存储和管理数据。...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值