查看: 168|回复: 0

[IOS开发教程] 【自问自答】关于 Swift 的几个疑问

发表于 5 天前

感觉自己给自己释疑,也是一个极为有趣的过程。这次,我还新增了“猜想”一栏,来尝试回答一些暂时没有足够资料支撑的问题。

Swift 版本是:4.0.3。不同版本的 Swift,可能无法复现问题。

个人记录,仅供参考,不保证严格意义上的正确性。

swift 中,如何在函数内,声明 static 变量 ? 问题描述:

以下语句,是编译不过的,提示:“static properties may only be declared on a type”

  1. func add() -> Int {
  2. static var base = 0
  3. base += 1
  4. return base
  5. }
  6. add()
  7. add()
  8. add()
复制代码
解决方案:

可以用内嵌类型的 static 属性来解决,如:

  1. func add() -> Int {
  2. struct Temp{
  3. static var base = 0
  4. }
  5. Temp.base += 1
  6. return Temp.base
  7. }
  8. add() // --> 1
  9. add() // --> 2
  10. add() // --> 3
复制代码

参考:https://stackoverflow.com/a/25354915

猜想:

同一作用域的同名内嵌类型,多次执行,只会真正定义一次.

swift 有没有可以进行全局埋点的黑魔法机制? 问题描述:

全局埋点,依赖于 runtime 机制, 所以换种问法就是: swift 中如何继续使用 objc 的runtime 机制.

解决方案:

纯Swift类没有动态性,但在方法、属性前添加dynamic修饰可以获得动态性。

继承自NSObject的Swift类,其继承自父类的方法具有动态性,其他自定义方法、属性需要加dynamic修饰才可以获得动态性。

若方法的参数、属性类型为Swift特有、无法映射到Objective-C的类型(如Character、Tuple),则此方法、属性无法添加dynamic修饰(会编译错误)

参考: http://www.infoq.com/cn/articles/dynamic-analysis-of-runtime-swift

快速验证,可使用:

  1. class A{
  2. @objc dynamic func funcA(){
  3. print("funcA")
  4. }
  5. }
  6. func methodSwizze(cls: AnyClass, originalSelector: Selector, swizzledSelector:Selector){
  7. let originalMethod = class_getInstanceMethod(cls, originalSelector)
  8. let swizzledMethod = class_getInstanceMethod(cls, swizzledSelector)
  9. if let originalMethod = originalMethod, let swizzledMethod = swizzledMethod {
  10. method_exchangeImplementations(originalMethod, swizzledMethod)
  11. }
  12. }
  13. extension A{
  14. @objc dynamic func funcB(){
  15. print("funcB")
  16. }
  17. }
  18. methodSwizze(cls: A.self, originalSelector: #selector(A.funcA), swizzledSelector: #selector(A.funcB))
  19. let a = A()
  20. a.funcB() // --> funcA
  21. a.funcA() // --> funcB
复制代码

注意: swift 4 中, 加 dynamic 的同时,也必须加 @objc -- 即不允许单独加 dynamic 标记.

猜想:

dynamic 是在用性能换灵活性.生产环境下,未来更可能的方案,可能是:

通过协议,约定必须实现的统计相关的方法 --> 通过单元测试,来保证遵循特定统计协议的类型,在特定的时机一定会调用协议规定的统计方法.

extension 中覆盖某个自定义的 framework 中的 open/public class 中的 private 方法,会发生什么事? 问题描述:

模块A:

  1. open class Book: NSObject {
  2. private func funcA(){
  3. print("private funcA")
  4. }
  5. public func callFuncA(){
  6. funcA()
  7. }
  8. }
复制代码

模块B:

  1. public extension Book {
  2. func funcA(){
  3. print("public funcA")
  4. }
  5. }
复制代码

问题:

模块B 中,以下代码的输出是?

  1. let book = Book()
  2. book.funcA() // --> ?
  3. book.callFuncA() // --> ?
复制代码
解决方案:

可以直接运行观察:

  1. let book = Book()
  2. book.funcA() // --> public funcA
  3. book.callFuncA() // --> private funcA
复制代码

所以: 通过 extension 覆盖其他模块open类的private方法,不会有任何诡异的问题.两个实现,都对彼此透明.

更进一步: 模块B以 Optional 方式引入模块A. 如果是在模块B中,通过 extension 覆盖模块A的private 方法.然后在模块 C 中同时引入了模块 A 和 B,此时模块C中类似的函数调用,会是哪个模块的方法实现生效?

  1. let book = Book()
  2. book.funcA() // --> public funcA
  3. book.callFuncA() // --> private funcA
复制代码

可以看到,仍然是模块B中的 public 级别的方法生效.

再进一步,如果模块 A 中的方法,由 private 改为 public,即:

  1. open class Book: NSObject {
  2. public func funcA(){
  3. print("original public funcA")
  4. }
  5. public func callFuncA(){
  6. funcA()
  7. }
  8. }
复制代码

此时模块C 中的调用,会报错:

error: ambiguous use of 'funcA()'
book.funcA()
^
A.Book:2:17: note: found this candidate
public func funcA()
^
B.Book:2:17: note: found this candidate
public func funcA()

如果模块 B 以 Required 方式引入模块A,模块C,只引入模块B,此时的调用结果,会不会有什么不同? --> 然而,并没有什么不同,依然是同样的 ambiguous 错误.

总结一下:

  • 可以安全地在 extension 中覆盖其他模块中open/public类中定义的非 public 方法.对于原有模块,会继续使用自身的非 public 的方法定义;定义其他模块,可以正确使用 extension 版本中的模块代码.

  • 不要尝试在 extension 中定义其他模块中 open/public类中定义的 public 方法.虽然可以定义,但是使用时,会引起 ambiguous 错误.

  • 在使用 extension 扩展其他模块中定义的类时,最好还是给自己扩展的方法加上特定前缀,不然第三方模块万一暴露的同名方法,自己的代码就彻底跪了.

猜想:

扩展第三方模块类时,使用自定义的前缀,总是一个好的习惯.

嵌套定义的类型,如果外层类型是 private, 内层类型是 open,内层类型.那么内层类型有可能在其他模块中被使用吗 ? 问题描述:
  1. open class Book: NSObject {
  2. private class InnerBook{
  3. open class DeeperBook{
  4. }
  5. }
  6. }
复制代码

在另一个 swift 模块中,能使用类似下面的类型初始化代码吗?

  1. var book = Book.InnerBook.DeeperBook()
复制代码
解决方案:

直接调用,会报错:

error: 'InnerBook' is inaccessible due to 'private' protection level

尝试修改为:

  1. open class Book: NSObject {
  2. open class InnerBook{
  3. open class DeeperBook{
  4. }
  5. }
  6. }
复制代码

依然报错:

error: 'Book.InnerBook.DeeperBook' initializer is inaccessible due to 'internal' protection level

根据提示,再修改下 DeeperBook 的初始化方法的访问级别:

  1. open class Book: NSObject {
  2. open class InnerBook{
  3. open class DeeperBook{
  4. public init() {
  5. }
  6. }
  7. }
  8. }
复制代码
猜想:

内嵌类型的方法的访问级别,并不会随着类型本身访问级别的宽松更变得比默认的 internal 更宽松.

疑问: 为什么函数定义外的 closure 不会引起作用域内其他变量引用计数的变化? 问题描述:

仔细观察以下不同代码片段的不同输出:

片段A:

  1. class Book{
  2. let name: String
  3. lazy var whoami:(()->String)? = {
  4. return self.name
  5. }
  6. init(name:String) {
  7. self.name = name
  8. }
  9. deinit {
  10. print("\(name) is being deinitialized")
  11. }
  12. }
  13. var aBook:Book? = Book(name: "风之影")
  14. print(aBook!.whoami!())
  15. aBook = nil
  16. /*
  17. 输出:
  18. 风之影
  19. */
复制代码

片段B:

  1. class Book{
  2. let name: String
  3. lazy var whoami:(()->String)? = {
  4. return self.name
  5. }
  6. init(name:String) {
  7. self.name = name
  8. }
  9. deinit {
  10. print("\(name) is being deinitialized")
  11. }
  12. }
  13. var aBook:Book? = Book(name: "风之影")
  14. print(aBook!.whoami!())
  15. aBook?.whoami = nil
  16. aBook = nil
  17. /*
  18. 输出:
  19. 风之影
  20. 风之影 is being deinitialized
  21. */
复制代码

片段C:

  1. class Book{
  2. let name: String
  3. lazy var whoami:(()->String)? = {
  4. return self.name
  5. }
  6. init(name:String) {
  7. self.name = name
  8. }
  9. deinit {
  10. print("\(name) is being deinitialized")
  11. }
  12. }
  13. var aBook:Book? = Book(name: "风之影")
  14. aBook?.whoami = {
  15. return aBook!.name + " new"
  16. }
  17. print(aBook!.whoami!())
  18. aBook = nil
  19. /*
  20. 输出:
  21. 风之影 new
  22. 风之影 is being deinitialized
  23. */
复制代码

片段A, aBook 内存泄露,经典的 closure self 循环引用问题.

片段B,是 closure self 循环引用的一个可选解决方案,即 self 主动切断对 closure 的引用.

片段C,比较诡异. aBook 引用了一个新的 closure,新的 closure 内又引用了 aBook 一次,但是 aBook 竟然还是可以正确释放,并没有预期中的内存泄露问题.令人费解!?

解决方案:

片段 D:

  1. class Book{
  2. let name: String
  3. lazy var whoami:(()->String)? = {
  4. return self.name
  5. }
  6. init(name:String) {
  7. self.name = name
  8. }
  9. deinit {
  10. print("\(name) is being deinitialized")
  11. }
  12. }
  13. var aBook:Book? = Book(name: "风之影")
  14. aBook?.whoami = {
  15. [aBook] in
  16. return aBook!.name + " new"
  17. }
  18. print(aBook!.whoami!())
  19. aBook = nil
  20. /*
  21. 输出:
  22. 风之影 new
  23. */
复制代码

可以看到,这样 aBook 就会泄露了.片段 D 与 片段 C 的区别在于 closure 中的那句 [aBook] in .这个语法,是我"杜撰"的,语义上近似于以强引用方式捕捉 aBook 对应的真实对象.官方文档中并没有提到有这种语法.

另外,参考 objc 中block 的行为,我尝试搜索相关 swift 中 栈(stack) block 的相关信息.如果 closure 也区分栈和堆,倒是还可以勉强解释.不过,并没有相关的信息,而且 closure 本身也是不支持 copy 操作的.

注意: 当前复现此问题用的是 swift 4.0.3 版本,不同版本中的 closure 的行为可能不一致.

猜想:

或许 swift 中,只有内部有可能直接使用 self 的 closure,才需要特别考虑closure引起的内存泄露问题.

个人猜测,可能是因为 self 比较特殊, closure 只能直接捕捉其真实对象.



回复

使用道具 举报