Lab.Lawliet

不用加减乘除做加法

Thu, 23 Jan 2025 00:00:00 GMT

一、题目

写一个函数，求两个整数之和，要求在函数体内不得使用 “+”、“-”、“*”、“/” 四则运算符号。

示例:

输入: a = 1, b = 1

输出: 2 提示：

a, b 均可能是负数或 0

结果不会溢出 32 位整数

来源：力扣（LeetCode）

链接：https://leetcode-cn.com/problems/bu-yong-jia-jian-cheng-chu-zuo-jia-fa-lcof

著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

二、解法

组件化

Thu, 23 Jan 2025 00:00:00 GMT

一、 CTMediator

二、 BeeHive

iOS独立开发者注册公司到App备案上架

Fri, 13 Oct 2023 00:00:00 GMT

一、背景

根据工业和信息化部发布的《工业和信息化部关于开展移动互联网应用程序备案工作的通知》要求，为进一步贯彻落实《中华人民共和国反电信网络诈骗法》《互联网信息服务管理办法》（国务院令第292号）等一系列法律法规要求，开发者需要积极配合相关部门做好移动 APP 备案工作，共促互联网行业健康可持续发展。

作为一名苦逼的 iOS 独立开发者，也要积极响应相关规定。经历了游戏版号、广告平台需要公司才能介入变现到现在的 APP 备案，感受到了行业的正规军化一个趋势。

自己其实也想了很久注册一个公司来做独立开发，但是一直以来都是用爱发电，几乎每年开发账号的 $99 都是搭进去收不回来的。就一直没有做。

去年底到现在情况好了很多，虽挣不到什么大钱，但开发账号和注册维持公司的成本开销现在看来并不大。

从八月中旬开始注册公司到现在10月13日 APP 备案号下来，虽然遇到一些小问题，但整体还是挺顺利的。也是时候将自己从注册公司到完成APP备案的完整路径记录分享一下了。相信对于和我处境相同的独立开发者或者是未来的独立开发者会有些许帮助。

个人身份备案不在讨论范围内，因为我没试过，有实践的同学也欢迎分享交流。

二、个人注册公司

这步比较简单，问了几个朋友都是第三方代理注册公司并记账的，我也就一样了，这里就不打广告了，想具体了解可以加我微信。

总之就是花钱解决。

三、网站备案

3.1 购买服务器

我是在阿里云买了轻量应用服务器，放了一个静态网站上去作为官网。按需选择自己需要的配置就行。这时网站还没有域名可以访问。

后面的流程也都在阿里云进行，其他服务商应该流程差不多

3.2 企业信息

有两种，个人、企业。为了所有流程身份的一致性，我选择了企业。要在拿到营业执照和所有印章后进行材料提交，需要上传相关实物照片。

3.3 购买域名

购买域名的时候需要选择绑定身份，个人或者企业，这里就可以选择已经认证通过的企业信息了。

3.4 域名备案、解析

先不要配置解析，配置了没备案也解析不了。去做备案还得先解除解析。

备案主体就选择上面已经认证过的企业信息，IP 就填你的网站的 IP。

首先阿里云会对资料进行初审，通过后会有客服电话打过来，告诉你初审通过了，会问你一下身份信息，然后告诉你会有个短信验证。收到后按短信内容去工信部网站验证即可。

短信验证完就到工信部审核了，这个时间会长点儿，我的5天就下来了。

然后在网站主页添加备案号并且点击跳转工信部网站即可。

再到后台配置一下域名解析。

3.5 企业邮箱（有坑）

开发账号转企业会用到，必须弄一个，记得和官网域名一致。

注意有坑！这里体现出了阿里云的鸡贼：

进入企业邮箱第一眼以为没有免费的！结果藏在这里：阿里云免费企业邮箱申请入口链接（2023新版申请流程）

四、苹果个人开发账号转公司账号

4.1 邓白氏码

如果你按照上面的流程进行的话到这步，那么你的材料就是齐全的。

怎么申请邓白氏，这里就不多言了，搜索一下就有了。

我在企业注册成功，但是公司相关物料还没寄到的情况下就申请了邓白氏，然后告诉我一个时间节点在邓白氏网站完成资料上传。但是我没有，第一次申请就这样浪费了。

这里还需要下载一份文档打印出来盖上公章，拍照上传。

后面材料到了再提申请了一次就顺利通过了，拿到邓白氏码了。

4.2 个人转企业账号

到开发者官网，

点击这里开始相关流程。

官网地址、官网域名的企业邮箱等资料提交后，一定注意邮件，会有一封邮件让你主动联系他们，然后会有电话打过来，如下图：

电话里会问你一些问题：

企业名称
核对你的信息
你在公司的职位
- 法人不是职位，说开发者就行
公司另一个人的信息，以及邮箱
- 邮箱不限制是企业邮箱

就记得这么多，电话来的就挺快挺突然的

然后就挺快的当天就好了，商店里开发者名字晚些也变成企业名字了。

五、 APP 备案

当然我也是在阿里云进行的，和域名备案一样都在 ICP 备案里。

下面是需要的资料：

5.1 APP 信息

云服务选择 轻量应用服务器，就是我买的那个服务器
- 选择其他选项后面项目会不一样
- 选择这个后只需要补充选择一下的 IP 地址
备注
- 填写 App Store 的链接
  - 应用详情点击分享复制链接就有了
  - 或者长按从 App Store 下载的包，点击分享也有
- 可以补充上 APP 是干嘛的
  - 初审通过的电话里客服也有问我 APP 是干嘛的，然后我在资料里的备注里加上了相关说明
APP 全部后台服务域名
- 我填了我的一个域名，虽然备案的 APP 并没有调用这个域名下的服务
其他项目都有很详细的说明，还有一些选填项目，就不再赘述

5.2 APP 平台信息

正常情况按照填写App特征信息就能获取所需要的信息。

但是作为独立开发者，大概都是 Xcode 自动管理证书的吧。我也是，那么怎么获取发布证书的特征信息了啊！

获取 Xcode 自动管理的证书特征信息

来到开发者网站，进入证书列表。

这个 Distribution Managed 就是 Xcode 管理的证书，但是我们无法下载查看。

打开 Web 调试，找到网络请求记录
找到 https://developer.apple.com/services-account/v1/certificates 这个地址的请求
返回的数据是个数组，找到对应的下标
- 你应该能看到一个 "certificateTypeId": "EK2BED77X3"，这个就是 Distribution Managed 类型的证书了
拷贝 certificateContent 字段内部的字符串
新建一个 .txt 文件，存入上面的字符串
修改文件后缀为 .cer 保存
然后在 Windows 系统下右键查看文件的详细信息，就有公钥和指纹了
- 是的，你没看错，要换到 Windows 😆，Mac 下看不到这个“证书”的特征信息

5.3 审核

还是阿里云会初审，然后阿里云初审通过来个电话核对信息，然后就工信部短信验证，最后就进工信部审核了等着吧。

5.4 App Store 更新

备案通过后就会有 APP 的备案号了，比如我的域名备案号是 沪ICP备XXXX号，APP 的备案号就是 沪ICP备XXXX号-XA。

记得在 Connect 里的 APP 信息页补充上 ICP 备案号，然后在 APP 内部（比如设置页）里添加 ICP 备案号的显示即可。

我的新版本已经通过审核发布了。

也祝大家备案顺利！

六、一些问题

6.1 个人可以备案么？

有朋友问了客服，说是可以备案，但是盈利得话就不行。具体会怎么落地到 App Store 我没法实践就不太清楚。

我猜可能类似之前游戏版号的做法。游戏有内购项目、或者下载收费的话，要在中国大陆发布就必须提供版号，Connect 后台上会提示的。

别想先不选中国大陆上线后再选上中国大陆，这种侮辱苹果智商的做法，虽然我自己就这么试过😂

6.2 可以批量备案么？

我在阿里云提交的，实测可以批量，可以避免多次备案，多次提交验证身份信息。不过好像只能一次三个，我加第四个的时候加不上了。

6.3 不联网 App 可以不备案么？

我看规则里写的可以不备案。但是实测 App Store 提交一个完全本地的 App，没有备案号就没法提交审核。

参考资料

App备案快速入门知识

工业和信息化部关于开展移动互联网应用程序备案工作的通知

《工业和信息化部关于开展移动互联网应用程序备案工作的通知》解读

一图读懂APP备案

阿里云免费企业邮箱申请入口链接（2023新版申请流程）

填写App特征信息

Swift编译流程

Wed, 01 Mar 2023 00:00:00 GMT

// 分析输出AST
swiftc main.swift -dump-parse

// 分析并且检查类型输出AST 
swiftc main.swift -dump-ast

// 生成中间体语言(SIL)，未优化 
swiftc main.swift -emit-silgen

// 生成中间体语言(SIL)，优化后的 
swiftc main.swift -emit-sil

// 生成LLVM中间体语言 (.ll文件) 
swiftc main.swift -emit-ir

// 生成LLVM中间体语言 (.bc文件) 
swiftc main.swift -emit-bc

// 生成汇编
swiftc main.swift -emit-assembly

// 编译生成可执行.out文件 
swiftc -o main.o main.swift

Swift Intermediate Language (SIL)

好文推荐：Swift编译器中间码SIL

Swift方法调度

Wed, 01 Mar 2023 00:00:00 GMT

纯 Swift 类

普通函数

class RyukieSwiftClass {
    var age: String?
    
    func hello() {
        print(age ?? "-")
    }
}

let ry = RyukieSwiftClass()
ry.age = "Ryukie"
ry.hello()

生成 SIL 文件，找到：

sil_vtable RyukieSwiftClass {
  #RyukieSwiftClass.age!getter: (RyukieSwiftClass) -> () -> String? : @main.RyukieSwiftClass.age.getter : Swift.String?	// RyukieSwiftClass.age.getter
  #RyukieSwiftClass.age!setter: (RyukieSwiftClass) -> (String?) -> () : @main.RyukieSwiftClass.age.setter : Swift.String?	// RyukieSwiftClass.age.setter
  #RyukieSwiftClass.age!modify: (RyukieSwiftClass) -> () -> () : @main.RyukieSwiftClass.age.modify : Swift.String?	// RyukieSwiftClass.age.modify
  #RyukieSwiftClass.hello: (RyukieSwiftClass) -> () -> () : @main.RyukieSwiftClass.hello() -> ()	// RyukieSwiftClass.hello()
  #RyukieSwiftClass.init!allocator: (RyukieSwiftClass.Type) -> () -> RyukieSwiftClass : @main.RyukieSwiftClass.__allocating_init() -> main.RyukieSwiftClass	// RyukieSwiftClass.__allocating_init()
  #RyukieSwiftClass.deinit!deallocator: @main.RyukieSwiftClass.__deallocating_deinit	// RyukieSwiftClass.__deallocating_deinit
}

可见：纯 Swift 类的函数，是存在一个 sil_vtable 类型的数据结构内的。

@objc、dynamic、@objc dynamic 关键字修饰的函数

对上面代码进行修改

class RyukieSwiftClass {
    var age: String?
    
    func hello() {
        print("hello: \(age ?? "-")")
    }
    
    dynamic func dynamicHelo() {
        print("dynamic: \(age ?? "-")")
    }
    
    @objc func atObjcHello() {
        print("@objc: \(age ?? "-")")
    }
    
    @objc dynamic func atObjcDynamicHello() {
        print("@objc dynamic: \(age ?? "-")")
    }
}

let ry = RyukieSwiftClass()
ry.age = "Ryukie"
ry.hello()
ry.dynamicHelo()
ry.atObjcHello()
ry.atObjcDynamicHello()

SIL:

sil_vtable RyukieSwiftClass {
  #RyukieSwiftClass.age!getter: (RyukieSwiftClass) -> () -> String? : @main.RyukieSwiftClass.age.getter : Swift.String?	// RyukieSwiftClass.age.getter
  #RyukieSwiftClass.age!setter: (RyukieSwiftClass) -> (String?) -> () : @main.RyukieSwiftClass.age.setter : Swift.String?	// RyukieSwiftClass.age.setter
  #RyukieSwiftClass.age!modify: (RyukieSwiftClass) -> () -> () : @main.RyukieSwiftClass.age.modify : Swift.String?	// RyukieSwiftClass.age.modify

// 普通函数
  #RyukieSwiftClass.hello: (RyukieSwiftClass) -> () -> () : @main.RyukieSwiftClass.hello() -> ()	// RyukieSwiftClass.hello()

// dynamic 函数
  #RyukieSwiftClass.dynamicHelo: (RyukieSwiftClass) -> () -> () : @main.RyukieSwiftClass.dynamicHelo() -> ()	// RyukieSwiftClass.dynamicHelo()

// @objc 函数
  #RyukieSwiftClass.atObjcHello: (RyukieSwiftClass) -> () -> () : @main.RyukieSwiftClass.atObjcHello() -> ()	// RyukieSwiftClass.atObjcHello()

  #RyukieSwiftClass.init!allocator: (RyukieSwiftClass.Type) -> () -> RyukieSwiftClass : @main.RyukieSwiftClass.__allocating_init() -> main.RyukieSwiftClass	// RyukieSwiftClass.__allocating_init()
  #RyukieSwiftClass.deinit!deallocator: @main.RyukieSwiftClass.__deallocating_deinit	// RyukieSwiftClass.__deallocating_deinit
}

通过 SIL 我们发现：普通函数、@objc 函数 和 dynamic 函数 都是通过 sil_vtable 存储的，而且内存空间连续。

但是 sil_vtable 内部少了 @objc dynamic 修饰的函数。我们通过汇编断点看一下：

图中我们发现 @objc dynamic 修饰的函数，是通过 objc_msgSend 进行调度的，所以并不在 sil_vtable 内。

extension

我们新增一个 extension 并调用其中的函数：

extension RyukieSwiftClass {
    func extensionHello() {
        print("extension: \(age ?? "-")")
    }
}

汇编端点发现 call 0x1000037e0 是直接通过地址调用的：

->  0x1000029d9 <+73>: mov    r13, qword ptr [rip + 0x58a0] ; SourceCodeStudy.ry : SourceCodeStudy.RyukieSwiftClass
    0x1000029e0 <+80>: call   0x1000037e0               ; SourceCodeStudy.RyukieSwiftClass.extensionHello() -> () at main.swift:35

且在 sil_vtable 结构中没有发现 extensionHello。

所以：在 Swift 类的 extension 中的函数是 静态调用 的。

子类

我们定义一个子类：

class RyukieSwiftSubClass: RyukieSwiftClass {
    func subHello() {
        print("sub: \(age ?? "-")")
    }
}


let subRy = RyukieSwiftSubClass()
subRy.age = "18"
subRy.hello()
subRy.subHello()
subRy.extensionHello()

SIL:

sil_vtable RyukieSwiftSubClass {
// 父类的结构
  #RyukieSwiftClass.age!getter: (RyukieSwiftClass) -> () -> String? : @main.RyukieSwiftClass.age.getter : Swift.String? [inherited]	// RyukieSwiftClass.age.getter
  #RyukieSwiftClass.age!setter: (RyukieSwiftClass) -> (String?) -> () : @main.RyukieSwiftClass.age.setter : Swift.String? [inherited]	// RyukieSwiftClass.age.setter
  #RyukieSwiftClass.age!modify: (RyukieSwiftClass) -> () -> () : @main.RyukieSwiftClass.age.modify : Swift.String? [inherited]	// RyukieSwiftClass.age.modify
  #RyukieSwiftClass.hello: (RyukieSwiftClass) -> () -> () : @main.RyukieSwiftClass.hello() -> () [inherited]	// RyukieSwiftClass.hello()
  #RyukieSwiftClass.dynamicHelo: (RyukieSwiftClass) -> () -> () : @main.RyukieSwiftClass.dynamicHelo() -> () [inherited]	// RyukieSwiftClass.dynamicHelo()
  #RyukieSwiftClass.atObjcHello: (RyukieSwiftClass) -> () -> () : @main.RyukieSwiftClass.atObjcHello() -> () [inherited]	// RyukieSwiftClass.atObjcHello()

// 自己的结构
  #RyukieSwiftClass.init!allocator: (RyukieSwiftClass.Type) -> () -> RyukieSwiftClass : @main.RyukieSwiftSubClass.__allocating_init() -> main.RyukieSwiftSubClass [override]	// RyukieSwiftSubClass.__allocating_init()
  #RyukieSwiftSubClass.subHello: (RyukieSwiftSubClass) -> () -> () : @main.RyukieSwiftSubClass.subHello() -> ()	// RyukieSwiftSubClass.subHello()
  #RyukieSwiftSubClass.deinit!deallocator: @main.RyukieSwiftSubClass.__deallocating_deinit	// RyukieSwiftSubClass.__deallocating_deinit
}

汇编端点：

    0x100002546 <+182>: mov    rax, qword ptr [rip + 0x5e9b] ; SourceCodeStudy.subRy : SourceCodeStudy.RyukieSwiftSubClass
    0x10000254d <+189>: mov    r13, rax
    0x100002550 <+192>: mov    rax, qword ptr [rax]
    0x100002553 <+195>: call   qword ptr [rax + 0x70]
    0x100002556 <+198>: mov    r13, qword ptr [rip + 0x5e8b] ; SourceCodeStudy.subRy : SourceCodeStudy.RyukieSwiftSubClass
    0x10000255d <+205>: mov    rax, qword ptr [r13]
    0x100002561 <+209>: call   qword ptr [rax + 0x90]
->  0x100002567 <+215>: mov    r13, qword ptr [rip + 0x5e7a] ; SourceCodeStudy.subRy : SourceCodeStudy.RyukieSwiftSubClass
    0x10000256e <+222>: call   0x100003370               ; SourceCodeStudy.RyukieSwiftClass.extensionHello() -> () at main.swift:35

我们发现子类的 sil_vtable 结构中包含了父类的结构，自己专有的部分跟在父类的结构之后。

子类的方法调度，没有特殊的方法变化。

override

如果重写父类方法呢？

override func hello() {
    print("override hello: \(age ?? "-")")
}

SIL 会有些许变化：

sil_vtable RyukieSwiftSubClass {
// ...
  #RyukieSwiftClass.hello: (RyukieSwiftClass) -> () -> () : @main.RyukieSwiftSubClass.hello() -> () [override]	// RyukieSwiftSubClass.hello()
// ...
}

final

静态调度，不会存在于 vtable 中

private fileprivate 的会被自动优化为 final

sil_vtable

我们找到 initClassVTable 源码：

/// Using the information in the class context descriptor, fill in in the
/// immediate vtable entries for the class and install overrides of any
/// superclass vtable entries.
static void initClassVTable(ClassMetadata *self) {
  const auto *description = self->getDescription();
  auto *classWords = reinterpret_cast<void **>(self);

  if (description->hasVTable()) {
    // 遍历添加 method，数组结构
    auto *vtable = description->getVTableDescriptor();
    auto vtableOffset = vtable->getVTableOffset(description);
    for (unsigned i = 0, e = vtable->VTableSize; i < e; ++i)
      classWords[vtableOffset + i] = description->getMethod(i);
  }

  if (description->hasOverrideTable()) {
    // 遍历处理 override 的 method
    auto *overrideTable = description->getOverrideTable();
    auto overrideDescriptors = description->getMethodOverrideDescriptors();

    for (unsigned i = 0, e = overrideTable->NumEntries; i < e; ++i) {
      auto &descriptor = overrideDescriptors[i];

      // Get the base class and method.
      auto *baseClass = descriptor.Class.get();
      auto *baseMethod = descriptor.Method.get();

      // If the base method is null, it's an unavailable weak-linked
      // symbol.
      if (baseClass == nullptr || baseMethod == nullptr)
        continue;

      // Calculate the base method's vtable offset from the
      // base method descriptor. The offset will be relative
      // to the base class's vtable start offset.
      auto baseClassMethods = baseClass->getMethodDescriptors().data();
      auto offset = baseMethod - baseClassMethods;

      // Install the method override in our vtable.
      auto baseVTable = baseClass->getVTableDescriptor();
      classWords[baseVTable->getVTableOffset(baseClass) + offset]
        = descriptor.Impl.get();
    }
  }
}

通过源码我们发现 sil_vtable 内部是一个数组的结构，通过下标读写。

结构体

struct RyukieStruct {
    func hello() {
        print("hello")
    }
    
    dynamic func dynamicHelo() {
        print("dynamic")
    }
}

extension RyukieStruct {
    func extensionHello() {
        print("extension")
    }
}

let st = RyukieStruct()
st.hello()
st.dynamicHelo()
st.extensionHello()

汇编断点：

    0x100005ba9 <+9>:  call   0x100005bc0               ; SourceCodeStudy.RyukieStruct.hello() -> () at main.swift:15
    0x100005bae <+14>: call   0x100005c80               ; SourceCodeStudy.RyukieStruct.dynamicHelo() -> () at main.swift:19
->  0x100005bb3 <+19>: call   0x100005d80               ; SourceCodeStudy.RyukieStruct.extensionHello() -> () at main.swift:25

发现都是通过地址直接静态调用的。

[译]编写高性能Swift代码-Writing High-Performance Swift Code(2022.8.25版)

Wed, 22 Feb 2023 00:00:00 GMT

编写高性能的 Swift 代码

文中的一些 Tips 能够帮助提高 Swift 程序的质量，并提高代码容错性和可读性。

一、开启优化 - Enabling Optimizations

首先你应该做的就是开启优化。Swift 提供了三种优化等级：

-Onone: 标准的开发模式。编译器提供最少的优化并且提供所有 debug 信息。
-O: 生产模式代码。编译器进行大量优化代码。调试信息会提供但是不完整。
-Osize: 一个特殊的模式，编译器会优先考虑代码大小，而不是性能。

在 Xcode 中，Project 的 Build Setting 中搜索 Optimization Level 就可以进行配置。

二、整模块优化 - Whole Module Optimizations (WMO)

默认状态下 Swift 会独立编译每个文件。这使得 Xcode 可以快速的并行编译多个文件。但是，每个文件分开变异阻碍了编译器进行优化。Swift 也可以把整个应用程序作为一个文件进行编译，并作为一个编译单元进行优化。编译会花费更久的时间，但是 run 会更快。

Whole-Module Optimization in Swift 3

Xcode 8 默认开启

三、减少动态派发 - Reducing Dynamic Dispatch

Swift 默认是和 Objective-C 一样非常动态的语言。与 Objective-C 不同的是，Swift 给了开发者可以通过减少或者避免动态特性，来提升程序运行时性能的能力。

下面由几个例子进行说明：

动态派发 - Dynamic Dispatch

类默认对方法调用和属性访问进行动态派发。例如下面的 a.aProperty, a.doSomething() and a.doSomethingElse() 动态派发的。

  class A {
    var aProperty: [Int]
    func doSomething() { ... }
    dynamic doSomethingElse() { ... }
  }

  class B: A {
    override var aProperty {
      get { ... }
      set { ... }
    }

    override func doSomething() { ... }
  }

  func usingAnA(_ a: A) {
    a.doSomething()
    a.aProperty = ...
  }

在 Swift 里，动态派发默认是间接地通过一个 vtable[^1] 进行调用。如果在声明里加上了 dynamic 关键字，Swift 会通过 Objective-C 的消息机制进行调用。两种方式相较于直接调用函数都更慢，因为阻碍了很多编译器可以进行优化[^2] 的地方，间接调用也多了很多开销。想要提升代码运行性能就需要限制动态特性。

建议：使用 `final` 当你确定被声明的不需要被重写

final 关键字会限制 class、method、property 不能被重写。这意味着编译器可以直接调用函数，而不是间接调用。下面的 C.array1 and D.array1 将会被直接访问[^3] 。相对的 D.array2 将会被通过一个 vtable 调用：

  final class C {
    // class 'C' 中所有声明的都不能被重写
    // No declarations in class 'C' can be overridden.
    var array1: [Int]
    func doSomething() { ... }
  }

  class D {
    // array1 不能被计算属性重写
    final var array1: [Int] // 'array1' cannot be overridden by a computed property.
    // array2 能被计算属性重写
    var array2: [Int]      // 'array2' *can* be overridden by a computed property.
  }

  func usingC(_ c: C) {
    // 访问 C.array1 不会经过动态派发
    c.array1[i] = ... // Can directly access C.array without going through dynamic dispatch.
    // 会直接调用 C.doSomething 不会经过虚函数表调用
    c.doSomething() = ... // Can directly call C.doSomething without going through virtual dispatch.
  }

  func usingD(_ d: D) {
    // 直接访问 D.array1 不经过动态派发
    d.array1[i] = ... // Can directly access D.array1 without going through dynamic dispatch.
    // 经过动态派发访问 D.array2
    d.array2[i] = ... // Will access D.array2 through dynamic dispatch.
  }

建议：使用 `private` 和 `fileprivate` 声明不需要被文件外界访问的内容

使用 private 和 fileprivate 关键字能够将这些声明的访问限制在该文件内部。这会让编译器能查出所有其它潜在的重写声明。由此编译器能够自动推断 final 关键字并删除方法的间接调用和空间访问。

如下：假设 E, F 在该文件内没有重写任何声明，那么 e.doSomething() 和 f.myPrivateVar 就能够被直接访问：


  private class E {
    func doSomething() { ... }
  }

  class F {
    fileprivate var myPrivateVar: Int
  }

  func usingE(_ e: E) {
    /**
    该文件内没有子类存在
    编译器可以移除 doSomething 的虚表调用，并直接调用 E 的 doSomething 方法
    */
    e.doSomething() // There is no sub class in the file that declares this class.
                    // The compiler can remove virtual calls to doSomething()
                    // and directly call E's doSomething method.
  }

  func usingF(_ f: F) -> Int {
    return f.myPrivateVar
  }

建议：如果启用了 `WMO`，在模块内部对不需要外部访问的内容使用 `internal` 关键字进行声明

WMO 使得编译器将整个模块的代码作为一个整体一次性进行编译。使编译单个声明时能够拥有更广的视野从而进行优化。当一个声明为 internal 就不会在模块外部被访问到，优化器可以根据是否存在潜在的声明重写，而自动推断出 final 关键字。

NOTE: 由于现在 Swift 默认的访问级别已经是 internal，通过开启 WMO 就不用额外的操作（WMO 也是默认开启的了）。

四、高效的使用容器类型 - Using Container Types Efficiently

Swift 标准库提供了重要功能：通用容器 Array 和 Dictionary。下面将介绍如何高效的使用这些类型。

建议：在数组中使用值类型

在 Swift 中，类型能够被分为两种：值类型 (structs, enums, tuples)，引用类型 (classes)。一个关键的差别是值类型不能被放入 NSArray。因此当使用值类型时，优化器就不需要去处理对 NSArray 的兼容。

并且对比引用类型，值类型仅当包含了引用类型的时候才需要引用计数。通过使用不包含引用类型的值类型，可以避免在 Array 内部的 retain 和 release 减少开销。


  // Don't use a class here.
  struct PhonebookEntry {
    var name: String
    var number: [Int]
  }

  var a: [PhonebookEntry]

需要时刻注意平衡使用大的值类型和引用类型。有时拷贝移动一个巨大的值类型可能消耗比管理一个引用类型的 retain/release 消耗还要大。

建议：不需要考虑 NSArray 桥接的时候可以使用 `ContiguousArray` 来存储引用类型


  class C { ... }
  var a: ContiguousArray<C> = [C(...), C(...), ..., C(...)]

Swift标准库源码阅读笔记 - Array和ContiguousArray

Array 需要考虑对 NSArray 的兼容，内部存在很多类型检查。

建议：使用引用修改而不是对象重新赋值 - Use inplace mutation instead of object-reassignment

在 Swift 标准库中所有的容器类型都是使用了 COW(copy-on-write)[^4] 机制来替代直接拷贝。在大多数情况下，编译器会引用容器而不是深拷贝。只有当容器的引用计数大于 1 并且容器被修改了，才会触发底层容器的拷贝。

如下：当 c 赋值给 d，不会触发拷贝。但是当 d 通过 append(2) 修改的时候，d 会先拷贝容器，然后 2 会被添加进 d：

  var c: [Int] = [ ... ]
  var d = c        // No copy will occur here.
  d.append(2)      // A copy *does* occur here.

如果使用不当，COW 有时会造成没必要的拷贝。例如下面的例子通过在方法内部返回一个新数组，进行对象重新赋值来达到 append_one。所有传入的参数都会被 reatin 然后在函数结束后 release。如果像下面这样实现一个 append_one 方法：

  func append_one(_ a: [Int]) -> [Int] {
    var a = a
    a.append(1)
    return a
  }

  var a = [1, 2, 3]
  a = append_one(a)

a 可能会被拷贝[^5]，尽管 a 在 append_one 结束后没有被使用。如果使用 inout 就可以避免：

  func append_one_in_place(a: inout [Int]) {
    a.append(1)
  }

  var a = [1, 2, 3]
  append_one_in_place(&a)

五、避免检查溢出的计算 - Wrapping operations

Swift 在执行一般整型计算的时候会检查是否溢出。但是在已知不会溢出的场景下依旧这么做就显得非常不合适了，也不符合高性能编码的期望。

建议：在已知不会溢出的情况下使用 `wrapping arithmetic` 进行不检查的整型计算 `&+`

在高性能编码中，如果你确定不会溢出，就可以使用 wrapping arithmetic 来避免检查。

  a: [Int]
  b: [Int]
  c: [Int]

  // Precondition: for all a[i], b[i]: a[i] + b[i] either does not overflow,
  // or the result of wrapping is desired.
  for i in 0 ... n {
    c[i] = a[i] &+ b[i]
  }

需要指出的是，&+ &- &* 在溢出的时候结果会简单的处理。例如：Int.max &+ 1 的结果是 Int.min（不像C语言里，INT_MAX + 1 是为无法定义的操作）。

六、范型 - Generics

Swift 通过范型提供了非常强大的抽象能力。Swift 编译器通过 MySwiftFunc<T> 生成可以为 T 执行的代码块。生成的代码块包含一个函数指针列表和一个包含 T 容器作为参数。MySwiftFunc<Int> 和 MySwiftFunc<String> 的不同表现，是通过传递不同的函数列表和容器大小来决定的。一个范型例子：

  class MySwiftFunc<T> { ... }

  // 生成为 Int 工作的代码
  MySwiftFunc<Int> X    // Will emit code that works with Int...
  // 生成为 String 工作的代码
  MySwiftFunc<String> Y // ... as well as String.

当开启了优化，Swift 编译器会检查每个调用调用，并检查其中使用的类型（比如非范型类型）。如果范型函数的定义对优化器是可见的并且类型是已知的，Swift 编译器将会生成一个针对这个特定类型版本的函数。这个过程叫做 specialization（定制化），可以避免一些范型相关的消耗。如下例子：

  class MyStack<T> {
    func push(_ element: T) { ... }
    func pop() -> T { ... }
  }

  func myAlgorithm<T>(_ a: [T], length: Int) { ... }

  // The compiler can specialize code of MyStack<Int>
  // 编译器会为范型 MyStack<Int> 生成特定代码
  var stackOfInts: MyStack<Int>

  // Use stack of ints.
  for i in ... {
    stack.push(...)
    stack.pop(...)
  }

  var arrayOfInts: [Int]
  // The compiler can emit a specialized version of 'myAlgorithm' targeted for
  // [Int]' types.
  // 编译器会生成针对 [Int] 版本的函数
  myAlgorithm(arrayOfInts, arrayOfInts.length)

建议：将范型声明放在需要使用它的模块内

优化器只能对声明在当前模块中的范型定义进行特化处理。如果 WMO 没有开启，即只会当声明和调用在同一个文件的时候才会处理。

NOTE: 标准库是个特例。定义在标准库中的对所有模块可见并可以被特化处理。

七、 Swift 中较大值类型的开销 - The cost of large Swift values

在 Swift 中，一些较大的值类型如果进行拷贝会比较耗时，并影响性能。

建议：较大的值类型使用写时复制 COW - Advice: Use copy-on-write semantics for large values

写时复制能够解决值类型大量拷贝的问题。实现写时拷贝最简单的方式就是使用现成的 COW 数据结构，比如 Array。Swift 的 Array 是值类型。但是 Array 的内容不会每次都拷贝，因为使用来写时复制。

我们使用 Array 改造 Tree 可以避免大量的拷贝操作。这提升了 Tree 数据结构的性能表现，并且将传递一个数组的时间复杂度由O(n)降低到了O(1)。

  struct Tree: P {
    var node: [P?]
    init() {
      node = [thing]
    }
  }

使用数组来实现 COW 机制有两个明显的缺点:

第一个问题就是数组中类似 "append" 和 "count" 的方法，它们在值封装中没有任何作用。这些方法让引用封装变得很不方便。我们可以通过创建一个隐藏未用到的 API 的封装结构来解决这个问题，并且优化器会移除它的开销，但是这样的封装并不能解决第二个问题。
第二个问题就是数组内存在保证程序安全性和与 Objective-C 进行交互的代码， Swift 会检查索引访问是否在数组边界内，以及保存值时会判断数组存储时否需要扩展存储空间。这些操作运行时都会降低程序速度。

一个替代方法就是实现一个 copy-on-write 机制的数据结构来代替数组作为值封装。下面的例子就是介绍如何构建一个这样的数据结构：

Note: 这样的解决办法，对于嵌套结构并非最优，并且一个基于 COW 数据结构的 addressor 会更加高效。然而在这种情况下，抛开标准库执行 addressor 是行不通的。 More details in this blog post by Mike Ash

final class Ref<T> {
  var val: T
  init(_ v: T) { val = v }
}

struct Box<T> {
  var ref: Ref<T>
  init(_ x: T) { ref = Ref(x) }

  var value: T {
    get { return ref.val }
    set {
      if !isKnownUniquelyReferenced(&ref) {
        ref = Ref(newValue)
        return
      }
      ref.val = newValue
    }
  }
}

Box 类型可以代替上个例子中的数组。

八、不安全的代码 - Unsafe code

Swift 中类总是采用引用计数。 Swift 编译器会在每次对象被访问时插入增加引用计数的代码。例如，考虑一个通过使用类实现遍历链表的例子。遍历链表是通过从一个节点到下一个节点移动引用实现： elem = elem.next。每次我们移动这个引用， Swift 将会增加 next 对象的引用计数，并且减少前一个对象的引用计数。这样的引用计数方法成本很高，但只要我们使用 Swift 的类就无法避免。


  final class Node {
    var next: Node?
    var data: Int
    ...
  }

建议：使用非托管的引用来避免引用计数带来的开销

Note: Unmanaged<T>._withUnsafeGuaranteedRef 不是公开的 API，并且今后将会被移除。所以不要使用它。

在性能优先代码中，你可以选择使用未托管的引用。其中 Unmanaged<T> 结构体就允许开发者关闭对于特殊引用的自动引用计数 (ARC) 功能。

当你这样做了，你需要确保有另外的引用引用这个被 Unmanaged 的实例，来保证在使用 Unmanaged 期间实例不会释放。


  // The call to ``withExtendedLifetime(Head)`` makes sure that the lifetime of
  // Head is guaranteed to extend over the region of code that uses Unmanaged
  // references. Because there exists a reference to Head for the duration
  // of the scope and we don't modify the list of ``Node``s there also exist a
  // reference through the chain of ``Head.next``, ``Head.next.next``, ...
  // instances.

  withExtendedLifetime(Head) {

    // Create an Unmanaged reference.
    var Ref: Unmanaged<Node> = Unmanaged.passUnretained(Head)

    // Use the unmanaged reference in a call/variable access. The use of
    // _withUnsafeGuaranteedRef allows the compiler to remove the ultimate
    // retain/release across the call/access.

    while let Next = Ref._withUnsafeGuaranteedRef { $0.next } {
      ...
      Ref = Unmanaged.passUnretained(Next)
    }
  }

Unmanaged.swift

Unmanaged

九、协议 - Protocols

建议：将智能由 class 实现的协议标记为 class-protocol

Swift 可以限定协议只能通过类实现。标记协议只能由类实现的一个优点就是，编译器可以基于只有类实现协议这一事实来优化程序。

例如，如果 ARC 内存管理系统知道正在处理类对象，那么就能够简单的保留(增加对象的引用计数)它。如果编译器不知道这一事实，它就不得不假设结构体也可以实现协议，那么就需要准备保留或者释放不可忽视的结构体，这样做的代价很高。

如果限定只能由类实现某个协议，那么就需要标记类实现的协议为类协议，以便获得更好的运行性能。

  protocol Pingable: AnyObject { func ping() -> Int }

Protocols

十、 left/var 被逃逸闭包捕获的性能消耗

可能很多人认为 let 和 var 的区别仅仅是语义层面的，起始其中也有性能方面的思考。一旦一个变量和一个闭包发生了绑定，就强制编译器生成一个逃逸闭包。例如：

  let f: () -> () = { ... } // Escaping closure
  // Contrasted with:
  ({ ... })() // Non Escaping closure
  x.map { ... } // Non Escaping closure

当一个 var 被逃逸闭包捕获，编译器必须在堆上开辟空间来存储这个 var 使得，创建者和闭包都能够读写这个 var。相对的当捕获一个 let。会直接在闭包的数据结构内添加一个该变量的 copy，而不用去堆上开辟空间。

建议：如果闭包不是真的需要逃逸，使用 `inout` 参数传递 var

inout 会确保不会在堆上再去开辟空间，避免了没必要的 retain/release 操作。

补充说明 - Footnotes

[^1]: A virtual method table or 'vtable' is a type specific table referenced by instances that contains the addresses of the type's methods. Dynamic dispatch proceeds by first looking up the table from the object and then looking up the method in the table.

[^2]: This is due to the compiler not knowing the exact function being called.

[^3]: i.e. a direct load of a class's field or a direct call to a function.

[^4]: An optimization technique in which a copy will be made if and only if a modification happens to the original copy, otherwise a pointer will be given.

[^5]: In certain cases the optimizer is able to via inlining and ARC optimization remove the retain, release causing no copy to occur.

dealloc

Thu, 16 Feb 2023 00:00:00 GMT

Dealloc 的实现机制

Dealloc 的实现机制是内容管理部分的重点，把这个知识点弄明白，对于全方位的理解内存管理的只是很有必要。

1. Dealloc 调用流程

首先调用 _objc_rootDealloc()
接下来调用 rootDealloc()
这时候会判断是否可以被释放，判断的依据主要有 5 个，判断是否有以上五种情况
- NONPointer_ISA
- weakly_reference
- has_assoc
- has_cxx_dtor
- has_sidetable_rc
如果有以上五中任意一种，将会调用 object_dispose() 方法，做下一步的处理。
如果没有之前五种情况的任意一种，则可以执行释放操作，C 函数的 free()。
执行完毕。

2. object_dispose() 调用流程

直接调用 objc_destructInstance()。
之后调用 C 函数的 free()。

3. objc_destructInstance() 调用流程

先判断 hasCxxDtor，如果有 C++ 的相关内容，要调用 object_cxxDestruct() ，销毁 C++ 相关的内容。
再判断 hasAssocitatedObjects，如果有的话，要调用 object_remove_associations()，销毁关联对象的一系列操作。
然后调用 clearDeallocating()。
执行完毕。

4. clearDeallocating() 调用流程

先执行 sideTable_clearDellocating()。
再执行 weak_clear_no_lock，在这一步骤中，会将指向该对象的弱引用指针置为 nil。
接下来执行 table.refcnts.eraser()，从引用计数表中擦除该对象的引用计数。
至此为止，Dealloc 的执行流程结束。

知识点梳理：HTML和浏览器

Wed, 01 Feb 2023 00:00:00 GMT

一、浏览器

1. Cookie、sessionStorage、localStorage

共同点

都是保存在浏览器端，并且是同源的

区别

Cookie 和 session 都可用来存储用户信息，cookie 存放于客户端，session 存放于服务器端，因为 cookie 存放于客户端有可能被窃取，所以 cookie 一般用来存放不敏感的信息，比如用户设置的网站主题，敏感的信息用 session 存储，比如用户的登陆信息，session 可以存放于文件，数据库，内存中都可以，cookie 可以服务器端响应的时候设置，也可以客户端通过 JS 设置 cookie 会在请求时在 http 首部发送给客户端，cookie 一般在客户端有大小限制，一般为 4K，

下面从几个方向区分一下 cookie，localstorage，sessionstorage 的区别

生命周期:
- Cookie:可设置失效时间，否则默认为关闭浏览器后失效 Localstorage:除非被手动清除，否则永久保存
- Sessionstorage:仅在当前网页会话下有效，关闭页面或浏览器后就会被清除 2、存放数据:
- Cookie:4k 左右
- Localstorage 和 sessionstorage:可以保存 5M 的信息
http 请求:
- Cookie:每次都会携带在 http 头中，如果使用 cookie 保存过多数据会带来性能问题
- 其他两个:仅在客户端即浏览器中保存，不参与和服务器的通信
易用性:
- Cookie:需要程序员自己封装，原生的 cookie 接口不友好
- 其他两个:即可采用原生接口，亦可再次封装
应用场景:
- 从安全性来说，因为每次 http 请求都回携带 cookie 信息，这样子浪费了带宽，所以 cookie 应该尽可能的少用
  - 此外 cookie 还需要指定作用域，不可以跨域调用，限制很多
  - 但是用户识别用户登陆来说，cookie 还是比 storage 好用，其他情况下可以用 storage
- localstorage 可以用来在页面传递参数
- sessionstorage 可以用来保存一些临时的数据，防止用户刷新页面后丢失了一些参数。

2. 说一下 web worker

MDN

在 HTML 页面中，如果在执行脚本时，页面的状态是不可响应的，直到脚本执行完成后，页面才变成可响应。

web worker 是运行在后台的 js，独立于其他脚本，不会影响页面的性能。并且通过 postMessage 将结果回传到主线程。这样在进行复杂操作的时候，就不会阻塞主线程了。

概念

Web Worker (工作线程) 是 HTML5 中提出的概念，分为两种类型，专用线程（Dedicated Web Worker） 和共享线程（Shared Web Worker）。

专用线程仅能被创建它的脚本所使用（一个专用线程对应一个主线程），而共享线程能够在不同的脚本中使用（一个共享线程对应多个主线程）。

专用线程可以看做是默认情况的 Web Worker，其加上修饰词的目的是为了与共享线程进行区分。

用途

Web Worker 的意义在于可以将一些耗时的数据处理操作从主线程中剥离，使主线程更加专注于页面渲染和交互。

懒加载
文本分析
流媒体数据处理
canvas 图形绘制
图像处理
...

需要注意的点

有同源限制
无法访问 DOM 节点
运行在另一个上下文中，无法使用Window对象
Web Worker 的运行不会影响主线程，但与主线程交互时仍受到主线程单线程的瓶颈制约。换言之，如果 Worker 线程频繁与主线程进行交互，主线程由于需要处理交互，仍有可能使页面发生阻塞
共享线程可以被多个浏览上下文（Browsing context）调用，但所有这些浏览上下文必须同源（相同的协议，主机和端口号）

3. Doctype 作用?

Doctype 声明于文档最前面，告诉浏览器以何种方式来渲染页面，这里有两种模式，严格模式和混杂模式。

严格模式与混杂模式如何区分? 它们有何意义?

严格模式的排版和 JS 运作模式是以该浏览器支持的最高标准运行
混杂模式，向后兼容，模拟老式浏览器，防止浏览器无法兼容页面

4. Cookie 如何防范 XSS 攻击

XSS(跨站脚本攻击)是指攻击者在返回的 HTML 中嵌入 javascript 脚本。

为了减轻这些攻击，需要在 HTTP 头部配上，set-cookie:

httponly
- 这个属性可以防止 XSS,它会禁止 javascript 脚本来访问 cookie。
secure
- 这个属性告诉浏览器仅在请求为 https 的时候发送 cookie。
结果应该是这样的:Set-Cookie=<cookie-value>.....

XSS 防御的总体思路是:对输入(和 URL 参数)进行过滤，对输出进行编码。也就是对提交的所有内容进行过滤，对 url 中的参数进行过滤，过滤掉会导致脚本执行的相关内容; 然后对动态输出到页面的内容进行 html 编码，使脚本无法在浏览器中执行。虽然对输入过滤可以被绕过，但是也还是会拦截很大一部分的 XSS 攻击。

5. cookie session 区别

cookie 数据存放在客户的浏览器上，session 数据放在服务器上。
cookie 不是很安全，别人可以分析存放在本地的 COOKIE 并进行 COOKIE 欺骗考虑到安全应当使用 session。
session 会在一定时间内保存在服务器上。当访问增多，会比较占用你服务器的性能，考虑到减轻服务器性能方面，应当使用 COOKIE。
单个 cookie 保存的数据不能超过 4K，很多浏览器都限制一个站点最多保存 20 个 cookie。

6. click在ios上有300ms延迟，原因及如何解决

原因

safari，为了能把PC端大屏幕的页面以较好的效果展示在小屏幕手机端上，采用了双击缩放（double tap to zoom）的方案。而这就是click在移动端ios会有300ms的缘由。

解决方案一：

禁止缩放，那么就没有了双击产生缩放的操作，那么就不需要等待300ms

<meta name="viewport" content="user-scalable=no" />

解决方案二： FastClcik

fast click 原理
- 监听touchend事件（touchstart touchend会先于click触发）
- 使用自定义DOM事件模拟一个click事件
- 把默认的click事件（300ms之后触发）禁止掉

很久不维护了，坑多

7. 浏览器缓存

HTTP强缓存和协商缓存

浏览器缓存是浏览器在本地磁盘对用户最近请求过的文档进行存储，当访问者再次访问同一页面时，浏览器就可以直接从本地磁盘加载文档。

所以根据上面的特点，浏览器缓存有下面的优点：

减少冗余的数据传输
减少服务器负担
加快客户端加载网页的速度

第一次请求时

在第一次请求时，服务器会将页面最后修改时间通过Last-Modified标识由服务器发送给客户端，客户端记录修改时间；服务器还会生成一个Etag，并发送给客户端。

浏览器后续再次进行请求时：

浏览器缓存主要分为强强缓存（也称本地缓存）和协商缓存（也称弱缓存）。根据上图，浏览器在第一次请求发生后，再次发送请求时：

浏览器请求某一资源时，会先获取该资源缓存的header信息，
- 然后根据header中的Cache-Control和Expires来判断是否过期。
- 若没过期则直接从缓存中获取资源信息，包括缓存的header的信息，所以此次请求不会与服务器进行通信。
- 这里判断是否过期，则是强缓存相关。后面会讲Cache-Control和Expires相关。
如果显示已过期，浏览器会向服务器端发送请求
- 这个请求会携带第一次请求返回的有关缓存的header字段信息
  - 比如客户端会通过If-None-Match头将先前服务器端发送过来的Etag发送给服务器，服务会对比这个客户端发过来的Etag是否与服务器的相同
    - 若相同，就将If-None-Match的值设为false，
      - 返回状态304
      - 客户端继续使用本地缓存，不解析服务器端发回来的数据
    - 若不相同就将If-None-Match的值设为true
      - 返回状态为200
      - 客户端重新机械服务器端返回的数据
- 客户端还会通过If-Modified-Since头将先前服务器端发过来的最后修改时间戳发送给服务器，服务器端通过这个时间戳判断客户端的页面是否是最新的，如果不是最新的，则返回最新的内容，如果是最新的，则返回304，客户端继续使用本地缓存。

两种缓存

缓存分为两种:强缓存和协商缓存，根据响应的 header 内容来决定。

强缓存、协商缓存什么时候用哪个

强缓存是利用http头中的Expires和Cache-Control两个字段来控制的，用来表示资源的缓存时间。强缓存中，普通刷新会忽略它，但不会清除它，需要强制刷新。浏览器强制刷新，请求会带上Cache-Control:no-cache和Pragma:no-cache
协商缓存就是由服务器来确定缓存资源是否可用，所以客户端与服务器端要通过某种标识来进行通信，从而让服务器判断请求资源是否可以缓存访问。
- 普通刷新会启用弱缓存，忽略强缓存。只有在地址栏或收藏夹输入网址、通过链接引用资源等情况下，浏览器才会启用强缓存，这也是为什么有时候我们更新一张图片、一个js文件，页面内容依然是旧的，但是直接浏览器访问那个图片或文件，看到的内容却是新的。

为什么要有Etag

你可能会觉得使用Last-Modified已经足以让浏览器知道本地的缓存副本是否足够新，为什么还需要Etag呢？HTTP1.1中Etag的出现主要是为了解决几个Last-Modified比较难解决的问题：

一些文件也许会周期性的更改，但是他的内容并不改变(仅仅改变的修改时间)，这个时候我们并不希望客户端认为这个文件被修改了，而重新GET；
某些文件修改非常频繁，比如在秒以下的时间内进行修改，(比方说1s内修改了N次)，If-Modified-Since能检查到的粒度是s级的，这种修改无法判断(或者说UNIX记录MTIME只能精确到秒)；
某些服务器不能精确的得到文件的最后修改时间。

Last-Modified与ETag是可以一起使用的，服务器会优先验证ETag，一致的情况下，才会继续比对Last-Modified，最后才决定是否返回304。

具体有哪些请求头是跟缓存相关的

强缓存相关字段有 expires，cache-control。如果 cache-control 与 expires 同时存在的话， cache-control 的优先级高于 expires。

协商缓存相关字段有 Last-Modified/If-Modified-Since，Etag/If-None-Match

8. 输入一个URL,到这个页面呈现出来的过程

DNS 解析
TCP 连接
发送 HTTP 请求服务器处理请求并返回 HTTP 报文浏览器解析渲染页面
连接结束

9. csrf 和 xss 的网络攻击及防范

CSRF
- 跨站请求伪造
  - 可以理解为攻击者盗用了用户的身份，以用户的名义发送了恶意请求，比如用户登录了一个网站后，立刻在另一个tab页面访问量攻击者用来制造攻击的网站，这个网站要求访问刚刚登陆的网站，并发送了一个恶意请求，这时候 CSRF 就产生了，比如这个制造攻击的网站使用一张图片，但是这种图片的链接却是可以修改数据库的，这时候攻击者就可以以用户的名义操作这个数据库
- 防御方式的话
  - 验证 HTTPReferer 字段
  - 在请求地址中添加 token 并验证
  - 在 HTTP 头中自定义属性并验证。
XSS
- 跨站脚本攻击
  - 是说攻击者通过注入恶意的脚本，在用户浏览网页的时候进行攻击，比如获取 cookie，或者其他用户身份信息，可以分为存储型和反射型，存储型是攻击者输入一些数据并且存储到了数据库中，其他浏览者看到的时候进行攻击，反射型的话不存储在数据库中，往往表现为将攻击代码放在 url 地址的请求参数中
- 防御的话为 cookie 设置 httpOnly 属性，对用户的输入进行检查，进行特殊字符过滤。

10. cookie 有哪些编码方式?

encodeURI()

11. 说说 302，301，304 的状态码

301 Moved Permanently 永久移动。
- 请求的资源已被永久的移动到新 URI，返回信息会包括新的 URI，浏览器会自动定向到新 URI。今后任何新的请求都应使用新的 URI 代替
302 Found 临时移动。
- 与 301 类似。但资源只是临时被移动。客户端应继续使用原有 URI
304 Not Modified 未修改。
- 所请求的资源未修改，服务器返回此状态码时，不会返回任何资源。客户端通常会缓存访问过的资源，通过提供一个头信息指出客户端希望只返回在指定日期之后修改的资源

二、 HTML

1. 对 HTML 语义化标签的理解

HTML5 语义化标签是指正确的标签包含了正确的内容，结构良好，便于阅读，比如 nav 表示导航条，类似的还有 article、header、footer 等等标签。

2. iframe 是什么?有什么缺点?

定义
- iframe 元素会创建包含另一个文档的内联框架
- 提示:可以将提示文字放在<iframe></iframe>之间，来提示某些不支持 iframe 的浏览器
缺点:
- 会阻塞主页面的 onload 事件
- 搜索引擎无法解读这种页面，不利于 SEO
- iframe 和主页面共享连接池，而浏览器对相同区域有限制所以会影响性能。

3. addEventListener 参数

event 指定事件名
function 指定要事件触发时执行的函数
useCapture 指定事件是否在捕获或冒泡阶段执行。

4. HTML5 新增的元素

首先 html5 为了更好的实践 web 语义化，增加了 header，footer，nav,aside,section 等语义化标签
在表单方面，为了增强表单，为 input 增加了 color，emial,data ,range 等类型，
在存储方面，提供了 sessionStorage，localStorage,和离线存储，通过这些存储方式方便数据在客户端的存储和获取
在多媒体方面规定了音频和视频元素 audio 和 vedio
另外还有地理定位，canvas 画布，拖放，多线程编程的 web worker 和 websocket 协议。

三、 CSS

1. 说一下盒子模型

MDN-强烈推荐好好读读

2. flex 弹性盒子

MDN-flex

3. 画条 0.5 px 的线

直接设置0.5px，在不同的浏览器会有不同的表现

transform 缩放

.scale-half {
    height: 1px;
    transform: scaleY(0.5);
    transform-origin: 50% 100%; /*为了防止线模糊*/
}

meta viewport

这样子就能缩放到原来的0.5倍，如果是1px那么就会变成0.5px。

<meta name="viewport" content="initial-scale=0.5, maximum-scale=1.0, user-scalable=no" />

注意：移动端适用，字体也会变小，原理是css的1px在手机上并不是物理上的1像素，可能是2像素，initial-scale的值改为0.5之后就只代表1像素

也可以直接用图片

4. 页面导入样式时，使用link和@import有什么区别

区别1：
- link是XHTML标签，除了加载CSS外，还可以定义RSS等其他事务；
- @import属于CSS范畴，只能加载CSS。
区别2：
- link引用CSS时，在页面载入时同时加载；
- @import需要页面网页完全载入以后加载。所以会出现一开始没有css样式，闪烁一下出现样式后的页面(网速慢的情况下)
区别3：
- link是XHTML标签，无兼容问题；
- @import是在CSS2.1提出的，低版本的浏览器不支持。
区别4：
- link支持使用Javascript控制DOM去改变样式；
- 而@import不支持。在html设计制作中，css有四种引入方式。

5. css四种引入方式

方式一：内联样式

<div style="display: none;background:red"></div>

方式二：嵌入样式

<head>
    <style>
      .content {
         background: red;
       }
    </style>
</head>

方式三：链接样式

<head>
    <link rel="stylesheet" type="text/css" href="style.css">
</head>

方式四：导入样式

导入方式指的是使用 CSS 规则引入外部 CSS 文件

<style>
    @import url(style.css);
</style>

或者写在css样式中

@charset "utf-8";
@import url(style.css);
*{ margin:0; padding:0;}
.notice-link a{ color:#999;}

总结

我们应尽量使用 <link> 标签导入外部 CSS 文件，避免或者少用使用其他三种方式。

6. transition 和 animation 的区别

animation属性类似于transition，他们都是随着时间改变元素的属性值，那么区别是什么？

其主要区别在于：transition需要触发一个事件才会随着时间改变其CSS属性；animation在不需要触发任何事件的情况下，也可以显式的随时间变化来改变元素CSS属性，达到一种动画的效果。

1）CSS的transition需要借助别的方式来触发，比如CSS的状态选择器（如:hover）或借助JavaScript来触发；animation可以自动触发

2）过渡只有一组（两个：开始-结束）关键帧，动画可以设置多个。

7. BFC 块格式化上下文

MDN-块格式化上下文

官方文档比较晦涩，建议搭配阅读

一次弄懂css的BFC

8. 清除浮动

清除浮动的四种方式及其原理理解

9. 垂直居中

CSS垂直居中的七个方法

设定行高（line-height）
- 行内元素
添加伪元素（::before、::after）
calc动态计算
使用表格或假装表格
transform
绝对定位
使用Flexbox

10. css3动画与js动画的区别

参考

JS动画

缺点：
- (1)JavaScript在浏览器的主线程中运行，而主线程中还有其它需要运行的JavaScript脚本、样式计算、布局、绘制任务等,对其干扰导致线程可能出现阻塞，从而造成丢帧的情况。
- (2)代码的复杂度高于CSS动画
优点：
- (1)JavaScript动画控制能力很强, 可以在动画播放过程中对动画进行控制：开始、暂停、回放、终止、取消都是可以做到的。
- (2)动画效果比css3动画丰富,有些动画效果，比如曲线运动,冲击闪烁,视差滚动效果，只有JavaScript动画才能完成
- (3)CSS3有兼容性问题，而JS大多时候没有兼容性问题

CSS动画

缺点：
- (1)运行过程控制较弱,无法附加事件绑定回调函数。CSS动画只能暂停,不能在动画中寻找一个特定的时间点，不能在半路反转动画，不能变换时间尺度，不能在特定的位置添加回调函数或是绑定回放事件,无进度报告
- (2)代码冗长。想用 CSS 实现稍微复杂一点动画,最后CSS代码都会变得非常笨重。
优点：
- (1)浏览器可以对动画进行优化。
- (2)代码相对简单,性能调优方向固定
- (3)对于帧速表现不好的低版本浏览器，CSS3可以做到自然降级，而JS则需要撰写额外代码

11. CSS动画流畅的原因与前提

渲染线程分为main thread(主线程)和compositor thread(合成器线程)。如果CSS动画只是改变transform和opacity，这时整个CSS动画得以在compositor thread完成（而JS动画则会在main thread执行，然后触发compositor进行下一步操作）。

在JS执行一些昂贵的任务时，main thread繁忙，CSS动画由于使用了compositor thread可以保持流畅。

CSS动画比JS流畅的前提：

JS在执行一些昂贵的任务
同时CSS动画不触发layout或paint，在CSS动画或JS动画触发了paint或layout时，需要main thread进行Layer树的重计算，这时CSS动画或JS动画都会阻塞后续操作。

只有如下属性的修改才符合“仅触发Composite，不触发layout或paint”：
- backface-visibility
- opacity
- *erspective
- perspective-origin
- transfrom

所以只有用上了3D加速或修改opacity时，css3动画的优势才会体现出来。

12. css3动画与js动画怎么选

如果动画只是简单的状态切换，不需要中间过程控制，在这种情况下，css动画是优选方案。它可以让你将动画逻辑放在样式文件里面，而不会让你的页面充斥 Javascript 库。

然而如果你在设计很复杂的富客户端界面或者在开发一个有着复杂UI状态的 APP。那么你应该使用js动画，这样你的动画可以保持高效，并且你的工作流也更可控。

所以，在实现一些小的交互动效的时候，就多考虑考虑CSS动画。

对于一些复杂控制的动画，使用javascript比较可靠。

13. 多行文本省略

#post-title {
  display: -webkit-box;
  text-overflow: ellipsis;
  -webkit-box-orient: vertical;
  -webkit-line-clamp: 2;
  overflow: hidden;
}

14. 聊聊 visibility=hidden, opacity=0，display:none

opacity=0，该元素隐藏起来了，但不会改变页面布局，并且，如果该元素已经绑定一些事件，如 click 事件，那么点击该区域，也能触发点击事件的
visibility=hidden，该元素隐藏起来了，但不会改变页面布局，但是不会触发该元素已经绑定的事件
display=none，把元素隐藏起来，并且会改变页面布局，可以理解成在页面中把该元素删除掉一样

15. 双边距重叠现象(外边距折叠)

多个相邻(兄弟或者父子关系)普通流的块元素垂直方向 marigin 会重叠

折叠的结果为:
- 两个相邻的外边距都是正数时，折叠结果是它们两者之间较大的值。
- 两个相邻的外边距都是负数时，折叠结果是两者绝对值的较大值。
- 两个外边距一正一负时，折叠结果是两者的相加的和。

16. position 属性比较

固定定位 fixed:
- 元素的位置相对于浏览器窗口是固定位置，即使窗口是滚动的它也不会移动。
- Fixed 定位使元素的位置与文档流无关，因此不占据空间。
- Fixed 定位的元素和其他元素重叠。
相对定位 relative:
- 如果对一个元素进行相对定位，它将出现在它所在的位置上。
- 然后，可以通过设置垂直或水平位置，让这个元素“相对于”它的起点进行移动。
- 在使用相对定位时，无论是否进行移动，元素仍然占据原来的空间。
- 因此，移动元素会导致它覆盖其它框。
绝对定位 absolute:
- 绝对定位的元素的位置相对于最近的已定位父元素，如果元素没有已定位的父元素，那么它的位置相对于<html>。
- absolute 定位使元素的位置与文档流无关，因此不占据空间。
- absolute 定位的元素和其他元素重叠。
粘性定位 sticky:
- 元素先按照普通文档流定位，然后相对于该元素在流中的 flow root(BFC)和 containing block(最近的块级祖先元素)定位。
- 而后，元素定位表现为在跨越特定阈值前为相对定位，之后为固定定位。
默认定位 Static:
- 默认值。没有定位，元素出现在正常的流中(忽略 top, bottom, left, right 或者 z-index 声明)。
inherit:
- 规定应该从父元素继承 position 属性的值。

17. css3 新特性

开放题。CSS3 边框如 border-radius，box-shadow 等;CSS3 背景如 background-size， background-origin 等;CSS3 2D，3D 转换如 transform 等;CSS3 动画如 animation 等。参考 https://www.cnblogs.com/xkweb/p/5862612.html

18. CSS 选择器有哪些

选择器	示例	MDN	-
类型选择器	`h1 { }`	MDN	-
通配选择器	`* { }`	MDN	-
类选择器	`.box { }`	MDN	-
ID 选择器	`#unique { }`	MDN	-
标签属性选择器	`a[title] { }`	MDN	-
伪类选择器	`p:first-child { }` `button:hover {}` 等	具体见：MDN	-
伪元素选择器	`p::first-line { }`	MDN	-
后代选择器	`article p`	MDN	-
子代选择器	`article > p`	MDN	-
相邻兄弟选择器	`h1 + p`	MDN	-
通用兄弟选择器	`h1 ~ p`	MDN	-

19. CSS选择器优先级

MDN

四、前端优化

1. 可优化内容

降低请求量
- 合并资源，减少 HTTP 请求数，minify / gzip 压缩，webP，lazyLoad。
加快请求速度
- 预解析 DNS，减少域名数，并行加载，CDN 分发。
缓存
- HTTP 协议缓存请求，离线缓存 manifest，离线数据缓存 localStorage。
渲染
- JS/CSS 优化，加载顺序，服务端渲染，pipeline。

2. 怎么看网站的性能如何

检测页面加载时间一般有两种方式：

一种是被动去测:
- 就是在被检测的页面置入脚本或探针，当用户访问网页时，探针自动采集数据并传回数据库进行分析
另一种主动监测的方式
- 即主动的搭建分布式受控环境，模拟用户发起页面访问请求，主动采集性能数据并分析，在检测的精准度上，专业的第三方工具效果更佳，比如说性能极客

知识点梳理：JavaSctipt

Wed, 01 Feb 2023 00:00:00 GMT

一键搞定iOS16横竖屏切换

Thu, 13 Oct 2022 00:00:00 GMT

前言

近期同事反馈视频横屏的功能失效了，在才发现 iOS16 下以前的方式无法使用了。于是完善了一些自己之前写的横竖屏切换的拓展。

一、 iOS16 之前

1.1 切换横屏

UIDevice.current.setValue(UIDeviceOrientation.landscapeLeft.rawValue, forKey: "orientation")

1.2 切换竖屏

UIDevice.current.setValue(UIDeviceOrientation.portrait.rawValue, forKey: "orientation")

1.3 切换结果监听

通过系统通知 UIDevice.orientationDidChangeNotification 监听提切换动作。

@objc
private func orientationDidChange(noti: Notification) {
    guard
        let device = noti.object as? UIDevice
    else {
        return
    }
    if device.orientation.isLandscape {
        print("横屏")
    } else {
        print("竖屏")
    }
}

二、 iOS16

更新了 iOS16 之后，发现上面的都没效果了，就...很可爱。iOS16 之后需要通过 Scene 来进行横竖屏的切换控制。

核心代码如下：

func enterFullScreen() {
    guard #available(iOS 16.0, *) else {
        UIDevice.current.setValue(UIDeviceOrientation.landscapeLeft.rawValue, forKey: "orientation")
        return
    }
    switchMode(full: true)
}

func exitFullScreen() {
    guard #available(iOS 16.0, *) else {
        UIDevice.current.setValue(UIDeviceOrientation.portrait.rawValue, forKey: "orientation")
        return
    }
    switchMode(full: false)
}

@available(iOS 16.0, *)
private func switchMode(full: Bool) {
    guard
        let scence = UIApplication.shared.connectedScenes.first as? UIWindowScene
    else {
        return
    }
    let orientation: UIInterfaceOrientationMask = full ? .landscape : .portrait
    let geometryPreferencesIOS = UIWindowScene.GeometryPreferences.iOS(interfaceOrientations: orientation)
    scence.requestGeometryUpdate(geometryPreferencesIOS) { error in
    }
}

三、RyukieSwifty/FullScreen

我对这些逻辑进行了封装可以简单的接入到项目之中。也提供了示例程序。GitHub: RyukieSwifty/FullScreen

pods 接入：

pod 'RyukieSwifty/FullScreen'

下面以一个 UIViewController 为例：

import UIKit
import RyukieSwifty

class FullScreenViewController: UIViewController {

    override func viewDidLoad() {
        super.viewDidLoad()
        setupUI()
    }
    
    // MARK: - Life
    override func viewWillDisappear(_ animated: Bool) {
        super.viewWillDisappear(animated)
        swifty.exitFullScreen()
    }
    
    override func viewWillAppear(_ animated: Bool) {
        super.viewWillAppear(animated)
        swifty.needFullScreen()
    }
    
    override func viewWillTransition(to size: CGSize, with coordinator: UIViewControllerTransitionCoordinator) {
        super.viewWillTransition(to: size, with: coordinator)
        if size.width > size.height {
            switchButton.isSelected = true
        } else {
            switchButton.isSelected = false
        }
    }
    // MARK: - Function-Public
    
    // MARK: - Function-Private
    
    // MARK: UI
    private func setupUI() {
        view.backgroundColor = .white
        
        switchButton
            .added(to: view)
            .layout { make in
                make?.center.equalToSuperview()
            }
    }
    
    // MARK: Buiness
    
    // MARK: Action
    @objc
    private func switchAction() {
        switchButton.isSelected ? swifty.exitFullScreen() : swifty.enterFullScreen()
    }
    
    // MARK: Request
    
    // MARK: - VarLet-Public
    
    // MARK: - VarLet-Private
    private lazy var switchButton: UIButton = {
        return UIButton()
            .config {
                $0.setTitleColor(.black, for: .normal)
                $0.setTitle("切换为横屏", for: .normal)
                $0.setTitle("切换为竖屏", for: .selected)
                $0.addTarget(self, action: #selector(switchAction), for: .touchUpInside)
            }
    }()
}

extension AppDelegate {
    func application(_ application: UIApplication, supportedInterfaceOrientationsFor window: UIWindow?) -> UIInterfaceOrientationMask {
        return application.swifty.supportedInterfaceOrientations
    }
}

重建二叉树

Sun, 08 May 2022 00:00:00 GMT

一、题目

输入某二叉树的前序遍历和中序遍历的结果，请重建该二叉树。假设输入的前序遍历和中序遍历的结果中都不含重复的数字。

例如，给出

前序遍历 preorder = [3,9,20,15,7]

中序遍历 inorder = [9,3,15,20,7]

返回如下的二叉树：

限制：

0 <= 节点个数 <= 5000

链接：https://leetcode-cn.com/problems/zhong-jian-er-cha-shu-lcof

著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

二、解法

func buildTree(_ preorder: [Int], _ inorder: [Int]) -> TreeNode? {
    guard preorder.isEmpty == false, inorder.isEmpty == false else {
        return nil
    }
    
    let root = TreeNode(preorder[0], nil, nil)
    
    /**
     对中序的进行遍历，寻找根结点在其中的位置
     从而划分左右中序遍历结果
     */
    for (idx, node) in inorder.enumerated() {
        if node == preorder[0] { // 找到根结点
            root.left = buildTree(
                Array(preorder[1..<idx+1]),// 根结点在中序中的下标可以算出其 左子树的元素数量
                Array(inorder[0..<idx]))
            root.right = buildTree(
                Array(preorder[idx+1..<preorder.endIndex]),// 根结点在中序中的下标可以算出其 右子树的元素数量
                Array(inorder[idx+1..<inorder.endIndex]))
        }
    }
    
    return root
}

替换空格

Thu, 28 Apr 2022 00:00:00 GMT

一、题目

请实现一个函数，把字符串 s 中的每个空格替换成"%20"。

示例 1：

输入：s = "We are happy."

输出："We%20are%20happy."

限制：

0 <= s 的长度 <= 10000

链接：https://leetcode-cn.com/problems/ti-huan-kong-ge-lcof

著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

二、解法

func replaceSpace(_ s: String) -> String {    
    var temp = ""
    for c in s {
        if String(c) == " " {
            temp += "%20"
        }
        else {
            temp += String(c)
        }
    }
    return temp
}

从尾到头打印链表

Thu, 28 Apr 2022 00:00:00 GMT

一、题目

输入一个链表的头节点，从尾到头反过来返回每个节点的值（用数组返回）。

示例 1：

输入：head = [1,3,2]

输出：[2,3,1]

二、解法

2.1 辅助空间

func reversePrint(_ head: ListNode?) -> [Int] {
    var res: [Int] = [], node = head
    
    while let n = node {
        res.insert(n.val, at: 0)
        node = node?.next
    }
    
    return res
}

2.2 递归

func reversePrint(_ head: ListNode?) -> [Int] {
    guard let node = head else {
        return []
    }
    return reversePrint(head?.next) + [node.val]
}

找出数组中重复的数字

Wed, 27 Apr 2022 00:00:00 GMT

一、题目

找出数组中重复的数字。

在一个长度为 n 的数组 nums 里的所有数字都在 0～n-1 的范围内。数组中某些数字是重复的，但不知道有几个数字重复了，也不知道每个数字重复了几次。请找出数组中任意一个重复的数字。

示例 1：

输入：

[2, 3, 1, 0, 2, 5, 3]

输出：2 或 3

限制：

2 <= n <= 100000

通过次数188,858提交次数280,286

链接：https://leetcode-cn.com/problems/shu-zu-zhong-zhong-fu-de-shu-zi-lcof

著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

二、解法

2.1 二分法

二分法时间 O(log2N) 空间 O(N)

func findRepeatNumber(_ nums: [Int]) -> Int {
    var dic: [Int : Int] = [:]
    var left = 0, right = nums.count - 1
    
    while left <= right {
        if let _ = dic[nums[left]] {
            return nums[left]
        }
        else {
            dic[nums[left]] = 1
        }
        
        if let _ = dic[nums[right]] {
            return nums[right]
        }
        else {
            dic[nums[right]] = 1
        }
        
        left += 1
        right -= 1
    }
    
    return 0
}

2.2 一个萝卜一个坑

由题目限制 n 个元素，取值范围 0～n-1 可知：每个元素的值对应的下标处的元素如果存在相同元素那么就说明重复了。

func findRepeatNumber(in nums: [Int]) -> Int {
    var temp = nums, index = 0
    
    while index < temp.count {
        let currentValue = temp[index]
        
        if currentValue == index {
            index += 1 // 注意前移的条件，不是直接遍历
            continue
        }
        
        if currentValue == temp[currentValue] {
            return currentValue
        }
        
        temp.swapAt(index, currentValue)
    }
    
    return -1
}

二维数组中的查找

Wed, 27 Apr 2022 00:00:00 GMT

一、题目

在一个 n * m 的二维数组中，每一行都按照从左到右递增的顺序排序，每一列都按照从上到下递增的顺序排序。请完成一个高效的函数，输入这样的一个二维数组和一个整数，判断数组中是否含有该整数。

示例:

现有矩阵 matrix 如下：

[
[1,   4,  7, 11, 15],
[2,   5,  8, 12, 19],
[3,   6,  9, 16, 22],
[10, 13, 14, 17, 24],
[18, 21, 23, 26, 30]
]

给定 target = 5，返回 true。

给定 target = 20，返回 false。

限制：

0 <= n <= 1000

0 <= m <= 1000

注意：本题与主站 240 题相同：https://leetcode-cn.com/problems/search-a-2d-matrix-ii/

链接：https://leetcode-cn.com/problems/er-wei-shu-zu-zhong-de-cha-zhao-lcof

著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

二、解法

2.1 从右上角开始

func findNumberIn2DArrayA(_ matrix: [[Int]], _ target: Int) -> Bool {
    guard matrix.isEmpty == false, let first = matrix.first, first.isEmpty == false else {
        return false
    }
    var x = first.count - 1, y = 0
    
    while y < matrix.count {
        let line = matrix[y]
        let lineFinal = line[line.count - 1]
        
        if lineFinal >= target {
            while x >= 0 {
                if line[x] != target {
                    x -= 1
                }
                else {
                    return true
                }
            }
        }
        
        y += 1
        x = first.count - 1
    }
    
    return false
}

2.2 从右上角开始优化

func findNumberIn2DArray(_ matrix: [[Int]], _ target: Int) -> Bool {
    guard matrix.isEmpty == false, let first = matrix.first, first.isEmpty == false else {
        return false
    }
    var x = first.count - 1, y = 0
    
    while y < matrix.count, x >= 0 {
        let value = matrix[y][x]
        if value > target { x -= 1 }
        else if value < target { y += 1 }
        else { return true }
    }
    
    return false
}

2.3 从左下角

func findNumberIn2DArray(_ matrix: [[Int]], _ target: Int) -> Bool {
    guard matrix.isEmpty == false, let first = matrix.first, first.isEmpty == false else {
        return false
    }
    var x = 0, y = matrix.count - 1
    
    while x < first.count, y >= 0 {
        let value = matrix[y][x]
        if value > target { y -= 1 }
        else if value < target { x += 1 }
        else { return true }
    }
    
    return false
}

68-II.二叉树的最近公共祖先

Tue, 26 Apr 2022 00:00:00 GMT

一、题目

给定一个二叉树, 找到该树中两个指定节点的最近公共祖先。

百度百科中最近公共祖先的定义为：“对于有根树 T 的两个结点 p、q，最近公共祖先表示为一个结点 x，满足 x 是 p、q 的祖先且 x 的深度尽可能大（一个节点也可以是它自己的祖先）。”

例如，给定如下二叉树: root = [3,5,1,6,2,0,8,null,null,7,4]

示例 1:

输入: root = [3,5,1,6,2,0,8,null,null,7,4], p = 5, q = 1

输出: 3

解释: 节点 5 和节点 1 的最近公共祖先是节点 3。

示例 2:

输入: root = [3,5,1,6,2,0,8,null,null,7,4], p = 5, q = 4

输出: 5

解释: 节点 5 和节点 4 的最近公共祖先是节点 5。因为根据定义最近公共祖先节点可以为节点本身。

说明:

所有节点的值都是唯一的。

p、q 为不同节点且均存在于给定的二叉树中。

来源：力扣（LeetCode）

链接：https://leetcode-cn.com/problems/er-cha-shu-de-zui-jin-gong-gong-zu-xian-lcof

著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

二、题解

func lowestCommonAncestor(root: TreeNode?, pNode: TreeNode, qNode: TreeNode) -> TreeNode? {
    guard let root = root, root.val != pNode.val, root.val != qNode.val else {
        return root
    }
    
    let left = lowestCommonAncestor(root: root.left, pNode: pNode, qNode: qNode)
    let right = lowestCommonAncestor(root: root.right, pNode: pNode, qNode: qNode)
        
    if left == nil, right == nil { return nil }
    if left == nil { return right }
    if right == nil { return left }
    return root
}

把字符串转换成整数

Wed, 20 Apr 2022 00:00:00 GMT

一、题目

写一个函数 StrToInt，实现把字符串转换成整数这个功能。不能使用 atoi 或者其他类似的库函数。

首先，该函数会根据需要丢弃无用的开头空格字符，直到寻找到第一个非空格的字符为止。

当我们寻找到的第一个非空字符为正或者负号时，则将该符号与之后面尽可能多的连续数字组合起来，作为该整数的正负号；假如第一个非空字符是数字，则直接将其与之后连续的数字字符组合起来，形成整数。

该字符串除了有效的整数部分之后也可能会存在多余的字符，这些字符可以被忽略，它们对于函数不应该造成影响。

注意：假如该字符串中的第一个非空格字符不是一个有效整数字符、字符串为空或字符串仅包含空白字符时，则你的函数不需要进行转换。

在任何情况下，若函数不能进行有效的转换时，请返回 0。

说明：

假设我们的环境只能存储 32 位大小的有符号整数，那么其数值范围为 [−2^31, 2^31 − 1]。如果数值超过这个范围，请返回 INT_MAX (2^31 − 1) 或 INT_MIN (−2^31) 。

示例 1:

输入: "42"

输出: 42

示例 2:

输入: " -42"

输出: -42

解释: 第一个非空白字符为 '-', 它是一个负号。我们尽可能将负号与后面所有连续出现的数字组合起来，最后得到 -42 。

示例 3:

输入: "4193 with words"

输出: 4193

解释: 转换截止于数字 '3' ，因为它的下一个字符不为数字。

示例 4:

输入: "words and 987"

输出: 0

解释: 第一个非空字符是 'w', 但它不是数字或正、负号。因此无法执行有效的转换。

示例 5:

输入: "-91283472332"

输出: -2147483648

解释: 数字 "-91283472332" 超过 32 位有符号整数范围。因此返回 INT_MIN (−231) 。

来源：力扣（LeetCode）

链接：https://leetcode-cn.com/problems/ba-zi-fu-chuan-zhuan-huan-cheng-zheng-shu-lcof

著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

二、解法

找规律

let numbers: [Character] = ["1", "2", "3", "4", "5", "6", "7", "8", "9", "0"]
let symbles: [Character] = ["-", "+"]
let space: Character = " "

func strToInt(_ str: String) -> Int {
    let chrs = Array(str)
    var res: String = ""
    var lastChr: Character?
    
    for idx in 0..<chrs.count {
        let c = chrs[idx]
        
        guard
            symbles.contains(c) || numbers.contains(c) || space == c
        else {
            return number(of: res)
        }
        
        if let last = lastChr {
            // 空格之后只能跟 空格 符号 数字
            if last == space {
                lastChr = c
                if symbles.contains(c) || numbers.contains(c) {
                    res.append(c)
                }
            }
            // 符号后只能跟数字
            else if symbles.contains(last), numbers.contains(c) {
                lastChr = c
                res.append(c)
            }
            // 数字后只能跟数字
            else if numbers.contains(last), numbers.contains(c) {
                lastChr = c
                res.append(c)
            }
            else {
                return number(of: res)
            }
        }
        else {
            if numbers.contains(c) {
                res.append(c)
            }
            else if symbles.contains(c) {
                res.append(c)
            }
            lastChr = c
        }
    }
    
    return number(of: res)
}

func number(of str: String) -> Int {
    guard str.isEmpty == false, let last = str.last, symbles.contains(last) == false else {
        return 0
    }
    let maxValue = NSDecimalNumber(decimal: pow(2, 31)).intValue - 1
    let minValue = -NSDecimalNumber(decimal: pow(2, 31)).intValue
    
    if let res = Int64(str) {
        if res > Int64(maxValue) { return maxValue }
        if res < Int64(minValue) { return minValue }
        return Int(res)
    }
    return str.contains("-") ? minValue : maxValue
}

68-I.二叉搜索树的最近公共祖先

Wed, 20 Apr 2022 00:00:00 GMT

一、题目

给定一个二叉搜索树, 找到该树中两个指定节点的最近公共祖先。

例如，给定如下二叉搜索树: root = [6,2,8,0,4,7,9,null,null,3,5]

示例 1:

输入: root = [6,2,8,0,4,7,9,null,null,3,5], p = 2, q = 8

输出: 6

解释: 节点 2 和节点 8 的最近公共祖先是 6。

示例 2:

输入: root = [6,2,8,0,4,7,9,null,null,3,5], p = 2, q = 4

输出: 2

解释: 节点 2 和节点 4 的最近公共祖先是 2, 因为根据定义最近公共祖先节点可以为节点本身。说明:

所有节点的值都是唯一的。

p、q 为不同节点且均存在于给定的二叉搜索树中。

来源：力扣（LeetCode）

链接：https://leetcode-cn.com/problems/er-cha-sou-suo-shu-de-zui-jin-gong-gong-zu-xian-lcof

著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

二、解法

官方没有Swift用例

func lowestCommonAncestor(root: TreeNode, pNode: TreeNode, qNode: TreeNode) -> TreeNode {
    let minNode = pNode.val > qNode.val ? qNode : pNode
    let maxNode = pNode.val < qNode.val ? qNode : pNode
    guard
        !(minNode.val < root.val && maxNode.val > root.val),// 左右分布，直接return根结点
        (minNode.val != root.val && maxNode.val != root.val),
        let oNode = maxNode.val > root.val ? root.right : root.left
    else {
        // 利用二叉搜索树的特性排除一些情况，分别在两侧的话公共先祖就是跟节点
        return root
    }
    
    return lowestCommonAncestor(root: oNode, pNode: pNode, qNode: qNode)
}

构建乘积数组

Mon, 18 Apr 2022 00:00:00 GMT

一、题目

给定一个数组 A[0,1,…,n-1]，请构建一个数组 B[0,1,…,n-1]，其中 B[i] 的值是数组 A 中除了下标 i 以外的元素的积, 即 B[i]=A[0]×A[1]×…×A[i-1]×A[i+1]×…×A[n-1]。

不能使用除法。

示例:

输入: [1,2,3,4,5]

输出: [120,60,40,30,24]

提示：

所有元素乘积之和不会溢出 32 位整数

a.length <= 100000

来源：力扣（LeetCode）

链接：https://leetcode-cn.com/problems/gou-jian-cheng-ji-shu-zu-lcof

著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

二、解法

动态规划

func constructArr(_ a: [Int]) -> [Int] {
    guard a.isEmpty == false else {
        return []
    }
    var res: [Int] = []
    /// 某位之前的乘积
    var dpL: [Int : Int] = [0 : 1]
    /// 某位之后的乘积
    var dpR: [Int : Int] = [(a.count - 1) : 1]
    
    for idx in 1..<a.count {
        let lastIdx = idx - 1
        if let last = dpL[lastIdx] {
            dpL[idx] = last * a[lastIdx]
        }
        
        let backwordIdx = a.count - idx - 1
        if let last = dpR[backwordIdx + 1] {
            dpR[backwordIdx] = last * a[backwordIdx + 1]
        }
        
    }

    for idx in 0..<a.count {
        if let l = dpL[idx], let r = dpR[idx] {
            res.append(l * r)
        }
    }
    
    return res
}

股票的最大利润

Sat, 16 Apr 2022 00:00:00 GMT

一、题目

假设把某股票的价格按照时间先后顺序存储在数组中，请问买卖该股票一次可能获得的最大利润是多少？

示例 1:

输入: [7,1,5,3,6,4]

输出: 5

解释: 在第 2 天（股票价格 = 1）的时候买入，在第 5 天（股票价格 = 6）的时候卖出，最大利润 = 6-1 = 5 。注意利润不能是 7-1 = 6, 因为卖出价格需要大于买入价格。

示例 2:

输入: [7,6,4,3,1]

输出: 0

解释: 在这种情况下, 没有交易完成, 所以最大利润为 0。

限制：

0 <= 数组长度 <= 10^5

来源：力扣（LeetCode）

链接：https://leetcode-cn.com/problems/gu-piao-de-zui-da-li-run-lcof

著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

二、解法

func maxProfit(_ prices: [Int]) -> Int {
    guard prices.isEmpty == false else {
        return 0
    }
    var p = 0, res = 0, bottom = prices[0]
    
    while p < prices.count {
        let item = prices[p]
        if item <= bottom {
            bottom = item
        }
        else if item - bottom > res {
            res = item - bottom
        }
        p += 1
    }
    
    return res
}

求1+2+…+n

Sat, 16 Apr 2022 00:00:00 GMT

一、题目

求 1+2+...+n ，要求不能使用乘除法、for、while、if、else、switch、case等关键字及条件判断语句（A?B:C）。

示例 1：

输入: n = 3

输出: 6

示例 2：

输入: n = 9

输出: 45

限制：

1 <= n <= 10000

来源：力扣（LeetCode）

链接：https://leetcode-cn.com/problems/qiu-12n-lcof

著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

二、解法

分析

因为有限制条件，我们就不能直接使用公式：Sn = n * (n + 1) / 2 或 Smn=(n+m)(n-m+1)/2
可以使用递归代替循环

func sumNums(_ n: Int) -> Int {
    if n == 0 { return 0 }
    return n + sumNums(n - 1)
}

58-I.翻转单词顺序

Thu, 14 Apr 2022 00:00:00 GMT

一、题目

输入一个英文句子，翻转句子中单词的顺序，但单词内字符的顺序不变。为简单起见，标点符号和普通字母一样处理。例如输入字符串"I am a student. "，则输出"student. a am I"。

示例 1：

输入: "the sky is blue"

输出: "blue is sky the"

示例 2：

输入: " hello world! "

输出: "world! hello"

解释: 输入字符串可以在前面或者后面包含多余的空格，但是反转后的字符不能包括。

示例 3：

输入: "a good example"

输出: "example good a"

解释: 如果两个单词间有多余的空格，将反转后单词间的空格减少到只含一个。

说明：

无空格字符构成一个单词。

输入字符串可以在前面或者后面包含多余的空格，但是反转后的字符不能包括。

如果两个单词间有多余的空格，将反转后单词间的空格减少到只含一个。

来源：力扣（LeetCode）

链接：https://leetcode-cn.com/problems/fan-zhuan-dan-ci-shun-xu-lcof

著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

二、解法

func reverseWords(_ s: String) -> String {
    var res: String = ""
    var temp: String = ""
    
    for i in s {
        if i == " " {
            if temp.isEmpty == false {
                res = (res.isEmpty == false) ? "\(temp) \(res)" : temp
                temp = ""
            }
        }
        else {
            temp = "\(temp)\(i)"
        }
    }
    
    if temp.isEmpty == false {
        res = (res.isEmpty == false) ? "\(temp) \(res)" : temp
    }
    
    return res
}

58-II.左旋转字符串

Thu, 14 Apr 2022 00:00:00 GMT

一、题目

字符串的左旋转操作是把字符串前面的若干个字符转移到字符串的尾部。请定义一个函数实现字符串左旋转操作的功能。比如，输入字符串"abcdefg"和数字2，该函数将返回左旋转两位得到的结果"cdefgab"。

示例 1：

输入: s = "abcdefg", k = 2

输出: "cdefgab"

示例 2：

输入: s = "lrloseumgh", k = 6

输出: "umghlrlose"

限制：

1 <= k < s.length <= 10000

来源：力扣（LeetCode）

链接：https://leetcode-cn.com/problems/zuo-xuan-zhuan-zi-fu-chuan-lcof

著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

二、解法

func reverseLeftWords(_ s: String, _ n: Int) -> String {
    let idx = s.index(s.startIndex, offsetBy: n)
    let pre = String(s[..<idx])
    let aft = String(s[idx...])
    return "\(aft)\(pre)"
}

59-I.滑动窗口的最大值

Thu, 14 Apr 2022 00:00:00 GMT

一、题目

给定一个数组 nums 和滑动窗口的大小 k，请找出所有滑动窗口里的最大值。

示例:

输入: nums = [1,3,-1,-3,5,3,6,7], 和 k = 3

输出: [3,3,5,5,6,7]

解释:

滑动窗口的位置                最大值
[1  3  -1] -3  5  3  6  7       3
1 [3  -1  -3] 5  3  6  7       3
1  3 [-1  -3  5] 3  6  7       5
1  3  -1 [-3  5  3] 6  7       5
1  3  -1  -3 [5  3  6] 7       6
1  3  -1  -3  5 [3  6  7]      7

提示：

你可以假设 k 总是有效的，在输入数组不为空的情况下，1 ≤ k ≤ 输入数组的大小。

来源：力扣（LeetCode）

链接：https://leetcode-cn.com/problems/hua-dong-chuang-kou-de-zui-da-zhi-lcof

著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

二、解法动态规划

func maxSlidingWindow(_ nums: [Int], _ k: Int) -> [Int] {
    var res: [Int] = []
    guard nums.isEmpty == false else {
        return res
    }
    var left = 0, right = k - 1
    /// 存放每个段落的最大值下标，Key为右边界
    var dp: [Int : Int] = [:]
    
    while right < nums.count {
        let newItem = nums[right]
        if let lastmaxIdx = dp[right - 1], lastmaxIdx >= left {// 上一个最大值在当前范围内
            let lastMax = nums[lastmaxIdx]
            if lastMax > newItem {
                res.append(lastMax)
                dp[right] = lastmaxIdx
            }
            else {
                res.append(newItem)
                dp[right] = right
            }
        }
        else {
            var curMaxIdx = right
            var curMax = nums[curMaxIdx]
            for i in left..<right {
                if nums[i] > curMax {
                    curMaxIdx = i
                    curMax = nums[curMaxIdx]
                }
            }
            res.append(curMax)
            dp[right] = curMaxIdx
        }
        
        right += 1
        left += 1
    }
    
    return res
}

59-II.队列的最大值

Thu, 14 Apr 2022 00:00:00 GMT

一、题目

请定义一个队列并实现函数 max_value 得到队列里的最大值，要求函数max_value、push_back 和 pop_front 的均摊时间复杂度都是O(1)。

若队列为空，pop_front 和 max_value 需要返回 -1

示例 1：

输入:

["MaxQueue","push_back","push_back","max_value","pop_front","max_value"]

[[],[1],[2],[],[],[]]

输出: [null,null,null,2,1,2]

示例 2：

输入:

["MaxQueue","pop_front","max_value"]

[[],[],[]]

输出: [null,-1,-1] 限制：

1 <= push_back,pop_front,max_value的总操作数 <= 10000

1 <= value <= 10^5

来源：力扣（LeetCode）

链接：https://leetcode-cn.com/problems/dui-lie-de-zui-da-zhi-lcof

著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

二、解法

实现一个优先队列么

n个骰子的点数

Thu, 14 Apr 2022 00:00:00 GMT

一、题目

把n个骰子扔在地上，所有骰子朝上一面的点数之和为s。输入n，打印出s的所有可能的值出现的概率。

你需要用一个浮点数数组返回答案，其中第 i 个元素代表这 n 个骰子所能掷出的点数集合中第 i 小的那个的概率。

示例 1:

输入: 1

输出: [0.16667,0.16667,0.16667,0.16667,0.16667,0.16667]

示例 2:

输入: 2

输出: [0.02778,0.05556,0.08333,0.11111,0.13889,0.16667,0.13889,0.11111,0.08333,0.05556,0.02778]

限制：

1 <= n <= 11

来源：力扣（LeetCode）

链接：https://leetcode-cn.com/problems/nge-tou-zi-de-dian-shu-lcof

著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

二、解法

数组内元素和为 1
要求每个和有多少种组合方式
每个组合方式数/总组合数就是概率了

func dicesProbability(_ n: Int) -> [Double] {
    let sRangeMin = n
    let sRangeMax = n * 6
    var total = 0
    var temp: [Int] = []
    var res: [Double] = []
    
    for s in sRangeMin...sRangeMax {
        let c = resultCount(of: s, by: n)
        total += c
        temp.append(c)
    }
    
    temp.forEach {
        res.append(Double($0) / Double(total))
    }
    
    return res
}

设 f(n,x) 为 n 个骰子和为 x 的组合数
f(n,x) = f(n-1, x-1) + f(n-1, x-2) + f(n-1, x-3) + f(n-1, x-4) + f(n-1, x-5) + f(n-1, x-6)

var dp: [String : Int] = [:]

/// 求 n 个 1-6 的数字和为 num 的组合数
/// - Parameters:
///   - num: -
///   - n: -
/// - Returns: 组合数
func resultCount(of num: Int, by n: Int) -> Int {
    guard num >= n, num <= n*6 else { // 注意控制边界条件
        return 0
    }
    
    guard n > 1 else {
        return 1
    }
    
    let key = "\(n) - \(num)"
    if let r = dp[key] {
        return r
    }
    
    var res: Int = 0
    for i in 1...6 {
        res += resultCount(of: num - i, by: n - 1)
    }
    
    dp[key] = res
    return res
}

扑克牌中的顺子

Thu, 14 Apr 2022 00:00:00 GMT

一、题目

从若干副扑克牌中随机抽 5 张牌，判断是不是一个顺子，即这5张牌是不是连续的。2～10为数字本身，A为1，J为11，Q为12，K为13，而大、小王为 0 ，可以看成任意数字。A 不能视为 14。

示例 1:

输入: [1,2,3,4,5]

输出: True

示例 2:

输入: [0,0,1,2,5]

输出: True

限制：

数组长度为 5

数组的数取值为 [0, 13] .

来源：力扣（LeetCode）

链接：https://leetcode-cn.com/problems/bu-ke-pai-zhong-de-shun-zi-lcof

著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

二、解法

func isStraight(_ nums: [Int]) -> Bool {
    var zeroCount = 0
    var last: Int?
    
    for i in nums.sorted() {
        if i == 0 {
            zeroCount += 1
        }
        else if let l = last {
            let deta = i - l
            if deta > 0 {
                zeroCount -= (deta - 1)
                last = i
            }
            else {
                return false
            }
        }
        else {
            last = i
        }
        
        if zeroCount < 0 {
            return false
        }
    }
    
    return true
}

圆圈中最后剩下的数字

Thu, 14 Apr 2022 00:00:00 GMT

一、题目

0,1,···,n-1这n个数字排成一个圆圈，从数字0开始，每次从这个圆圈里删除第m个数字（删除后从下一个数字开始计数）。求出这个圆圈里剩下的最后一个数字。

例如，0、1、2、3、4这5个数字组成一个圆圈，从数字0开始每次删除第3个数字，则删除的前4个数字依次是2、0、4、1，因此最后剩下的数字是3。

示例 1：

输入: n = 5, m = 3

输出: 3

示例 2：

输入: n = 10, m = 17

输出: 2 限制：

1 <= n <= 10^5 1 <= m <= 10^6

来源：力扣（LeetCode）

链接：https://leetcode-cn.com/problems/yuan-quan-zhong-zui-hou-sheng-xia-de-shu-zi-lcof

著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

二、解法

超时

func lastRemaining(_ n: Int, _ m: Int) -> Int {
    var right = m - 1
    var nums: [Int] = Array(0..<n)
    
    while nums.count > 1 {
        right = (right < nums.count) ? right : (right % nums.count)
        
        nums.remove(at: right)
        
        right += (m - 1)
    }
    
    return nums[0]
}

数学解法

能力有限。理解不能

和为s的两个数字

Thu, 31 Mar 2022 00:00:00 GMT

一、题目

输入一个递增排序的数组和一个数字s，在数组中查找两个数，使得它们的和正好是s。如果有多对数字的和等于s，则输出任意一对即可。

示例 1：

输入：nums = [2,7,11,15], target = 9

输出：[2,7] 或者 [7,2]

示例 2：

输入：nums = [10,26,30,31,47,60], target = 40

输出：[10,30] 或者 [30,10]

限制：

1 <= nums.length <= 10^5

1 <= nums[i] <= 10^6

来源：力扣（LeetCode）

链接：https://leetcode-cn.com/problems/he-wei-sde-liang-ge-shu-zi-lcof

著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

二、解法

2.1 Map

func twoSum(_ nums: [Int], _ target: Int) -> [Int] {
    var temp: [Int : Int] = [:]
    for num in nums {
        guard target >= num else { break }
        if let other = temp[num] {
            return [num, other]
        }
        temp[target - num] = num
    }
    return []
}

2.2 双指针

func twoSum(_ nums: [Int], _ target: Int) -> [Int] {
    var l = 0, r = nums.count - 1
    
    while l < r {
        let a = nums[l], b = nums[r]
        if a + b > target {
            r -= 1
        }
        else if a + b < target {
            l += 1
        }
        else {
            return [a, b]
        }
    }
    
    return []
}

56-II.数组中数字出现的次数II

Tue, 29 Mar 2022 00:00:00 GMT

一、题目

在一个数组 nums 中除一个数字只出现一次之外，其他数字都出现了三次。请找出那个只出现一次的数字。

示例 1：

输入：nums = [3,4,3,3]

输出：4

示例 2：

输入：nums = [9,1,7,9,7,9,7]

输出：1

限制：

1 <= nums.length <= 10000

1 <= nums[i] < 2^31

来源：力扣（LeetCode）

链接：https://leetcode-cn.com/problems/shu-zu-zhong-shu-zi-chu-xian-de-ci-shu-ii-lcof

著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

二、解法

创建一个临时队列，遍历 nums
- 数字 item 存在，下标为 lastIdx
  - 插入 item 到队列末端
  - 移除 lastIdx 下标元素
- 不存在
  - 插入到队列头部
遍历完成，队列头部元素即为结果

func singleNumber(_ nums: [Int]) -> Int {
    var queue: [Int] = []
    
    for item in nums {
        if let lastIdx = queue.firstIndex(of: item) {
            queue.remove(at: lastIdx)
            queue.append(item)
        }
        else {
            queue.insert(item, at: 0)
        }
    }
    
    return queue[0]
}

56-I.数组中数字出现的次数

Thu, 24 Mar 2022 00:00:00 GMT

一、题目

一个整型数组 nums 里除两个数字之外，其他数字都出现了两次。请写程序找出这两个只出现一次的数字。要求时间复杂度是O(n)，空间复杂度是O(1)。

示例 1：

输入：nums = [4,1,4,6]

输出：[1,6] 或 [6,1]

示例 2：

输入：nums = [1,2,10,4,1,4,3,3]

输出：[2,10] 或 [10,2]

限制：

2 <= nums.length <= 10000

来源：力扣（LeetCode）

链接：https://leetcode-cn.com/problems/shu-zu-zhong-shu-zi-chu-xian-de-ci-shu-lcof

著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

二、分析

2.1 HashMap

HashMap 解法很容易想到，但是不符合空间复杂度的要求。

2.2 位运算

如果只有一个不同的话全员异或就能得出结果，本题我们如果能够将数组拆分为两个是不是就能得出结果了？

[1,2,10,4,1,4,3,3] 对应的二进制如下

设结果为 x y 两个元素
全员异或结果 n = x ^ y = 1000
那么怎么分成两个数组呢？要拆分需要一个基准，即一个用来区分两个数组元素不同的点
我们回到 n ，我们可以知道必有两个不同的，所以结果 n 必定至少有一位为 1，那么我们可以分为两组：
- 这一位为 1 的元素
- 这一位为 0 的元素
为了找到这一位1，我们定义一个临时变量 t = 1，逐步左移 & n 找到为1的情况。
接下来便利元素，通过 & t 是否大于 1 来区分元素，分别累积异或 x 或者 y
最终的 x，y 就是我们要找的两个元素了

时间复杂度 O(N) 或者说是 2N，控件复杂度 O(1)

func singleNumbers(_ nums: [Int]) -> [Int] {
    var x = 0, y = 0, n = 0, t = 1
    nums.forEach { n ^= $0 }
    while (t & n) == 0 { t <<= 1 }
    nums.forEach {
        (($0 & t) >= 1) ? (x ^= $0) : (y ^= $0)
    }
    return [x, y]
}

55-I.二叉树的深度

Wed, 23 Mar 2022 00:00:00 GMT

一、题目

输入一棵二叉树的根节点，求该树的深度。从根节点到叶节点依次经过的节点（含根、叶节点）形成树的一条路径，最长路径的长度为树的深度。

例如：

给定二叉树 [3,9,20,null,null,15,7]，

返回它的最大深度 3 。

提示：

节点总数 <= 10000

来源：力扣（LeetCode）

链接：https://leetcode-cn.com/problems/er-cha-shu-de-shen-du-lcof

著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

二、解法

2.1 递归

func maxDepth(_ root: TreeNode?) -> Int {
    guard let tree = root else { return 0 }
    if tree.left == nil, tree.right == nil { return 1 }
    return max(maxDepth(tree.left), maxDepth(tree.right)) + 1
}

2.2 非递归

func maxDepth(_ root: TreeNode?) -> Int {
    var deep = 0
    guard let root = root else { return deep }
    var queue: [TreeNode] = [root]
    var currentLevelCount = 1
    var nextLevelCount = 0
    
    while queue.isEmpty == false {
        let current = queue.removeFirst()
        currentLevelCount -= 1
        
        if let left = current.left {
            queue.append(left)
            nextLevelCount += 1
        }
        
        if let right = current.right {
            queue.append(right)
            nextLevelCount += 1
        }
        
        if currentLevelCount == 0 {
            deep += 1
            currentLevelCount = nextLevelCount
            nextLevelCount = 0
        }
    }
    
    return deep
}

55-II.平衡二叉树

Wed, 23 Mar 2022 00:00:00 GMT

一、题目

输入一棵二叉树的根节点，判断该树是不是平衡二叉树。如果某二叉树中任意节点的左右子树的深度相差不超过1，那么它就是一棵平衡二叉树。示例 1:

给定二叉树 [3,9,20,null,null,15,7]

返回 true 。

示例 2:

给定二叉树 [1,2,2,3,3,null,null,4,4]

返回 false 。

限制：

0 <= 树的结点个数 <= 10000

来源：力扣（LeetCode）

链接：https://leetcode-cn.com/problems/ping-heng-er-cha-shu-lcof

著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

二、解法

深度有用到上一题的思路。

func isBalanced(_ root: TreeNode?) -> Bool {
    let deepL = maxDepth(root?.left)
    let deepR = maxDepth(root?.right)
    if (deepL == 0 && deepR == 0) {
        return true
    }
    if (abs(deepL - deepR) > 1) {
        return false
    }
    return (isBalanced(root?.left) && isBalanced(root?.right))
}

func maxDepth(_ root: TreeNode?) -> Int {
    var deep = 0
    guard let root = root else { return deep }
    var queue: [TreeNode] = [root]
    var currentLevelCount = 1
    var nextLevelCount = 0
    
    while queue.isEmpty == false {
        let current = queue.removeFirst()
        currentLevelCount -= 1
        
        if let left = current.left {
            queue.append(left)
            nextLevelCount += 1
        }
        
        if let right = current.right {
            queue.append(right)
            nextLevelCount += 1
        }
        
        if currentLevelCount == 0 {
            deep += 1
            currentLevelCount = nextLevelCount
            nextLevelCount = 0
        }
    }
    
    return deep
}

第一个只出现一次的字符

Tue, 22 Mar 2022 00:00:00 GMT

一、题目

在字符串 s 中找出第一个只出现一次的字符。如果没有，返回一个单空格。 s 只包含小写字母。

示例 1:

输入：s = "abaccdeff"

输出：'b'

示例 2:

输入：s = ""

输出：' '

限制：

0 <= s 的长度 <= 50000

来源：力扣（LeetCode）

链接：https://leetcode-cn.com/problems/di-yi-ge-zhi-chu-xian-yi-ci-de-zi-fu-lcof

著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

二、解法

func firstUniqChar(_ s: String) -> Character {
    let strArr = Array(s)
    var dp: [Character : Int] = [:]
    var indexs: [Character] = []
    
    strArr.forEach {
        if dp[$0] != nil {
            if let idx = indexs.firstIndex(of: $0) {
                indexs.remove(at: idx)                
            }
        }
        else {
            dp[$0] = 1
            indexs.append($0)
        }
    }
    
    return indexs.first ?? " "
}

53-I.在排序数组中查找数字

Tue, 22 Mar 2022 00:00:00 GMT

一、题目

统计一个数字在排序数组中出现的次数。

示例 1:

输入: nums = [5,7,7,8,8,10], target = 8

输出: 2

示例 2:

输入: nums = [5,7,7,8,8,10], target = 6

输出: 0 提示：

0 <= nums.length <= 105

-109 <= nums[i] <= 109

nums 是一个非递减数组

-109 <= target <= 109

来源：力扣（LeetCode）

链接：https://leetcode-cn.com/problems/zai-pai-xu-shu-zu-zhong-cha-zhao-shu-zi-lcof

著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

二、解法

func search(_ nums: [Int], _ target: Int) -> Int {
    guard
        let first = nums.firstIndex(of: target),
        let last = nums.lastIndex(of: target)
    else {
        return 0
    }
    return last - first + 1
}

53-II.0～n-1中缺失的数字

Tue, 22 Mar 2022 00:00:00 GMT

一、题目

一个长度为n-1的递增排序数组中的所有数字都是唯一的，并且每个数字都在范围0～n-1之内。在范围0～n-1内的n个数字中有且只有一个数字不在该数组中，请找出这个数字。

示例 1:

输入: [0,1,3]

输出: 2

示例 2:

输入: [0,1,2,3,4,5,6,7,9]

输出: 8

限制：

1 <= 数组长度 <= 10000

来源：力扣（LeetCode）

链接：https://leetcode-cn.com/problems/que-shi-de-shu-zi-lcof

著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

二、分析

2.1 下标匹配

本题为有序的数据，因此可以通过下标匹配来寻找缺失的数字

func missingNumber(_ nums: [Int]) -> Int {
    var tmp = 0
    
    for i in nums {
        if tmp != i {
            return tmp
        }
        else {
            tmp += 1
        }
    }
    
    return tmp
}

2.2 二分法

排序数组中的搜索问题，首先可以想到 二分法 解决，时间复杂度降低为了 O(logN)。

func missingNumber(_ nums: [Int]) -> Int {
    var per = 0, aft = nums.count - 1
    while per <= aft {
        // 求中间下标
        let m = (per + aft) / 2

        if nums[m] == m {
            per = m + 1
        }
        else {
            aft = m - 1
        }
    }
    return per
}

二叉搜索树的第k大节点

Tue, 22 Mar 2022 00:00:00 GMT

一、题目

给定一棵二叉搜索树，请找出其中第 k 大的节点的值。

示例 1:

输入: root = [3,1,4,null,2], k = 1

输出: 4

示例 2:

输入: root = [5,3,6,2,4,null,null,1], k = 3

输出: 4 限制：

1 ≤ k ≤ 二叉搜索树元素个数

来源：力扣（LeetCode）

链接：https://leetcode-cn.com/problems/er-cha-sou-suo-shu-de-di-kda-jie-dian-lcof

著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

二、分析

根据二叉搜索树的特性，我们通过中序遍历得到有序的数组就可以轻松获得结果

func kthLargest(_ root: TreeNode?, _ k: Int) -> Int {
    var inorderArr: [Int] = []
    
    func inorder(_ node: TreeNode?) {
        guard let n = node else {
            return
        }
        
        inorder(n.right)
        inorderArr.append(n.val)
        inorder(n.left)
    }
    
    inorder(root)
    
    return inorderArr[k - 1]
}

两个链表的第一个公共节点

Mon, 21 Mar 2022 00:00:00 GMT

一、题目

输入两个链表，找出它们的第一个公共节点。

如下面的两个链表：

在节点 c1 开始相交。

示例 1：

输入：intersectVal = 8, listA = [4,1,8,4,5], listB = [5,0,1,8,4,5], skipA = 2, skipB = 3

输出：Reference of the node with value = 8

输入解释：相交节点的值为 8 （注意，如果两个列表相交则不能为 0）。从各自的表头开始算起，链表 A 为 [4,1,8,4,5]，链表 B 为 [5,0,1,8,4,5]。在 A 中，相交节点前有 2 个节点；在 B 中，相交节点前有 3 个节点。

示例 2：

输入：intersectVal = 2, listA = [0,9,1,2,4], listB = [3,2,4], skipA = 3, skipB = 1

输出：Reference of the node with value = 2

输入解释：相交节点的值为 2 （注意，如果两个列表相交则不能为 0）。从各自的表头开始算起，链表 A 为 [0,9,1,2,4]，链表 B 为 [3,2,4]。在 A 中，相交节点前有 3 个节点；在 B 中，相交节点前有 1 个节点。

示例 3：

输入：intersectVal = 0, listA = [2,6,4], listB = [1,5], skipA = 3, skipB = 2

输出：null

输入解释：从各自的表头开始算起，链表 A 为 [2,6,4]，链表 B 为 [1,5]。由于这两个链表不相交，所以 intersectVal 必须为 0，而 skipA 和 skipB 可以是任意值。

解释：这两个链表不相交，因此返回 null。

注意：

如果两个链表没有交点，返回 null.

在返回结果后，两个链表仍须保持原有的结构。

可假定整个链表结构中没有循环。

程序尽量满足 O(n) 时间复杂度，且仅用 O(1) 内存。

本题与主站 160 题相同：https://leetcode-cn.com/problems/intersection-of-two-linked-lists/

来源：力扣（LeetCode）

链接：https://leetcode-cn.com/problems/liang-ge-lian-biao-de-di-yi-ge-gong-gong-jie-dian-lcof

著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

二、分析

示例1，中看到公共节点位8，而不是1。可能有些同学会感到很疑惑。但其实这里两个节点的比较并不是数值的比较，而是内存地址的比较。同样值是1，但却是两个不同内存地址的两个节点。知道这个前提，这个题目就很简单两。

三、题解

本体没有官方 Swift 用例。这里我们自己构造数据结构

3.1 ListNode

public class ListNode: Equatable {
    public static func == (lhs: ListNode, rhs: ListNode) -> Bool {
        Unmanaged.passUnretained(lhs).toOpaque() == Unmanaged.passUnretained(rhs).toOpaque()
    }
    
    public var val: Int
    public var next: ListNode?
    public init(_ val: Int) {
        self.val = val
        self.next = nil
    }
}

3.2 题解

func getIntersectionNode(headA: ListNode, headB: ListNode) -> ListNode? {
    var temp: [ListNode] = []
    var headA: ListNode? = headA
    var headB: ListNode? = headB
    
    while let a = headA {
        temp.append(a)
        headA = a.next
    }
    
    while let b = headB {
        if temp.contains(where: { $0 == b }) {
            return b
        }
        headB = b.next
    }
    
    return nil
}

3.3 用例

let n0 = ListNode(0)
let n11 = ListNode(1)
let n12 = ListNode(1)
let n4 = ListNode(4)
let n42 = ListNode(4)
let n51 = ListNode(5)
let n52 = ListNode(5)
let n8 = ListNode(8)

// [4,1,8,4,5]
n4.next = n11
n11.next = n8
n8.next = n42
n42.next = n52

// [5,0,1,8,4,5]
n51.next = n0
n0.next = n12
n12.next = n8

let res = getIntersectionNode(headA: n4, headB: n51)
print(res?.val)

最长不含重复字符的子字符串

Tue, 15 Mar 2022 00:00:00 GMT

一、题目

请从字符串中找出一个最长的不包含重复字符的子字符串，计算该最长子字符串的长度。

示例 1:

输入: "abcabcbb"

输出: 3

解释: 因为无重复字符的最长子串是 "abc"，所以其长度为 3。

示例 2:

输入: "bbbbb"

输出: 1

解释: 因为无重复字符的最长子串是 "b"，所以其长度为 1。

示例 3:

输入: "pwwkew"

输出: 3

解释: 因为无重复字符的最长子串是 "wke"，所以其长度为 3。请注意，你的答案必须是子串的长度，"pwke" 是一个子序列，不是子串。

提示：

s.length <= 40000

来源：力扣（LeetCode）

链接：https://leetcode-cn.com/problems/zui-chang-bu-han-zhong-fu-zi-fu-de-zi-zi-fu-chuan-lcof

著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

二、解法

func lengthOfLongestSubstring(_ s: String) -> Int {
    guard s.isEmpty == false else {
        return 0
    }
    let stringArr: [Character] = Array(s)
    var maxCount: Int = 0
    /// 最后一次元素出现的下标
    var map: [Character : Int] = [ : ]
    /// 一个重复段内的不重复子串长度
    var temp: Int = 0
    
    for idx in 0..<stringArr.count {
        if let last = map[stringArr[idx]] {
            temp = (temp < (idx - last)) ? (temp + 1) : (idx - last)
        }
        else {
            temp += 1
        }
        map[stringArr[idx]] = idx
        maxCount = max(maxCount, temp)
    }
    
    return maxCount
}

可以简化为

func lengthOfLongestSubstring(_ s: String) -> Int {
    ...

    for idx in 0..<stringArr.count {
        let last = map[stringArr[idx]] ?? -1
        temp = (temp < (idx - last)) ? (temp + 1) : (idx - last)
        map[stringArr[idx]] = idx
        maxCount = max(maxCount, temp)
    }
    
    ...
}

数字序列中某一位的数字

Thu, 10 Mar 2022 00:00:00 GMT

一、题目

数字以0123456789101112131415…的格式序列化到一个字符序列中。

在这个序列中，第5位（从下标0开始计数）是5，第13位是1，第19位是4，等等。

请写一个函数，求任意第n位对应的数字。

示例 1：

输入：n = 3

输出：3

示例 2：

输入：n = 11

输出：0

限制：

0 <= n < 2^31

注意：本题与主站 400 题相同：https://leetcode-cn.com/problems/nth-digit/

来源：力扣（LeetCode）

链接：https://leetcode-cn.com/problems/shu-zi-xu-lie-zhong-mou-yi-wei-de-shu-zi-lcof

著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

二、分析

本题我们先要看看为了找到下标为 n 的数字 x ，我们需要什么：

在那个数中 num
其在 num 中的下标
即可求得 x

把数组排成最小的数

Thu, 10 Mar 2022 00:00:00 GMT

一、题目

输入一个非负整数数组，把数组里所有数字拼接起来排成一个数，打印能拼接出的所有数字中最小的一个。

示例 1:

输入: [10,2]

输出: "102"

示例 2:

输入: [3,30,34,5,9]

输出: "3033459"

提示:

0 < nums.length <= 100

说明:

输出结果可能非常大，所以你需要返回一个字符串而不是整数

拼接起来的数字可能会有前导 0，最后结果不需要去掉前导 0

来源：力扣（LeetCode）

链接：https://leetcode-cn.com/problems/ba-shu-zu-pai-cheng-zui-xiao-de-shu-lcof

著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

二、优先队列

func minNumber(_ nums: [Int]) -> String {
    var queue = SwiftPriorityQueue<Int>.init(hasHigherPriority: {
        return hasHigher(x: $0, compare: $1)
    }, isEqual: {
        $0 == $1
    })
    
    var result: String = ""
    
    nums.forEach {
        queue.enqueue($0)
    }
        
    while let value = queue.dequeue() {
        result.append("\(value)")
    }
        
    return result
}

func hasHigher(x: Int, compare y: Int) -> Bool {
    let aArr = [Character](String(x))
    let bArr = [Character](String(y))
    
    let resultA = Int(String(aArr + bArr)) ?? 0
    let resultB = Int(String(bArr + aArr)) ?? 0
    
    return resultA <= resultB
}

三、自带的排序

func minNumber(_ nums: [Int]) -> String {
    let queue = nums.sorted { return hasHigher(x: $0, compare: $1) }
    var result: String = ""
    queue.forEach {
        result.append("\($0)")
    }
    return result
}

func hasHigher(x: Int, compare y: Int) -> Bool {
    let aArr = [Character](String(x))
    let bArr = [Character](String(y))
    
    let resultA = Int(String(aArr + bArr)) ?? 0
    let resultB = Int(String(bArr + aArr)) ?? 0
    
    return resultA <= resultB
}

把数字翻译成字符串

Thu, 10 Mar 2022 00:00:00 GMT

一、题目

给定一个数字，我们按照如下规则把它翻译为字符串：0 翻译成 “a” ，1 翻译成 “b”，……，11 翻译成 “l”，……，25 翻译成 “z”。一个数字可能有多个翻译。请编程实现一个函数，用来计算一个数字有多少种不同的翻译方法。

示例 1:

输入: 12258

输出: 5

解释: 12258有5种不同的翻译，分别是"bccfi", "bwfi", "bczi", "mcfi"和"mzi"

提示：

0 <= num < 231

来源：力扣（LeetCode）

链接：https://leetcode-cn.com/problems/ba-shu-zi-fan-yi-cheng-zi-fu-chuan-lcof

著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

礼物的最大价值

Thu, 10 Mar 2022 00:00:00 GMT

一、题目

在一个 m*n 的棋盘的每一格都放有一个礼物，每个礼物都有一定的价值（价值大于 0）。你可以从棋盘的左上角开始拿格子里的礼物，并每次向右或者向下移动一格、直到到达棋盘的右下角。给定一个棋盘及其上面的礼物的价值，请计算你最多能拿到多少价值的礼物？示例 1:

输入:

[
  [1,3,1],
  [1,5,1],
  [4,2,1]
]

输出: 12

解释: 路径 1→3→5→2→1 可以拿到最多价值的礼物

提示：

0 < grid.length <= 200

0 < grid[0].length <= 200

来源：力扣（LeetCode）

链接：https://leetcode-cn.com/problems/li-wu-de-zui-da-jie-zhi-lcof

著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

二、图解

三、解法

func maxValue(_ grid: [[Int]]) -> Int {
    let w = grid[0].count
    let h = grid.count
    var dp: [[Int]] = Array(repeating: Array(repeating: 0, count: w), count: h)
    
    for y in 0..<h {
        for x in 0..<w {
            let value = grid[y][x]
            if x == 0, y == 0 { dp[y][x] = value }
            else if y == 0, x > 0 { dp[y][x] = dp[y][x-1] + value }
            else if y > 0, x == 0 { dp[y][x] = dp[y-1][x] + value }
            else { dp[y][x] = max(dp[y][x-1], dp[y-1][x]) + value }
        }
    }
    
    return dp[h-1][w-1]
}

1～n整数中1出现的次数

Tue, 22 Feb 2022 00:00:00 GMT

一、题目

输入一个整数 n ，求1～n这n个整数的十进制表示中1出现的次数。

例如，输入12，1～12这些整数中包含1 的数字有1、10、11和12，1一共出现了5次。

示例 1：

输入：n = 12

输出：5

示例 2：

输入：n = 13

输出：6

限制：

1 <= n < 2^31

注意：本题与主站 233 题相同：https://leetcode-cn.com/problems/number-of-digit-one/

来源：力扣（LeetCode）

链接：https://leetcode-cn.com/problems/1nzheng-shu-zhong-1chu-xian-de-ci-shu-lcof

著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

二、分析

2.1 暴力

当然遍历全部数字，进行累加理论上是可行的。但是如果真写出这样的代码就别想通过面试了🤷‍♂️。

2.2 按位分析

我们需要知道一个前提，1出现的次数和就是1在每一位上出现的次数的和。那么我们如何计算出每一位上出现1的次数呢？

下面我们以310562为例进行一下分析。

百位

我们想知道在这位出现1的次数，我们定义当前位的数字为 num = 5 ，其左边的所有数字为 pre = 310 ，右边的数字为 aft = 62 ，当前位为 base = 100 。

左组合数量：
- 0 ～ 310
- pre + 1
右组合数量：
- 0 ～ 99
- base
 - 因为 1 < 5 ，百位为1时位数足够，可以取到 99
 - 其实就等于当前的位，即100

次数 = (pre + 1) * base

千位

pre = 31, num = 0, base = 1000, aft = 562

当前位为0，当为1时必须需要前面退位，如上图变化
- 前范围变为 0 ～ 30
左组合数量
- 0 ～ 30
- pre
右组合数量：
- 0 ～ 999
- base

次数 = (pre * base)

万位

pre = 3, num = 1, base = 10000, aft = 0562

当 pre 取 0 ～ 2 时：
- 左组合数量
  - 0 ～ 2
  - pre
- 右组合数量：
  - 0 ～ 999
  - base
当 pre 取 3 时：
- 左组合数量
  - 3
  - 1
- 右组合数量：
  - 0 ～ 562
  - (aft + 1)

次数 = (pre * base) * (aft + 1)

左数 & 右数

上面将所有三种特殊情况的次数计算方式都推导出来了。剩下推出 pre aft num 的公式即可。

根据规律推导出：
- pre = n / base / 10
- aft = n % base
- num = n / base % 10

下面我们就可以根据上面的公式完成遍历的逻辑了。

三、编码

func countDigitOne(_ n: Int) -> Int {
    var base = 1
    var sum = 0

    while base <= n {
        let pre = n / base / 10
        let aft = n % base
        let num = n / base % 10
                
        if num == 1 {
            sum += ((pre * base) + (aft + 1))
        }
        else if num == 0 {
            sum += (pre * base)
        }
        else {
            sum += ((pre + 1) * base)
        }
                
        base *= 10
    }
    
    return sum
}

连续子数组的最大和

Mon, 21 Feb 2022 00:00:00 GMT

一、题目

输入一个整型数组，数组中的一个或连续多个整数组成一个子数组。求所有子数组的和的最大值。

要求时间复杂度为O(n)。

示例1:

输入: nums = [-2,1,-3,4,-1,2,1,-5,4]

输出: 6

解释: 连续子数组 [4,-1,2,1] 的和最大，为 6。

提示：

1 <= arr.length <= 10^5

-100 <= arr[i] <= 100

注意：本题与主站 53 题相同：https://leetcode-cn.com/problems/maximum-subarray/

来源：力扣（LeetCode）

链接：https://leetcode-cn.com/problems/lian-xu-zi-shu-zu-de-zui-da-he-lcof

著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

二、解法一：找规律图解

如图中，纵坐标表示的是累加和，绿色代表的是我们需要求的最大子数组和。我们发现下面的规律：

我们需要找的是整体呈上升趋势的分段
- 即：区段内的累加和大于0
如果区段内的累加和小于0那么当前区段是呈下降趋势的
- 这段我们可以丢弃，即将累加和重置
分析出这样的规律后我们就可以编码了

func maxSubArray(_ nums: [Int]) -> Int {
    var currentSum = nums[0]
    var maxSum = nums[0]
    
    for idx in 1..<nums.count {
        if currentSum < 0 { // 前面的是下降趋势，丢弃之前的
            currentSum = nums[idx]
        }
        else {
            currentSum += nums[idx]
        }
        maxSum = max(maxSum, currentSum)
    }
    return maxSum
}

三、解法二：动态规划

如果用函数 f(i) 代表第i个数子结尾的子数组最大和，那么有下面的关系：

i == 0 或者 f(i-1) <= 0
- f(i) = nums[i]
else
- f(i) = f(i-1) + nums[i]

转化成代码：

func maxSubArray(_ nums: [Int]) -> Int {
    var dp: [Int] = Array(repeating: 0, count: nums.count)

    for i in 0..<nums.count {
        if i == 0 || (i > 0 && dp[i-1] <= 0) {
            dp[i] = nums[i]
        }
        else {
            dp[i] = dp[i - 1] + nums[i]
        }
    }

    return dp.max() ?? nums[0]
}

四、总结

本题考查对时间复杂度的理解。如果给出 O(n2) O(n3) 的算法，是很难通过面试的。
考察队动态规划的理解，如果熟练掌握动态规划算法，那么就可以轻松的找到解题方案。
如果没有想到使用动态规划，通过分析计算过程寻找规律同样可以找到解法。

iOS截屏防护方案

Fri, 18 Feb 2022 00:00:00 GMT

前言

想必很多同学都有遇到过或者想过怎么能防止系统截图，但通过大量的搜索并没有找到具体的实现方案。

一、常见方案

1.1 系统通知

UIApplication.userDidTakeScreenshotNotification 这个系统通知是在完成截屏动作后，系统给到 App 的，在收到这个通知后做处理，并不能达到防护的效果。

微信的付款吗就是这样的实现，在截屏后提供一个警示内容。

1.2 小红书

在使用小红书的截屏的时候顶部状态栏会添加一个小红书的水印如下图：

它是怎么实现的呢？我有两个猜测：

第一种：水印一直在，刘海后面

因为非刘海屏没有这个水印，所以估计是这样，但是通过切换到任务管理器状态并没有看到有那个水印。

第二种：通过什么黑科技加上的？

不是第一种，难道真的是又什么黑科技？

继续验证

我觉得肯定是第一种，觉得任务切换的状态下是不是那个水印被系统隐藏掉。想道还有 QuickTime 可以投屏来验证。

破案，果然是藏在刘海后面的，没有继续深入的价值了🤷‍♂️。

1.3 ScreenShieldKit

在寻找解决方案的时候发现了这样一个SDK ScreenShieldKit

Contact us for more information and to receive a free evaluation SDK!

这句话一看就是收钱的了，抱着能白嫖绝不三连的宗旨，先略过暂不深入研究。（开玩笑，如果你觉得我的方案不错，本文求赞评转+Star！）

1.4 爱奇艺

爱奇艺使用的是截图后直接读取用户相册删除图片的方式进行的，不给权限，截图就不会被删除。

1.5 UITextField

当我们将一个 UITextField 的 isSecureTextEntry 设置为 true 的时候，会隐去输入的文案用 圆点 替代。并且在进行录屏或者截屏的时候都会被系统隐去。

下面用我的个人项目梦见账本

如下图我正在用 QuickTime 进行录屏：

那么我们是否可以使用这种特性呢？

二、 RyukieSwifty/ScreenShield

基于 UITextField 的效果我实现了一个 ScreenShieldView 可以很方便的进行使用。

GitHub: RyukieSwifty/ScreenShield

如果觉得不错的话，欢迎留个⭐️哦

2.1 使用方式

Cocoapods 导入

pod 'RyukieSwifty/ScreenShield'

使用

例如对整个控制器的 View 进行截屏防护：

import UIKit
import RyukieSwifty

class TransactionAddViewController: UIViewController {
    // MARK: - Life
    override func loadView() {
        view = ScreenShieldView.create()
    }
    ...
}

2.2 如何实现的

按照向里面添加子视图的方式验证具体的原因，最后发现这个效果是由一个私有类实现的 _UITextLayoutCanvasView 。他本质上也是一个 UIView ，所以理论上只要我们能够创建出来一个它，那么就可以将想要保护的内容添加进去。

由于它是私有类，无法直接创建，并且如果直接通过字符串区创建也担心有审核风险，于是我通过下面的方式来创建。

private func makeSecureView() -> UIView? {
    let field = UITextField()
    field.isSecureTextEntry = true
    let fv = field.subviews.first
    fv?.subviews.forEach { $0.removeFromSuperview() }
    fv?.isUserInteractionEnabled = true
    return fv
}

当前手头没有更多的系统版本设备可以测试，已经验证的 13.7 ～ 15.3.1 是没问题的。

不排除会存在某些版本上 UITextField 的结构发生了调整导致失效的问题，如果有，欢迎在 GitHub 提 issue 。

总结

不知道各位有没有其他的实现方式，有的话欢迎一起交流。

如果本文有帮到你，欢迎赞评转+Star！

提高编译速度

Fri, 18 Feb 2022 00:00:00 GMT

iOS-提高编译速度

forward declaration

使用@class ClassName而不是#import ClassName.h
能大大提高编译速度

组件库打包优化

对不经常变更的库做成Framework或者.a
这部分代码就不需要重新编译了

常用头文件放到预编译文件里

XCode的pch文件是预编译文件，这里的内容在执行XCode build之前就已经被预编译，并且引入到每一个.m文件里了。

Debug模式下不生成dsym文件

开启编译当前架构版本

Debug模式下关闭编译优化

参考

https://blog.csdn.net/Hello_Hwc/article/details/53557308

图片格式-WebP

Fri, 18 Feb 2022 00:00:00 GMT

Google出品，Android原生支持，iOS需要单独适配如SD和Kinfisher
基于VP8编码
比JPEG小40+
有损无损都有
PNG转
- PNG 转 WebP 的压缩率要高于 PNG 原图压缩率，同样支持有损与无损压缩
- 转换后的 WebP 体积大幅减少，图片质量也得到保障（同时肉眼几乎无法看出差异）
- 转换后的 WebP 支持 Alpha 透明和 24-bit 颜色数，不存在 PNG8 色彩不够丰富和在浏览器中可能会出现毛边的问题
JPEG转效果更佳

App启动速度优化

Fri, 18 Feb 2022 00:00:00 GMT

一：启动时间

启动时间 = main()之前的时间 + main()之后的时间

1.1 如何衡量时间

通过添加环境变量可以打印出APP的启动时间分析
- Edit scheme -> Run -> Arguments
- DYLD_PRINT_STATISTICS 设置为 1
- 如果需要更详细的信息，那就将 DYLD_PRINT_STATISTICS_DETAILS 设置为 1

1.2 作为开发者我们可以介入的地方有哪些？

二: main()之前

2.1 dyld

iOS的动态链接器，可以用来装载Mach-O文件（可执行文件、动态库等）

启动APP时，dyld所做的事情有
- 装载APP的可执行文件，同时会递归加载所有依赖的动态库
- 当dyld把可执行文件、动态库都装载完毕后，会通知Runtime进行下一步的处理

2.2 runtime

启动APP时，runtime所做的事情有
- 调用map_images进行可执行文件(.o)内容的解析和处理
- 在load_images中调用call_load_methods，调用所有Class和Category的+load方法
- 进行各种objc结构的初始化（注册Objc类 、初始化类对象等等）
- 调用C++静态初始化器和__attribute__((constructor))修饰的函数

到此为止，可执行文件和动态库中所有的符号(Class，Protocol，Selector，IMP，…)都已经按格式成功加载到内存中，被runtime所管理

2.3 可优化点

减少不必要的framework
framework应当设为optional和required，如果该framework在当前App支持的所有iOS系统版本都存在，那么就设为required，否则就设为optional，因为optional会有些额外的检查
合并或者删减一些OC类，关于清理项目中没用到的类，使用工具AppCode代码检查功能，查到当前项目中没有用到的类如
删除废弃方法
+load里少做事情，用+initialize方法和dispatch_once取代所有的__attribute__((constructor))、C++静态构造器、ObjC的+load
尽量不用C++虚函数(创建虚函数有开销)
Swift尽量使用Struct

三: main()之后

主要是App本身相关的一些初始化服务

不适用xib/sb,使用代码加载首页视图
NSUserDefaults实际上是在Library文件夹下会生产一个plist文件，如果文件太大的话一次能读取到内存中可能很耗时，这个影响需要评估，如果耗时很大的话需要拆分(需考虑老版本覆盖安装兼容问题)
每次用NSLog方式打印会隐式的创建一个Calendar，因此需要删减启动时各业务方打的log，或者仅仅针对内测版输出log
梳理应用启动时发送的所有网络请求，是否可以统一在异步线程请求
首页相关控制器的viewDidLoad/viewWillAppear里少做操作或者延迟做
少做/不做 I/O 操作,或者异步做

参考

https://techblog.toutiao.com/2017/01/17/iosspeed/

IDL自动化埋点

Fri, 18 Feb 2022 00:00:00 GMT

IDL自动化生成埋点模型

使用定义好的IDL语言规范生成JSON上传至指定仓库
Jenkins脚本转化生成代码，上传至指定仓库
项目同步更新相关仓库，在需要埋点的地方埋点时使用相关事件模型即可

渲染原理及优化

Fri, 18 Feb 2022 00:00:00 GMT

将图形渲染到屏幕是CPU和GPU协同完成的一个过程.

一、职责与分工

CPU
- 计算视图Frame
- 图片解码
- 将需要绘制的纹理图片通过数据总线传递给GPU
GPU
- 纹理混合
- 顶点变换与计算
- 像素点的填充计算
- 渲染到缓冲区
时钟信号
- 垂直同步信号V-Sync
- 水平同步信号H-Sync
iOS设备双缓冲机制
- 显示系统通常会引入两个帧缓冲区

二、双缓冲机制

有前帧缓存、后帧缓存，即GPU会预先渲染好一帧放入一个缓冲区内（前帧缓存），让视频控制器读取
当下一帧渲染好后，GPU会直接把视频控制器的指针指向第二个缓冲器（后帧缓存）
当你视频控制器已经读完一帧，准备读下一帧的时候
- GPU会等待显示器的VSync信号发出后，前帧缓存和后帧缓存会瞬间切换
- 后帧缓存会变成新的前帧缓存，同时旧的前帧缓存会变成新的后帧缓存

2.1 卡顿产生的原因

如果在一个VSync时间内CPU或GPU没有将处理完成的数据提交到帧缓冲区，那一帧就会被丢弃

按照60fps刷新率，每隔16ms就会又一次VSync信号

2.2 卡顿优化-CPU

尽量用轻量级的对象，比如用不到事件处理的地方，可以考虑使用CALayer取代UIView
不要频繁地调用UIView的相关属性，比如frame、bounds、transform等属性，尽量减少不必要的修改
尽量提前计算好布局，在有需要时一次性调整对应的属性，不要多次修改属性
Autolayout会比直接设置frame消耗更多的CPU资源
图片的size最好刚好跟UIImageView的size保持一致
控制一下线程的最大并发数量
尽量把耗时的操作放到子线程

2.3 卡顿优化-GPU

尽量避免短时间内大量图片的显示，尽可能将多张图片合成一张进行显示
尽量减少视图数量和层次
减少透明的视图（alpha<1），不透明的就设置opaque为YES
尽量避免出现离屏渲染

2.4 卡顿检测

YYFPSLabel
- 基于 DisplayLink
- 每次++，少了就掉帧了
Runloop
- 在 主线程 的 Runloop 中创建一个 Observer
- 监听事务
- 在 子线程 开启计时
- 两次事务的间隔超过一定的时间就标识有事务比较耗时
微信的 Matrix
- 也是基于 Runloop 的，更全面
滴滴 Doraemon
- 主线程发不断发信号

三、图片加载的过程

3.1 imageNamed

使用后会有缓存，适合重复使用的场景

When searching the asset catalog, this method prefers an asset containing a symbol image over an asset with the same name containing a bitmap image. Because symbol images are supported only in iOS 13 and later, you may include both types of assets in the same asset catalog. The system automatically falls back to the bitmap image on earlier versions of iOS. You cannot use this method to load system symbol images; use the init(systemName:) method instead.

This method checks the system caches for an image object with the specified name and returns the variant of that image that is best suited for the main screen. If a matching image object is not already in the cache, this method creates the image from an available asset catalog or loads it from disk. The system may purge cached image data at any time to free up memory. Purging occurs only for images that are in the cache but are not currently being used.

In iOS 9 and later, this method is thread safe.

3.2 imageWithContentsOfFile

不会创建缓存，适合于低频使用的资源图

This method does not cache the image object.

3.3 具体过程

将UIImage赋值给UIImageView
一个隐式的CATransaction捕捉到了UIImageView图层树的变化
主线程下个RunLoop到来时，CoreAnimation提交了这个Transaction
- 这个过程可能会对图片进行Copy操作，而受图片是否字节对齐等因素的影响，这个Copy操作可能包含一下部分或全部操作：
- 分配内存缓冲区，用于管理文件IO和解压缩操作
- 将图片数据从磁盘读取到内存
- 将图片数据解码成未压缩的位图格式，这是个非常耗时的CPU操作
- CPU计算好图片Frame，对图片解压后，交给GPU进行渲染
- CoreAnimation的CALayer用位图数据渲染UIImageView
渲染流程
- GPU获取图片坐标
- 将坐标交给顶点着色器
  - 顶点计算
- 将图片光栅化
  - 获取图片对应屏幕上的像素点
- 片元着色器计算
  - 计算每个像素点最终显示的颜色值
- 从帧缓存区中渲染到屏幕上

四、为什么需要解压缩

4.1 位图 JPG PNG

位图就是一个像素数组，包含了每个像素点的信息。
JPG和PNG都是压缩的位图
- JPG有损压缩
- PNG无损压缩，支持alpha通道

4.2 获取原始图片数据

UIImage *image = [UIImage imageNamed:@"text.png"];
CFDataRef rawData = CGDataProviderCopyData(CGImageGetDataProvider(image.CGImage));

五、界面优化

5.1 预排版

提前进行相关计算，例如在 Cell 复用之前就通过数据模型对相关 Layout 信息进行计算。否则每次复用都进行计算就很浪费性能了。

5.2 预解码

系统默认会在主线程对图片进行解压，但该操作是个非常耗时的操作。所以现在就出现了对图片进行异步解压的方案。核心方法是CGBitmapContextCreate。

SDWebImage可以在sd_decompressedImageWithImage处断点调试过程

下面是我在我的个人项目梦见账本中的账户封面设置中用做的优化：

public struct SwiftyImageLoader {
    public static let colorSpace: CGColorSpace = CGColorSpaceCreateDeviceRGB()
    
    public static func imageRefContainsAlpha(imageRef: CGImage) -> Bool {
        switch imageRef.alphaInfo {
        case .none, .noneSkipFirst, .noneSkipLast:
            return false
        default:
            return true
        }
    }
}

extension UIImageView {
    func asyncSet(newImage: UIImage?) {
        guard let image = newImage else {
            self.image = nil
            return
        }
        
        DispatchQueue.global().async { [weak self] in
            guard let imageRef = image.cgImage else {
                self?.setImageInMainQueue(image: image)
                return
            }

    //        let bytesPerPixel: Int = 4
            let bitsPerComponent: Int = 8
            
            // device color space
            let colorspaceRef = SwiftyImageLoader.colorSpace
            let hasAlpha = SwiftyImageLoader.imageRefContainsAlpha(imageRef: imageRef)
            
            // iOS display alpha info (BRGA8888/BGRX8888)
            // 位移枚举可以这样写
            let bitmapInfo: CGBitmapInfo = CGBitmapInfo(rawValue: hasAlpha
                                                            ? CGImageAlphaInfo.premultipliedFirst.rawValue
                                                            : CGImageAlphaInfo.noneSkipFirst.rawValue)
                .union(.byteOrder32Little)
            
            let width = imageRef.width
            let height = imageRef.height
            
            // kCGImageAlphaNone is not supported in CGBitmapContextCreate.
            // Since the original image here has no alpha info, use kCGImageAlphaNoneSkipLast
            // to create bitmap graphics contexts without alpha info.
            
            guard
                let context: CGContext = CGContext.init(data: nil, width: width, height: height, bitsPerComponent: bitsPerComponent, bytesPerRow: 0, space: colorspaceRef, bitmapInfo: bitmapInfo.rawValue)
            else {
                self?.setImageInMainQueue(image: image)
                return
            }
            
            // Draw the image into the context and retrieve the new bitmap image without alpha
    //        CGContextDrawImage
            context.draw(imageRef, in: CGRect(origin: .zero, size: CGSize(width: width, height: height)))
            
            guard
                let imageRefWithoutAlpha = context.makeImage()
            else {
                self?.setImageInMainQueue(image: image)
                return
            }
            let imageWithoutAlpha = UIImage(cgImage: imageRefWithoutAlpha, scale: image.scale, orientation: image.imageOrientation)
            self?.setImageInMainQueue(image: imageWithoutAlpha)
            //  CGContextRelease(context) Swift 会自动去管理了，不用手动去释放了
        }
    }
    
    private func setImageInMainQueue(image: UIImage) {
        DispatchQueue.main.async { [weak self] in
            self?.image = image
        }
    }
}

5.3 按需加载

一般我们卡顿主要是因为列表有大量的图片，我们可以选择在滚动的时候采用展示展位图，滚动停止的时候再展示相关图片的方式来提高性能。

当然这样对于用户的浏览体验来说会有一些影响。

5.4 异步渲染

UIView 和 CALayer 的关系

Graver

美团开源Graver框架：用“雕刻”诠释iOS端UI界面的高效渲染

从 Graver 源码再来看异步渲染

Graver 好像是借鉴了 YYAsyncLayer 有争议，后来取消开源了。

「利用 Metrics 和 Diagnostics 提高性能」网络研讨活动

Fri, 18 Feb 2022 00:00:00 GMT

前言

之前参与了Apple「利用 Metrics 和 Diagnostics 提高性能」网络研讨活动，之前只简单的总结了一下，现在整理一下。感觉有些东西还是挺实用的。

一：内存指标

平均挂起内存和峰值内存
内存管理会影响启动时间（冷启动热启动）
通过这些指标了解内存的使用，可以：
- 发现难以重现的内存泄露问题
- 减小挂起平均内存
  - 减少挂起内存占用有助于减少应用在后台被释放的几率

二：MetricKit

搜集电池和性能指标和诊断的框架
应用内接入后就可以通过API获取丰富的性能指标数据
如果有必要可以将数据上报到自己的平台上，也可以作为开发过程中西能调优的工具

三：Xcode Metrics Organizer

在Xcode中Window下拉菜单选择Organizer

这里是可以选择版本的包含：AppStore（Release）和 TestFlight（Beta）

Reports
- 这里的数据也是系统自动收集的，前提是用户需要允许给Apple共享数据
- Crashes
  - 实测是可以看到具体崩溃信息的，无须上传符号表
    - 自己的小项目没有太多的崩溃可以看，后面找时间看下公司的项目的信息
- Disk Writes
  - 没看到数据，可能是有异常才会上报吧
- Energy
  - 没看到数据，可能是有异常才会上报吧
Metrics
- 无须应用内集成MetricsKit就可以看到相关数据
- 前提是用户量达到一定的水平
  - 具体是多少并没有提到，反正我自己的小App是没有的TAT
- 需要用户在设置系统的时候统一将数据共享给Apple，否则是没有该用户的数据的
- 所有数据都是苹果系统内自动收集上报的

四：App Store Connect API

这是苹果提供的一套REST API接口，可以直接通过请求获取Metrics数据。

但是需要和上面的满足一样的前提：达到一定用户量

五：参考

附本次主题参考资料：（会后Apple邮件提供的）

mprove performance and battery life in your app

Improving Battery Life and Performance

Optimizing Storage in Your App

MetricKit

Improving Your App's Performance

离屏渲染

Fri, 18 Feb 2022 00:00:00 GMT

iOS离屏渲染

一: 什么是离屏渲染

如果要爱屏幕上显示内容,我们需要一块至少和屏幕数据量一样大的FrameBuffer作为像素数据的缓存区域,也是GPU储存渲染结果的地方. 如果有时面临一些限制,无法把渲染结果直接写入FrameBuffer而是存在别的区域之后再写入FrameBuffer这个过程就是离屏渲染

App -> OffscreenBuffer -> FrameBuffer

二: CPU离屏渲染

UIView中实现了drawRect就算内部没有实际代码,系统也会为这个view申请一片内存区域等待CoreGraphics可能的绘画操作
很多人对于开一块CGContext来画图的操作也成为离屏渲染,因为数据是存入了CGContext而不是FrameBuffer
进一步讲其实所有CPU进行的光栅化操作(文字渲染,图片解码)都无法直接绘制到有GPU管理的FrameBuffer中,只能暂时放在另一块内存中
但是苹果工程师说CPU渲染并非真正意义的离屏渲染
- https://lobste.rs/s/ckm4uw/performance_minded_take_on_ios_design#c_itdkfh
- 实现DrawRect打开Xcode调试的“Color offscreen rendered yellow”开关,该区域不会变黄

三: GPU渲染

画家算法

主要渲染操作都是由CoreAnimation和Render Server模块通过调用显卡驱动提供的接口OpenGL/Metal来执行的

对于每一层Layer,Render Server会按照深度排序依次输出到FrameBuffer
后一层覆盖前一层,达到最终效果
此过程不可逆
- 遮住的部分数据永久丢失无法修改
想要突破这个限制
- 在FrameBuffer外开辟一块空间
- 把待处理的Layer画上去
- 进行修改后再写回FrameBuffer

GPU离屏渲染

上面开辟空间渲染,真个过程就算离屏渲染
对于每层Layer如果能通过单次遍历即可完成渲染的话效率最高
- 否则只能开辟离屏Buffer来完成一些复杂操作

四: 常见离屏渲染场景

4.1 cornerRadius+clipsToBounds

如果只是设置cornerRadius,而不剪切内容,或者只裁掉矩形区域以外的内容,并不会触发离屏渲染

4.2 shadow

阴影的形状未必是矩形
只能在Layer以上的内容全部渲染完成后才能知道形状是什么
- 这样只能离屏渲染,将上层内容渲染完成,知道了shadow的形状,将shadow添加到FrameBuffer
- 再把内容回执上去
- 如果事先告诉了CoreAnimation(通过shadowPath)阴影的几何形状的话就不需要依赖Layer了

4.3 group opacity

两个带透明度的图层叠加
叠加部分无法通过一次遍历即完成
会触发离屏渲染

4.4 mask

作用在Layer所有子Layer之上的而且可能有透明度
离屏渲染

4.5 UIBlurEffect

无法一次遍历完成

4.6 allowsEdgeAntialiasing 抗锯齿

无法一次遍历完成

4.7 UIButton & UIImageView

UIButton
- 默认自带背景图层
- 切圆角会有离屏渲染

// clipsToBounds = YES 有
- (UIButton *)bgImageButton {
    if (!_imageButton) {
        _imageButton = [[UIButton alloc] init];
        [_imageButton setBackgroundImage:[UIImage imageNamed:@"bg_image"] forState:UIControlStateNormal];
        _imageButton.layer.cornerRadius = 15;
        _imageButton.contentMode = UIViewContentModeScaleAspectFill;
        _imageButton.clipsToBounds = YES;
    }
    return _imageButton;
}

// clipsToBounds = YES 有
- (UIButton *)imageButton {
    if (!_bgImageButton) {
        _bgImageButton = [[UIButton alloc] init];
        [_bgImageButton setImage:[UIImage imageNamed:@"bg_image"] forState:UIControlStateNormal];
        _bgImageButton.layer.cornerRadius = 15;
        _bgImageButton.contentMode = UIViewContentModeScaleAspectFill;
        _bgImageButton.clipsToBounds = YES;
    }
    return _bgImageButton;
}

- (UIButton *)colorButton {
    if (!_colorButton) {
        _colorButton = [[UIButton alloc] init];
        [_colorButton setBackgroundColor:[UIColor greenColor]];
        _colorButton.layer.cornerRadius = 15;
        _colorButton.clipsToBounds = YES;
        // 不加 title 就没有
        [_colorButton setTitle:@"Ryukie" forState:UIControlStateNormal];
    }
    return _colorButton;
}

UIImageView
- 默认无背景图层
- 默认情况下直接图片切圆角不会触发离屏渲染
- 如果内部加了子视图会离屏渲染

// 没有
- (UIImageView *)imageView {
    if (!_imageView) {
        _imageView = [[UIImageView alloc] init];
        _imageView.image = [UIImage imageNamed:@"bg_image"];
        _imageView.layer.cornerRadius = 15;
        _imageView.clipsToBounds = YES;
    }
    return _imageView;
}

// 有
- (UIImageView *)imageView {
    if (!_imageView) {
        _imageView = [[UIImageView alloc] init];
        _imageView.image = [UIImage imageNamed:@"bg_image"];
        _imageView.layer.cornerRadius = 15;
        _imageView.clipsToBounds = YES;
        
        UIView *redView = [[UIView alloc] initWithFrame:CGRectMake(0, 0, 50, 50)];
        redView.backgroundColor = [UIColor redColor];
        [_imageView addSubview:redView];
    }
    return _imageView;
}

五: GPU离屏渲染性能影响

GPU操作是高度流水线化的.正常情况一直在向FrameBuffer中输出
当需要开启另一块内存进行其他操作,要暂时停止向FrameBuffer中输出,进行相关操作
完成后再向FrameBuffer中输出内容

TableView/CollectionView中滚动每一帧变化都会触发重绘一旦发生离屏渲染,上面的切换操作将会发生很多次(60/s)

六: 利用离屏渲染

6.1 只离屏渲染一次

CALayer的shouldRasterize属性
- 可以把Layer及其子Layer,还有圆角等内容保存在内存中
- 下一帧可以服用,而不会继续触发离屏渲染
- 注意
  - 如果本来就不复杂,也没有圆角等,打开反而会触发一次不必要的离屏渲染
  - 缓存有限,不会超过屏幕总像素的2.5倍
  - 超过100ms没用就被释放
  - 静态内容,如果有resize或动画的话就失效了,需要重新离屏渲染
    - 针对这种情况，Xcode提供了“Color Hits Green and Misses Red”的选项，帮助我们查看缓存的使用是否符合预期
- 除了用来优化离屏渲染还可以用于展示十分复杂的Layer

七: 什么时候需要CPU渲染

渲染新能调优核心在于
- 平衡CPU&GPU的负载
- 让他们各自做自己擅长的事情
文字(CoreText使用CoreGraphics渲染)图片(ImageIO)的渲染
- GPU不擅长这些事情
- 需要CPU处理完再交给GPU
  - 例如:
  - 一个圆角实现
    - 用CoreGraphics给图片加圆角-CPU完成
    - 这样就不用给容器设置cornerRadius避免可能发生的离屏渲染
注意点:
- 渲染不是CPU强项,调用CoreGraphics会消耗一定的计算时间,因此CPU渲染放在后台线程去完成,然后回到主线程将结果返回给CoreAnimation.但是多线程间数据同步会增加一定的复杂度
  - 也是AsyncDisplayKit/Texture的主要思想
- CPU渲染速度慢,适合不复杂的元素
  - 没有硬件加速的视频解码...酸爽啊
- 渲染结果bitmap数据量较大(一般为解码后的UIImage),需要及时释放
- 选择用CPU渲染的话就没必要触发GPU的离屏渲染,否则会有两块相同内存
- 善用工具进行检测

八: 优化

使用AsyncDisplayKit/Texture框架
图片圆角
- 采用不适用容器裁剪的方式,用上面提到过的预处理图片的方式
视屏圆角
- 创建四个弧形Layer盖住四个角
- 图片也可以
View的圆形边框
- 如果没有backgroundColor可以使用cornerRadius来做
阴影
- 使用shadowPath
特殊形状View
- 使用layer mask并打开shouldRasterize来对渲染结果进行缓存
模糊
- 不采用系统提供的UIVisualEffect，而是另外实现模糊效果（CIGaussianBlur），并手动管理渲染结果

九: 总结

CPU渲染虽然也是“离屏”，但是通常提到的离屏渲染是发生在GPU 如果一个layer无法在一次遍历就完成绘制，那么就不得不触发离屏渲染离屏渲染的开销主要在与frame buffer与离屏buffer之间的上下文切换。如果无法避免，也可以通过有效利用shouldRasterize，减少触发的次数 CPU和GPU是相互扶持的关系。CPU渲染效率不高，但是较为通用灵活；GPU擅长并行计算，但也有捉襟见肘之时，此时CPU可以适当给与帮助

参考

https://medium.com/@jasonyuh/关于离屏渲染的深入研究-e776f56b3e60 https://blog.ibireme.com/2015/11/12/smooth_user_interfaces_for_ios/

优先队列

Wed, 16 Feb 2022 00:00:00 GMT

一、什么是优先队列

如果有这样一个数据流 1，2，3，4，5，6，7，8 我们需要按照一定的优先级找到满足条件（最大或者最小）的元素，并且每次取出最高优先级的元素后，内部元素依旧能够按照既定优先级保证最高优先级的元素在顶端。

二、最大堆 & 最小堆

堆 分为 最大堆 和 最小堆 ，其实就是 完全二叉树
- 最大堆
  - 要求节点的元素都要大于等于其孩子
- 最小堆
  - 要求节点元素都小于等于其左右孩子
两者对左右孩子的大小关系不做任何要求

为什么用 `二叉树` 来实现呢？

如果使用数组复杂度会更高

三、插入元素

如下数据流，我们按照顺序插入数据，并且每次返回最大的元素，我们就可以使用优先队列（最大堆）。

步骤1

插入 1 和 5 ，如图二叉树结构
叶子节点 5 > 1 ，不符合优先级规则，需要交换位置
等价数组为
- [5, 1]

步骤2

插入 6
- 每次插入都插入到当前最深层从左往右的位置，或者创建下一层
6 大于父节点 5，需要调整位置
交换 5 6
等价数组为
- [6, 1, 5]

步骤3

插入 2
- 这一层满了，下一层最左边
2 大于父节点 1，需要调整
交换 2 1
等价数组为
- [6, 2, 5, 1]

步骤4

插入 7
7 大于父节点 2，需要调整
交换 7 2
- 7 的父节点变为 6，还需要调整
- 交换 7 6
等价数组为
- [7, 6, 5, 1, 2]

步骤5

插入 4，父节点为 5，无需调整
等价数组为
- [7, 6, 5, 1, 2, 4]

步骤6

插入 3，父节点为 5，无需调整
等价数组为
- [7, 6, 5, 1, 2, 4, 3]

步骤7

插入 8
- 下一层
大于父节点 1，交换
大于父节点 6，交换
大于父节点 7，交换
等价数组为
- [8, 7, 5, 6, 2, 4, 3, 1]

插入代码实现

基础数据结构

public struct SwiftPriorityQueue<Element> {
    private let _hasHigherPriority: (Element, Element) -> Bool
    private let _isEqual: (Element, Element) -> Bool

    private var _elements = [Element]()

    public init(hasHigherPriority: @escaping (Element, Element) -> Bool, isEqual: @escaping (Element, Element) -> Bool) {
        _hasHigherPriority = hasHigherPriority
        _isEqual = isEqual
    }

    public func peek() -> Element? {
        return _elements.first
    }
    
    public func array() -> [Element] {
        return _elements
    }

    public var isEmpty: Bool {
        return _elements.count == 0
    }
    
    public var count: Int {
        return _elements.count
    }
}

插入逻辑

// 插入
public mutating func enqueue(_ element: Element) {
    _elements.append(element)
    bubbleToHigherPriority(_elements.count - 1)
}

// 爬升
private mutating func bubbleToHigherPriority(_ initialUnbalancedIndex: Int) {
    precondition(initialUnbalancedIndex >= 0)
    precondition(initialUnbalancedIndex < _elements.count)

    var unbalancedIndex = initialUnbalancedIndex

    while unbalancedIndex > 0 {
        let parentIndex = (unbalancedIndex - 1) / 2
        guard _hasHigherPriority(_elements[unbalancedIndex], _elements[parentIndex]) else { break }
        _elements.swapAt(unbalancedIndex, parentIndex)
        unbalancedIndex = parentIndex
    }
}

四、移除元素

我们还以上面完成的 优先队列 数据结构为例，继续对移除元素的操作进行研究。

这里我们计划移除 5 元素（当前下表为A）
现将其和尾部元素交换
移除尾部元素
检查 A 处元素是否需要爬升
- 是
  - 将其上浮
    - 此处 A 元素为 1，小于父节点 8，无需处理
检查 A 处元素是否需要下沉
- 是
  - 将其下降
    - 此处 A 元素为 1，小于子节点，进行下沉处理

移除与下沉逻辑实现

private mutating func removeAt(_ index: Int) {
    // 是否是最后一个元素
    let removingLast = index == _elements.count - 1
    if !removingLast {
        _elements.swapAt(index, _elements.count - 1)
    }

    _ = _elements.popLast()

    if !removingLast {
        // 检查并保持优先队列的元素
        bubbleToHigherPriority(index)
        bubbleToLowerPriority(index)
    }
}

private mutating func bubbleToLowerPriority(_ initialUnbalancedIndex: Int) {
    precondition(initialUnbalancedIndex >= 0)
    precondition(initialUnbalancedIndex < _elements.count)

    var unbalancedIndex = initialUnbalancedIndex
    while true {
        // 根据二叉树的结构，当前节点左叶子节点的下标为 unbalancedIndex * 2 + 1
        let leftChildIndex = unbalancedIndex * 2 + 1
        // 根据二叉树的结构，当前节点右叶子节点的的下标为 unbalancedIndex * 2 + 2
        let rightChildIndex = unbalancedIndex * 2 + 2

        var highestPriorityIndex = unbalancedIndex

        // 左叶子更高
        if leftChildIndex < _elements.count && _hasHigherPriority(_elements[leftChildIndex], _elements[highestPriorityIndex]) {
            highestPriorityIndex = leftChildIndex
        }

        // 右叶子更高
        if rightChildIndex < _elements.count && _hasHigherPriority(_elements[rightChildIndex], _elements[highestPriorityIndex]) {
            highestPriorityIndex = rightChildIndex
        }

        guard highestPriorityIndex != unbalancedIndex else { 
            break // 不用调整优先级
        }

        // 交换元素
        _elements.swapAt(highestPriorityIndex, unbalancedIndex)

        // 保存更高优先级的下标，继续进行对比
        unbalancedIndex = highestPriorityIndex
    }
}

Swift 完整实现

下面的优先队列实现是参考 RxSwift 中的

public struct SwiftPriorityQueue<Element> {
    private let _hasHigherPriority: (Element, Element) -> Bool
    private let _isEqual: (Element, Element) -> Bool

    private var _elements = [Element]()

    public init(hasHigherPriority: @escaping (Element, Element) -> Bool, isEqual: @escaping (Element, Element) -> Bool) {
        _hasHigherPriority = hasHigherPriority
        _isEqual = isEqual
    }

    public mutating func enqueue(_ element: Element) {
        _elements.append(element)
        bubbleToHigherPriority(_elements.count - 1)
    }

    public func peek() -> Element? {
        return _elements.first
    }
    
    public func array() -> [Element] {
        return _elements
    }

    public var isEmpty: Bool {
        return _elements.count == 0
    }
    
    public var count: Int {
        return _elements.count
    }

    public mutating func dequeue() -> Element? {
        guard let front = peek() else {
            return nil
        }

        removeAt(0)

        return front
    }

    public mutating func remove(_ element: Element) {
        for i in 0 ..< _elements.count {
            if _isEqual(_elements[i], element) {
                removeAt(i)
                return
            }
        }
    }

    private mutating func removeAt(_ index: Int) {
        let removingLast = index == _elements.count - 1
        if !removingLast {
            _elements.swapAt(index, _elements.count - 1)
        }

        _ = _elements.popLast()

        if !removingLast {
            bubbleToHigherPriority(index)
            bubbleToLowerPriority(index)
        }
    }

    private mutating func bubbleToHigherPriority(_ initialUnbalancedIndex: Int) {
        precondition(initialUnbalancedIndex >= 0)
        precondition(initialUnbalancedIndex < _elements.count)

        var unbalancedIndex = initialUnbalancedIndex

        while unbalancedIndex > 0 {
            let parentIndex = (unbalancedIndex - 1) / 2
            guard _hasHigherPriority(_elements[unbalancedIndex], _elements[parentIndex]) else { break }
            _elements.swapAt(unbalancedIndex, parentIndex)
            unbalancedIndex = parentIndex
        }
    }

    private mutating func bubbleToLowerPriority(_ initialUnbalancedIndex: Int) {
        precondition(initialUnbalancedIndex >= 0)
        precondition(initialUnbalancedIndex < _elements.count)

        var unbalancedIndex = initialUnbalancedIndex
        while true {
            let leftChildIndex = unbalancedIndex * 2 + 1
            let rightChildIndex = unbalancedIndex * 2 + 2

            var highestPriorityIndex = unbalancedIndex

            if leftChildIndex < _elements.count && _hasHigherPriority(_elements[leftChildIndex], _elements[highestPriorityIndex]) {
                highestPriorityIndex = leftChildIndex
            }

            if rightChildIndex < _elements.count && _hasHigherPriority(_elements[rightChildIndex], _elements[highestPriorityIndex]) {
                highestPriorityIndex = rightChildIndex
            }

            guard highestPriorityIndex != unbalancedIndex else { break }
            _elements.swapAt(highestPriorityIndex, unbalancedIndex)

            unbalancedIndex = highestPriorityIndex
        }
    }
}

extension SwiftPriorityQueue : CustomDebugStringConvertible {
    public var debugDescription: String {
        return _elements.debugDescription
    }
}

数据流中的中位数

Mon, 14 Feb 2022 00:00:00 GMT

题目

如何得到一个数据流中的中位数？如果从数据流中读出奇数个数值，那么中位数就是所有数值排序之后位于中间的数值。如果从数据流中读出偶数个数值，那么中位数就是所有数值排序之后中间两个数的平均值。

例如，

[2,3,4] 的中位数是 3

[2,3] 的中位数是 (2 + 3) / 2 = 2.5

设计一个支持以下两种操作的数据结构：

void addNum(int num) - 从数据流中添加一个整数到数据结构中。 double findMedian() - 返回目前所有元素的中位数。

示例 1：

输入：

["MedianFinder","addNum","addNum","findMedian","addNum","findMedian"]

[[],[1],[2],[],[3],[]]

输出：[null,null,null,1.50000,null,2.00000]

示例 2：

输入：

["MedianFinder","addNum","findMedian","addNum","findMedian"]

[[],[2],[],[3],[]]

输出：[null,null,2.00000,null,2.50000]

限制：

最多会对 addNum 、 findMedian 进行 50000 次调用。

注意：本题与主站 295 题相同：https://leetcode-cn.com/problems/find-median-from-data-stream/

来源：力扣（LeetCode）

链接：https://leetcode-cn.com/problems/shu-ju-liu-zhong-de-zhong-wei-shu-lcof 著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

大小堆

class MedianFinder {
    
    var minStack = SwiftPriorityQueue<Int>(hasHigherPriority: { $0 > $1 }, isEqual: { $0 == $1 })
    var maxStack = SwiftPriorityQueue<Int>(hasHigherPriority: { $0 < $1 }, isEqual: { $0 == $1 })
    
    /** initialize your data structure here. */
    init() {

    }
    
    func addNum(_ num: Int) {
        if maxStack.count > minStack.count {
            minStack.enqueue(num)
        }
        else if minStack.count > maxStack.count {
            maxStack.enqueue(num)
        }
        else {
            if let minMax = minStack.array().first, minMax > num {
                minStack.enqueue(num)
            }
            else if let maxMin = maxStack.array().first, maxMin < num {
                maxStack.enqueue(num)
            }
            else {
                maxStack.enqueue(num)
            }
        }
        
        if let minMax = minStack.array().first, let maxMin = maxStack.array().first, minMax > maxMin {
            minStack.dequeue()
            minStack.enqueue(maxMin)
            
            maxStack.dequeue()
            maxStack.enqueue(minMax)
        }
        
//        print("大堆：\(maxStack)")
//        print("小堆：\(minStack)")
//        print("======")
    }

    func findMedian() -> Double {
        if minStack.count == maxStack.count, let a = minStack.peek(), let b = maxStack.peek() {
            return Double((a + b)) / 2.0
        }
        else if minStack.count > maxStack.count {
            return Double(minStack.peek() ?? 0)
        }
        else if maxStack.count > minStack.count {
            return Double(maxStack.peek() ?? 0)
        }
        return 0
    }
}

let obj = MedianFinder()
obj.addNum(-1)
obj.addNum(-2)
obj.addNum(-3)
obj.addNum(-4)
obj.addNum(-5)
obj.addNum(6)

let ret_2: Double = obj.findMedian()

Swift - 优先队列

import Foundation

public struct SwiftPriorityQueue<Element> {
    private let _hasHigherPriority: (Element, Element) -> Bool
    private let _isEqual: (Element, Element) -> Bool

    private var _elements = [Element]()

    public init(hasHigherPriority: @escaping (Element, Element) -> Bool, isEqual: @escaping (Element, Element) -> Bool) {
        _hasHigherPriority = hasHigherPriority
        _isEqual = isEqual
    }

    public mutating func enqueue(_ element: Element) {
        _elements.append(element)
        bubbleToHigherPriority(_elements.count - 1)
    }

    public func peek() -> Element? {
        return _elements.first
    }
    
    public func array() -> [Element] {
        return _elements
    }

    public var isEmpty: Bool {
        return _elements.count == 0
    }
    
    public var count: Int {
        return _elements.count
    }

    public mutating func dequeue() -> Element? {
        guard let front = peek() else {
            return nil
        }

        removeAt(0)

        return front
    }

    public mutating func remove(_ element: Element) {
        for i in 0 ..< _elements.count {
            if _isEqual(_elements[i], element) {
                removeAt(i)
                return
            }
        }
    }

    private mutating func removeAt(_ index: Int) {
        let removingLast = index == _elements.count - 1
        if !removingLast {
            _elements.swapAt(index, _elements.count - 1)
        }

        _ = _elements.popLast()

        if !removingLast {
            bubbleToHigherPriority(index)
            bubbleToLowerPriority(index)
        }
    }

    private mutating func bubbleToHigherPriority(_ initialUnbalancedIndex: Int) {
        precondition(initialUnbalancedIndex >= 0)
        precondition(initialUnbalancedIndex < _elements.count)

        var unbalancedIndex = initialUnbalancedIndex

        while unbalancedIndex > 0 {
            let parentIndex = (unbalancedIndex - 1) / 2
            guard _hasHigherPriority(_elements[unbalancedIndex], _elements[parentIndex]) else { break }
            _elements.swapAt(unbalancedIndex, parentIndex)
            unbalancedIndex = parentIndex
        }
    }

    private mutating func bubbleToLowerPriority(_ initialUnbalancedIndex: Int) {
        precondition(initialUnbalancedIndex >= 0)
        precondition(initialUnbalancedIndex < _elements.count)

        var unbalancedIndex = initialUnbalancedIndex
        while true {
            let leftChildIndex = unbalancedIndex * 2 + 1
            let rightChildIndex = unbalancedIndex * 2 + 2

            var highestPriorityIndex = unbalancedIndex

            if leftChildIndex < _elements.count && _hasHigherPriority(_elements[leftChildIndex], _elements[highestPriorityIndex]) {
                highestPriorityIndex = leftChildIndex
            }

            if rightChildIndex < _elements.count && _hasHigherPriority(_elements[rightChildIndex], _elements[highestPriorityIndex]) {
                highestPriorityIndex = rightChildIndex
            }

            guard highestPriorityIndex != unbalancedIndex else { break }
            _elements.swapAt(highestPriorityIndex, unbalancedIndex)

            unbalancedIndex = highestPriorityIndex
        }
    }
}

extension SwiftPriorityQueue : CustomDebugStringConvertible {
    public var debugDescription: String {
        return _elements.debugDescription
    }
}

深度优先&广度优先

Wed, 09 Feb 2022 00:00:00 GMT

冒泡排序

Wed, 09 Feb 2022 00:00:00 GMT

一、常规冒泡

func bubbleSortA(nums: [Int]) -> [Int] {
    var nums = nums
    let count = nums.count
    
    for i in 0..<count {
        print("<")
        for j in (i + 1)..<count {
            if nums[i] > nums[j] {
                nums.swapAt(i, j)
            }
            print(nums)
        }
        print(">\n")
    }
    
    return nums
}

二、外层优化

当发现在某一趟排序中没有发生交换，则说明排序已经完成，所以可以在此趟排序后结束排序，在每趟排序前设置flag，当其未发生变化时，终止算法

func bubbleSortB(nums: [Int]) -> [Int] {
    print("bubbleSortB")
    
    var nums = nums
    let count = nums.count
    
    for i in 0..<count {
        var swapFlag = true
        print("<")
        for j in (i + 1)..<count {
            if nums[i] > nums[j] {
                nums.swapAt(i, j)
                swapFlag = false
            }
            print(nums)
        }
        print(">\n")
        if swapFlag {
            break
        }
    }
    
    return nums
}

三、内层优化

在每趟排序中，右面的许多元素已经是有序的结果了，可算法还是进行后面数值的排序，因此进行第二次优化

func bubbleSortC(nums: [Int]) -> [Int] {
    print("bubbleSortC")
    
    var nums = nums
    var boundary = nums.count - 1
    var lastSwapIdx = 0
    
    for _ in 0..<nums.count {
        var swapFlag = true
        print("<")
        for j in 0..<boundary {
            if nums[j] > nums[j+1] {
                nums.swapAt(j, j+1)
                swapFlag = false
                lastSwapIdx = j
            }
            print(nums)
        }
        print(">\n")
        boundary = lastSwapIdx
        if swapFlag {
            break
        }
    }
    
    return nums
}

四、对比

let numbers: [Int] = [3, 5, 1, 11, 2, 4, 12]

bubbleSortA(nums: numbers)
bubbleSortB(nums: numbers)
bubbleSortC(nums: numbers)

输出：

<
[3, 5, 1, 11, 2, 4, 12]
[1, 5, 3, 11, 2, 4, 12]
[1, 5, 3, 11, 2, 4, 12]
[1, 5, 3, 11, 2, 4, 12]
[1, 5, 3, 11, 2, 4, 12]
[1, 5, 3, 11, 2, 4, 12]
>

<
[1, 3, 5, 11, 2, 4, 12]
[1, 3, 5, 11, 2, 4, 12]
[1, 2, 5, 11, 3, 4, 12]
[1, 2, 5, 11, 3, 4, 12]
[1, 2, 5, 11, 3, 4, 12]
>

<
[1, 2, 5, 11, 3, 4, 12]
[1, 2, 3, 11, 5, 4, 12]
[1, 2, 3, 11, 5, 4, 12]
[1, 2, 3, 11, 5, 4, 12]
>

<
[1, 2, 3, 5, 11, 4, 12]
[1, 2, 3, 4, 11, 5, 12]
[1, 2, 3, 4, 11, 5, 12]
>

<
[1, 2, 3, 4, 5, 11, 12]
[1, 2, 3, 4, 5, 11, 12]
>

<
[1, 2, 3, 4, 5, 11, 12]
>

<
>

bubbleSortB
<
[3, 5, 1, 11, 2, 4, 12]
[1, 5, 3, 11, 2, 4, 12]
[1, 5, 3, 11, 2, 4, 12]
[1, 5, 3, 11, 2, 4, 12]
[1, 5, 3, 11, 2, 4, 12]
[1, 5, 3, 11, 2, 4, 12]
>

<
[1, 3, 5, 11, 2, 4, 12]
[1, 3, 5, 11, 2, 4, 12]
[1, 2, 5, 11, 3, 4, 12]
[1, 2, 5, 11, 3, 4, 12]
[1, 2, 5, 11, 3, 4, 12]
>

<
[1, 2, 5, 11, 3, 4, 12]
[1, 2, 3, 11, 5, 4, 12]
[1, 2, 3, 11, 5, 4, 12]
[1, 2, 3, 11, 5, 4, 12]
>

<
[1, 2, 3, 5, 11, 4, 12]
[1, 2, 3, 4, 11, 5, 12]
[1, 2, 3, 4, 11, 5, 12]
>

<
[1, 2, 3, 4, 5, 11, 12]
[1, 2, 3, 4, 5, 11, 12]
>

<
[1, 2, 3, 4, 5, 11, 12]
>

bubbleSortC
<
[3, 5, 1, 11, 2, 4, 12]
[3, 1, 5, 11, 2, 4, 12]
[3, 1, 5, 11, 2, 4, 12]
[3, 1, 5, 2, 11, 4, 12]
[3, 1, 5, 2, 4, 11, 12]
[3, 1, 5, 2, 4, 11, 12]
>

<
[1, 3, 5, 2, 4, 11, 12]
[1, 3, 5, 2, 4, 11, 12]
[1, 3, 2, 5, 4, 11, 12]
[1, 3, 2, 4, 5, 11, 12]
>

<
[1, 3, 2, 4, 5, 11, 12]
[1, 2, 3, 4, 5, 11, 12]
[1, 2, 3, 4, 5, 11, 12]
>

<
[1, 2, 3, 4, 5, 11, 12]
>

摩尔投票

Wed, 09 Feb 2022 00:00:00 GMT

什么是摩尔投票

摩尔投票 是一种用来解决 绝对众数 问题的算法。

在一个集合中，如果一个元素的出现次数比其他所有元素的出现次数之和还多，那么就称它为这个集合的 绝对众数 。等价地说， 绝对众数 的出现次数大于总元素数的一半。

摩尔投票 的过程非常简单，让我们把找到绝对众数的过程想象成一次选举。我们维护一个 m ，表示当前的候选人，然后维护一个 cnt 。对于每一张新的选票，如果它投给了当前的候选人，就把 cnt 加1，否则就把 cnt 减1（也许你可以想象成，B的一个狂热支持者去把A的一个支持者揍了一顿，然后两个人都没法投票）。特别地，计票时如果 cnt == 0 ，我们可以认为目前谁都没有优势，所以新的选票投给谁，谁就成为新的候选人。

如果我们要求的是 众数 ，这样的做法并不能给出正确答案，但如果要求的是 绝对众数 （且绝对众数确实存在），那么 m 一定是正确的。

39.数组中出现次数超过一半的数字

算法学习笔记(78): 摩尔投票

数组中出现次数超过一半的数字

Wed, 09 Feb 2022 00:00:00 GMT

一、题目

数组中有一个数字出现的次数超过数组长度的一半，请找出这个数字。

你可以假设数组是非空的，并且给定的数组总是存在多数元素。

示例 1:

输入: [1, 2, 3, 2, 2, 2, 5, 4, 2] 输出: 2

限制：

1 <= 数组长度 <= 50000

注意：本题与主站 169 题相同：https://leetcode-cn.com/problems/majority-element/

来源：力扣（LeetCode）

链接：https://leetcode-cn.com/problems/shu-zu-zhong-chu-xian-ci-shu-chao-guo-yi-ban-de-shu-zi-lcof

著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

二、题解

2.1 哈希表统计法

func majorityElementHash(_ nums: [Int]) -> Int {
    var temp: [Int : Int] = [:]
    
    for item in nums {
        if let count = temp[item] {
            if count == (nums.count / 2) {
                return item
            }
            temp[item] = count + 1
        }
        else {
            temp[item] = 1
        }
    }
    
    return nums[0]
}

2.2 数组排序法

将数组 nums 排序，数组中点的元素一定为众数。

func majorityElementArray(_ nums: [Int]) -> Int {
    nums.sorted()[nums.count / 2]
}

2.3 摩尔投票法

核心理念为票数正负抵消。此方法时间和空间复杂度分别为 O(N) O(1) 为本题的最佳解法。

func majorityElementMo(_ nums: [Int]) -> Int {
    var score = 0
    var x = 0
    for n in nums {
        if score == 0 {
            x = n
        }
        score += (x == n ? 1 : -1)
    }
    return x
}

算法学习笔记(78): 摩尔投票

TabView使用

Mon, 24 Jan 2022 00:00:00 GMT

https://www.hackingwithswift.com/books/ios-swiftui/creating-tabs-with-tabview-and-tabitem

切圆角

.cornerRadius(14)
.clipShape(Capsule())

导航栏形式

默认大标题

.navigationBarTitleDisplayMode( xx )

/**
/// Inherit the display mode from the previous navigation item.
case automatic

/// Display the title within the standard bounds of the navigation bar.
case inline

/// Display a large title within an expanded navigation bar.
case large
*/

Search

Mon, 24 Jan 2022 00:00:00 GMT

Searchable modifier in SwiftUI: A UISearchController and UISearchBar equivalent

利用 Searchable 修飾符　輕鬆在 SwiftUI List 視圖中實作搜尋欄

How to add a search bar to filter your data

SwifUI中使用WKWebView

Mon, 24 Jan 2022 00:00:00 GMT


import WebKit
import SwiftUI

struct WebView: UIViewRepresentable {
    typealias UIViewType = WKWebView

    let webView: WKWebView
    
    func makeUIView(context: Context) -> WKWebView {
        return webView
    }
    
    func updateUIView(_ uiView: WKWebView, context: Context) { }
}

class WebViewNavigationDelegate: NSObject, WKNavigationDelegate {
    func webView(_ webView: WKWebView, decidePolicyFor navigationAction: WKNavigationAction, decisionHandler: @escaping (WKNavigationActionPolicy) -> Void) {
        // TODO
        decisionHandler(.allow)
    }
    
    func webView(_ webView: WKWebView, decidePolicyFor navigationResponse: WKNavigationResponse, decisionHandler: @escaping (WKNavigationResponsePolicy) -> Void) {
        // TODO
        decisionHandler(.allow)
    }
}

class WebViewModel: ObservableObject {
    let webView: WKWebView
    
    private let navigationDelegate: WebViewNavigationDelegate
    
    init() {
        let configuration = WKWebViewConfiguration()
        configuration.websiteDataStore = .nonPersistent()
        webView = WKWebView(frame: .zero, configuration: configuration)
        navigationDelegate = WebViewNavigationDelegate()
        
        webView.navigationDelegate = navigationDelegate
        setupBindings()
    }
    
    @Published var urlString: String = ""
    @Published var canGoBack: Bool = false
    @Published var canGoForward: Bool = false
    @Published var isLoading: Bool = false
    
    private func setupBindings() {
        webView.publisher(for: \.canGoBack)
            .assign(to: &$canGoBack)
        
        webView.publisher(for: \.canGoForward)
            .assign(to: &$canGoForward)
        
        webView.publisher(for: \.isLoading)
            .assign(to: &$isLoading)
        
    }
    
    func loadUrl() {
        guard let url = URL(string: urlString) else {
            return
        }
        
        webView.load(URLRequest(url: url))
    }
    
    func loadHTML(html: String) {
        webView.loadHTMLString(html, baseURL: nil)
    }
    
    func goForward() {
        webView.goForward()
    }
    
    func goBack() {
        webView.goBack()
    }
}

参考

Create a web browser with WebKit and SwiftUI

自动释放池与Runloop

Sun, 19 Dec 2021 00:00:00 GMT

一、寻找线索

为了探究 autoreleasepool 的原理，我们需要定位到源码。我们通过汇编断点试试

我们在 main 函数中添加断点：

这里我们发现 @autoreleasepool 关键字实际调用的是： objc_autoreleasePoolPush。同时还发现一个与之匹配的 objc_autoreleasePoolPop 。

void *
objc_autoreleasePoolPush(void)
{
    return AutoreleasePoolPage::push();
}

在源码中我们可以发现最终调用的是 AutoreleasePoolPage 的方法

二、 AutoreleasePoolPage

/***********************************************************************
   Autorelease pool implementation

   A thread's autorelease pool is a stack of pointers. 
   Each pointer is either an object to release, or POOL_BOUNDARY which is 
     an autorelease pool boundary.
   A pool token is a pointer to the POOL_BOUNDARY for that pool. When 
     the pool is popped, every object hotter than the sentinel is released.
   The stack is divided into a doubly-linked list of pages. Pages are added 
     and deleted as necessary. 
   Thread-local storage points to the hot page, where newly autoreleased 
     objects are stored. 
**********************************************************************/

一个线程的自动释放池是一个栈结构，存放的指针。每个指针要么是一个待释放的对象，要么是一个自动释放边界 POOL_BOUNDARY 。

一个 pool token 是一个指向该自动释放池的 POOL_BOUNDARY 的指针。

栈被绑定到一个双向链表。Pages 会按需进行增删。

POOL_BOUNDARY 边界的作用是防止访问到不该访问的内存区域
- 只在第一页中存在哨兵对象
这里使用双向链表的作用是， Page 能够互相找到
- 每页的内存地址并不是连续的

分页结构图

每页的容量，源码中有 1 << 12

Push 流程

Pop 流程

先入后出
- 从栈顶开始通过内存平移进行处理
一个 Page 空了就将这个 Page 释放
- 并将上一个 Page ，即父节点设为 Hot

三、一个注意点

通过 alloc new copy mutablecopy other 前缀的方法创建的对象不会加入自动释放池。

四、 Runloop

4.1 什么是RunLoop

使程序一直运行并接受用户输入
决定程序在何时应该处理那些事件
消息队列
节省CPU时间

4.2 RunLoop 与线程

线程 和 RunLoop 之间是一一对应的(可嵌套)，其关系是保存在一个全局的 Dictionary 里
线程结束时销毁, 或手动退出

4.3 结构

struct __CFRunLoop {
    CFMutableSetRef _commonModes;     // Set
    CFMutableSetRef _commonModeItems; // Set<Source/Observer/Timer>
    CFRunLoopModeRef _currentMode;    // Current Runloop Mode
    CFMutableSetRef _modes;           // Set
    ...
};

Source

RunLoop 的数据源抽象类

RunLoop运行必须要在加入NSTimer或Source0、Sourc1、Observer输入后运行否则会直接退出

Source0: 处理App内部事件, App自行管理

包含了一个函数指针，它并不能主动触发事件
调用 CFRunLoopSourceSignal(source)，将这个 Source 标记为待处理
调用 CFRunLoopWakeUp(runloop) 来唤醒 RunLoop，让其处理这个事件

Source1: 由RunLoop内核管理, MachPort驱动(进程间通讯)

包含了一个 mach_port 和一个 函数指针
被用于通过内核和其他线程相互发送消息
如解锁/摇晃等

Timer

包含了时长和 函数指针

Observer

向外部报告 RunLoop 状态的变化

typedef CF_OPTIONS(CFOptionFlags, CFRunLoopActivity) {
    kCFRunLoopEntry         = (1UL << 0), // 即将进入Loop
    kCFRunLoopBeforeTimers  = (1UL << 1), // 即将处理 Timer
    kCFRunLoopBeforeSources = (1UL << 2), // 即将处理 Source
    kCFRunLoopBeforeWaiting = (1UL << 5), // 即将进入休眠
    kCFRunLoopAfterWaiting  = (1UL << 6), // 刚从休眠中唤醒
    kCFRunLoopExit          = (1UL << 7), // 即将退出Loop
};

Observer 与 AutoreleasePool(UIKit)

Observer 在RunLoop两次Sleep间 Pop旧的并释放对象 Push新的

Mode

struct __CFRunLoopMode {
    CFStringRef _name;            // Mode Name, 例如 @"kCFRunLoopDefaultMode"
    CFMutableSetRef _sources0;    // Set
    CFMutableSetRef _sources1;    // Set
    CFMutableArrayRef _observers; // Array
    CFMutableArrayRef _timers;    // Array
    ...
};

在同一时间必须且只能在一个Mode下运行
切换Mode必须退出RunLoop,重启
保证页面滑动流畅的关键

NSDefaultRunLoopMode // 默认状态 空闲状态
UITrackingRunLoopMode // 滑动
//私有Mode

当创建一个 Timer 并加到 DefaultMode 时，Timer 会得到重复回调，但此时滑动一个TableView 时，RunLoop 会将 mode 切换为 TrackingRunLoopMode，这时 Timer 就不会被回调，并且也不会影响到滑动操作。这两个 Mode 都已经被标记为Common

特殊Mode:

NSRunLoopCommonModes

有时你需要一个 Timer，在两个 Mode 中都能得到回调，一种办法就是将这个 Timer 分别加入这两个 Mode。还有一种方式，就是将 Timer 加入到顶层的 RunLoop 的 commonModeItems 中。commonModeItems 被 RunLoop 自动更新到所有具有 Common 的 Mode 里去。

4.4 Runloop 原理

五、 AutoreleasePool 什么时候创建？什么时候销毁？

App启动后，系统在主线程RunLoop 里注册两个Observser,其回调都是_wrapRunLoopWithAutoreleasePoolHandler()。

第一个 Observer 监视的事件是 Entry(即将进入Loop)
- 其回调内会调用 _objc_autoreleasePoolPush() 创建自动释放池。其优先级最高，保证创建释放池发生在其他所有回调之前。
第二个 Observer 监视了两个事件
- _BeforeWaiting(准备进入休眠) 时 _ 调用_objc_autoreleasePoolPop() 和 _objc_autoreleasePoolPush() 释放旧的池 并 创建新池；
- _Exit(即将退出Loop) 时 _ 调用 _objc_autoreleasePoolPop() 来释放自动释放池。
- 这个 Observer 优先级最低，保证其释放池子发生在其他所有回调之后。

现在我们知道了AutoreleasePool是在RunLoop即将进入RunLoop和准备进入休眠这两种状态的时候被创建和销毁的。

所以AutoreleasePool的释放有如下两种情况。

一是Autorelease对象是在当前的runloop迭代结束时释放的，而它能够释放的原因是系统在每个runloop迭代中都加入了自动释放池Push和Pop。
二是手动调用AutoreleasePool的释放方法（drain方法）来销毁AutoreleasePool

参考

Threading Programming Guide - Runloop

Timer优化

Mon, 13 Dec 2021 00:00:00 GMT

前言

NSTimer 是 iOS 开发中老生常谈的知识点了，今天再来唠叨一番。

一、 NSTimer 常规使用

通过下面简单的 Demo 看看现象。

#import "NSTimerViewController.h"

@interface NSTimerViewController ()
@property (nonatomic, strong) NSTimer *timer;
@property (nonatomic, assign) NSInteger count;
@end

@implementation NSTimerViewController

- (void)viewDidLoad {
    [super viewDidLoad];
    
    [self selfTargetTimer];
}

#pragma mark - 不同 NSTimer 使用方式
/// 常规使用 self 作为 Target 的 NSTimer
- (void)selfTargetTimer {
    self.timer = [NSTimer scheduledTimerWithTimeInterval:1 target:self selector:@selector(countAction) userInfo:nil repeats:YES];
    [[NSRunLoop currentRunLoop] addTimer:self.timer forMode:NSRunLoopCommonModes];
}

#pragma mark - Action
- (void)countAction {
    self.count += 1;
    NSLog(@"%@ - %ld",self, self.count);
}

- (void)dealloc {
    [self.timer invalidate];
    self.timer = nil;
    NSLog(@"NSTimerViewController dealloc");
}

@end

我们反复 Push 到这个 ViewController ，出现了典型的内存泄露。

通过内存图我们能够发现，根本原因是 RunLoop -> Timer <-> Self 这样的一个持有关系。

而在该API的文档中也是有说明的。

为了解决内存泄露，我们需要打破这个循环引用。

1.1 weakSelf

我们用 weakself 替代 Self 是否有用呢？

__weak typeof(self)weakSelf = self;
self.timer = [NSTimer scheduledTimerWithTimeInterval:1 target:weakSelf selector:@selector(countAction) userInfo:nil repeats:YES];
[[NSRunLoop currentRunLoop] addTimer:self.timer forMode:NSRunLoopCommonModes];

还是一样，这里是 RunLoop -> Timer <-> weakSelf -> Self 依旧没有打破。

1.2 block

还有这样一个 API

+ (NSTimer *)scheduledTimerWithTimeInterval:(NSTimeInterval)interval 
                                    repeats:(BOOL)repeats 
                                      block:(void (^)(NSTimer *timer))block;

我们试试

__weak typeof(self)weakSelf = self;
    self.timer = [NSTimer scheduledTimerWithTimeInterval:1 repeats:YES block:^(NSTimer * _Nonnull timer) {
        [weakSelf countAction];
    }];

这个 API 就可以很好的避免循环引用了。这里的关系是 RunLoop -> Timer -> block 。这里只需要注意不要让 block 产生内存泄露就ok了。

二、自定义 Timer

2.1 加一层间接

通过封装，解决 Timer 和 Self 的强引用关系： RunLoop -> Timer -> ?? ~~ Self

#import <objc/message.h>

@interface RYTimer ()

@property (nonatomic, weak) id target;
@property (nonatomic, assign) SEL aSelector;
@property (nonatomic, strong) NSTimer *timer;

@end

@implementation RYTimer

- (instancetype)initWithTimeInterval:(NSTimeInterval)ti target:(id)aTarget selector:(SEL)aSelector userInfo:(nullable id)userInfo repeats:(BOOL)yesOrNo {
    if (self == [super init]) {
        self.target = aTarget;
        self.aSelector = aSelector;
        
        if ([self.target respondsToSelector:self.aSelector]) {
            Method method = class_getInstanceMethod([self.target class], aSelector);
            const char *type = method_getTypeEncoding(method);
            class_addMethod([self class], aSelector, (IMP)fireIMP, type);
            
            self.timer = [NSTimer scheduledTimerWithTimeInterval:ti target:self selector:aSelector userInfo:userInfo repeats:yesOrNo];
        }
    }
    return self;
}

void fireIMP(RYTimer *timer){
    if (timer.target) {
        void (*ry_msgSend)(void *,SEL, id) = (void *)objc_msgSend;
        ry_msgSend((__bridge void *)(timer.target), timer.aSelector,timer.timer);
    }else{
        [timer invalidate];
    }
}

- (void)invalidate{
    [self.timer invalidate];
    self.timer = nil;
}

- (void)dealloc{
    NSLog(@"%s",__func__);
}

@end

2.2 消息转发机制

我们同样可以利用消息转发机制来对 Timer 进行优化，这里的思想和上面一样，都是使用了一层间接，但是具体实现方式不同。这里使用了 NSProxy 结合消息转发实现。

@interface RYProxy : NSProxy

+ (instancetype)proxyWithTransformObject:(id)object;

@end


@interface RYProxy ()

@property (nonatomic, weak) id object;

@end

@implementation RYProxy

+ (instancetype)proxyWithTransformObject:(id)object {
    RYProxy *proxy = [RYProxy alloc];
    proxy.object = object;
    return proxy;
}

-(id)forwardingTargetForSelector:(SEL)aSelector {
    return self.object;
}

- (NSMethodSignature *)methodSignatureForSelector:(SEL)sel{
    if (self.object) {
    }
    return [self.object methodSignatureForSelector:sel];

}

- (void)forwardInvocation:(NSInvocation *)invocation{
    if (self.object) {
        [invocation invokeWithTarget:self.object];
    }
}

@end

虽然 Target 并不是 Self 但经过消息转发，最终处理消息的还是消息的还是 Self 。

RYProxy *timerProxy = [RYProxy proxyWithTransformObject:self];
self.timer = [NSTimer scheduledTimerWithTimeInterval:1 target:timerProxy selector:@selector(countAction) userInfo:nil repeats:YES];

SideTable和weak底层实现

Fri, 10 Dec 2021 00:00:00 GMT

我们先看一个小题目，看看下面的输出回事什么样的？

NSObject *objc = [[NSObject alloc] init];

NSLog(@"%zd - %@",(long)CFGetRetainCount((__bridge CFTypeRef)(objc)), objc);

__weak typeof(id) weakObjc = objc;

NSLog(@"%zd - %@",(long)CFGetRetainCount((__bridge CFTypeRef)(objc)), objc);

NSLog(@"%zd - %@",(long)CFGetRetainCount((__bridge CFTypeRef)(weakObjc)), weakObjc);

输出：

1、1、2。是不是很迷惑？别急我们慢慢来

前言

前面在对内存管理进行研究的时候接触到了 SideTalbe ，今天我们也依然会和他见面，它究竟是什么呢？

void 
objc_object::sidetable_lock()
{
    SideTable& table = SideTables()[this];
    table.lock();
}

SideTable 可以看出， SideTable 是有多张的。它是一个 HashMap 。

一、 SideTable 的结构

struct SideTable {
    spinlock_t slock;
    // 引用计数 Map
    RefcountMap refcnts;
    // 若引用 Map
    weak_table_t weak_table;

    SideTable() {
        memset(&weak_table, 0, sizeof(weak_table));
    }

    ~SideTable() {
        _objc_fatal("Do not delete SideTable.");
    }

    void lock() { slock.lock(); }
    void unlock() { slock.unlock(); }
    void forceReset() { slock.forceReset(); }

    ...
};

简单了解了 SideTable 后我们继续回到题目。

二、 weak 做了什么

2.1 调试

在这里打上汇编断点

走到了 objc_initWeak

objc_initWeak

storeWeak

weak_register_no_lock

注册一个对象 - weak指针对。如果没有的话，创建一个 weak 的 entry 对象。

参数：

weak_table : SideTable 地址
referent : 被弱引用的对象
referrer : 弱引用指针地址

append_referrer

把 referrer 加进 entry 的 inline_referrers

这里又见到了熟悉的 3/4 扩容

weak_entry_t

struct weak_entry_t {
    DisguisedPtr<objc_object> referent;
    union {
        struct {
            // 一个对象可以有多个 referent
            weak_referrer_t *referrers;
            uintptr_t        out_of_line_ness : 2;
            uintptr_t        num_refs : PTR_MINUS_2;
            uintptr_t        mask;
            uintptr_t        max_hash_displacement;
        };
        struct {
            // out_of_line_ness field is low bits of inline_referrers[1]
            weak_referrer_t  inline_referrers[WEAK_INLINE_COUNT];
        };
    };

    ...

    weak_entry_t(objc_object *newReferent, objc_object **newReferrer)
        : referent(newReferent)
    {
        inline_referrers[0] = newReferrer;
        for (int i = 1; i < WEAK_INLINE_COUNT; i++) {
            inline_referrers[i] = nil;
        }
    }
};

三、回到题目继续分析

我们在这里下个断点，并打开汇编断点：

来到了 objc_loadWeakRetained

objc_loadWeakRetained

内部继续跟进来到了 rootTryRetain ，这里内部引用计数会加

总结

weak 原理
- 得到 SideTable 的弱引用表
- 得到一个 weak_entry_t
- 把 referent 加入到 entry 的数组 inline_referrers
- 如果 weak_table 需要扩容
  - 3/4 扩容，类似与方法列表
- 把 new_entry 加入到 weak_table 中
当我们使用一个 weakObjc 的时候，会调用 rootTryRetain ，所以引用计数会 +1。也就是这里我们看到输出为 2 的原因所在。

从一个面试题看TaggedPointer

Thu, 09 Dec 2021 00:00:00 GMT

前言

之前我们在WWDC20-runtime优化中有初步接触到了 TaggedPointer 。本文就讲结合一个面试题加深对它的理解。

一、一个面试题

分析一下下面的代码会有什么问题

#import "ViewController.h"

@interface ViewController ()

@property (nonatomic, strong) dispatch_queue_t  queue;
@property (nonatomic, strong) NSString *nameStr;

@end

@implementation ViewController

- (void)viewDidLoad {
    [super viewDidLoad];
    
    [self taggedPointerDemo];

}

- (void)taggedPointerDemo {
  
    self.queue = dispatch_queue_create("Ryukie", DISPATCH_QUEUE_CONCURRENT);
    
    for (int i = 0; i<100000; i++) {
        dispatch_async(self.queue, ^{
            self.nameStr = [NSString stringWithFormat:@"Ryukie"];
             NSLog(@"%@",self.nameStr);
        });
    }
}

- (void)touchesBegan:(NSSet<UITouch *> *)touches withEvent:(UIEvent *)event{
    for (int i = 0; i<100000; i++) {
        dispatch_async(self.queue, ^{
            self.nameStr = [NSString stringWithFormat:@"RyukieRyukieRyukieRyukieRyukieRyukieRyukieRyukieRyukieRyukie"];
            NSLog(@"%@",self.nameStr);
        });
    }
}

@end

1.1 分析

乍一看本题考验的是多线程读写，很难想到和 TaggedPointer 有关。本题两处中的不同点是字符串的长度而已。而根据我们之前对 TaggedPointer 的了解，其中的 Payload 会用来存储数据。但是 Payload 的长度是有限的，过长的数据就无法完整保存进去。

所以，这里分析两处的指针类型是不同的。

1.2 断点调试

较短的字符串

这里发现指针类型为 NSTaggedPointerString 。明显是一个 TaggedPointer 。

较长的字符串

这里的指针类型为 __NSCFString 是一个普通的指针。

1.3 问题

在第二段代码运行中出现了野指针的崩溃。

1.4 思考

根据奔溃的现象，你可能会想到。 TaggedPointer 的 Retain 和 Release 难道和普通的有不同么？

二、源码分析

在 OC 源码中找到：

- (id)retain {
    return _objc_rootRetain(self);
}

进一步找到具体实现：

objc_object::rootRetain(bool tryRetain, objc_object::RRVariant variant)
{
    if (slowpath(isTaggedPointer())) return (id)this;
    ...
}

通过 Retain 的源码，我们可以看出，在判断是 TaggedPointer 之后就直接 return 了，没有进行任何操作。

那么 Release 呢？我们探索一下源码：

objc_object::rootRelease(bool performDealloc, objc_object::RRVariant variant)
{
    if (slowpath(isTaggedPointer())) return false;
    ...
}

发现这里和 Retain 是一样的处理。

三、问题分析

初步了解了 Retain 和 Release 对与 TaggedPointer 之后，我们就很容易理解上面的面试题所发生的现象了

TaggedPointer 的较短的字符串没有进行 Retain Release 所以多线程异步读写过程中没有出现野指针错误
非 TaggedPointer 的较长的字符串，由于进行了多线程异步读写操作，不断的 Retain Release ，所以可能出现野指针错误。

总结

TaggedPointer 是用于特定类型的小对象的，并不是那些类型就都是 TaggedPointer 。前提是 Payload 要能够装得下。
Retain Release 对 TaggedPointer 的特殊处理，也提高了 TaggedPointer 的效率，同时在多线程场景下的安全性也比较高。

Retain&Release

Thu, 09 Dec 2021 00:00:00 GMT

前言

到现在我们接触到了三种指针： TaggedPointer 、 Nonpointer isa 和 纯isa 。

经过上文对 TaggedPointer 的探索，我们接触到了 Reatin 和 Release ，发现他们对 TaggedPointer 有特殊处理的。本文将更加深入的对 Reatin 和 Release 进行研究。

一、 Retain

objc_object::rootRetain(bool tryRetain, objc_object::RRVariant variant)
{
    // 不处理 TaggedPointer 直接 return
    if (slowpath(isTaggedPointer())) return (id)this;

    ...

    do {
        transcribeToSideTable = false;
        newisa = oldisa;
        if (slowpath(!newisa.nonpointer)) {
            // 非 nonpointer 通过 sidetable 处理
            ClearExclusive(&isa.bits);
            if (tryRetain) return sidetable_tryRetain() ? (id)this : nil;
            else return sidetable_retain(sideTableLocked);
        }
        
        ...

        uintptr_t carry; // 标志 extra_rc 容量是否还能够承受
        newisa.bits = addc(newisa.bits, RC_ONE, 0, &carry);  // extra_rc++

        if (slowpath(carry)) {
            // 超出 extra_rc 容量
            // newisa.extra_rc++ overflowed
            if (variant != RRVariant::Full) {
                ClearExclusive(&isa.bits);
                return rootRetain_overflow(tryRetain);
            }
            // 保留一般的引用计数，并将另一半拷贝到 side table
            // Leave half of the retain counts inline and 
            // prepare to copy the other half to the side table.
            if (!tryRetain && !sideTableLocked) sidetable_lock();
            sideTableLocked = true;
            transcribeToSideTable = true;
            newisa.extra_rc = RC_HALF;
            newisa.has_sidetable_rc = true;
        }
    } while (slowpath(!StoreExclusive(&isa.bits, &oldisa.bits, newisa.bits)));

    if (variant == RRVariant::Full) {
        if (slowpath(transcribeToSideTable)) {
            // Copy the other half of the retain counts to the side table.
            sidetable_addExtraRC_nolock(RC_HALF);
        }

        if (slowpath(!tryRetain && sideTableLocked)) sidetable_unlock();
    } else {
        ASSERT(!transcribeToSideTable);
        ASSERT(!sideTableLocked);
    }

    return (id)this;
}

小结

TaggedPointer 不处理，直接 return
Nonpointer isa
- BITFIELD 和 SideTable 结合使用
  - 当 BITFIELD 的 extra_rc 容量足够的时候持续 ++
  - 当 BITFIELD 的 extra_rc 容量不够的时候
    - extra_rc 减半，拷贝一半到 SideTable 进行管理
    - 同时标志位 has_sidetable_rc 改变
纯isa
- 通过 SideTable 管理

二、 Release

objc_object::rootRelease(bool performDealloc, objc_object::RRVariant variant)
{
    // 不处理 TaggedPointer 直接 return
    if (slowpath(isTaggedPointer())) return false;

    ...

retry:
    do {
        newisa = oldisa;
        if (slowpath(!newisa.nonpointer)) {
            // 非 nonpointer 通过 sidetable 处理
            ClearExclusive(&isa.bits);
            return sidetable_release(sideTableLocked, performDealloc);
        }
        ...
        // don't check newisa.fast_rr; we already called any RR overrides
        uintptr_t carry;
        newisa.bits = subc(newisa.bits, RC_ONE, 0, &carry);  // extra_rc--
        if (slowpath(carry)) {
            // don't ClearExclusive()
            // extra_rc 见底 跳转执行 underflow
            goto underflow;
        }
    } while (slowpath(!StoreReleaseExclusive(&isa.bits, &oldisa.bits, newisa.bits)));

    if (slowpath(newisa.isDeallocating()))
        goto deallocate;

    ...
    return false;

 underflow:
    // extra_rc 见底后，从 SideTable 拿回引用计数，或者销毁
    // newisa.extra_rc-- underflowed: borrow from side table or deallocate

    // abandon newisa to undo the decrement
    newisa = oldisa;

    if (slowpath(newisa.has_sidetable_rc)) {
        // 如果有使用 SideTable
        if (variant != RRVariant::Full) {
            ClearExclusive(&isa.bits);
            return rootRelease_underflow(performDealloc);
        }

        // Transfer retain count from side table to inline storage.
        
        if (!sideTableLocked) {
            ClearExclusive(&isa.bits);
            sidetable_lock();
            sideTableLocked = true;
            // Need to start over to avoid a race against 
            // the nonpointer -> raw pointer transition.
            oldisa = LoadExclusive(&isa.bits);
            goto retry;
        }

        // 从 SideTable 移除引用计数
        // Try to remove some retain counts from the side table.        
        auto borrow = sidetable_subExtraRC_nolock(RC_HALF);

        bool emptySideTable = borrow.remaining == 0; // we'll clear the side table if no refcounts remain there

        if (borrow.borrowed > 0) {
            // Side table retain count decreased.
            // Try to add them to the inline count.
            bool didTransitionToDeallocating = false;
            // 修改 extra_rc 及标志位
            newisa.extra_rc = borrow.borrowed - 1;  // redo the original decrement too
            newisa.has_sidetable_rc = !emptySideTable;
            ...
        }
        else {
            // Side table is empty after all. Fall-through to the dealloc path.
        }
    }

deallocate:
    // Really deallocate.
    // 销毁
    ...

    if (performDealloc) {
        ((void(*)(objc_object *, SEL))objc_msgSend)(this, @selector(dealloc));
    }
    return true;
}

小结

TaggedPointer 不处理，直接 return
Nonpointer isa
- BITFIELD 和 SideTable 结合使用
  - 当 BITFIELD 的 extra_rc 容量未见底的时候持续 --
  - 当 BITFIELD 的 extra_rc 容量见底的时候
    - 检查标志位 has_sidetable_rc
      - 使用了 SideTable
        
        将 SideTable 中的引用计数转移回 BITFIELD 的 extra_rc 进行处理
      - 未使用 SideTable
        
        需要销毁
纯isa
- 通过 SideTable 管理

三、总结

通过对 Retain 和 Release 源码的探索，发现使用 TaggedPointer 和 Nonpointer isa 在内存管理的效率上会更高。一旦 SideTable 介入，流程就回变的复杂还要上锁解锁，影响效率。虽然一般开发过程中很难遇到这种情况，但是理解了这些后，对一些问题一些现象就能更清楚的看到本质。

参考

对象本质探究与isa

iOS原生嵌入FlutterModule

Wed, 08 Dec 2021 00:00:00 GMT

Flutter Module

为了将 Flutter 嵌入原生项目，我们需要创建一个 Flutter Module

方式一：通过AS创建 Module

方式二：通过命令行创建

flutter create -t module 你的module名字比如my_module命名要符合规范

配置Podfile

flutter_application_path = 'flutter Module 路径'
load File.join(flutter_application_path, '.ios', 'Flutter', 'podhelper.rb')

target 'FlutterDemo' do
  # Comment the next line if you don't want to use dynamic frameworks
  use_frameworks!

end

配置完成后 pod install

Key

Thu, 02 Dec 2021 00:00:00 GMT

Key 的作用

我们创建这样一个示例：

import 'dart:math';

import 'package:flutter/material.dart';

void main() {
  runApp(const MyApp());
}

class MyApp extends StatelessWidget {
  const MyApp({Key? key}) : super(key: key);

  @override
  Widget build(BuildContext context) {
    return MaterialApp(
      title: 'Flutter Demo',
      theme: ThemeData(
        primarySwatch: Colors.blue,
      ),
      home: HomePage(),
    );
  }
}

class HomePage extends StatefulWidget {
  const HomePage({Key? key}) : super(key: key);
  @override
  _HomePageState createState() => _HomePageState();
}

class _HomePageState extends State<HomePage> {
  //key的作用就非常大了！！
  List<Widget> items = [
    ColorItem('第1个'),
    ColorItem('第2个'),
    ColorItem('第3个'),
  ];

  @override
  Widget build(BuildContext context) {
    return Scaffold(
      appBar: AppBar(
        title: const Text('Key的作用'),
      ),
      body: Row(
        mainAxisAlignment: MainAxisAlignment.center,
        children: items,
      ),
      floatingActionButton: FloatingActionButton(
        child: const Icon(Icons.add),
        onPressed: () {
          setState(() {
            items.removeAt(0);
          });
        },
      ),
    );
  }
}

class ColorItem extends StatefulWidget {
  final String title;

  ColorItem(this.title, {Key? key}) : super(key: key);

  @override
  _ColorItemState createState() => _ColorItemState();
}

class _ColorItemState extends State<ColorItem> {
  final color = Color.fromRGBO(
      Random().nextInt(256), Random().nextInt(256), Random().nextInt(256), 1.0);
  @override
  Widget build(BuildContext context) {
    return Container(
      width: 100,
      height: 100,
      child: Text(widget.title),
      color: color,
    );
  }
}

运行发现了上面的现象，作为有 iOS 开发经验的我们，很容易联想到这应该是和复用有关的现象。

复用问题

这里我们需要理解， ColorItem 作为一个 StatefulWidget 它是由两部分组成的： Widget 和 State 。这里就是 Widget 被移除后， State 还在内存中。所以出现了复用异常的问题。

那么将数据放在 Widget 中按照这里分析的理论来说应该就没有这个现象了吧？我们试试：

class ColorItem extends StatefulWidget {
  final String title;
  // 移到 Widget 中
  final color = Color.fromRGBO(
      Random().nextInt(256), Random().nextInt(256), Random().nextInt(256), 1.0);

  ColorItem(this.title, {Key? key}) : super(key: key);

  @override
  _ColorItemState createState() => _ColorItemState();
}

class _ColorItemState extends State<ColorItem> {
  @override
  Widget build(BuildContext context) {
    return Container(
      width: 100,
      height: 100,
      child: Text(widget.title),
      color: widget.color,
    );
  }
}

验证成功！那么具体原因是什么呢？

增量渲染与 canUpdate

我们来到 Widget 的实现中， canUpdate 方法决定了一个 Widget 的 Element 是否会被更新，而 Element 的更新，又直接关系到了增量渲染。

同时满足两个条件：

新旧 Widget 的类型相同
新旧 Widget 的 Key 相同
- 如果 Key 是空的，只通过类型判断，就算他们的子 Widget 完全不同

这里就很好的解释了一开始发生的异常现象。

/// Whether the `newWidget` can be used to update an [Element] that currently
/// has the `oldWidget` as its configuration.
///
/// An element that uses a given widget as its configuration can be updated to
/// use another widget as its configuration if, and only if, the two widgets
/// have [runtimeType] and [key] properties that are [operator==].
///
/// If the widgets have no key (their key is null), then they are considered a
/// match if they have the same type, even if their children are completely
/// different.
static bool canUpdate(Widget oldWidget, Widget newWidget) {
    return oldWidget.runtimeType == newWidget.runtimeType
        && oldWidget.key == newWidget.key;
}

图解

Widget 和 Element 是一一对应的，而 State 是在 Element 中的。

移除一个 Widget 开始检查
第一个 Element 检查到第二个 Widget
- 调用 canUpdate
  - 类型相同
  - Key 为空
  - return ture
- 于是就用 第一个Element 更新 第二个Widget
依次类推，就发生了前面的异常现象

既然这里提到了 Key ，那么加上 Key 是否就可以上面这个问题呢？

Key 的使用

这里为每个 ColorItem 加上 Key ，并将 Color 属性放回 State 中：

...

class _HomePageState extends State<HomePage> {
  //key的作用就非常大了！！
  List<Widget> items = [
    ColorItem(
      '第1个',
      key: ValueKey(1),
    ),
    ColorItem(
      '第2个',
      key: ValueKey(2),
    ),
    ColorItem(
      '第3个',
      key: ValueKey(3),
    ),
  ];

  @override
  Widget build(BuildContext context) {
    ...
  }
}

class ColorItem extends StatefulWidget {
  final String title;
  ...
}

class _ColorItemState extends State<ColorItem> {
  final color = Color.fromRGBO(
      Random().nextInt(256), Random().nextInt(256), Random().nextInt(256), 1.0);
  ...
}

有效！

Key

Key 本身是一个抽象类，有一个工厂方法：

/// A [Key] is an identifier for [Widget]s, [Element]s and [SemanticsNode]s.
///
/// A new widget will only be used to update an existing element if its key is
/// the same as the key of the current widget associated with the element.
///
/// {@youtube 560 315 https://www.youtube.com/watch?v=kn0EOS-ZiIc}
///
/// Keys must be unique amongst the [Element]s with the same parent.
///
/// Subclasses of [Key] should either subclass [LocalKey] or [GlobalKey].
///
/// See also:
///
///  * [Widget.key], which discusses how widgets use keys.
@immutable
abstract class Key {
  /// Construct a [ValueKey<String>] with the given [String].
  ///
  /// This is the simplest way to create keys.
  const factory Key(String value) = ValueKey<String>;

  /// Default constructor, used by subclasses.
  ///
  /// Useful so that subclasses can call us, because the [new Key] factory
  /// constructor shadows the implicit constructor.
  @protected
  const Key.empty();
}

它有两个子类
- LocalKey
  - 同一个 父Element 内唯一的
- GlobalKey
  - 整个 App 内唯一

刚才用的 ValueKey 是 LocalKey 的子类。

LocalKey

区别哪个 Element 要保留，哪个 Element 要删除。

/// A key that is not a [GlobalKey].
///
/// Keys must be unique amongst the [Element]s with the same parent. By
/// contrast, [GlobalKey]s must be unique across the entire app.
///
/// See also:
///
///  * [Widget.key], which discusses how widgets use keys.
abstract class LocalKey extends Key {
  /// Abstract const constructor. This constructor enables subclasses to provide
  /// const constructors so that they can be used in const expressions.
  const LocalKey() : super.empty();
}

ValueKey
- 以值作为参数（数字、字符串等）
ObjectKey
- 以对象作为参数
UniqueKey
- 创建唯一标识

GlobalKey

在整个 App 中 唯一的Key。 GlobalKey 可以唯一标识一个元素，比如访问一个 BuildContext 或者一个 Widget。对于 StatefulWidget 而言， GlobalKey 也可以访问 State 。

当有 GlobalKey 的 Widget 被移动到 Widget树 中新的位置的话，会重新渲染他们的子树。

为了渲染子树，一个 Widget 必须在同一个动画帧内完成在树中，从旧位置移动到新位置。

重新渲染一个使用 GlobalKey 的 Element 是很消耗性能的，因为会触发调用所有相关的 State 的 deactivate 方法，然后让所有依赖 InheritedWidget 的 Widget 重建。

所以如果你不需要达到上面的效果，那么建议使用其他的 Key 。

注意点

两个在同一个树中的 Widget 不能同时有相同的 GlobalKey 。尝试这样做的话在运行时会触发异常。
GlobalKeys 不应该再每次 build 的时候被重新创建。他们应该是长期被一个 State 所持有的。
- 例如：
  - 每次 build 的时候都创建一个新的 GlobalKey 会丢弃和 旧Key 相关的子树，并为新Key创建一个新树。除了会损害性能，这种操作还有可能会对子树造成未知的影响。
  - 例如子树中的 GestureDetector 将无法继续追踪正在进行中的手势，因为它会在每次 build 的时候被重新创建
比较好的做法是：
- 让一个 State 持有这个 GlobalKey ，并且在 Build 方法外初始化它
- 比如在 State.initState 中

GlobalKey简单示例

import 'dart:math';

import 'package:flutter/material.dart';

void main() {
  runApp(const MyApp());
}

class MyApp extends StatelessWidget {
  const MyApp({Key? key}) : super(key: key);

  @override
  Widget build(BuildContext context) {
    return MaterialApp(
      title: 'Flutter Demo',
      theme: ThemeData(
        primarySwatch: Colors.blue,
      ),
      home: GlobalKeyDemo(),
    );
  }
}

class GlobalKeyDemo extends StatelessWidget {

  final GlobalKey<_GKeyItemState> _gKey = GlobalKey();

  GlobalKeyDemo({Key? key}) : super(key: key);

  @override
  Widget build(BuildContext context) {
    return Scaffold(
      appBar: AppBar(
        title: const Text('Key的作用'),
      ),
      body: Center(
        child: GKeyItem(key: _gKey,),
      ),
      floatingActionButton: FloatingActionButton(
        child: const Icon(Icons.add),
        onPressed: () {
          _gKey.currentState?.setState(() {
            _gKey.currentState?.count += 1;
          });
        },
      ),
    );
  }
}


class GKeyItem extends StatefulWidget {
  const GKeyItem({Key? key}) : super(key: key);

  @override
  _GKeyItemState createState() => _GKeyItemState();
}

class _GKeyItemState extends State<GKeyItem> {
  int count = 0;

  @override
  Widget build(BuildContext context) {
    return Center(
      child: Text('$count'),
    );
  }
}

调用原生相册

Thu, 02 Dec 2021 00:00:00 GMT

MethodChannel

Flutter 与原生交互的通道是 MethodChannel。下面我们通过调用 iOS 原生相册选择来体验一下。

示例代码

定义一个Channel

MethodChannel _channel = const MethodChannel('mine_header/channel');

给原生发送指令

_channel.invokeMapMethod('sel_avatar');

原生处理指令

import UIKit
import Flutter

/// 这里将指令用 枚举包装，便于使用
enum MineChannelMethod: String {
    case AvatarPick = "sel_avatar"
}

@UIApplicationMain
@objc class AppDelegate: FlutterAppDelegate {
    override func application(
        _ application: UIApplication,
        didFinishLaunchingWithOptions launchOptions: [UIApplication.LaunchOptionsKey: Any]?
    ) -> Bool {
        GeneratedPluginRegistrant.register(with: self)
        
        if let flutterVC = window?.rootViewController as? FlutterViewController, 
        let messenger = flutterVC as? FlutterBinaryMessenger 
        {
            // 实例化 channel
            let mineChannel = FlutterMethodChannel.init(name: "mine_header/channel", binaryMessenger: messenger)
            mineChannel.setMethodCallHandler { call, result in
                guard 
                    call.method.isEmpty == false, 
                    let method = MineChannelMethod(rawValue: call.method) 
                else {
                    return
                }
                
                switch method {
                case .AvatarPick:
                    let picker = UIImagePickerController()
                    picker.modalPresentationStyle = .overFullScreen
                    picker.delegate = self
                    flutterVC.present(picker, animated: true, completion: nil)
                }
                
            }
        }
        
        return super.application(application, didFinishLaunchingWithOptions: launchOptions)
    }
}

extension AppDelegate: UIImagePickerControllerDelegate, UINavigationControllerDelegate {
    func imagePickerController(_ picker: UIImagePickerController, didFinishPickingMediaWithInfo info: [UIImagePickerController.InfoKey : Any]) {
        picker.dismiss(animated: true, completion: nil)
    }
    
    func imagePickerControllerDidCancel(_ picker: UIImagePickerController) {
        picker.dismiss(animated: true, completion: nil)
    }
}

检验效果

数据传递

通过检查选择完成后的回调我们发现 info 中包含的数据：

[__C.UIImagePickerControllerInfoKey(_rawValue: UIImagePickerControllerMediaType): public.image, __C.UIImagePickerControllerInfoKey(_rawValue: UIImagePickerControllerImageURL): file:///private/var/mobile/Containers/Data/Application/8A9A613F-32F9-4E45-8CB3-BB882CC9F590/tmp/3BC0596E-8B97-4E64-B260-269668F9CA73.png, __C.UIImagePickerControllerInfoKey(_rawValue: UIImagePickerControllerOriginalImage): <UIImage:0x281538f30 anonymous {1125, 2436} renderingMode=automatic>, __C.UIImagePickerControllerInfoKey(_rawValue: UIImagePickerControllerReferenceURL): assets-library://asset/asset.PNG?id=65B7A1B5-597F-4B97-B8E3-9CA019A9A526&ext=PNG]

我们需要将图片路径回传给 Flutter 。

if let imgPath = info[UIImagePickerController.InfoKey.imageURL] as? URL {
    print(imgPath.absoluteString)
}

file:///private/var/mobile/Containers/Data/Application/EE26C1FB-3551-4454-8BAA-B62CADD2B311/tmp/C2302E64-C587-4975-9A24-BD43B34FA0F1.png

if let imgPath = (info[UIImagePickerController.InfoKey.imageURL] as? URL)?.absoluteString, imgPath.count > 8 {
    let path = String(imgPath.suffix(from: String.Index.init(utf16Offset: 7, in: imgPath)))
    print(path)
}

截取有效字段： /private/var/mobile/Containers/Data/Application/C7341168-0BCB-4712-8092-CB2661798888/tmp/828FF919-E315-4401-B76D-C774F5F2EF25.png

数据回传

if let imgPath = (info[UIImagePickerController.InfoKey.imageURL] as? URL)?.absoluteString, imgPath.count > 8 {
    let path = String(imgPath.suffix(from: String.Index.init(utf16Offset: 7, in: imgPath)))
    channel?.invokeMethod("rec_imagePath", arguments: path)
}

数据接收

final String _selAvatar = 'sel_avatar';
final String _reciveImagePath = 'rec_imagePath';
final MethodChannel _channel = const MethodChannel('mine_header/channel');

@override
void initState() {
    super.initState();
    _channel.setMethodCallHandler( (call) async {
      if (call.method == _reciveImagePath) {
        print('${call.arguments}');
        setState(() {
          _avatarPath = call.arguments.toString();
        });
      }
    });
}

得到： flutter: /private/var/mobile/Containers/Data/Application/336E79D6-B33A-4ABC-A380-4501E1550E1D/tmp/D50D8A94-3625-4CA7-8D2B-2C6AD0CCCC67.png

数据展示

class MeHeaderView extends StatelessWidget {
  Function()? avatarTap;
  File? avatarFile;

  MeHeaderView({this.avatarTap, this.avatarFile});

  @override
  Widget build(BuildContext context) {
    return Container(
            ...
                decoration: BoxDecoration(
                    image: DecorationImage(
                    fit: BoxFit.fitWidth,
                    image: (avatarFile == null
                        ? const AssetImage('images/header_avatar.GIF')
                        : FileImage(avatarFile!)) as ImageProvider,
                    ),
                ),
            ),
            ...
  }
}

Widget的生命周期

Mon, 29 Nov 2021 00:00:00 GMT

StatelessWidget

构造方法
Build方法

StatefulWidget

Widget 的构造方法
Widget 的 createState 方法
State 的构造方法
State 的 initState 方法
State 的 didChangeDependencies 方法
- 依赖的 InheritedWidget （共享数据）发生变化后 didChangeDependencies 才会调用
State 的 build 方法
- 当调用 setState ，会重新调用 Build 进行渲染
  - setState 内部主要是利用 _element 调用 markNeedsBuild
Widget 销毁的时候，调用 State 的 dispose 方法

Widget树&Render树&Element树

Mon, 29 Nov 2021 00:00:00 GMT

Widget 的渲染原理

不是所有的 Widget 都会被独立渲染。只有继承 RenderObjectWidget 的才会创建 RenderObject 对象。

在 Flutter 中，有三个树非常重要， Widget树 、 Render树 、 Element树。Flutter引擎是针对 Render树 进行渲染。

Widget树、 Render树、 Element树

每一个 Widget 都会创建一个 Elememt 对象
- 隐式调用 createElement 方法。
  - Element 加入 Element树 中
  - 它会创建三种 Element
RenderElement 主要是创建 RenderObject 对象
- 继承 RenderObjectWidget 的 Widget 会创建 RenderElement
- Flutter 会调用 mount 方法，调用 createRanderObject 方法
StatefulElement 继承 ComponentElement
- StatefulWidget 会创建 StatefulElement
- 调用 createState 创建 State
- 将 Widget 赋值给 state
- 调用 state 的 build 方法，并将自己 Element 传出去
  - build 里面的 context 就是 element
StatelessElement 继承 ComponentElement
- StatelessWidget 会创建 StatelessElement
- 主要就是调用 build 方法，并将自己 Element 传出去

Future&Microtask

Sat, 27 Nov 2021 00:00:00 GMT

多个 Future

下面多个 Future 的执行顺序会是什么样的呢？

void main() {
  Future( () {
    sleep(const Duration(seconds: 1));
    return "${DateTime.now()}: 1";
  })
  .then((value){
    print(value);
  });

  Future( () {
    sleep(const Duration(seconds: 1));
    return "${DateTime.now()}: 2";
  })
      .then((value){
    print(value);
  });

  Future( () {
    sleep(const Duration(seconds: 1));
    return "${DateTime.now()}: 3";
  })
      .then((value){
    print(value);
  });

  Future( () {
    sleep(const Duration(seconds: 1));
    return "${DateTime.now()}: 4";
  })
      .then((value){
    print(value);
  });
}

分析：多个 Future 是按照代码顺序，依次添加到任务队列的，会依次被执行。所以会按顺序输出。

flutter: 2021-11-27 15:34:53.829132: 1
flutter: 2021-11-27 15:34:54.855321: 2
flutter: 2021-11-27 15:34:55.863015: 3
flutter: 2021-11-27 15:34:56.870869: 4

依赖连续调用

如果有几个异步任务是有一定的顺序或者结果依赖的，那么可以通过 then 的链式调用进行：

int number = 1;

void main() {
  Future(() {
    sleep(const Duration(seconds: 1));
    number += 1;
    print("${DateTime.now()}: $number");
    return number;
  }).then((value) {
    sleep(const Duration(seconds: 1));
    value += 1;
    print("${DateTime.now()}: $value");
    return value;
  }).then((value) {
    sleep(const Duration(seconds: 1));
    value += 1;
    print("${DateTime.now()}: $value");
    return value;
  }).then((value) {
    sleep(const Duration(seconds: 1));
    value += 1;
    print("${DateTime.now()}: $value");
    return value;
  });
}

输出的结果：

flutter: 2021-11-27 15:43:29.512735: 2
flutter: 2021-11-27 15:43:30.537787: 3
flutter: 2021-11-27 15:43:31.544347: 4
flutter: 2021-11-27 15:43:32.549391: 5

多个无依赖的任务结束后处理

开发中，我们还会遇到一些多个异步任务都执行完再去做一些事情的场景。 Future 也有提供这种歌场景的功能：

void main() {
  Future.wait([
    Future(() {
      sleep(Duration(seconds: 1));
      print('${DateTime.now()}: 1');
      return "任务1";
    }),
    Future(() {
      sleep(Duration(seconds: 1));
      print('${DateTime.now()}: 2');
      return "任务2";
    }),
    Future(() {
      sleep(Duration(seconds: 1));
      print('${DateTime.now()}: 3');
    }),
    Future(() {
      sleep(Duration(seconds: 1));
      print('${DateTime.now()}: 4');
    }),
    Future(() {
      sleep(Duration(seconds: 1));
      print('${DateTime.now()}: 5');
      return "任务5";
    }),
  ]).then((value) {
    print(value);
  });
}

输出：

flutter: 2021-11-27 15:50:47.972739: 1
flutter: 2021-11-27 15:50:49.000895: 2
flutter: 2021-11-27 15:50:50.008548: 3
flutter: 2021-11-27 15:50:51.015465: 4
flutter: 2021-11-27 15:50:52.023024: 5
flutter: [任务1, 任务2, null, null, 任务5]

这里和使用单个 Future 一样，也可以通过 then 来处理结果。通过输出内容我们可以发现，这里的 then 里的 value 其实是一个数组，并且如果数组内部的顺序是和 Future 数组的顺序保持一致的。

scheduleMicrotask

scheduleMicrotask 也是异步编程常用的一个 API，它的优先级比 Future 会高，同一队列中，会优先将 微任务 处理完成再去处理 Future。

题目

这里通过一个题目考验一下：

void main() {
  Future((){
    print('1');
  }).then((value){
    print('2');
    scheduleMicrotask((){
      print('3');
    });
  }).then((value){
    print('4');
  });

  scheduleMicrotask((){
    print('5');
  });

  Future((){
    print('6');
  });

  scheduleMicrotask((){
    print('7');
  });

  print('8');
}

思考一下这里的输出会是什么样的顺序呢？不要运行，欢迎在评论中告诉我哦。

Dart异步编程:Isolates和事件循环

Sat, 27 Nov 2021 00:00:00 GMT

前言

Dart 是单线程语言，它为 Futures Steams 后台作业，以及编写现代化、异步、响应式的 Flutter 应用程序所需的其他内容提供支持。

Isolate

Isolate 是所有 Dart 代码运行的地方。它就像机器中的一个小空间，它拥有自己的内存块和运行事件循环的单一线程。

在其他语言中，比如 C++ 你可以让多个线程共享相同的内存。并运行他们想要的代码。但是在 Dart 中，每个线程都有自己的 Isolate 和它自己的内存，它只处理事件。

许多 Dart 应用程序，在单一 Isolate 中运行所有代码。但是如果需要，你可以使用多个 Isolate。

如果你要运行的计算量太过庞大，如果它在主要的 Isolate 中运行的话，会导致应用程序扔掉当前的栈帧（Drop Frame）

子Isolate

你可以使用 Isolate.spawn 或者 Flutter 的计算函数，两者都会创建一个单独的 Isolate 来进行运算。让你主要的 Isolate 可以不受影响。

新的 Isolate 将会获得独立的事件循环和自己的内存，即使原本的 Isolate 是这个新 Isolate 的母体，原本的 Isolate 也不可以访问它。

这就是 Isolate 名称的来源。这些小空间之间彼此隔离。

Isolate 间通讯

Isolate 间合作的唯一方式，是来回传递消息。

一个 Isolate 会给另一个 Isolate 发送消息，接收消息的 Isolate 会使用他的事件循环处理消息。

Isolate 为什么这样设计

缺乏共享内存，可能听起来有些严格。特别如果你是使用 Java C++ 这样的语言的话。但它对 Dart 编译器有一些关键性的好处。

比如:

Isolate 的内存分配和垃圾回收不需要锁
因为他只有单一线程，因此如果它不忙，你就知道内存没有发生变化。这对 Flutter 应用程序非常有用。它有时需要快速构建和拆解很多 Widget。

事件循环

想象一下，应用程序的生命，在时间轴中延伸。期间会有很多外部信息的输入，而我们并不能预知这些信息什么时候会输入。这时我们就需要一个永不阻塞的线程来处理所有事件，它运行一个事件循环。

他从事件队列中，取出最旧的事件，处理它，返回，再取出下一个事件处理，依次循环，直到队列清空。

当事件清空，事件循环就会进入等待，直到有新的事件加入队列。

所有高级API都可用于异步编程。他们全部建立在这个简单的循环上。

Isolate 的使用

真多线程

void main() {
  print('${DateTime.now()}: 1');

  Isolate.spawn(isolateFunc, 15);

  sleep(Duration(seconds: 3));
  print('${DateTime.now()}: Sleep end');
}

void isolateFunc(int value) {
  sleep(Duration(seconds: 1));
  print('${DateTime.now()}: isolateFunc end $value');
}

通过日志我们发现：

flutter: 2021-11-28 10:12:09.313570: 1
flutter: 2021-11-28 10:12:10.422793: isolateFunc end 15
flutter: 2021-11-28 10:12:12.349747: Sleep end

sleep 的3秒并没有影响到 Isolate 调用，这里真正实现了多线程。

资源竞争

在进行 iOS 多线程开发的时候，我们会遇到资源竞争的问题。我们通常通过加锁来保证逻辑的正常。那么在使用 Isolate 的时候会不会也遇到这样的情况呢？

int number = 1;

void main() {
  print('${DateTime.now()}: 1');

  Isolate.spawn(isolateFunc, 1);
  Isolate.spawn(isolateFunc, 2);
  Isolate.spawn(isolateFunc, 3);
  Isolate.spawn(isolateFunc, 4);
  Isolate.spawn(isolateFunc, 5);
  Isolate.spawn(isolateFunc, 6);
  Isolate.spawn(isolateFunc, 7);
  Isolate.spawn(isolateFunc, 8);
  Isolate.spawn(isolateFunc, 9);
  Isolate.spawn(isolateFunc, 10);

  sleep(Duration(seconds: 5));
  print('${DateTime.now()}: Sleep end，number = $number');
}

void isolateFunc(int value) {
  number += 1;
  print('${DateTime.now()}: 第$value个调用， number = $number');
}

按照 iOS 开发经验理解，上面的输出应该是乱序的，而且 number 的读写也是会比较乱的。且 sleep 5秒后输出的 number 值会 +10。

我们看下输出：

flutter: 2021-11-28 10:24:18.275046: 1
flutter: 2021-11-28 10:24:18.506326: 第1个调用， number = 2
flutter: 2021-11-28 10:24:18.543709: 第3个调用， number = 2
flutter: 2021-11-28 10:24:18.572635: 第4个调用， number = 2
flutter: 2021-11-28 10:24:18.589551: 第5个调用， number = 2
flutter: 2021-11-28 10:24:18.613625: 第7个调用， number = 2
flutter: 2021-11-28 10:24:18.613557: 第8个调用， number = 2
flutter: 2021-11-28 10:24:18.618459: 第2个调用， number = 2
flutter: 2021-11-28 10:24:18.645893: 第6个调用， number = 2
flutter: 2021-11-28 10:24:18.669942: 第10个调用， number = 2
flutter: 2021-11-28 10:24:18.674398: 第9个调用， number = 2
flutter: 2021-11-28 10:24:23.296321: Sleep end，number = 1

确实是乱序执行的，符合多线程的特征
number 值全部都只 +1 了，都是2
- 这里就关系到前文有提到的 Isolate 的特性之一：
  - 含有独立的内存空间
  - 这里每个 Isolate 内的 number 都是独立的

线程间通讯

这里的通讯需要通过端口 Port 来进行，并且完成后需要手动释放。

int number = 1;

void main() async {
  print('${DateTime.now()}: 1');

  // 创建端口
  ReceivePort port = ReceivePort();
  // Isolate
  Isolate iso = await Isolate.spawn(isolateFunc, port.sendPort);
  // 监听数据变化
  port.listen((message) {
    number = message;
    print('${DateTime.now()}: 监听到 number = $number');
    // 关闭端口
    port.close();
    // 销毁 Isolate
    iso.kill();
  });
}

void isolateFunc(SendPort send) {
  sleep(Duration(seconds: 3));
  send.send(15);
}

输出：

flutter: 2021-11-28 10:38:59.982321: 1
flutter: 2021-11-28 10:39:03.114209: 监听到 number = 15

compute

compute 是对 Isolate 的封装可以达到一样的效果：

int number = 0;

void main() async {
  print('${DateTime.now()}: 1');

  compute(comFunc, 1);
  compute(comFunc, 2);
  compute(comFunc, 3);
  compute(comFunc, 4);
  compute(comFunc, 5);
  compute(comFunc, 6);
  compute(comFunc, 7);
  compute(comFunc, 8);
  compute(comFunc, 9);
  compute(comFunc, 10);
}

void comFunc(int value) {
  number = value;
  print('${DateTime.now()}: value = $value number = $number');
}

输出：

flutter: 2021-11-28 10:54:03.331916: value = 6 number = 6
flutter: 2021-11-28 10:54:03.337162: value = 5 number = 5
flutter: 2021-11-28 10:54:03.382666: value = 4 number = 4
flutter: 2021-11-28 10:54:03.404757: value = 1 number = 1
flutter: 2021-11-28 10:54:03.406688: value = 7 number = 7
flutter: 2021-11-28 10:54:03.424210: value = 3 number = 3
flutter: 2021-11-28 10:54:03.433246: value = 8 number = 8
flutter: 2021-11-28 10:54:03.447492: value = 2 number = 2
flutter: 2021-11-28 10:54:03.494157: value = 9 number = 9
flutter: 2021-11-28 10:54:03.495839: value = 10 number = 10

进程间通讯

可以通过返回值的形式进行：

int number = 0;

void main() async {
  number = await compute(comFunc, 1);

  print(number);
}

int comFunc(int value) {
  sleep(Duration(seconds: 2));
  return number + value;
}

输出：

flutter: 1

参考

https://medium.com/dartlang/dart-asynchronous-programming-isolates-and-event-loops-bffc3e296a6a

https://www.youtube.com/watch?v=vl_AaCgudcY&t=53s

异步编程之Future

Fri, 26 Nov 2021 00:00:00 GMT

代码执行顺序

下面一段代码的执行顺序是很明显的

int number = 1;

void main() {
  print('${DateTime.now()} start: $number');

  doSomeThing();

  print('${DateTime.now()} end: $number');
}

doSomeThing() {
  for(int i = 0; i < 1000000000; i++) {
    number += 1;
  }
  print('${DateTime.now()}  $number');
}

顺序输出没有什么问题

flutter: 2021-11-26 19:53:59.727819 start: 1
flutter: 2021-11-26 19:54:02.463404  1000000001
flutter: 2021-11-26 19:54:02.463815 end: 1000000001

async

加上 async 呢？是不是就变成异步的了？

int number = 1;

void main() {
  print('${DateTime.now()} start: $number');

  doSomeThing();

  print('${DateTime.now()} end: $number');
}

doSomeThing() async {
  for(int i = 0; i < 1000000000; i++) {
    number += 1;
  }
  print('${DateTime.now()}  $number');
}

并没有什么变化，依然按顺序同步执行。

flutter: 2021-11-26 19:57:19.945126 start: 1
flutter: 2021-11-26 19:57:22.676219  1000000001
flutter: 2021-11-26 19:57:22.678135 end: 1000000001

Future

在上文16.第三方库导入与网络数据异步请求与展示中我们的有用到 Future 进行异步网络请求。这里我们模拟网络请求，将耗时操作进行包装：

int number = 1;

void main() {
  print('${DateTime.now()} start: $number');

  doSomeThing();

  print('${DateTime.now()} end: $number');
}

doSomeThing() {
  Future( () {
    for(int i = 0; i < 1000000000; i++) {
      number += 1;
    }
    print('${DateTime.now()}  $number');
  });
}

通过打印我们发现这里的确是异步执行的：

flutter: 2021-11-26 20:01:22.301321 start: 1
flutter: 2021-11-26 20:01:22.306180 end: 1
flutter: 2021-11-26 20:01:25.041822  1000000001

Future是什么

通过查看源码我们能够发现。它是一个工厂构造函数。

  factory Future(FutureOr<T> computation()) {
    _Future<T> result = new _Future<T>();
    Timer.run(() {
      try {
        result._complete(computation());
      } catch (e, s) {
        _completeWithErrorCallback(result, e, s);
      }
    });
    return result;
  }

async - await

思考一下，下面代码的执行顺序会是什么样呢？

nt number = 1;

void main() {
  print('${DateTime.now()} start: $number');

  doSomeThing();

  print('${DateTime.now()} end: $number');
}

doSomeThing() async {
  await Future( () {
    for(int i = 0; i < 1000000000; i++) {
      number += 1;
    }
    print('${DateTime.now()}  $number');
  });
  print('doSomeThing结束');
}

这里进行一下简单的分析：

在 doSomeThing 内
- Future 是异步执行的
- 但 Future 加了 await，那么在当前作用域中，后面的代码就会被阻塞。
  - 即 print('doSomeThing结束'); 这段代码会等待 Future 内的任务完成才执行。
main 函数内
- 三行代码执行是按顺序执行的，不会受 doSomeThing 内部的 await 的影响
按照预期输出应为：
- start
- end
- print('${DateTime.now()} $number');
- doSomeThing结束

执行验证✅

flutter: 2021-11-26 20:09:46.105049 start: 1
flutter: 2021-11-26 20:09:46.114976 end: 1
flutter: 2021-11-26 20:09:48.872681  1000000001
flutter: doSomeThing结束

async 和 await 是成对出现的。你也可以试试只写 await，看看是什么效果。

then 与任务的返回值

对 Future 有所了解的话，知道通过 then 我们可以在任务完成的时候进行一些操作。下面对代码嫂做修改：

int number = 1;

void main() {
  print('${DateTime.now()} start: $number');

  doSomeThing();

  print('${DateTime.now()} end: $number');
}

doSomeThing() async {
  await Future( () {
    for(int i = 0; i < 1000000000; i++) {
      number += 1;
    }
    print('${DateTime.now()}  $number');
  }).then( (value) {
    print('then: ${DateTime.now()}  $value');
  });
  print('doSomeThing结束');
}

输出：

flutter: 2021-11-26 20:20:39.641708 start: 1
flutter: 2021-11-26 20:20:39.649521 end: 1
flutter: 2021-11-26 20:20:42.388725  1000000001
flutter: then: 2021-11-26 20:20:42.390922  null
flutter: doSomeThing结束

这里 then 回调里的 value 是空的，该怎样为 value 赋值呢？很简单，直接在 Future 的任务中 return 就可以了

这里再次修改代码：

int number = 1;

void main() {
  print('${DateTime.now()} start: $number');

  doSomeThing();

  print('${DateTime.now()} end: $number');
}

doSomeThing() async {
  await Future( () {
    for(int i = 0; i < 1000000000; i++) {
      number += 1;
    }
    return number;
  }).then( (value) {
    print('then: ${DateTime.now()}  $value');
  });
  print('doSomeThing结束');
}

输出验证✅

flutter: 2021-11-26 20:23:45.843172 start: 1
flutter: 2021-11-26 20:23:45.850300 end: 1
flutter: then: 2021-11-26 20:23:48.584267  1000000001
flutter: doSomeThing结束

符合预期。

请求数据保留

Thu, 25 Nov 2021 00:00:00 GMT

前言

前文中可以发现一个问题，每次切换页面，都会重新请求数据。而实际开发中，我们会对数据进行保留，在需要的时候再进行数据更新。

Mixin

调整继承关系

多继承 AutomaticKeepAliveClientMixin

class MessagePage extends StatefulWidget {
  @override
  _MessagePageState createState() => _MessagePageState();
}

class _MessagePageState extends State<MessagePage> with AutomaticKeepAliveClientMixin<MessagePage> {
    ...
}

重写 wantKeepAlive

class _MessagePageState extends State<MessagePage> with AutomaticKeepAliveClientMixin<MessagePage> {
    ...

    @override
    bool get wantKeepAlive => true;
}

调整 build 方法

  @override
  Widget build(BuildContext context) {
    super.build(context);
    return Scaffold(...);
  }

调整 MyHomePage （标签Tab页）

原先我们的切换Tab的逻辑是这样的：

class _MyHomePageDataSource extends State<MyHomePage> {
  int _selectedTab = 0;
  final List<Widget> _pages = [
      MessagePage(), 
      ContactsPage(), 
      MommentPage(), 
      MinePage()
      ];

  @override
  Widget build(BuildContext context) {
    return Scaffold(
      body: _pages[_selectedTab],
      ...
    );

并非所有的子页面的 widget 都在标签容器的 widget 树中，导致每次切换都会去重新生成渲染。

我们需要做如下调整：
- 构建 PageController
- 调整 Body 为 PageView，并绑定 PageController 和 pages
- 通过 PageController 切换子页面

class _MyHomePageDataSource extends State<MyHomePage> {
  int _selectedTab = 0;
  final List<Widget> _pages = [
    MessagePage(),
    ContactsPage(),
    MommentPage(),
    MinePage()
  ];
  // 一、 构建 PageController
  final PageController _pageController = PageController();

  @override
  Widget build(BuildContext context) {
    return Scaffold(
        // 二、 调整 Body 为 PageView， 并绑定 PageController 和 pages
      body: PageView(
        controller: _pageController,
        children: _pages,
      ),
      bottomNavigationBar: BottomNavigationBar(
        selectedItemColor: Colors.green,
        unselectedItemColor: Colors.grey,
        currentIndex: _selectedTab,
        onTap: (idx) {
          setState(() {
            _selectedTab = idx;
            // 三、 通过 PageController 切换子页面
            _pageController.jumpToPage(_selectedTab);
          });
        },
        items: const [...],
      ),
    );
  }
}

检查效果

PageView

滑动切换子页面

在使用总突然发现可以通过滑动切换 PageView 的子页面。但是底部的标签选中没有变化，下面我们来处理一下。

同步标签切换

通过 onPageChanged 来监听页面的切换，同步修改选中标签。

body: PageView(
        onPageChanged: (idx) {
          setState(() {
            _selectedTab = idx;
          });
        },
        controller: _pageController,
        children: _pages,
      ),

关闭滑动切换

当然，不需要滑动的话可以通过 physics 来进行关闭。

body: PageView(
    physics: const NeverScrollableScrollPhysics(),
    controller: _pageController,
    children: _pages,
),

悬浮菜单列表

Tue, 23 Nov 2021 00:00:00 GMT

class MessagePage extends StatefulWidget {
  @override
  _MessagePageState createState() => _MessagePageState();
}

class _MessagePageState extends State<MessagePage> {
  PopupMenuItem _buildPopItem(String title, IconData icon) {
    return PopupMenuItem(
      child: Row(
        children: [
          Icon(
            icon,
            color: Colors.white,
          ),
          SizedBox(width: 8,),
          Text(
            title,
            style: const TextStyle(color: Colors.grey),
          ),
        ],
      ),
    );
  }

  @override
  Widget build(BuildContext context) {
    return Scaffold(
      appBar: AppBar(
        title: const Text('微信'),
        actions: [
          PopupMenuButton(
            color: Colors.black,
            // 设置垂直偏移量
            offset: const Offset(0, 60),
            itemBuilder: (context) {
              return [
                _buildPopItem('发起群聊', Icons.chat_bubble),
                _buildPopItem('添加朋友', Icons.person_add),
                _buildPopItem('扫一扫', Icons.qr_code_scanner),
                _buildPopItem('收付款', Icons.check_box),
              ];
            },
          ),
        ],
      ),
      body: Container(
        color: Colors.yellow,
        child: const Image(image: AssetImage('images/公众号.png')),
      ),
    );
  }
}

Mock数据小技巧

Tue, 23 Nov 2021 00:00:00 GMT

Mock 接口

http://rap2.taobao.org

Mock 用户

https://randomuser.me/documentation

Mock 生成规则

http://mockjs.com/examples.html#String

第三方库导入与网络数据异步请求与展示

Tue, 23 Nov 2021 00:00:00 GMT

前言

在 iOS 开发中我们经常使用 CocoaPods 等工具进行包管理。那么在 flutter 开发中又该如何进行呢？

一、 http

这是官方提供来一个网络库：http

点击复制

1.1 修改 pubspec.yaml 配置文件

1.2 更新依赖库

1.3 在使用的地方导入

import 'package:http/http.dart' as http;

二、异步函数

2.1 简单汇总Service

简单汇总一下Service，便于后续使用。

import 'package:flutter/material.dart';

class ServiceURL {
  /// 会话列表
  static Uri conversationList = Uri.parse('xxxxxx');
}

2.2 发送请求

这里简单选择在 initState 中进行网络请求，调用移步方法

  @override
  void initState() {
    super.initState();
    _loadConversation();
  }

  /// 加载会话列表
  void _loadConversation() async {
    var response = await http.get(ServiceURL.conversationList);
    print(response.body);
  }

这里可以发现，和我们在 iOS 开发中的网络请求的调用形式有很大差别。iOS开发中我们都是通过回调的形式接收请求结果的。这里使用 await。

三、数据模型转换

接收到网络数据后我们自然需要进行数据模型的转换。

3.1 定义数据模型

import 'package:flutter/material.dart';

class ConversationData {
  final String nick;
  final String avatar;
  final String lastestMessage;

  ConversationData({
    required this.nick,
    required this.avatar,
    required this.lastestMessage,
  });

  factory ConversationData.formMap(Map map) {
    return ConversationData(
      nick: map['nick'],
      avatar: map['avatar'],
      lastestMessage: map['lastest_message'],
    );
  }
}

3.2 Json 转 Map


  List _conversations = [];
  bool _isLoading = false;

  /// 加载会话列表
  void _loadConversation() async {
    _isLoading = true;
    var response = await http.get(ServiceURL.conversationList);
    _isLoading = false;
    if (response.statusCode == 200) {
      final bodyMap = json.decode(response.body);
      final result = bodyMap['lists'].map((item) {
        return ConversationData.formMap(item);
      }).toList();

      setState(() {
        _conversations = result;
      });
    } else {
      throw Exception('请求失败：${response.statusCode}');
    }
  }

3.3 构建 Cell

Text
- 样式设置
- 缩略方式设置
- 设置最大宽度
Container
- 设置图片圆角

class ConversationCell extends StatelessWidget {
  ConversationCell({required this.conversation});

  final ConversationData conversation;

  @override
  Widget build(BuildContext context) {
    return Container(
      height: 60,
      color: Colors.white,
      child: Stack(
        children: [
          Align(
            alignment: Alignment.center,
            child: Container(
              child: Row(
                crossAxisAlignment: CrossAxisAlignment.center,
                children: [
                  const SizedBox(
                    width: 12,
                  ),
                  // 圆角
                  Container(
                    width: 48,
                    height: 48,
                    decoration: BoxDecoration(
                      borderRadius: BorderRadius.circular(4),
                      image: DecorationImage(
                          // 网络图片
                        image: NetworkImage(conversation.avatar),
                      ),
                    ),
                  ),
                  const SizedBox(
                    width: 12,
                  ),
                  Column(
                    crossAxisAlignment: CrossAxisAlignment.start,
                    children: [
                      const SizedBox(height: 12),
                      Text(
                        conversation.nick,
                        maxLines: 1,
                        style: const TextStyle(
                          fontSize: 14,
                          fontWeight: FontWeight.w500,
                        ),
                      ),
                      Container(
                          // 限制宽度
                        width: UIConfig.screenWidth(context) * 0.7,
                        child: Text(
                          conversation.lastestMessage,
                          maxLines: 1,
                          // 缩略样式
                          overflow: TextOverflow.ellipsis,
                          style: const TextStyle(
                            fontSize: 12,
                            fontWeight: FontWeight.w400,
                          ),
                        ),
                      )
                    ],
                  ),
                ],
              ),
            ),
          ),
          // 分割线
          Align(
            alignment: Alignment.bottomCenter,
            child: Container(
              margin: const EdgeInsets.only(left: 70),
              height: 0.5,
              color: Colors.grey,
            ),
          ),
        ],
      ),
    );
  }
}

3.4 构建 ListView

  Widget _itemForRow(BuildContext context, int index) {
      return ConversationCell(conversation: _conversations[index]);
  }

  @override
  Widget build(BuildContext context) {
    return Scaffold(
      appBar: AppBar(...),
      body: Container(
        color: Colors.yellow,
        child: _isLoading
            ? Center(
                child: Text('Loading'),
              )
            : ListView.builder(
                itemBuilder: _itemForRow,
                itemCount: _conversations.length,
              ),
      ),
    );
  }

3.5 效果

四、 Future & FutureBuilder

除了按照上面这种我们在 iOS 开发中一样常规的思路进行请求和展示外，再介绍另一种可以处理这种场景。

4.1 请求方法修改

之前的加载方法：

  /// 加载会话列表
  void _loadConversation() async {
    var response = await http.get(ServiceURL.conversationList);
    if (response.statusCode == 200) {
      final bodyMap = json.decode(response.body);
      
      _conversations = bodyMap['lists']
                            .map((item) {
                                return ConversationData.formMap(item);
                            })
                            .toList();

    } else {
      throw Exception('请求失败：${response.statusCode}');
    }
  }

修改为：

  /// 加载会话列表
  Future<List> _loadConversation() async {
    var response = await http.get(ServiceURL.conversationList);
    if (response.statusCode == 200) {
      final bodyMap = json.decode(response.body);
      return bodyMap['lists'].map((item) {
        return ConversationData.formMap(item);
      }).toList();
    } else {
      throw Exception('请求失败：${response.statusCode}');
    }
  }

4.2 ListView 修改

AsyncSnapshot

包含有绑定的 future 回调的数据，也包含异步任务的状态。我们可以用来判断是否展示加载页面。

  @override
  Widget build(BuildContext context) {
    return Scaffold(
      appBar: AppBar(...),
      body: Container(
        color: Colors.yellow,
        child: FutureBuilder(
          // 传入 Future
          future: _loadConversation(),
          builder: (context, AsyncSnapshot snap){
            // 判断请求状态
            if (snap.connectionState != ConnectionState.done) {
              return const Center(
                child: Text('Loading'),
              );
            }
            // 根据结果处理数据展示
            return ListView(
              children: snap.data.map<Widget>((item){
                return ConversationCell(conversation: item);
              }).toList(),
            );
          },
        ),
      ),
    );
  }

4.3 看看效果

五、结合上面两种方式

结合上面两种方式，这里使用 Future 调整加载数据的函数。

5.1 请求函数修改

  /// 加载会话列表
  Future<List> _loadConversation() async {
    _isLoading = true;
    var response = await http.get(ServiceURL.conversationList);
    _isLoading = false;
    if (response.statusCode == 200) {
      final bodyMap = json.decode(response.body);
      final result = bodyMap['lists'].map((item) {
        return ConversationData.formMap(item);
      }).toList();

      return result;
    } else {
      throw Exception('请求失败：${response.statusCode}');
    }
  }

5.2 回调处理

  @override
  void initState() {
    super.initState();
    _loadConversation().then((value) {
      // value 就是 Future 里 return 的结果
      setState(() {
        _conversations = value;
      });
    });
  }

5.3 异常处理

通过 Future 我们也可以捕捉异常。

  @override
  void initState() {
    super.initState();
    _loadConversation().then((value) {
      setState(() {
        _conversations = value;
      });
    }).catchError((error) {
      print(error);
    });
  }

5.4 设置超时

  @override
  void initState() {
    super.initState();
    _loadConversation().then((value) {
      setState(() {
        _conversations = value;
      });
    }).catchError((error) {
      print(error);
    }).whenComplete(() {
      print('Done');
    }).timeout(Duration(seconds: 10));
  }

六、保留数据

总结

第一种方式更加接近我们 iOS 开发中的思路
第二种方式 Future & FutureBuilder 更加充分利用 Future 特性
而结合二者的方式则对我这个iOS刚入门Flutter的新手而言，更加熟悉同时也有一些新的体验

完整代码

GitHub

ListView滑动到指定位置

Mon, 22 Nov 2021 00:00:00 GMT

前言

在进行列表视图的开发场景中，通过索引快速滑动到指定 section 是常见的功能。那么在 flutter 中我们该如何实现这种功能呢？本文就将以联系人页面为例进行讲解。

分析ListView

在 iOS 开发中我们常使用 open func scrollToItem(at indexPath: IndexPath, at scrollPosition: UICollectionView.ScrollPosition, animated: Bool) 这类方法来实现 CollectionView 和 TableView 下的滚动到指定位置的效果。

但 flutter 的 ListView 并不含有这种分组的概念，也没有提供这种便利的方法，但是有基础API可以为我们提供一些思路。

ScrollController

我们可以在为 ListView 绑定一个 ScrollController ，它的作用可以理解为我们进行 iOS 开发中的相关代理，但是他的作用会更富一些。

为来滚动到指定位置，这里提供了两个 API，更具体的说明可以点进头文件查看注释，这里就不再赘述。

animateTo

有动画

  Future<void> animateTo(
    double offset, {
    required Duration duration,
    required Curve curve,
  }) async {
    assert(_positions.isNotEmpty, 'ScrollController not attached to any scroll views.');
    await Future.wait<void>(<Future<void>>[
      for (int i = 0; i < _positions.length; i += 1) _positions[i].animateTo(offset, duration: duration, curve: curve),
    ]);
  }

jumpTo

无动画

  void jumpTo(double value) {
    assert(_positions.isNotEmpty, 'ScrollController not attached to any scroll views.');
    for (final ScrollPosition position in List<ScrollPosition>.from(_positions))
      position.jumpTo(value);
  }

这里为了实现通讯录滑动到组头部的效果，选择使用 jumpTo。

提前计算好每组的偏移量

class _ContactsPageState extends State<ContactsPage> {
  final List<Friends> _contacts = [];// 联系人数组
  final List<Friends> _systems = []; // 顶部系统入口数组
  final List<String> _indexs = []; // 索引
  ScrollController _scroller = ScrollController();
  Map<int, double> _indexOffsets = {}; // 偏移量Map
  
  @override
  void initState() {
    super.initState();

    double offsetY = 0;

    _contacts
      ..addAll(friendsData)
      ..addAll(friendsData)
      ..sort((a, b) {
        if (a.indexLetter == null || b.indexLetter == null) {
          return 0;
        }
        return a.indexLetter!.compareTo(b.indexLetter!);
      });

    _systems
        .addAll(friendsHeaderData);

    offsetY = ContactCell.baseCellHeight * friendsHeaderData.length.toDouble();// 第一个联系人组的顶部偏移量为顶部系统入口的总高度

    var index = 0;
    
    _contacts.forEach((element) {
      if (element.indexLetter != null && _indexs.contains(element.indexLetter) == false) {
        _indexs.add(element.indexLetter!);

        _indexOffsets.addAll({ index : offsetY });

        index += 1;
        // 基础Cell高度，加上顶部分组头部高度
        offsetY += ContactCell.baseCellHeight + ContactCell.indexHeight;
      }
      else {
        // 基础Cell高度
        offsetY += ContactCell.baseCellHeight;
      }
    });
  }

  ...
}

IndexBar的事件处理

IndexBar(
    dataSource: _indexs,
    callBack: (index, title) {
        if (_indexOffsets[index] != null) {
        _scroller.jumpTo(_indexOffsets[index]!);
        }
    },
)

项目完整代码

GitHub

索引条：手势及clamp函数

Sun, 21 Nov 2021 00:00:00 GMT

前言

在进行类似联系人页面的开发过程中，我们经常会遇到侧边栏索引条。在iOS中我们只需要简单设置即可使用系统提供的控件。

这里我们使用 Flutter 自定义一个索引条，来熟悉一些常用的知识点。

一、一个索引条包含什么？

数据源
- 索引数组
点击手势
滑动手势
事件回调

二、开始布局

索引条展示的数据是可变的，所以这里我们使用有状态的Widget进行布局。这里以 Container + Column 进行基础封装，看看效果。

import 'package:flutter/material.dart';

class IndexBar extends StatefulWidget {
  IndexBar({
    required this.dataSource,
  });

  final List<String> dataSource;
  final double _indexItemHeight = 22;

  @override
  _IndexBarState createState() => _IndexBarState();
}

class _IndexBarState extends State<IndexBar> {
  List<Widget> _indexsWidgets = [];

  @override
  void initState() {
    super.initState();

    for (int i = 0; i < widget.dataSource.length; i++) {
      _indexsWidgets.add(Container(
        height: widget._indexItemHeight,
        child: Text(
          widget.dataSource[i],
          style: const TextStyle(color: Colors.grey),
        ),
      ));
    }
  }

  @override
  Widget build(BuildContext context) {
    return GestureDetector(
      onTapUp: (details) {
        RenderBox box = context.findRenderObject() as RenderBox;
        Offset point = box.globalToLocal(details.globalPosition);
        double y = point.dy;
        // 在当前 Widget 内的 Offset
        print(y);
      },
      child: Container(
        width: 22,
        color: const Color.fromRGBO(1, 1, 1, 0.2),
        child: Column(
          mainAxisAlignment: MainAxisAlignment.center,
          crossAxisAlignment: CrossAxisAlignment.center,
          children: _indexsWidgets,
        ),
      ),
    );
  }
}

基础使用，传入索引数组：

  @override
  Widget build(BuildContext context) {
    return Scaffold(
      ...
      body: Stack(
        children: [
          Container(...),
          Align(
            alignment: Alignment.centerRight,
            child: Column(
              mainAxisAlignment: MainAxisAlignment.center,
              children: [
                IndexBar(dataSource: _indexs)
              ],
            ),
          ),
        ],
      )
    );
  }

这里我们完成了基础布局，和数据源的传入，下面我们继续完善。

三、点击事件

这里我们需要定位到具体点击了哪个 index 所以 onTap 不能够满足，这里通过注释我们可以发现 onTapUp 回调带有更多信息。我们使用这个进行点击事件的处理

typedef GestureTapUpCallback = void Function(TapUpDetails details);

现在我们能够获取点击坐标了，接下来进行计算获得具体 index。

flutter: L
flutter: N
flutter: E
flutter: B
flutter: J
flutter: L
flutter: J
flutter: K
flutter: N
flutter: J
flutter: F

四、滑动事件

和点击事件类似，这里我们添加一下滑动选择事件：

onVerticalDragUpdate: (details) {
  RenderBox box = context.findRenderObject() as RenderBox;
  Offset point = box.globalToLocal(details.globalPosition);
  print('onVerticalDragUpdate${widget.dataSource[_currentIndex(point)]}');
},
onTapUp: (details) {
  RenderBox box = context.findRenderObject() as RenderBox;
  Offset point = box.globalToLocal(details.globalPosition);
  print('onTapUp${widget.dataSource[_currentIndex(point)]}');
},

测试有效：

flutter: onVerticalDragUpdateF
flutter: onVerticalDragUpdateF
flutter: onVerticalDragUpdateH
flutter: onVerticalDragUpdateH
flutter: onVerticalDragUpdateH

五、事件回调

内部的事件处理完成了，我们来来添加一下外部的回调：

定义回调类型

typedef IndexBarSelectCallBack = void Function(int index,  String title);

class IndexBar extends StatefulWidget {
  IndexBar({
    required this.dataSource,
    required this.callBack
  });

  final List<String> dataSource;
  final double _indexItemHeight = 22;
  final IndexBarSelectCallBack callBack;

  @override
  _IndexBarState createState() => _IndexBarState();
}

调整事件处理及回调

onVerticalDragUpdate: (details) {
  RenderBox box = context.findRenderObject() as RenderBox;
  Offset point = box.globalToLocal(details.globalPosition);
  int index = _currentIndex(point);
  String title = widget.dataSource[index];
  widget.callBack(index, title);
},
onTapUp: (details) {
  RenderBox box = context.findRenderObject() as RenderBox;
  Offset point = box.globalToLocal(details.globalPosition);
  int index = _currentIndex(point);
  String title = widget.dataSource[index];
  widget.callBack(index, title);
},

外部传入回调

六、 Clamp 函数

在滑动偏移过大超出范围的时候会发生越界，出现下面的警告

RangeError (index): Invalid value: Not in inclusive range 0..10: 14

这里安利一个很好用的函数 clamp 来对方法 _currentIndex(Offset point) 进行一下优化：

int _currentIndex(Offset point) {
  return (point.dy ~/ widget._indexItemHeight).clamp(0, widget.dataSource.length - 1);
}

这样就对返回的值的范围作出了限制。

七、最终代码

https://github.com/RyukieSama/FlutterStudy/blob/master/fake_wechat/lib/widgets/contacts/index_bar.dart

有状态Widget初始化重写&链式调用&排序

Sat, 20 Nov 2021 00:00:00 GMT

前言

前文我们通过联系人页面聊到了断言的使用，本文将继续结合该场景了机更多 Flutter 开发小技巧。

初始化方法重写

对于一个 StatefulWidget 我们如果需要在其初始化的时候进行一些操作的话，可以通过重写 initState() 来达到效果。

class _ContactsPageState extends State<ContactsPage> {

  @override
  void initState() {
    super.initState();

    // 添加数据
    _contacts
        .addAll(friendsData);

    _systems
        .addAll(friendsHeaderData);
  }

  ...
}

链式调用

在 iOS 开发中，比如使用 SnapKit 进行UI控件约束布局的时候，我们经常会用到这样的链式调用，非常爽。

make.leading.trailing.top.equalToSuperview()

其实在 Flutter 开发中我们也可以使用类似的写法：

@override
  void initState() {
    super.initState();

    // 链式调用 多次添加元素
    _contacts
      ..addAll(friendsData)
      ..addAll(friendsData);

    _systems.addAll(friendsHeaderData);
  }

排序

在上面可以看到 ..addAll(friendsData) 这样连续进行了调用。那么是否可以做的更多呢？

通常联系人列表我们会进行按字母排序，这里通过链式调用进行尝试：

@override
  void initState() {
    super.initState();
    _contacts
      ..addAll(friendsData)
      ..addAll(friendsData)
      ..sort((a, b) {
        if (a.indexLetter == null || b.indexLetter == null) {
          return 0;
        }
        return a.indexLetter!.compareTo(b.indexLetter!);
      });
    _systems.addAll(friendsHeaderData);
  }

和 Swift sort 的不同

这里你可能会发现，这里的 sort 函数和 Swift 的略有不同，内部回调的返回值不是 bool 而是 int 。

结合函数头文件注释我们可以了解更多：

  /// Sorts this list according to the order specified by the [compare] function.
  ///
  /// The [compare] function must act as a [Comparator].
  /// ```dart
  /// var numbers = ['two', 'three', 'four'];
  /// // Sort from shortest to longest.
  /// numbers.sort((a, b) => a.length.compareTo(b.length));
  /// print(numbers);  // [two, four, three]
  /// ```
  /// The default [List] implementations use [Comparable.compare] if
  /// [compare] is omitted.
  /// ```dart
  /// List<int> nums = [13, 2, -11];
  /// nums.sort();
  /// print(nums);  // [-11, 2, 13]
  /// ```
  /// In that case, the elements of the list must be [Comparable] to
  /// each other.
  ///
  /// A [Comparator] may compare objects as equal (return zero), even if they
  /// are distinct objects.
  /// The sort function is not guaranteed to be stable, so distinct objects
  /// that compare as equal may occur in any order in the result:
  /// ```dart
  /// var numbers = ['one', 'two', 'three', 'four'];
  /// numbers.sort((a, b) => a.length.compareTo(b.length));
  /// print(numbers);  // [one, two, four, three] OR [two, one, four, three]
  /// ```
  void sort([int compare(E a, E b)?]);

简略写法

这里的排序函数可以在条件比较简单的情况下可以简写，提高编码效率

未简写

sort((a, b) {
  if (a.indexLetter == null || b.indexLetter == null) {
    return 0;
  }
  return a.indexLetter!.compareTo(b.indexLetter!);
});

简写

sort( (a, b) => a.indexLetter.compareTo(b.indexLetter) );

头文件注释中有这样简写说明，平时多阅读注释，可以帮助我们写出更有语言特色风格的代码哦～

Cell点击跳转

Thu, 18 Nov 2021 00:00:00 GMT

前言

在 iOS 开发中，TableView 的 cell 的点击事件是通过代理处理的。那么在 Flutter 中，我们又该怎么处理呢？

首先我们看看点击事件一般是怎样处理的。

点击事件

这里我们可以使用 GestureDetector widget 来包装需要处理点击事件的 widget 。

事件回调 onTap 本质是一个无参数的函数。

/// A tap with a primary button has occurred.
///
/// This triggers when the tap gesture wins. If the tap gesture did not win,
/// [onTapCancel] is called instead.
///
/// See also:
///
///  * [kPrimaryButton], the button this callback responds to.
///  * [onTapUp], which is called at the same time but includes details
///    regarding the pointer position.
final GestureTapCallback? onTap;

/// Signature for when a tap has occurred.
///
/// See also:
///
///  * [GestureDetector.onTap], which matches this signature.
///  * [TapGestureRecognizer], which uses this signature in one of its callbacks.
typedef GestureTapCallback = void Function();

这样我们就可以通过为 Cell 添加一个回调类型的成员，来传入事件。

class MomentHomeCell extends StatelessWidget {
  final String title;
  final String? subTitle;
  final String imageName;
  final String? subImageName;
  final GestureTapCallback? didSelected;

  MomentHomeCell(
      {required this.title,
      this.subTitle,
      required this.imageName,
      this.subImageName,
      this.didSelected});

  @override
  Widget build(BuildContext context) {
    return GestureDetector(
      onTap: didSelected,
      child: ...,
    );
  }
}

使用的地方就可以直接传入事件了：

MomentHomeCell(
              title: '朋友圈',
              imageName: 'images/朋友圈.png',
              didSelected: () {
                print('111');
              },
            ),

页面跳转 Navigator

在 iOS 中我们都是通过 NavigationController 来进行页面跳转的。在 Flutter 中就要用到 Navigator 这个 widget 来进行处理了。

class _MommentPageState extends State<MommentPage> {
  @override
  Widget build(BuildContext context) {
    return Scaffold(
      appBar: AppBar(
        ...
      ),
      body: Container(
        color: Colors.brown,
        child: ListView(
          children: <Widget>[
            MomentHomeCell(
              title: '朋友圈',
              imageName: 'images/朋友圈.png',
              didSelected: () {
                Navigator.of(context).push(
                  MaterialPageRoute(
                      builder: (BuildContext context) => MomentDetailPage(title: '朋友圈',),
                  )
                );
              },
            ),
            ...
          ],
        ),
      ),
    );
  }
}

代码规范

Thu, 18 Nov 2021 00:00:00 GMT

常见警告

Name non-constant identifiers using lowerCamelCase.

如上图，警告。这里不是 const 不能使用大写开头的驼峰。

DO name non-constant identifiers using lowerCamelCase.

Class members, top-level definitions, variables, parameters, named parameters and named constructors should capitalize the first letter of each word except the first word, and use no separators.

GOOD:

var item;

HttpRequest httpRequest;

align(clearItems) {
  // ...
}

https://dart-lang.github.io/linter/lints/non_constant_identifier_names.html

通过联系人Cell看断言

Thu, 18 Nov 2021 00:00:00 GMT

前言

我们在构建如微信联系人页类似的 Cell 时，主要有两种。一种是加载网络图片，用来现实我们的联系人；一种是本地图片，用来显示一些系统入口，如公众号等。那么如何优雅的完成这样对两种形式数据展示的 Cell 呢？借助这个场景，我们来了解一下 断言 。

不使用断言

这样的代码，并没有什么明显问题。

普通联系人传入 avatarUrl 网络图片
系统入口传入 assetName 资源名称
avatarUrl 和 assetName 都是可选字段，即均可为空

这样的隐患是无法保证至少有一个是有值的。下面我们使用断言进行优化，如果两者都为空就会抛出异常。

class _ContactCell extends StatelessWidget {
  const _ContactCell({
    required this.name,
    this.avatarUrl,
    this.assetName,
  });

  final String name;
  final String? avatarUrl;
  final String? assetName;

  @override
  Widget build(BuildContext context) {
    return Container(
      height: 60,
      color: Colors.white,
      child: Stack(
        children: [
          Row(
            children: [
              Row(
                children: [
                  const SizedBox(
                    width: 12,
                  ),
                  avatarUrl != null
                      ? Container(
                          width: 48,
                          height: 48,
                          decoration: BoxDecoration(
                            borderRadius: BorderRadius.circular(4),
                            image: DecorationImage(
                              image: NetworkImage(avatarUrl!),
                            ),
                          ),
                        )
                      : Container(),
                  assetName != null
                      ? Container(
                          width: 48,
                          height: 48,
                          decoration: BoxDecoration(
                            borderRadius: BorderRadius.circular(4),
                            image: DecorationImage(
                              image: AssetImage(assetName!),
                            ),
                          ),
                        )
                      : Container(),
                  const SizedBox(
                    width: 12,
                  ),
                  Text(
                    name,
                    style: const TextStyle(
                      fontSize: 16,
                      fontWeight: FontWeight.w500,
                    ),
                  ),
                ],
              ),
            ],
          ),
          Positioned(
            left: 50,
            bottom: 0,
            child: Container(
              height: 1,
              color: Colors.grey,
            ),
          ),
        ],
      ),
    );
  }
}

使用断言进行优化

这里在构造方法加了断言： assert((avatarUrl != null || assetName != null), '至少一张图片')

如果两者都为空，那么就会抛出如图异常：

class _ContactCell extends StatelessWidget {
  const _ContactCell({
    required this.name,
    this.avatarUrl,
    this.assetName,
  }) : assert((avatarUrl != null || assetName != null), '至少一张图片');

  final String name;
  final String? avatarUrl;
  final String? assetName;

  @override
  Widget build(BuildContext context) {
    return Container(
      height: 60,
      color: Colors.white,
      child: Stack(
        children: [
          Row(
            children: [
              Row(
                children: [
                  const SizedBox(
                    width: 12,
                  ),
                  avatarUrl != null
                      ? Container(
                          width: 48,
                          height: 48,
                          decoration: BoxDecoration(
                            borderRadius: BorderRadius.circular(4),
                            image: DecorationImage(
                              image: NetworkImage(avatarUrl!),
                            ),
                          ),
                        )
                      : Container(),
                  assetName != null
                      ? Container(
                          width: 48,
                          height: 48,
                          decoration: BoxDecoration(
                            borderRadius: BorderRadius.circular(4),
                            image: DecorationImage(
                              image: AssetImage(assetName!),
                            ),
                          ),
                        )
                      : Container(),
                  const SizedBox(
                    width: 12,
                  ),
                  Text(
                    name,
                    style: const TextStyle(
                      fontSize: 16,
                      fontWeight: FontWeight.w500,
                    ),
                  ),
                ],
              ),
            ],
          ),
          Positioned(
            left: 50,
            bottom: 0,
            child: Container(
              height: 1,
              color: Colors.grey,
            ),
          ),
        ],
      ),
    );
  }
}

Positioned与Container嵌套无法充满容器

Sat, 13 Nov 2021 00:00:00 GMT

问题

是这样的，写好了Cell，想给Cell添加分割线，我自己在iOS开发中一般都是直接加在Cell里面的。这里我也准备这样实现。

前面有使用过 Position ，思考通过 Stack + Position + Container 理论上可以实现。于是有了下面的代码：


  @override
  Widget build(BuildContext context) {
    return Container(
      color: Colors.white,
      height: 44,
      child: Stack(
        children: [
          Row(
            mainAxisAlignment: MainAxisAlignment.spaceBetween,
            children: [
              Container(
                padding: const EdgeInsets.all(10),
                color: Colors.green,
                child: Row(
                  children: [
                    Image(image: AssetImage(imageName)),
                    const SizedBox(
                      width: 8,
                    ),
                    Text(title),
                  ],
                ),
              ),
              Container(
                  color: Colors.yellow,
                  child: Row(
                    children: [
                      subTitle != null ? Text(subTitle!) : Container(),
                      subImageName != null
                          ? Image.asset(subImageName!)
                          : Container(),
                      Image.asset(
                        'images/icon_right.png',
                        width: 15,
                      )
                    ],
                  ))
            ],
          ),
          Positioned(
            left: 48,
            bottom: 0,
            child: Container(
              height: 0.5,
              color: Colors.red,
            ),
          ),
        ],
      )
    );
  }

这里希望得到的效果是，左边留 48 空隙，右边贴边的分割线。但是时机效果并没有出现：

Align

这里改用 Align 就可以实现效果了。

Align(
    alignment: Alignment.bottomCenter,
    child: Container(
        margin: EdgeInsets.only(left: 48),
        height: 0.5,
        color: Colors.grey,
    ),
)

参考

https://cloud.tencent.com/developer/article/1402558

openURL

Sat, 13 Nov 2021 00:00:00 GMT

前言

在 UIKit 中我们通常使用下面方式来打开 外部链接，那么在 SwiftUI 中我们该怎样使用呢？

UIApplication.shared.open(url, options: [ : ], completionHandler: nil)

一、注入环境变量

@Environment(\.openURL) var openURL

... 

ZStack {
    Color.blue
    Text("App Store")
        .fontWeight(.medium)
        .foregroundColor(.white)
        .onTapGesture {
            openURL.callAsFunction(url) { accepted in }
        }
}

...

二、 Link

Link(destination: url, label: {
    ZStack {
        Color.blue
        Text("App Store")
            .fontWeight(.medium)
            .foregroundColor(.white)
    }
})

参考

EnvironmentValues

BottomNavigationBar

Sun, 07 Nov 2021 00:00:00 GMT

前言

开发一个应用，界面的开始大部分情况下都是一个底部标签控制器。而在Flutter中就是 BottomNavigationBar 。

一、创建 BottomNavigationBar

这里我想创建一个类似微信的底部标签，Widget内我会这样写：

  @override
  Widget build(BuildContext context) {
    return Scaffold(
      bottomNavigationBar: BottomNavigationBar(
        items: const [
          BottomNavigationBarItem(
            icon: Icon(Icons.chat),
            label: '微信',
          ),
          BottomNavigationBarItem(
            icon: Icon(Icons.contact_mail),
            label: '通讯录',
          ),
          BottomNavigationBarItem(
            icon: Icon(Icons.nature_people),
            label: '发现',
          ),
          BottomNavigationBarItem(
            icon: Icon(Icons.settings),
            label: '我',
          ),
        ],
      ),
    );
  }

显示问题

看看效果：

怎么什么都没有？仔细看下其实都是白色的，我们设置一下颜色看看：

  @override
  Widget build(BuildContext context) {
    return Scaffold(
      bottomNavigationBar: BottomNavigationBar(
        selectedItemColor: Colors.green,
        unselectedItemColor: Colors.grey,
        ...
      ),
    );
  }

但是选中的标签的样式会比较突出，怎么改成我们熟悉的样式呢？

  @override
  Widget build(BuildContext context) {
    return Scaffold(
      bottomNavigationBar: BottomNavigationBar(
        type: BottomNavigationBarType.fixed,
        selectedItemColor: Colors.green,
        unselectedItemColor: Colors.grey,
        ...
      ),
    );
  }

二、选中标签

这里明显是需要 StatefulWidget 的。通过 BottomNavigationBar: onTap 修改选中的标签

class MyHomePage extends StatefulWidget {
  const MyHomePage({Key? key}) : super(key: key);

  @override
  State<StatefulWidget> createState() {
    return _MyHomePageDataSource();
  }
}

class _MyHomePageDataSource extends State<MyHomePage> {
  int _selectedTab = 0;

  @override
  Widget build(BuildContext context) {
    return Scaffold(
      bottomNavigationBar: BottomNavigationBar(
        ...
        currentIndex: _selectedTab,
        onTap: (idx) {
          setState(() {
            _selectedTab = idx;
          });
        },
        ...
      ),
    );
  }
}

三、页面切换

选中了标签我们也需要切换到对应的页面才行，而具体显示哪个页面是由 Scaffold 的 body 控制的。

class _MyHomePageDataSource extends State<MyHomePage> {
  int _selectedTab = 0;
  final List<Widget> _pages = [MessagePage(), ContactsPage(), MommentPage(), MinePage()];

  @override
  Widget build(BuildContext context) {
    return Scaffold(
      body: _pages[_selectedTab],// 切换页面
      bottomNavigationBar: BottomNavigationBar(
        ...
        currentIndex: _selectedTab,
        onTap: (idx) {
          setState(() {
            _selectedTab = idx; // 切换选中标签
          });
        },
        ...
      ),
    );
  }
}

原文视频文件暂缺。</video>

MaterialApp

Sun, 07 Nov 2021 00:00:00 GMT

MaterialApp 一些小Tips

class MyApp extends StatelessWidget {
  const MyApp({Key? key}) : super(key: key);

  @override
  Widget build(BuildContext context) {
    return MaterialApp(
      theme: ThemeData(
        primarySwatch: Colors.orange,// 导航背景
        splashColor: const Color.fromRGBO(1, 1, 1, 0), // 去掉点击波纹
      ),
      title: "FakeWechat", // Android 任务中心标题
      home: MyHomePage(),
    );
  }
}

android资源配置

Sun, 07 Nov 2021 00:00:00 GMT

一、 App名称

android - app - src - main - AndroidManifest.xml - android:label

二、图片资源

与 iOS 不同，安卓应用的图片资源不是按 1x 2x 3x 来区分的。

android - app - src - main - res

哦们可以看到以下目录：

mipmap-mdpi
- 相当于 1x
mipmap-hdpi
- 相当于 1.5x
mipmap-xhdpi
- 相当于 2x
mipmap-xxhdpi
- 相当于 3x
mipmap-xxxhdpi
- 相当于 4x

注意：命名不能驼峰，用下划线

三、启动页

四、其他图片

修改 pubspec.yaml 文件

# To add assets to your application, add an assets section, like this:
# assets:
#   - images/a_dot_burr.jpeg
#   - images/a_dot_ham.jpeg

注意：这里格式需要严格对齐

错误：

正确：

这里写入文件夹路径或者文件路径都可以

五、使用图片

Image(image: AssetImage('路径/xxxxxx.png'))

状态管理

Sat, 06 Nov 2021 00:00:00 GMT

前言

Flutter 的渲染模式是增量渲染，当一部分有变化的时候就将原先的替换掉。所以页面元素没有必要拥有状态。但是这样对于时机开发并不友好，尤其对于数据驱动的复杂的页面。

这样就出现了 有状态的Widget ：数据逻辑与渲染逻辑拆分开来，数据保留，页面增量渲染。

StatefulWidget

在我们需要可变数据驱动的Widget时，需要两个重要的部分：由数据驱动渲染。

import 'package:flutter/material.dart';

// 渲染逻辑
class MyStatefulWidget extends StatefulWidget {
  const MyStatefulWidget({Key? key}) : super(key: key);

  @override
  State<StatefulWidget> createState() {
    return _MyStateDataSource();
  }
}

// 数据逻辑
class _MyStateDataSource extends State<MyStatefulWidget> {
  int _clickCount = 0;

  @override
  Widget build(BuildContext context) {
    return Container(
      color: Colors.red,
      child: FloatingActionButton(
        child: Text("$_clickCount"),
        onPressed: () {
          setState(() {// 触发状态改变，重新渲染
            _clickCount += 1;
          });
        },
      ),
    );
  }
}

增量渲染

你可能会想，改动一个小数据整个Widget都重新渲染，效率是不是很低啊？

不用担心这里采用的是增量渲染，通过树状的结构实现只修改使用到对应数据的叶子Widget。

初见Flutter

Wed, 03 Nov 2021 00:00:00 GMT

一、 Flutter的特点

不依赖原生UI
- 拥有独立的渲染引擎
- 包体积会变大
界面更新逻辑和原生不一样（增量渲染）
- 重新创建一个新的 Widget
为什么 Flutter 中大量 final 修饰的属性， const 修饰的构造方法（常量对象）
- 因为 Flutter 的渲染逻辑，是增量渲染。 Widget 结构是树状结构
- 想改变屏幕内容就直接改变 Widget 对象
- 常量对象 的创建效率更高

二、万物皆 Widget

Flutter的Widget分两类
- 有状态： StatefulWidget
- 无状态： StatelessWidget

三、 MaterialApp（App素材

home属性（主页面）
- 需要一个Widget
- Scaffold小部件
  - 带有导航栏（appBar）的小部件
  - 导航栏可以设置文字、颜色。而且可以自定义Widget
- body属性。
  - 显示在导航栏下面的区域。传递一个Widget给他
debugShowCheckedModeBanner属性。
- 是否显示Debug标记（便于我们在调试版本中做操作）

小Tips

1. 未导入相关文件

option + enter 即可快捷导入

2. 强退AS缓存的问题

清理下面的文件即可

Layout

Wed, 03 Nov 2021 00:00:00 GMT

一、方向部件

Row
- 水平方向
- 主轴方向：向右
Column
- 垂直方向
- 主轴方向：向下
Stack
- 屏幕内外方向
- 主轴方向：向屏幕外

1.1 主轴方向调整

Row 和 Column 可以通过调整主轴方向达到不同布局效果。

1. 默认主轴方向

class MyRowColumn extends StatelessWidget {
  @override
  Widget build(BuildContext context) {
    return Container(
      color: Colors.white,
      alignment: Alignment(1, 0),// x 对 Row 没影响 y 对 Column 无效
      child: Column(
        children: [
          Container(
            child: Icon(Icons.add_a_photo),
            color: Colors.red,
            alignment: Alignment(0,0),
          ),
          Container(
            child: Icon(Icons.add_alarm),
            color: Colors.yellow,
            alignment: Alignment(-1,0),
          ),
          Container(
            child: Icon(Icons.add_alert),
            color: Colors.green,
            alignment: Alignment(1,0),
          ),
        ],
      ),
    );
  }
}

2. MainAxisAlignment.center

3. MainAxisAlignment.end

4. MainAxisAlignment.spaceAround

5. MainAxisAlignment.start

6. MainAxisAlignment.spaceBetween

7. MainAxisAlignment.spaceEvenly

1.3 交叉轴

交叉轴是垂直与主轴方向的

class MyRowColumn extends StatelessWidget {
  @override
  Widget build(BuildContext context) {
    return Container(
      color: Colors.brown,
      child: Column(
        mainAxisAlignment: MainAxisAlignment.spaceEvenly,
        crossAxisAlignment: CrossAxisAlignment.start,
        children: [
          Container(
            child: Icon(
              Icons.add_a_photo,
              size: 100,
            ),
            color: Colors.red,
          ),
          Container(
            child: Icon(
              Icons.add_alarm,
              size: 50,
            ),
            color: Colors.yellow,
          ),
          Container(
            child: Icon(
              Icons.add_alert,
              size: 30,
            ),
            color: Colors.green,
          ),
        ],
      ),
    );
  }
}

1.4 Stack

如下布局我们可以得到如图效果

class MyStack extends StatelessWidget {
  const MyStack({Key? key}) : super(key: key);

  @override
  Widget build(BuildContext context) {
    return Container(
      child: Stack(
        children: [
          Container(
            color: Colors.red,
            child: const Icon(
            Icons.add_alarm,
            size: 200,
            color: Colors.green,
            ),
          ),
          Container(
            color: Colors.green,
            child: const Icon(
            Icons.add_a_photo,
            size: 100,
            color: Colors.yellow,
            ),
          ),
          Container(
            color: Colors.black,
            child: const Icon(
            Icons.add_a_photo_rounded,
            size: 60,
            color: Colors.blue,
            ),
          ),
        ],
      ),
    );
  }
}

1. 子Widget布局调整

我们可以发现，默认都是从左上角开始布局的。如果想要调整子Widget的位置我们该怎么做呢？

2. Positioned

A [Positioned] widget must be a descendant of a [Stack].

只可用于 Stack

通过 Positioned 我们可以调整子Widget 相对父Widget 的位置

Positioned(
    right: 12,
    top: 12,
    child: Container(
        color: Colors.black,
        child: const Icon(
        Icons.add_a_photo_rounded,
        size: 60,
        color: Colors.blue,
        ),
    ),
),

3. margin

外边距

Container(
    margin: const EdgeInsets.only(left: 12),
    color: Colors.green,
    child: const Icon(
    Icons.add_a_photo,
    size: 100,
    color: Colors.yellow,
    ),
),

4. padding

内边距，通过对比可以明显发现红色区域被由内而外的撑大了

Container(
    padding: const EdgeInsets.all(50),
    color: Colors.red,
    child: const Icon(
    Icons.add_alarm,
    size: 200,
    color: Colors.green,
    ),
),

5. Positioned 与 margin 的区别

从上面的效果可以看出，这里好像 Positioned 与 margin 的效果基本一致。

Positioned
- 尽可用于 Stack
- 相对于父Widget的
margin
- 外边距
- 相对于相邻Widget的

二、宽高比

用 AspectRatio 可以来指定宽高比

如果同时设定了宽高那么 AspectRatio 就会失效

class MyRatio extends StatelessWidget {
  const MyRatio({Key? key}) : super(key: key);

  @override
  Widget build(BuildContext context) {
    return Container(
      color: Colors.white,
      child: Container(
        color: Colors.red,
        width: 100,
        child: const AspectRatio(aspectRatio: 1/3),
      ),
    );
  }
}

序列化二叉树

Wed, 27 Oct 2021 00:00:00 GMT

一、题目

请实现两个函数，分别用来序列化和反序列化二叉树。

你需要设计一个算法来实现二叉树的序列化与反序列化。这里不限定你的序列 / 反序列化算法执行逻辑，你只需要保证一个二叉树可以被序列化为一个字符串并且将这个字符串反序列化为原始的树结构。

提示：输入输出格式与 LeetCode 目前使用的方式一致，详情请参阅 LeetCode 序列化二叉树的格式。你并非必须采取这种方式，你也可以采用其他的方法解决这个问题。

输入：root = [1,2,3,null,null,4,5]
输出：[1,2,3,null,null,4,5]

链接：https://leetcode-cn.com/problems/xu-lie-hua-er-cha-shu-lcof

著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

二、分析

本题官方没有 Swift 用例。本体难度为困难。

凭空想象是很难想到解决办法，我们用例子就很容易找到规律了。本题和 32-I.从上到下打印二叉树较为相似。

编码 的解题基本思路是逐层扫描。可采用辅助队列进行解决。

解码 的思路和 编码 相似，除了辅助队列，我们还需要额外一个指针进行辅助。

三、代码

3.1 编码

func serialize(root: TreeNode) -> String {
    var result = ""
    var queue: [TreeNode?] = [root]
    
    while queue.isEmpty == false {
        if let first = queue.first, let node = first {
            result.append((result.isEmpty ? "\(node.val)" : ",\(node.val)"))
            
            queue.append(node.left)
            queue.append(node.right)
        }
        else {
            result.append(",null")
        }
        
        queue.removeFirst()
    }
    
    return result
}

3.2 解码

func deserialize(data: String) -> TreeNode? {
    let array: [String] = data.components(separatedBy: ",")
    var nodes: [TreeNode?] = []
    array.forEach { item in
        if let v = Int(item) {
            nodes.append(TreeNode(v))
        }
        else {
            nodes.append(nil)
        }
    }
    
    if nodes.isEmpty == true { return nil }
    
    var queue: [TreeNode] = []
    var index = 0
    
    if let f = nodes.first, let n = f {
        queue.append(n)
    }
    
    while queue.isEmpty == false {
        if let node = queue.first, index + 1 < nodes.count, index + 2 < nodes.count {
            node.left = nodes[index + 1]
            node.right = nodes[index + 2]
            
            if let l = node.left {
                queue.append(l)
            }
            
            if let r = node.right {
                queue.append(r)
            }
            
            index += 2
        }
        
        queue.removeFirst()
    }
    
    return nodes.first ?? nil
}

3.3 测试用例

let root1 = TreeNode(1)
let root2 = TreeNode(2)
let root3 = TreeNode(3)
let root4 = TreeNode(4)
let root5 = TreeNode(5)

root1.left = root2
root1.right = root3

root3.left = root4
root3.right = root5

// 编码
let s1 = serialize(root: root1)

// 解码
let node = deserialize(data: s1)

// 再编码验证
if let n = node {
    serialize(root: n)
}

二叉搜索树与双向链表

Wed, 20 Oct 2021 00:00:00 GMT

题目

输入一棵二叉搜索树，将该二叉搜索树转换成一个排序的循环双向链表。要求不能创建任何新的节点，只能调整树中节点指针的指向。

为了让您更好地理解问题，以下面的二叉搜索树为例：

我们希望将这个二叉搜索树转化为双向循环链表。链表中的每个节点都有一个前驱和后继指针。对于双向循环链表，第一个节点的前驱是最后一个节点，最后一个节点的后继是第一个节点。

下图展示了上面的二叉搜索树转化成的链表。“head” 表示指向链表中有最小元素的节点。

特别地，我们希望可以就地完成转换操作。当转化完成以后，树中节点的左指针需要指向前驱，树中节点的右指针需要指向后继。还需要返回链表中的第一个节点的指针。

来源：力扣（LeetCode）

分析

题解

由于没有官方没有 Swift 的用例，这里自己写了用例来测试

代码

var head: TreeNode?, last: TreeNode?

func treeToDoublyList(root: TreeNode) -> TreeNode {
    handle(root: root)
    last?.right = head
    head?.left = last
    return root
}

func handle(root: TreeNode) -> TreeNode {
    if let left = root.left {
        if let rightOfLeft = left.right {
            let node = handle(root: rightOfLeft)
            root.left = node
            node.left = left
            node.right = root
        }
        
        if let leftOfLeft = left.left, leftOfLeft.left == nil {
            leftOfLeft.right = left
            head = leftOfLeft
        }
    }
    
    if let right = root.right {
        if let leftOfRight = right.left {
            let node = handle(root: leftOfRight)
            root.right = node
            node.right = right
            node.left = root
        }
        
        if let rightOfRight = right.right, rightOfRight.right == nil {
            rightOfRight.left = right
            last = rightOfRight
        }
    }
    
    return root
}

用例

let t1 = TreeNode(1)
let t2 = TreeNode(2)
let t3 = TreeNode(3)
let t4 = TreeNode(4)
let t5 = TreeNode(5)
let t6 = TreeNode(6)
let t7 = TreeNode(7)

t4.left = t2
t4.right = t6

t2.left = t1
t2.right = t3

t6.left = t5
t6.right = t7

let arr = [t1, t2, t3, t4, t5, t6, t7]

func log(root: TreeNode) {
    if let left = root.left {
        print("\(root.val)左：\(left.val)")
    }
    else {
        print("\(root.val)左：nil")
    }
    
    if let right = root.right {
        print("\(root.val)右：\(right.val)")
    }
    else {
        print("\(root.val)右：nil")
    }
}

arr.forEach { log(root: $0) }

print("=== 双向转换 ===")
treeToDoublyList(root: t4)

arr.forEach { log(root: $0) }

输出：

1左：nil
1右：nil
2左：1
2右：3
3左：nil
3右：nil
4左：2
4右：6
5左：nil
5右：nil
6左：5
6右：7
7左：nil
7右：nil
=== 双向转换 ===
1左：7
1右：2
2左：1
2右：3
3左：2
3右：4
4左：3
4右：5
5左：4
5右：6
6左：5
6右：7
7左：6
7右：1

应用图标圆角

Sun, 17 Oct 2021 00:00:00 GMT

应用图标圆角

Icon1024.png - 1024px - 179.649 Icon512.png - 512px - 89.825 Icon.png - 57px - 10 Icon@2x.png - 114px - 20 Icon-72.png - 72px - 12.632 Icon-72@2x.png - 144px - 25.263 Icon-Small.png - 29px - 5.088 Icon-Small@2x.png - 58px - 10.175

iPhone App Icons - Exact Radius?

通过符号表找到符号

Sun, 26 Sep 2021 00:00:00 GMT

一、需要用到的结构

1.1 懒加载符号表

懒加载符号表是再用到的时候才会进行符号绑定的表。我们分析MachO可以发现NSLog就在这里面

1.2 总符号表

完整的符号表在这里

1.3 间接符号表

在懒加载符号表中，我们发现，都有个Indirect Pointer。这就说名这里是间接符号。先在我们来到间接符号表：

我们可以发现这里面和懒加载符号表中标有Indirect Pointer的有对应关系。

二、找到NSLog的符号

在IndirectSymbols中我们找到NSLog。

2.1 Data=000000B8

这里的值代表了当前间接符号在总表中的下标。我们换算一下十进制：184

2.2 Symbols

找到下标184的，Data为000000CE，description:String table index。也就是String Table的下标。

2.3 StringTables

来到StringTable，第一个地址为00011230，我们加上下标000000CE，得到0x112FE

这里我们就找到了_NSLog

三、fishhook是和我们这种反向的一个过程

11.fishhook原理

LLVM

Sun, 26 Sep 2021 00:00:00 GMT

一、编程语言类型

1.1 解释型语言

python 、 JS 就属于常见的 解释型语言 。他们无需生成 可执行文件 就能够执行。

他们的执行过程如下：

1.2 编译型语言

我们常用的 C\C++ 、 Objective-C 、 Swift 则属于 编译型语言 需要经过下面的过程生成 可执行文件 后才能执行。

二、 LLVM 概述

LLVM 是 构架编译器(compiler) 的 框架系统 ，以 C++ 编写而成，用于优化以任意程序语言编写的程序的 编译时间(compile-time) 、 链接时间(link-time) 、 运行时间(run-time) 以及 空闲时间(idle-time) ，对开发者保持开放，并兼容已有脚本。

LLVM 计划启动于2000年，最初由美国UIUC大学的 ChrisLattner 博士主持开展。2006年 ChrisLattner 加盟 AppleInc 并致力于 LLVM 在 Apple 开发体系中的应用。 Apple 也是 LLVM 计划的主要资助者。

目前 LLVM 已经被 苹果IOS开发工具 、 Xilinx Vivado 、 Facebook 、 Google 等各大公司采用。

ChrisLattner 也是 Swift 之父。给大佬🧎‍♂️了

2.1 传统编译器设计

编译器前端

编译器前端的任务是 解析源代码 。它会进行： 词法分析 ， 语法分析 ， 语义分析 ，检查源代码是否存在错误 ，然后构建 抽象语法树(Abstract Syntax Tree, AST) 。 LLVM 的前端还会生成 中间代码(intermediate representation，IR) 。

优化器

优化器负责进行 各种优化 ， 改善代码的运行时间 ，例如消除冗余计算等。

后端 / 代码生成器

将代码映射到 目标指令集 ， 生成机器语言 ，并且 进行机器相关的代码优化 。

2.2 iOS的编译器架构

ObjectiveC / C / C++ 使用的编译器前端是 Clang ， Swift 是 Swift ， 后端 都是 LLVM 。

2.3 LLVM的设计

当编译器决定支持多种源语言或多种硬件架构时， LLVM 最重要的地方就来了。

其他的编译器如 GCC 是非常成功的一款编译器，但由于它是作为整体应用程序设计的，因此它的用途受到了很大的限制。

LLVM 设计的最重要方面是，使用 通用的代码表示形式(IR) ，它是用来在编译器中表示代码的形式。所以 LLVM 可以为任何编程语言 独立编写前端 ，并且可以为任意硬件架构 独立编写后端 。

三、 Clang

对于我们的开发人员来说，接触最多的就是我们的 Clang 。

Clang 是 LLVM 项目中的一个子项目。它是基于 LLVM架构 的 轻量级编译器 ，诞生之初是为了替代 GCC ，提供更快的编译速度。它是负责编译 C、C++、Objecte-C 的编译器，它属于整个 LLVM 架构中的，编译器前端。对于开发者来说，研究 Clang 可以给我们带来很多好处。

四、 Objective-C 的编译流程探索

我们以下面的代码为例进行探索

#import <Foundation/Foundation.h>

int addResult(int a, int b) {
    return a + b;
}

#define ADD_FUNCTION(x, y) addResult(x, y)

int main(int argc, const char * argv[]) {
    @autoreleasepool {
        int numA = 1;
        int b1 = 1;
        int b2 = 2;
        int numB = b1 + b2;
        int result = ADD_FUNCTION(numA, numB);
        NSLog(@"结果是：%d", result);
    }
    return 0;
}

4.1 编译阶段概览

通过下面的命令我们可以列出完整的编译阶段：

clang -ccc-print-phases main.m

0:输入文件
- 找到源文件
1:预处理
- 这个过程处理包括宏的替换，头文件的导入
2:编译
- 进行词法分析、语法分析、检测语法是否正确，最终生成IR
3:后端
- 这里LLVM会通过一个一个的Pass(可以理解为一个节点)去优化，每个Pass做一些事情，最终生成汇编代码
4:汇编
- 生成目标文件
5:链接
- 链接需要的动态库和静态库，生成相应的镜像可执行文件
6:绑定结构
- 根据不同的系统架构，生成对应的可执行文件

4.2 预处理

clang -E main.m >> 预处理.m

通过对比，很明显的发现这里的宏定义被替换掉了。

4.3 编译阶段

词法分析

这里会把代码切成一个个 Token ，比如 大小括号 ， 等于号 还有 字符串 等。

clang -fmodules -fsyntax-only -Xclang -dump-tokens main.m

语法分析

语法分析的任务是 验证语法是否正确 。在词法分析的基础上将单词序列组合成各类语法短语，如 “程序” ， “语句” ， “表达式” 等，然后将所有节点组成 抽象语法树(AbstractSyntaxTree，AST) 。语法分析其目的就是 对源程序进行分析判断，在结构上是否正确 。

clang -fmodules -fsyntax-only -Xclang -ast-dump main.m

生产中间代码IR

clang -S -fobjc-arc -emit-llvm main.m

这里会生成 .ll 文件，抽取一段 addResult 相关代码简单进行一下分析：

; Function Attrs: noinline nounwind optnone ssp uwtable
define i32 @addResult(i32 %0, i32 %1) #1 {
  %3 = alloca i32, align 4 // 开辟 32 bit 空间， 4个字节， 为 %3
  %4 = alloca i32, align 4
  store i32 %0, i32* %3, align 4 // 将 %0 参数存到 %3
  store i32 %1, i32* %4, align 4
  %5 = load i32, i32* %3, align 4 // 从 %3 中读取到 %5
  %6 = load i32, i32* %4, align 4
  %7 = add nsw i32 %5, %6 // %5 + %6 的值存到 %7
  ret i32 %7 // 返回 %7 32bit
}

main 函数：

; Function Attrs: noinline optnone ssp uwtable
define i32 @main(i32 %0, i8** %1) #2 {
  %3 = alloca i32, align 4
  %4 = alloca i32, align 4
  %5 = alloca i8**, align 8
  %6 = alloca i32, align 4
  %7 = alloca i32, align 4
  %8 = alloca i32, align 4
  %9 = alloca i32, align 4
  %10 = alloca i32, align 4
  store i32 0, i32* %3, align 4
  store i32 %0, i32* %4, align 4
  store i8** %1, i8*** %5, align 8
  %11 = call i8* @llvm.objc.autoreleasePoolPush() #3
  store i32 1, i32* %6, align 4
  store i32 1, i32* %7, align 4
  store i32 2, i32* %8, align 4
  %12 = load i32, i32* %7, align 4
  %13 = load i32, i32* %8, align 4
  %14 = add nsw i32 %12, %13
  store i32 %14, i32* %9, align 4
  %15 = load i32, i32* %6, align 4
  %16 = load i32, i32* %9, align 4
  %17 = call i32 @addResult(i32 %15, i32 %16)
  store i32 %17, i32* %10, align 4
  %18 = load i32, i32* %10, align 4
  notail call void (i8*, ...) @NSLog(i8* bitcast (%struct.__NSConstantString_tag* @_unnamed_cfstring_ to i8*), i32 %18)
  call void @llvm.objc.autoreleasePoolPop(i8* %11)
  ret i32 0
}

编译优化

这里 debug 模式下默认没有进行优化。

我们传入对应的优化等级，再生成一次 .ll 看看（这里用了和 release 一样的 Os ）：

clang -Os -S -fobjc-arc -emit-llvm main.m -o main优化过.ll

addResult

; Function Attrs: norecurse nounwind optsize readnone ssp uwtable willreturn
define i32 @addResult(i32 %0, i32 %1) local_unnamed_addr #1 {
  %3 = add nsw i32 %1, %0
  ret i32 %3
}

main

; Function Attrs: optsize ssp uwtable
define i32 @main(i32 %0, i8** nocapture readnone %1) local_unnamed_addr #2 {
  %3 = tail call i8* @llvm.objc.autoreleasePoolPush() #3
  notail call void (i8*, ...) @NSLog(i8* bitcast (%struct.__NSConstantString_tag* @_unnamed_cfstring_ to i8*), i32 4) #5, !clang.arc.no_objc_arc_exceptions !9
  tail call void @llvm.objc.autoreleasePoolPop(i8* %3) #3
  ret i32 0
}

这里发现优化后的中间代码简介了不少，并且代码中冗余的计算逻辑直接生成了结果

bitCode

这是 xcode7 以后开启 bitcode 苹果会做进一步的优化，生成 bc 的中间代码。我们可以试试用优化后的 IR 代码生成 bc 代码。

clang -emit-llvm -c main优化过.ll -o main优化过.bc

这里的 bc 文件无法使用文本方式进行查看

生成汇编代码

可以通过的 .bc 或者 .ll 代码生成汇编代码

clang -S -fobjc-arc main优化过.bc -o main优化过.s
或
clang -S -fobjc-arc main未优化.ll -o main未优化.s

对比一下优化前后的汇编代码，发现优化后的指令少了很多：

生成目标文件

clang -fmodules -c main未优化.s -o main未优化.o

目标文件的生成，是 汇编器 以汇编代码作为 输入 ，将 汇编代码 转换为 机器代码 ，最后输出目标文件(object-file) ，这个阶段就是属于 编译器后端 的工作了。

查看符号

xcrun nm -nm main未优化.o

输出：

                 (undefined) external _NSLog
                 (undefined) external ___CFConstantStringClassReference
                 (undefined) external _objc_autoreleasePoolPop
                 (undefined) external _objc_autoreleasePoolPush
0000000000000000 (__TEXT,__text) external _addResult
0000000000000020 (__TEXT,__text) external _main
000000000000008e (__TEXT,__ustring) non-external l_.str

_NSLog 是一个是 undefined external 的
- undefined
  - 表示在当前文件暂时找不到符号 _NSLog
- external
  - 表示这个符号是外部可以访问的

有兴趣可以移步通过符号表找到符号有介绍查找 _NSLog 的过程

生成可执行文件

连接器 把编译产生的 .o文件 和 (dylib .a)文件 ，生成一个 mach-o文件(可执行文件) 。

clang main.o -o main

报错：

Undefined symbols for architecture x86_64:
  "_NSLog", referenced from:
      _main in main.o
  "___CFConstantStringClassReference", referenced from:
      CFString in main.o
  "_objc_autoreleasePoolPop", referenced from:
      _main in main.o
  "_objc_autoreleasePoolPush", referenced from:
      _main in main.o
ld: symbol(s) not found for architecture x86_64

因为这里用到了 Foundation 框架内的符号 NSLog 不能直接生成，我们加上参数

clang -framework Foundation main.o -o main

生成成功：

查看符号

xcrun nm -nm main

输出：

                 (undefined) external _NSLog (from Foundation)
                 (undefined) external ___CFConstantStringClassReference (from CoreFoundation)
                 (undefined) external _objc_autoreleasePoolPop (from libobjc)
                 (undefined) external _objc_autoreleasePoolPush (from libobjc)
                 (undefined) external dyld_stub_binder (from libSystem)
0000000100000000 (__TEXT,__text) [referenced dynamically] external __mh_execute_header
0000000100003ed0 (__TEXT,__text) external _addResult
0000000100003ef0 (__TEXT,__text) external _main
0000000100008018 (__DATA,__data) non-external __dyld_private

这里的符号就已经和对应的框架对应起来了，如： _NSLog (from Foundation) 。而且 mach-o 文件中的偏移地址也有了。

五、 Swift 编译流程

分析输出AST
- swiftc main.swift -dump-parse
分析并且检查类型输出AST
- swiftc main.swift -dump-ast
生成中间体语言(SIL)，未优化
- swiftc main.swift -emit-silgen
生成中间体语言(SIL)，优化后的
- swiftc main.swift -emit-sil
生成LLVM中间体语言 (.ll文件)
- swiftc main.swift -emit-ir
生成LLVM中间体语言 (.bc文件)
- swiftc main.swift -emit-bc
生成汇编
- swiftc main.swift -emit-assembly
编译生成可执行.out文件
- swiftc -o main.o main.swift

参考

LLVM

Clang 1 Which OSX library to link against (command line) to use NSLog?

关于Block你所该知道的一切

Sat, 18 Sep 2021 00:00:00 GMT

一、 block 的分类

全局 block 、 堆 block 、 栈 block 。

1.1 NSGlobalBlock 全局 block

位于全局区
未捕获任何变量或只捕获全局静态变量

未捕获任何变量

<__NSGlobalBlock__: 0x100004030>

只捕获全局静态变量

1.2 堆 block

位于堆区
在 block 内部使用 局部变量 或者 OC属性 ，并且赋值给 强引用 或者 Copy修饰 的变量

<__NSMallocBlock__: 0x1007049e0>

1.3 栈 block

位于栈区
在 block 内部使用 局部变量 或者 OC属性 ，但 不 赋值给 强引用 或者 Copy修饰 的变量

<__NSStackBlock__: 0x7ffeefbff378>

1.4 面试题（一）

下面输出的结果会是什么样？

NSObject *obj = [NSObject new];
NSLog(@"%ld", CFGetRetainCount((__bridge CFTypeRef)(obj)));

void (^blockA)(void) = ^{
    NSLog(@"%ld", CFGetRetainCount((__bridge CFTypeRef)(obj)));
};
blockA();

void (^ __weak blockB)(void) = ^{
    NSLog(@"%ld", CFGetRetainCount((__bridge CFTypeRef)(obj)));
};
blockB();

void (^blockC)(void) = [blockB copy];
blockC();

这里涉及到关于 block类型 的底层知识，我们到最后在进行解析。

1.5 面试题（二）

下面输出的结果会是什么样？

int num = 0;
void (^ __weak blockA)(void) = nil;
{
    void (^ __weak blockB)(void) = ^{
        NSLog(@"%d", num);
    };
    blockA = blockB;
    NSLog(@"=");
}
blockA();

1.6 面试题（三）

下面输出的结果会是什么样？

int num = 0;
void (^ __weak blockA)(void) = nil;
{
    void (^ blockB)(void) = ^{
        NSLog(@"%d", num);
    };
    blockA = blockB;
    NSLog(@"=");
}
blockA();

二、堆、栈block的生命周期

这里结合 二、三面试题 来进行探索。

2.1 面试题二解读

很可能有同学会给出只会打印 = 的答案。这就是对于 堆、栈block的生命周期 理解的不够深入。正确的输出如下

为什么呢？关键是对 blockB 的生命周期理解错误。一般会这么理解：

这里先不讲为什么，我们再看下 面试题三。

2.2 面试题三解读

这里发生了野指针访问崩溃了。

2.3 堆 block 的生命周期

在大括号内部下断点可以看到，这时 blockB 为 堆block 且有值。

赋值给 blockA 。

出了大括号后 blockA 为空了，说明 blockB 释放掉了。

因为作为 存储在堆上 的 堆block 其生命周期仅存在于大括号内部。

2.4 栈 block 的生命周期

那么 面试题二 中的 blockB 的生命周期又是怎样的呢？

blockB 为 栈block 。

赋值给 blockA 。

出了大括号的作用域了， blockA 的地址依旧没变，说明 blockB 没有被释放。

因为作为 存储在栈中 的 栈block 其生命周期与 调用栈 相同。函数调用栈结束后释放。

三、捕获变量的底层实现

3.1 普通变量的捕获

int num = 1;
void (^block)(void) = ^{
    NSLog(@"%d", num);
};
block();

我们将上面的代码还原成 C++ ：

struct __block_impl {
  void *isa;
  int Flags;
  int Reserved;
  void *FuncPtr;
};

block 的本质是一个结构体 __main_block_impl_0 ，如果有需要捕获的变量，结构体内部会生成一个成员用来存储，例子中是 int num;
__main_block_func_0 保存的是 block 的具体需要执行的函数
__block_impl 是 block 的具体具体的一些数据，如函数等
__main_block_desc_0 是描述 block 特征的一个数据结构

这段代码中做了些什么呢？

一、创建 block ：

1、调用 __main_block_impl_0 的 构造函数

2、传入 __main_block_func_0 函数 和 __main_block_desc_0_DATA 的地址 和 变量 num

3、指定 block 类型：impl.isa = &_NSConcreteStackBlock; （这里的堆block对应的是 _NSConcreteStackBlock ）

4、存储标志位： impl.Flags = flags;

5、存储函数： impl.FuncPtr = fp;

6、描述内容赋值： Desc = desc;

二、执行 block ：

1、获取 __main_block_func_0 函数： ((void (*)(__block_impl *))((__block_impl *)block)->FuncPtr)

2、将 block 作为参数传入： ((void (*)(__block_impl *))((__block_impl *)block)->FuncPtr)((__block_impl *)block);

三、执行函数 __main_block_func_0 ：

1、从 __main_block_impl_0 中取出变量 num ： int num = __cself->num;

2、执行 NSLog ： NSLog((NSString *)&__NSConstantStringImpl__var_folders_py_7v1wvf813z5bmw0hr97yplwc0000gn_T_main_e543c2_mi_1, num);

3.2 __block 普通变量的捕获

__block int num = 0;
void (^block)(void) = ^{
    num ++;
    NSLog(@"%d", num);
};
block();

将上面的代码转为 C++

我们发现多了几种数据类型： __Block_byref_num_0 、 __main_block_copy_0 、 __main_block_dispose_0 。

加了 __block 的变量，这里被用 __Block_byref_num_0 数据结构包装了一下，这里传入的 num 也是通过地址的形式传入的。

3.3 捕获实例变量

不活实例变量和 3.2 没有什么区别。

NSNumber *num = @100;
void (^block)(void) = ^{
    NSLog(@"%@", num);
};
block();

3.4 全局 block

static const NSString *string = @"aaaaaaa";
int main(int argc, const char * argv[]) {
    @autoreleasepool {
        void (^block)(void) = ^{
            NSLog(@"%@", string);
        };
        block();
    }
}

3.5 栈 block

int num = 0;
void (^ __weak block)(void) = ^{
    NSLog(@"%d", num);
};
block();

这里还原 C++ 你可能会遇到包错：

error: cannot create __weak reference because the current deployment target does not support weak references
        void (^ __attribute__((objc_ownership(weak))) block)(void)

加上一些参数即可：

clang -rewrite-objc -fobjc-arc -fobjc-runtime=ios-13.0.0 main.m -o main.cpp

这里发现 __weak 实际是用 __attribute__((objc_ownership(weak))) 进行了包装，这里还没有什么更有用的线索，我们先继续探究。

3.6 _NSConcreteStackBlock

相信细心的你一定能发现一个问题，不论什么类型的 block ，还原出的 C++ 底层源码中都是 impl.isa = &_NSConcreteStackBlock; 看名字是个 栈 block 。和实际运行打断点运行时看到的不一样啊。下面我们就来分析一下这里发生了什么。

四、运行时 block 类型的确定

由于这里并没有什么具体线索，我们通过下断点，并打开汇编。这里是一个 全局block 。

4.1 进入汇编断点

4.2 objc_retainBlock

通过 libobjc.A.dylib`objc_retainBlock: 发现它在 libobjc 中。

在 oc 源码中定位到了相关代码，但更进一步调用的 _Block_copy 并没有找到，我们继续回到汇编，继续执行下一步。

4.3 _Block_copy

这例进入了 _Block_copy 的汇编，发现它是 libsystem_blocks 中的，我们来 libclosure 中寻找一下线索，找到了下面的源码。

void *_Block_copy(const void *arg) {
    struct Block_layout *aBlock;

    if (!arg) return NULL;
    
    // The following would be better done as a switch statement
    aBlock = (struct Block_layout *)arg;
    if (aBlock->flags & BLOCK_NEEDS_FREE) {
        /// 根据标志位判断，需要释放
        // latches on high
        latching_incr_int(&aBlock->flags);
        return aBlock;
    }
    else if (aBlock->flags & BLOCK_IS_GLOBAL) {
        /// 根据标志位判断，为一个 全局block 直接返回
        return aBlock;
    }
    else {
        // 是一个 堆 block 就进行 copy 开辟空间的操作，拷贝到了堆上
        struct Block_layout *result =
            (struct Block_layout *)malloc(aBlock->descriptor->size);
        if (!result) return NULL;
        memmove(result, aBlock, aBlock->descriptor->size); // bitcopy first
#if __has_feature(ptrauth_calls)
        // Resign the invoke pointer as it uses address authentication.
        result->invoke = aBlock->invoke;
#endif
        result->flags &= ~(BLOCK_REFCOUNT_MASK|BLOCK_DEALLOCATING);    // XXX not needed
        result->flags |= BLOCK_NEEDS_FREE | 2;  // logical refcount 1
        _Block_call_copy_helper(result, aBlock);
        // Set isa last so memory analysis tools see a fully-initialized object.
        // 设置 isa 为 堆block
        result->isa = _NSConcreteMallocBlock;
        return result;
    }
}

五、汇编验证 block 的类型转换

5.1 全局block

一直来到 _Block_copy 内，读取 x0 寄存器 （ARM64下，x0这时存的是消息的接收者）。

进入 _Block_copy 时，就已经标识为全局block 了。

我们发现输出了这样数据结构 signature invoke ，后面再具体看他们代表了什么。

<__NSGlobalBlock__: 0x1006f8028>
 signature: "v8@?0"
 invoke   : 0x1006f5edc (/private/var/containers/Bundle/Application/49DA1CBF-A462-4433-80DE-19721201954A/BlockÊé¢Á¥¢.app/BlockÊé¢Á¥¢`__41-[ViewController touchesBegan:withEvent:]_block_invoke)

5.2 堆block

进入 _Block_copy 时，显示的是栈block 。

<__NSStackBlock__: 0x16d6651b8>
 signature: "v8@?0"
 invoke   : 0x10279de90 (/private/var/containers/Bundle/Application/A3A281E1-1993-4E28-8F30-3EED05043A20/BlockÊé¢Á¥¢.app/BlockÊé¢Á¥¢`__41-[ViewController touchesBegan:withEvent:]_block_invoke)

和源码所写的一样，这里进行了 malloc ：

在 _Block_copy return 之前我们再看一下 x0 ：

这里已经变成了堆block

<__NSMallocBlock__: 0x281030ab0>
 signature: "v8@?0"
 invoke   : 0x10279de90 (/private/var/containers/Bundle/Application/A3A281E1-1993-4E28-8F30-3EED05043A20/BlockÊé¢Á¥¢.app/BlockÊé¢Á¥¢`__41-[ViewController touchesBegan:withEvent:]_block_invoke)

_block 捕获变量的变化

进入 _Block_copy 时：

<__NSStackBlock__: 0x16b21d1a0>
 signature: "v8@?0"
 invoke   : 0x104be5da0 (/private/var/containers/Bundle/Application/76397764-704E-4CA4-80F3-D94500849B81/BlockÊé¢Á¥¢.app/BlockÊé¢Á¥¢`__41-[ViewController touchesBegan:withEvent:]_block_invoke)
 copy     : 0x104be5e04 (/private/var/containers/Bundle/Application/76397764-704E-4CA4-80F3-D94500849B81/BlockÊé¢Á¥¢.app/BlockÊé¢Á¥¢`__copy_helper_block_e8_32r)
 dispose  : 0x104be5e3c (/private/var/containers/Bundle/Application/76397764-704E-4CA4-80F3-D94500849B81/BlockÊé¢Á¥¢.app/BlockÊé¢Á¥¢`__destroy_helper_block_e8_32r)

在 _Block_copy return 之前

<__NSMallocBlock__: 0x2823a83f0>
 signature: "v8@?0"
 invoke   : 0x100825da0 (/private/var/containers/Bundle/Application/D167E1D0-2772-42C4-83F1-819FC7250D2D/BlockÊé¢Á¥¢.app/BlockÊé¢Á¥¢`__41-[ViewController touchesBegan:withEvent:]_block_invoke)
 copy     : 0x100825e04 (/private/var/containers/Bundle/Application/D167E1D0-2772-42C4-83F1-819FC7250D2D/BlockÊé¢Á¥¢.app/BlockÊé¢Á¥¢`__copy_helper_block_e8_32r)
 dispose  : 0x100825e3c (/private/var/containers/Bundle/Application/D167E1D0-2772-42C4-83F1-819FC7250D2D/BlockÊé¢Á¥¢.app/BlockÊé¢Á¥¢`__destroy_helper_block_e8_32r)

这里的数据结构又发生了变化，多了 copy dispose 。

5.3 栈block

通过查看调用栈，我们发现并没有调用 objc_retainBlock 。没有进行 _Block_copy 操作。

六、 Block_layout 结构分析

6.1 isa

block 的类型：全局、堆、栈

6.2 flags

这些标志位都标明了不同的使用时间，有 运行时：runtime 有 编译期：compiler

// Values for Block_layout->flags to describe block objects
enum {
    /// 正在释放
    BLOCK_DEALLOCATING =      (0x0001),  // runtime
    /// 引用计数掩码
    BLOCK_REFCOUNT_MASK =     (0xfffe),  // runtime
    /// 需要释放
    BLOCK_NEEDS_FREE =        (1 << 24), // runtime
    /// 是否拥有拷贝辅助函数 有的话就有 Block_descriptor_2
    BLOCK_HAS_COPY_DISPOSE =  (1 << 25), // compiler
    /// 是否拥有 block 析构函数
    BLOCK_HAS_CTOR =          (1 << 26), // compiler: helpers have C++ code
    /// 标志是否有垃圾回收 MAC
    BLOCK_IS_GC =             (1 << 27), // runtime
    /// 是否是 全局block
    BLOCK_IS_GLOBAL =         (1 << 28), // compiler
    /// 和 BLOCK_HAS_SIGNATURE 对应
    BLOCK_USE_STRET =         (1 << 29), // compiler: undefined if !BLOCK_HAS_SIGNATURE
    /// 有签名 有的话就有 Block_descriptor_3
    BLOCK_HAS_SIGNATURE  =    (1 << 30), // compiler
    /// 有拓展 Layout
    BLOCK_HAS_EXTENDED_LAYOUT=(1 << 31)  // compiler
};

6.3 reserved

保留字段

6.4 invoke

函数指针，即block中具体需要执行的内容。

6.5 descriptor

这里我们在看下其中的 Block_descriptor

这里就和我们之前输出的内容对应上了：

<__NSMallocBlock__: 0x2823a83f0>
 signature: "v8@?0"
 invoke   : 0x100825da0 (/private/var/containers/Bundle/Application/D167E1D0-2772-42C4-83F1-819FC7250D2D/BlockÊé¢Á¥¢.app/BlockÊé¢Á¥¢`__41-[ViewController touchesBegan:withEvent:]_block_invoke)
 copy     : 0x100825e04 (/private/var/containers/Bundle/Application/D167E1D0-2772-42C4-83F1-819FC7250D2D/BlockÊé¢Á¥¢.app/BlockÊé¢Á¥¢`__copy_helper_block_e8_32r)
 dispose  : 0x100825e3c (/private/var/containers/Bundle/Application/D167E1D0-2772-42C4-83F1-819FC7250D2D/BlockÊé¢Á¥¢.app/BlockÊé¢Á¥¢`__destroy_helper_block_e8_32r)

虽然 Block_layout 的内存结构中只有 Block_descriptor_1 ，但是通过解读源码，可以发现， Block_descriptor_2 和 Block_descriptor_3 的读取是通过内存平移实现的，具体有哪些数据可读则是根据 标识位 来判别。

Block_descriptor_1

基础数据，一定有的

Block_descriptor_2

COPY 相关字段，有 BLOCK_HAS_COPY_DISPOSE 标志位时有。

Block_descriptor_3

签名相关数据，有 BLOCK_HAS_SIGNATURE 标志位时有。

七、 block 签名

上面的 Block_descriptor_3 中咱们提到了签名。如上面例子输出的 signature: "v8@?0" 很眼熟，它其实是 Type Encodings 类型编码，我们在属性中有遇到过。

v8@?0
- v 表示返回值为空
- 8 表示参数的总大小
- @? 表示block，
- 0 表示从0号字节开始

具体可以对照官方文档

NSMethodSignature

我们也可以通过 NSMethodSignature 来输出详细它的代表信息。

(lldb) po [NSMethodSignature signatureWithObjCTypes:"v8@?0"]
<NSMethodSignature: 0xac5982543c221e27>
    number of arguments = 1
    frame size = 224
    is special struct return? NO
    return value: -------- -------- -------- --------
        type encoding (v) 'v'
        flags {}
        modifiers {}
        frame {offset = 0, offset adjust = 0, size = 0, size adjust = 0}
        memory {offset = 0, size = 0}
    argument 0: -------- -------- -------- --------
        type encoding (@) '@?'
        flags {isObject, isBlock} // 是个对象，也是一个 block
        modifiers {}
        frame {offset = 0, offset adjust = 0, size = 8, size adjust = 0}
        memory {offset = 0, size = 8}

八、 __block 捕获变量的生命周期

我们再来研究下捕获变量的原理，我们继续通过汇编探索。

这里会调用到 _Block_object_assign

我们找到相关源码：

8.1 捕获变量类型

// Values for _Block_object_assign() and _Block_object_dispose() parameters
enum {
    // see function implementation for a more complete description of these fields and combinations
    /// 对象
    BLOCK_FIELD_IS_OBJECT   =  3,  // id, NSObject, __attribute__((NSObject)), block, ...
    /// block
    BLOCK_FIELD_IS_BLOCK    =  7,  // a block variable
    /// __block 修饰的变量
    BLOCK_FIELD_IS_BYREF    =  8,  // the on stack structure holding the __block variable
    /// 
    BLOCK_FIELD_IS_WEAK     = 16,  // declared __weak, only used in byref copy helpers
    BLOCK_BYREF_CALLER      = 128, // called from __block (byref) copy/dispose support routines.
};

8.2 _Block_object_assign

//
// When Blocks or Block_byrefs hold objects then their copy routine helpers use this entry point
// to do the assignment.
//
void _Block_object_assign(void *destArg, const void *object, const int flags) {
    const void **dest = (const void **)destArg;
    switch (os_assumes(flags & BLOCK_ALL_COPY_DISPOSE_FLAGS)) {
        // 一、 捕获的是对象
      case BLOCK_FIELD_IS_OBJECT:
        /*******
        id object = ...;
        [^{ object; } copy];
        ********/

        /**
        _Block_retain_object 的实现：
        static void (*_Block_retain_object)(const void *ptr) = _Block_retain_object_default;

        _Block_retain_object_default 的实现：
        static void _Block_retain_object_default(const void *ptr __unused) { }

        其实什么都没做
        */
        _Block_retain_object(object);

        // 指针拷贝，引用计数 +1
        *dest = object;
        break;

        // 二、 捕获的是 block
      case BLOCK_FIELD_IS_BLOCK:
        /*******
        void (^object)(void) = ...;
        [^{ object; } copy];
        ********/

        /**
        前文有关于 _Block_copy 的讲解么这里就不多说了
        */
        *dest = _Block_copy(object);
        break;
    
      case BLOCK_FIELD_IS_BYREF | BLOCK_FIELD_IS_WEAK:
      case BLOCK_FIELD_IS_BYREF:
      // 三、 捕获的是 __block / __weak __block 修饰的变量
        /*******
         // copy the onstack __block container to the heap
         // Note this __weak is old GC-weak/MRC-unretained.
         // ARC-style __weak is handled by the copy helper directly.
         __block ... x;
         __weak __block ... x;
         [^{ x; } copy];
         ********/

        *dest = _Block_byref_copy(object);
        break;
        
      case BLOCK_BYREF_CALLER | BLOCK_FIELD_IS_OBJECT:
      case BLOCK_BYREF_CALLER | BLOCK_FIELD_IS_BLOCK:
        /*******
         // copy the actual field held in the __block container
         // Note this is MRC unretained __block only. 
         // ARC retained __block is handled by the copy helper directly.
         __block id object;
         __block void (^object)(void);
         [^{ object; } copy];
         ********/

        *dest = object;
        break;

      case BLOCK_BYREF_CALLER | BLOCK_FIELD_IS_OBJECT | BLOCK_FIELD_IS_WEAK:
      case BLOCK_BYREF_CALLER | BLOCK_FIELD_IS_BLOCK  | BLOCK_FIELD_IS_WEAK:
        /*******
         // copy the actual field held in the __block container
         // Note this __weak is old GC-weak/MRC-unretained.
         // ARC-style __weak is handled by the copy helper directly.
         __weak __block id object;
         __weak __block void (^object)(void);
         [^{ object; } copy];
         ********/

        *dest = object;
        break;

      default:
        break;
    }
}

8.3 _Block_byref_copy

__Block 捕获外界变量的操作内存拷贝等

static struct Block_byref *_Block_byref_copy(const void *arg) {
    // 使用 Block_byref 结构转换一下
    struct Block_byref *src = (struct Block_byref *)arg;

    if ((src->forwarding->flags & BLOCK_REFCOUNT_MASK) == 0) {
        // 如果是通过引用计数管理的对象，就进行 malloc ，创建一个 copy
        // src points to stack
        struct Block_byref *copy = (struct Block_byref *)malloc(src->size);
        copy->isa = NULL;
        // byref value 4 is logical refcount of 2: one for caller, one for stack
        copy->flags = src->flags | BLOCK_BYREF_NEEDS_FREE | 4;

        /**
        统一 forwarding 指向 copy
        所以 __block 修饰的指向的是同一片内存空间
        */ 
        copy->forwarding = copy; // patch heap copy to point to itself
        src->forwarding = copy;  // patch stack to point to heap copy


        copy->size = src->size;

        if (src->flags & BLOCK_BYREF_HAS_COPY_DISPOSE) {
            // Trust copy helper to copy everything of interest
            // If more than one field shows up in a byref block this is wrong XXX
            struct Block_byref_2 *src2 = (struct Block_byref_2 *)(src+1);
            struct Block_byref_2 *copy2 = (struct Block_byref_2 *)(copy+1);
            copy2->byref_keep = src2->byref_keep;
            copy2->byref_destroy = src2->byref_destroy;

            if (src->flags & BLOCK_BYREF_LAYOUT_EXTENDED) {
                struct Block_byref_3 *src3 = (struct Block_byref_3 *)(src2+1);
                struct Block_byref_3 *copy3 = (struct Block_byref_3*)(copy2+1);
                copy3->layout = src3->layout;
            }

            /**
            捕获到了外部变量
            调用 byref_keep 
            内存处理
            被捕获变量生命周期的保存
            */
            (*src2->byref_keep)(copy, src);
        }
        else {
            // Bitwise copy.
            // This copy includes Block_byref_3, if any.
            memmove(copy+1, src+1, src->size - sizeof(*src));
        }
    }
    // already copied to heap
    else if ((src->forwarding->flags & BLOCK_BYREF_NEEDS_FREE) == BLOCK_BYREF_NEEDS_FREE) {
        latching_incr_int(&src->forwarding->flags);
    }
    
    return src->forwarding;
}

这里我们遇到了用来包装捕获变量的 Block_byref 结构体，还有个一个 byref_keep 与生命周期相关的函数调用，但是他们的来源并没有什么线索，我们只能继续从 C++ 中寻找一些线索。

8.4 Block_byref

其中除了 Block_byref 还有 Block_byref_2 ， Block_byref_3 。他们和前面的 Block_descriptor_1 一样，也是通过标志位区分，通过内存平移进行读写的

// __Block 修饰的结构体
struct Block_byref {
    void *isa;
    struct Block_byref *forwarding;
    volatile int32_t flags; // contains ref count
    uint32_t size;
};

// __Block 修饰的结构体 byref_keep 和 byref_destroy 函数 - 来处理里面持有对象的保持和销毁
struct Block_byref_2 {
    // requires BLOCK_BYREF_HAS_COPY_DISPOSE
    BlockByrefKeepFunction byref_keep;
    BlockByrefDestroyFunction byref_destroy;
};

// 拓展 layout
struct Block_byref_3 {
    // requires BLOCK_BYREF_LAYOUT_EXTENDED
    const char *layout;
};

8.5 通过 C++ 理解 Block_byref 结构

位了更深入的理解 Block_byref 的结构，我们通过还原 C++ 找一下线索：

__block NSNumber *num = @100;
void (^block)(void) = ^{
    num = @101;
    NSLog(@"%@", num);
};
block();


/**
对应的 Block_byref 类型结构体
*/
struct __Block_byref_num_0 {
  void *__isa;
__Block_byref_num_0 *__forwarding;
 int __flags;
 int __size;
 void (*__Block_byref_id_object_copy)(void*, void*);
 void (*__Block_byref_id_object_dispose)(void*);
 NSNumber *num;
};

struct __main_block_impl_0 {
  struct __block_impl impl;
  struct __main_block_desc_0* Desc;
  __Block_byref_num_0 *num; // by ref
  __main_block_impl_0(void *fp, struct __main_block_desc_0 *desc, __Block_byref_num_0 *_num, int flags=0) : num(_num->__forwarding) {
    impl.isa = &_NSConcreteStackBlock;
    impl.Flags = flags;
    impl.FuncPtr = fp;
    Desc = desc;
  }
};

...

int main(int argc, const char * argv[]) {
    /* @autoreleasepool */ { __AtAutoreleasePool __autoreleasepool; 

        // Block_byref 构造函数
        __attribute__((__blocks__(byref))) __Block_byref_num_0 num = {
            /**
            Block_byref 的 
            void *isa;
            */
            (void*)0, 
            /**
            Block_byref 的 
            struct Block_byref *forwarding;
            */
            (__Block_byref_num_0 *)&num, 
            /**
            Block_byref 的 
            volatile int32_t flags;
            */ 
            33554432, 
            /**
            Block_byref 的 
            uint32_t size;
            */
            sizeof(__Block_byref_num_0), 
            /**
            Block_byref_2 的
            BlockByrefKeepFunction byref_keep;
            */ __Block_byref_id_object_copy
            __Block_byref_id_object_copy_131, 
            /**
            Block_byref_2 的
            BlockByrefDestroyFunction byref_destroy;
            */
            __Block_byref_id_object_dispose_131, 
            // *num
            ((NSNumber *(*)(Class, SEL, int))(void *)objc_msgSend)(objc_getClass("NSNumber"), sel_registerName("numberWithInt:"), 100)
            };
            
        void (*block)(void) = ((void (*)())&__main_block_impl_0((void *)__main_block_func_0, &__main_block_desc_0_DATA, (__Block_byref_num_0 *)&num, 570425344));
        ((void (*)(__block_impl *))((__block_impl *)block)->FuncPtr)((__block_impl *)block);

    }
    return 0;
}

byref_keep

再次调用 _Block_object_assign （详见 8.2），这时传入的 flag 为 131 ，二进制为 1000 0011，而 BLOCK_FIELD_IS_OBJECT = 3 ，所以会执行 BLOCK_FIELD_IS_OBJECT 相关的分支，进行 拷贝 与 引用计数 + 1 。

static void __Block_byref_id_object_copy_131(void *dst, void *src) {
 _Block_object_assign((char*)dst + 40, *(void * *) ((char*)src + 40), 131);
}

byref_destroy

调用 _Block_object_dispose 进行销毁

static void __Block_byref_id_object_dispose_131(void *src) {
 _Block_object_dispose(*(void * *) ((char*)src + 40), 131);
}

九、补充：面试题一解析

这里是 1 应该都没什么疑问

NSObject *obj = [NSObject new];
NSLog(@"%ld", CFGetRetainCount((__bridge CFTypeRef)(obj)));

这里为什么是 3 呢？

void (^blockA)(void) = ^{
    NSLog(@"%ld", CFGetRetainCount((__bridge CFTypeRef)(obj)));
};
blockA();

这是引用了一个局部变量
- 内部创建了一个结构体对 obj 进行了 引用 ，引用计数+1
这个 block 被 强引用 ，它是一个 堆block
- 从上面的源码学习中我们得知， block 的类型是运行时确定的
- 而在这个过程中，进行了 _Block_copy，引用计数 +1
所以这里打印出了 3

为什么是 4

void (^ __weak blockB)(void) = ^{
    NSLog(@"%ld", CFGetRetainCount((__bridge CFTypeRef)(obj)));
};
blockB();

这是引用了一个局部变量
- 内部创建了一个结构体对 obj 进行了 引用 ，引用计数+1
这个 block 被 弱引用 ，它是一个 栈block，引用计数不变

为什么是5

void (^blockC)(void) = [blockB copy];
blockC();

将栈blockB 进行了 copy，引用计数 +1

总结

__block 捕获变量进行了三重拷贝：

变量A 被 __block 修饰，就会被 blockB 从 栈 上 拷贝 到 堆 上
- _Block_copy
blockB 捕获 Block_byref C 并 拷贝
- _Block_object_assign - _Block_byref_copy
Block_byref C 对捕获的 变量A 进行拷贝
- _Block_object_assign - byref_keep

参考

libclosure

锁｜递归锁

Tue, 14 Sep 2021 00:00:00 GMT

一、锁的分类

提到锁的分类一般都能说出两种：互斥锁、自旋锁。这些年我一直是按上厕所理解的，印象挺深的。

1.1 互斥锁

有人在用厕所了
- 上锁
来一个人就外面等着
- 外面的也要排队
里面的完事儿了
- 解锁
按排队的顺序下一个进去，继续循环

关键就是两点：互斥、同步（顺序等待）。

1.2 自旋锁

有人在用厕所了
- 上锁
来一个人就外面等着
- 但一个个都是暴脾气，不想排队，都不停在拽门，想抢先进去
里面的完事儿了
- 解锁
这堆人里面就有一个抢进去了
- 其他的继续不停的拽门

关键就是两点：互斥、忙等（死循环）。

其实锁还有一些更细分的类型，下面我们就来看看

二、递归锁 & 非递归锁

2.1 多线程混乱

我们来看一个例子，下面打印输出会是什么样。

let queue = DispatchQueue.init(label: "RyukieQ", qos: .default, attributes: .concurrent, autoreleaseFrequency: .workItem, target: nil)

func testLog(times: Int) {
    print("\(times) 号选手上完厕所了，线程： \(Thread.current)")
    if times > 0 {
        testLog(times: times - 1)
    }
}

func demo() {
    for _ in 0..<10 {
        queue.async {
            testLog(times: 10)
        }
    }
}

demo()

这里很简单，上厕所会十分的混乱。输出如下：

10 号选手上完厕所了，线程： <NSThread: 0x10073cab0>{number = 2, name = (null)}
9 号选手上完厕所了，线程： <NSThread: 0x10073cab0>{number = 2, name = (null)}
10 号选手上完厕所了，线程： <NSThread: 0x100536080>{number = 3, name = (null)}
9 号选手上完厕所了，线程： <NSThread: 0x100536080>{number = 3, name = (null)}
8 号选手上完厕所了，线程： <NSThread: 0x100536080>{number = 3, name = (null)}
7 号选手上完厕所了，线程： <NSThread: 0x100536080>{number = 3, name = (null)}
6 号选手上完厕所了，线程： <NSThread: 0x100536080>{number = 3, name = (null)}
...

2.2 NSLock

let lock1 = NSLock()

func demo1() {
    for _ in 0..<10 {
        queue.async {
            lock1.lock()
            testLog(times: 10)
            lock1.unlock()
        }
    }
}

加了锁后，大家都在很好的排队上厕所了，完美。

10 号选手上完厕所了，线程： <NSThread: 0x104845250>{number = 2, name = (null)}
9 号选手上完厕所了，线程： <NSThread: 0x104845250>{number = 2, name = (null)}
8 号选手上完厕所了，线程： <NSThread: 0x104845250>{number = 2, name = (null)}
7 号选手上完厕所了，线程： <NSThread: 0x104845250>{number = 2, name = (null)}
6 号选手上完厕所了，线程： <NSThread: 0x104845250>{number = 2, name = (null)}
5 号选手上完厕所了，线程： <NSThread: 0x104845250>{number = 2, name = (null)}
4 号选手上完厕所了，线程： <NSThread: 0x104845250>{number = 2, name = (null)}
3 号选手上完厕所了，线程： <NSThread: 0x104845250>{number = 2, name = (null)}
2 号选手上完厕所了，线程： <NSThread: 0x104845250>{number = 2, name = (null)}
1 号选手上完厕所了，线程： <NSThread: 0x104845250>{number = 2, name = (null)}
0 号选手上完厕所了，线程： <NSThread: 0x104845250>{number = 2, name = (null)}
...

2.3 NSLock 递归加锁的问题

这次我们换个地方加锁，也和我们一般的业务场景相似，大多情况是在最上层具体业务场景加锁。

let lock1 = NSLock()

func testLog1(times: Int) {
    lock1.lock() // 不断递归加锁
    print("\(times) 号选手上完厕所了，线程： \(Thread.current)")
    if times > 0 {
        testLog1(times: times - 1)
    }
    lock1.unlock()
}

func demo11() {
    for _ in 0..<10 {
        queue.async {
            testLog1(times: 10)
        }
    }
}

demo11()

这时的输出就有些不一样了，只输出了这一行。因为 NSLock 是非递归锁，但是这里又在循环递归加锁，这里就产生了类似死锁的现象。

10 号选手上完厕所了，线程： <NSThread: 0x104031980>{number = 2, name = (null)}

2.4 NSRecursiveLock

NSRecursiveLock 是可递归的

let lock2 = NSRecursiveLock()

func demo22() {
    for _ in 0..<10 {
        queue.async {
            testLog2(times: 10)
        }
    }
}

func testLog2(times: Int) {
    lock2.lock()
    print("\(times) 号选手上完厕所了，线程： \(Thread.current)")
    if times > 0 {
        testLog2(times: times - 1)
    }
    lock2.unlock()
}

demo22()

这时厕所又恢复了秩序。

10 号选手上完厕所了，线程： <NSThread: 0x101012b50>{number = 2, name = (null)}
9 号选手上完厕所了，线程： <NSThread: 0x101012b50>{number = 2, name = (null)}
8 号选手上完厕所了，线程： <NSThread: 0x101012b50>{number = 2, name = (null)}
7 号选手上完厕所了，线程： <NSThread: 0x101012b50>{number = 2, name = (null)}
6 号选手上完厕所了，线程： <NSThread: 0x101012b50>{number = 2, name = (null)}
5 号选手上完厕所了，线程： <NSThread: 0x101012b50>{number = 2, name = (null)}
4 号选手上完厕所了，线程： <NSThread: 0x101012b50>{number = 2, name = (null)}
3 号选手上完厕所了，线程： <NSThread: 0x101012b50>{number = 2, name = (null)}
2 号选手上完厕所了，线程： <NSThread: 0x101012b50>{number = 2, name = (null)}
1 号选手上完厕所了，线程： <NSThread: 0x101012b50>{number = 2, name = (null)}
0 号选手上完厕所了，线程： <NSThread: 0x101012b50>{number = 2, name = (null)}
10 号选手上完厕所了，线程： <NSThread: 0x1010130d0>{number = 3, name = (null)}
9 号选手上完厕所了，线程： <NSThread: 0x1010130d0>{number = 3, name = (null)}
8 号选手上完厕所了，线程： <NSThread: 0x1010130d0>{number = 3, name = (null)}
7 号选手上完厕所了，线程： <NSThread: 0x1010130d0>{number = 3, name = (null)}
6 号选手上完厕所了，线程： <NSThread: 0x1010130d0>{number = 3, name = (null)}
5 号选手上完厕所了，线程： <NSThread: 0x1010130d0>{number = 3, name = (null)}
4 号选手上完厕所了，线程： <NSThread: 0x1010130d0>{number = 3, name = (null)}
3 号选手上完厕所了，线程： <NSThread: 0x1010130d0>{number = 3, name = (null)}
...

多线程递归加锁的问题

按照官方文档的说明：

NSRecursiveLock 类定义了一个可以被同一个线程多次获取而不会导致线程死锁的锁。递归锁会跟踪它被成功获取的次数。每次成功获取锁都必须通过相应的解锁调用来平衡。只有当所有的 lock 和 unlock 调用都平衡时，锁才真正被释放，以便其他线程可以获取它。
顾名思义，这种类型的锁通常用于递归函数内部，以防止递归阻塞线程。您可以类似地在非递归情况下使用它来调用语义要求它们也获取锁的函数。这是一个通过递归获取锁的简单递归函数的示例。如果您没有为此代码使用 NSRecursiveLock 对象，则再次调用该函数时线程将死锁。
注意
- 因为在所有锁调用与解锁调用平衡之前不会释放递归锁，所以您应该仔细权衡使用性能锁的决定与潜在的性能影响。长时间持有任何锁可能会导致其他线程阻塞，直到递归完成。

总结一下： NSRecursiveLock 不支持多线程递归重复加锁。这也是平时更多使用 @synchronized 的一个原因，更全面，支持多线程递归加锁。

但是你可能发现了，我这里的代码使用没有任何问题。我怀疑是不是 Swift 下的 NSRecursiveLock 有所不同引起的。我再写用个 OC 看看。

果然是会崩溃。

可见 Swift 下有所不同，至于为什么我还没有找到线索，如果你知道的话欢迎交流。

参考

锁｜NSConditionLock

Tue, 14 Sep 2021 00:00:00 GMT

一、 NSConditionLock

先来看一个面试题，下面代码输出的顺序会是什么样。

let conditionLock = NSConditionLock(condition: 2)
let queue1 = DispatchQueue.global(qos: .unspecified)
let queue2 = DispatchQueue.global(qos: .background)
let queue3 = DispatchQueue.global(qos: .default)

queue1.async {
    conditionLock.lock(whenCondition: 1)
    print("1")
    conditionLock.unlock(withCondition: 0)
}

queue2.async {
    conditionLock.lock(whenCondition: 2)
    print("2")
    conditionLock.unlock(withCondition: 1)
}

queue3.async {
    conditionLock.lock()
    print("3")
    conditionLock.unlock()
}

1.1 API 简单介绍

相信很多同学和我一样没怎么用过这个锁，对着几个API也是蒙的。下面就先介绍一下这些API吧。

lock(whenCondition:)
- 在锁定操作成功之前，接收者的条件必须等于 Condition 。这个方法会阻塞线程的执行，直到可以获取到锁，即满足 Condition 。
unlock(withCondition:)
- 解锁并设置 Condition
lock
- 如果没有其他线程获得锁那它能执⾏此⾏以下代码，如果已经有其他线程获得锁，则等待，直⾄其他线程解锁
unlock
- 解锁

1.2 分析

queue1 、 queue2 、 queue3根据优先级从高到低： queue1 > queue3 > queue2

如果不看锁的部分，执行的顺序大概率是 1 3 2。但是这里有锁，所以这里的优先级是一个迷惑项。

执行步骤如下：

condition = 2
- 满足 2 的进入条件，但是 queue3 优先级更高，所以 3 大概率优先输出
- 3 输出
- condition 不变
condition 满足 2 的条件
- 可以执行 2
- 2 输出
- 解锁 condition = 1
condition 满足 1 的条件
- 可以执行 1
- 1 输出
- 解锁 condition = 0

参考

锁｜性能分析

Mon, 13 Sep 2021 00:00:00 GMT

前言

锁是面试中较为常见的内容，在这个越来越卷的行情下，你觉得你对锁的知识了解的够深（卷）么？

一、 iOS的锁

1.1 经典的性能对比图

下面是一张经典的各种锁方案的性能对比图，相信很多人都见过，出自ibireme大佬。

但是这已经是多年以前的测试对比了，现如今又是什么样的结果呢？我们自己来测试一下吧！

1.2 锁的性能测试

测试代码

用 Swift 的方式来测试一下各个锁 10W 次加锁解锁的耗时吧，顺便熟悉下 Swift 下各种锁的用法：

class ViewController: UIViewController {

    override func viewDidLoad() {
        super.viewDidLoad()
        view.backgroundColor = .brown
    }

    override func touchesBegan(_ touches: Set<UITouch>, with event: UIEvent?) {
        test_OSSpinLock()
        test_dispatch_semaphore_t()
        test_os_unfair_lock_lock()
        test_pthread_mutex_t()
        test_NSlock()
        test_NSCondition()
        test_PTHREAD_MUTEX_RECURSIVE()
        test_NSRecursiveLock()
        test_NSConditionLock()
        test_synchronized()
    }

    let excuteTimes = 100_000
    
    func test_OSSpinLock() {
        var lock = OS_SPINLOCK_INIT
        let start = CFAbsoluteTimeGetCurrent()
        for _ in 0..<excuteTimes {
            OSSpinLockLock(&lock)
            OSSpinLockUnlock(&lock)
        }
        let end = CFAbsoluteTimeGetCurrent()
        let deta = (end - start) * 1000
        print("test_OSSpinLock: \(deta)ms")
    }
    
    func test_dispatch_semaphore_t() {
        let lock = DispatchSemaphore(value: 1)
        let start = CFAbsoluteTimeGetCurrent()
        for _ in 0..<excuteTimes {
            _ = lock.wait(timeout: .distantFuture)
            lock.signal()
        }
        let end = CFAbsoluteTimeGetCurrent()
        let deta = (end - start) * 1000
        print("test_dispatch_semaphore_t: \(deta)ms")
    }
    
    func test_os_unfair_lock_lock() {
        var lock = os_unfair_lock.init()
        let start = CFAbsoluteTimeGetCurrent()
        for _ in 0..<excuteTimes {
            os_unfair_lock_lock(&lock)
            os_unfair_lock_unlock(&lock)
        }
        let end = CFAbsoluteTimeGetCurrent()
        let deta = (end - start) * 1000
        print("test_os_unfair_lock_lock: \(deta)ms")
    }
    
    func test_pthread_mutex_t() {
        var lock = pthread_mutex_t()
        pthread_mutex_init(&lock, nil)
        let start = CFAbsoluteTimeGetCurrent()
        for _ in 0..<excuteTimes {
            pthread_mutex_lock(&lock)
            pthread_mutex_unlock(&lock)
        }
        let end = CFAbsoluteTimeGetCurrent()
        let deta = (end - start) * 1000
        print("test_pthread_mutex_t: \(deta)ms")
    }
    
    func test_NSlock() {
        let lock = NSLock()
        let start = CFAbsoluteTimeGetCurrent()
        for _ in 0..<excuteTimes {
            lock.lock()
            lock.unlock()
        }
        let end = CFAbsoluteTimeGetCurrent()
        let deta = (end - start) * 1000
        print("test_NSlock: \(deta)ms")
    }
    
    func test_NSCondition() {
        let lock = NSCondition()
        let start = CFAbsoluteTimeGetCurrent()
        for _ in 0..<excuteTimes {
            lock.lock()
            lock.unlock()
        }
        let end = CFAbsoluteTimeGetCurrent()
        let deta = (end - start) * 1000
        print("test_NSCondition: \(deta)ms")
    }
    
    func test_PTHREAD_MUTEX_RECURSIVE() {
        var mutext_recurive = pthread_mutex_t()
        var attr = pthread_mutexattr_t()
        pthread_mutexattr_init(&attr)
        pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_RECURSIVE)
        pthread_mutex_init(&mutext_recurive, &attr)
        let start = CFAbsoluteTimeGetCurrent()
        for _ in 0..<excuteTimes {
            pthread_mutex_lock(&mutext_recurive)
            pthread_mutex_unlock(&mutext_recurive)
        }
        let end = CFAbsoluteTimeGetCurrent()
        let deta = (end - start) * 1000
        print("test_PTHREAD_MUTEX_RECURSIVE: \(deta)ms")
    }
    
    func test_NSRecursiveLock() {
        let lock = NSRecursiveLock()
        let start = CFAbsoluteTimeGetCurrent()
        for _ in 0..<excuteTimes {
            lock.lock()
            lock.unlock()
        }
        let end = CFAbsoluteTimeGetCurrent()
        let deta = (end - start) * 1000
        print("test_NSRecursiveLock: \(deta)ms")
    }
    
    func test_NSConditionLock() {
        let lock = NSConditionLock()
        let start = CFAbsoluteTimeGetCurrent()
        for _ in 0..<excuteTimes {
            lock.lock()
            lock.unlock()
        }
        let end = CFAbsoluteTimeGetCurrent()
        let deta = (end - start) * 1000
        print("test_NSConditionLock: \(deta)ms")
    }
    
    func test_synchronized() {
        let start = CFAbsoluteTimeGetCurrent()
        for _ in 0..<excuteTimes {
            // Swift 的 @synchronized
            objc_sync_enter(self)
            objc_sync_exit(self)
        }
        let end = CFAbsoluteTimeGetCurrent()
        let deta = (end - start) * 1000
        print("test_synchronized: \(deta)ms")
    }
}

`ARM64` 架构

iPhoneX 下

test_OSSpinLock: 70.26898860931396ms
test_dispatch_semaphore_t: 37.284016609191895ms
test_os_unfair_lock_lock: 31.321048736572266ms
test_pthread_mutex_t: 32.119035720825195ms
test_NSlock: 33.952951431274414ms
test_NSCondition: 33.511996269226074ms
test_PTHREAD_MUTEX_RECURSIVE: 32.86397457122803ms
test_NSRecursiveLock: 34.38997268676758ms
test_NSConditionLock: 40.94898700714111ms
test_synchronized: 49.324989318847656ms

从快到慢：

os_unfair_lock_lock
pthread_mutex_t
PTHREAD_MUTEX_RECURSIVE
NSCondition
NSlock
NSRecursiveLock
dispatch_semaphore_t
NSConditionLock
synchronized
OSSpinLock

非 `ARM64`

iPhone8 模拟器下

test_OSSpinLock: 37.75501251220703ms
test_dispatch_semaphore_t: 39.17098045349121ms
test_os_unfair_lock_lock: 37.19806671142578ms
test_pthread_mutex_t: 35.0489616394043ms
test_NSlock: 37.10508346557617ms
test_NSCondition: 34.54601764678955ms
test_PTHREAD_MUTEX_RECURSIVE: 32.772064208984375ms
test_NSRecursiveLock: 34.829020500183105ms
test_NSConditionLock: 39.30199146270752ms
test_synchronized: 39.29495811462402ms

从快到慢：

PTHREAD_MUTEX_RECURSIVE
NSCondition
NSRecursiveLock
pthread_mutex_t
NSlock
os_unfair_lock_lock
OSSpinLock
dispatch_semaphore_t
synchronized
NSConditionLock

总结

此处的结果并不能作为绝对结论。根据设备硬件及运行情况有不同，有兴趣可以自行进行调试。但总体各方案间的差距并没有到非常致命的地步。

synchronized 仍然是开发中我们最常使用的一种，性能OK、使用方便（不用操心 lock unlock）。

参考

不再安全的 OSSpinLock

锁｜@synchronized

Mon, 13 Sep 2021 00:00:00 GMT

一、定位到 synchronized 相关源码

那么 synchronized 是怎么实现的呢？在 Xcode 中 @synchronized 是无法直接点进去的。我们尝试在 objc 源码中找线索。

这里找到了成对出现的 objc_sync_exit / objc_sync_enter。怀疑他就是 @synchronized 的底层实现。那么如何来验证一下呢？

这里我决定将 OC 代码还原为 C++ 代码来看看。

通过 clang -rewrite-objc main.m -o main.cpp 来进行还原。定位到 main 函数，其中的确成对出现了 objc_sync_exit / objc_sync_enter。

int main(int argc, const char * argv[]) {
    /* @autoreleasepool */ { __AtAutoreleasePool __autoreleasepool;
        NSObject *obj = ((NSObject *(*)(id, SEL))(void *)objc_msgSend)((id)objc_getClass("NSObject"), sel_registerName("new"));
        { id _rethrow = 0; id _sync_obj = (id)obj; objc_sync_enter(_sync_obj);
            try {
                struct _SYNC_EXIT { _SYNC_EXIT(id arg) : sync_exit(arg) {}
                    ~_SYNC_EXIT() {objc_sync_exit(sync_exit);}
                    id sync_exit;
                } _sync_exit(_sync_obj);
                
                NSLog((NSString *)&__NSConstantStringImpl__var_folders_py_7v1wvf813z5bmw0hr97yplwc0000gn_T_main_7d2c6c_mi_0);
            } catch (id e) {_rethrow = e;}
            { struct _FIN { _FIN(id reth) : rethrow(reth) {}
                ~_FIN() { if (rethrow) objc_exception_throw(rethrow); }
                id rethrow;
            } _fin_force_rethow(_rethrow);}
        }
        
    }
    return 0;
}

接下来我们可以放心的在 objc 源码中继续探索了。

二、 objc_sync_enter

int objc_sync_enter(id obj)
{
    int result = OBJC_SYNC_SUCCESS;
    if (obj) {
        // 通过传入的 obj 创建一个 SyncData
        SyncData* data = id2data(obj, ACQUIRE);
        ASSERT(data);
        data->mutex.lock();
    } else {
        /// 如果传入的 obj 为空的话什么都不做
        // @synchronized(nil) does nothing
        if (DebugNilSync) {
            _objc_inform("NIL SYNC DEBUG: @synchronized(nil); set a breakpoint on objc_sync_nil to debug");
        }
        objc_sync_nil();
    }
    return result;
}

这里会利用传入的 obj 通过 id2data 获取一个 SyncData 结构体指针
如果传入的 obj 为空，什么都不做

三、 objc_sync_exit

int objc_sync_exit(id obj)
{
    int result = OBJC_SYNC_SUCCESS;
    if (obj) {
        SyncData* data = id2data(obj, RELEASE); 
        if (!data) {
            result = OBJC_SYNC_NOT_OWNING_THREAD_ERROR;
        } else {
            // 尝试解锁
            bool okay = data->mutex.tryUnlock();
            if (!okay) {
                // 解锁失败
                result = OBJC_SYNC_NOT_OWNING_THREAD_ERROR;
            }
        }
    } else {
        // @synchronized(nil) does nothing
    }
    return result;
}

四、 SyncData 的数据结构

typedef struct alignas(CacheLineSize) SyncData {
    struct SyncData* nextData;
    DisguisedPtr<objc_object> object;
    int32_t threadCount;  // number of THREADS using this block
    recursive_mutex_t mutex;
} SyncData;

nextData
- SyncData 指针，可见是个 单向链表 的结构
- 这个结构是 synchronized 可嵌套使用的关键点，后续会降到
object
- 传入的 obj
threadCount
- 有多少个线程在使用当前 block
mutex
- 递归锁

五、 id2data

static SyncData* id2data(id object, enum usage why)
{
    spinlock_t *lockp = &LOCK_FOR_OBJ(object);
    SyncData **listp = &LIST_FOR_OBJ(object);
    SyncData* result = NULL;

    。。。
}

5.1 找到 object 对应的数据结构

LOCK_FOR_OBJ
- 找到对应的锁 spinlock_t
LIST_FOR_OBJ
- 找到对应的 SyncData 的指针的指针

通过源码是从一个全剧静态哈希表 static StripedMap<SyncList> sDataLists 中获取的。

5.2 sDataLists 全剧静态哈希表

通过源码可以发现，貌似一个Hash表的结构。

容量大小 StripeCount

真机容量为 8，其他为 64

#if TARGET_OS_IPHONE && !TARGET_OS_SIMULATOR
    enum { StripeCount = 8 };
#else
    enum { StripeCount = 64 };
#endif

范型容器 array

这里容器的类型为 SyncList

struct PaddedT {
    T value alignas(CacheLineSize);
};

PaddedT array[StripeCount];

容器元素 SyncList

struct SyncList {
    SyncData *data;
    spinlock_t lock;
    constexpr SyncList() : data(nil), lock(fork_unsafe_lock) { }
};

哈希下标算法 indexForPointer

地址 addr 右移 4位 得到 A
地址 addr 右移 9位 得到 B
A 异或 B 得到 C
用 C 模 容量 得到下标
- 保证了不会越界

static unsigned int indexForPointer(const void *p) {
    uintptr_t addr = reinterpret_cast<uintptr_t>(p);
    return ((addr >> 4) ^ (addr >> 9)) % StripeCount;
}

思考一下：下标冲突了怎么办？

哈希冲突：拉链法（单向链表）

上面的图很好的描绘了哈希冲突时的情况
- obj 计算出的下标冲突时会在链表中添加一个节点

5.3 查找TLS快速缓存（如果支持的话）

通过 线程局部存储（TLS：Thread Local Storage） 查找快速缓存。

5.4 fetch_cache 查找缓存

内部操作和 查找TLS快速缓存 基本一致。

5.5 未命中缓存

遍历链表查找

5.6 第一次进入及链表操作

这里通过头插法插入解决哈希冲突

到这里再回头看拉链法的那张图是否就更清楚了？

六、 SyncCacheItem

作为缓存的数据结构，其中的 lockCount 代表了，这个一个 Block 在 当前线程 锁了多少次（即嵌套锁）。

typedef struct {
    SyncData *data;
    unsigned int lockCount;  // number of times THIS THREAD locked this block
} SyncCacheItem;

七、总结

这里的设计十分巧妙，刚开始发现在真机下容器的大小只有 8 的时候还在想，难道最多只能有 8 个锁么？结果其中还存在单向链表的数据结构，同时使用单向链表还解决了哈希冲突。赞叹真的是很精妙的设计呀！👍

从源码中我们也可以注意到一些点：
- 锁的对象不要为空
- 锁的对象的生命周期要合适，不要中途就被释放了
  - 这也是平时我们用 self 的原因
- 尽量选择一样的 obj 来加锁，可以使 sDataLists 结构更简单

参考

栅栏函数

Sat, 11 Sep 2021 00:00:00 GMT

前言

最近在 Swift 中想用到栅栏函数，结果犯了难，怎么调用写不出来，也是稍微查了一下才知道怎么样用。

顺手总结回顾一下栅栏函数吧。

什么是栅栏函数

Dispatch Barrier

我们瞅瞅官方文档的定义：在并发调度队列中执行的任务的同步点

说人话：可以控制并发对列任务的执行顺序

1.1 常用的API

dispatch_barrier_async
- 前面的任务执行完才会执行这里面的
dispatch_barrier_sync
- 阻塞线程，前面的任务执行完才会执行这里面的，然后再执行后面的

下面我们看看实际的使用效果

二、 Swift 中该怎么写栅栏函数呢

dispatch_barrier_async / dispatch_barrier_sync 这两个 API 是用不了的。

2.1 创建并发队列

根据提示，我们先创建一个队列：

let queue = DispatchQueue.init(label: "RyukieQueue", qos: .default, attributes: .concurrent, autoreleaseFrequency: .workItem, target: nil)

参数
- label
  - 队列名字
- qos
  - 优先级
- attributes
  - 属性列表，可以在这里设置同步异步（添加了 .concurrent 就是并发对列，否则就是穿行队列）
- autoreleaseFrequency
  - block 内制动释放的频率
- target
  - 想要 block 在哪个对列执行，默认是当前对列

2.2 创建栅栏函数

通过文档发现这个API

参数
- group
  - 调度组
- qos
  - 优先级
- flags
  - 附加属性，可以在这里设置为栅栏函数
- work
  - block

queue.async(group: nil, qos: .default, flags: .barrier) {
    xxx
}

三、异步栅栏函数 + 自定义队列

let queue = DispatchQueue.init(label: "RyukieQueue", qos: .default, attributes: .concurrent, autoreleaseFrequency: .workItem, target: nil)
        
queue.async {
    print("1: \(Thread.current)")
    sleep(1)
}
// 异步栅栏函数
queue.async(group: nil, qos: .default, flags: .barrier) {
    print("barrier - async: \(Thread.current)")
    for _ in 0...100 {
        print("...")
    }
}

queue.async {
    print("2: \(Thread.current)")
}

queue.async {
    print("3: \(Thread.current)")
}

queue.async {
    print("4: \(Thread.current)")
}

print("=========: \(Thread.current)")

这里的代码你觉得会是怎么样的执行结果呢？

输出：

1: <NSThread: 0x6000018f1040>{number = 6, name = (null)}
=========: <NSThread: 0x6000018b0800>{number = 1, name = main}
barrier - async: <NSThread: 0x6000018f1040>{number = 6, name = (null)}
...

...
...
4: <NSThread: 0x6000018f6fc0>{number = 4, name = (null)}
3: <NSThread: 0x6000018f0540>{number = 5, name = (null)}
2: <NSThread: 0x6000018f1040>{number = 6, name = (null)}

3.1 流程分析

图中蓝线代表了代码执行的顺序
2/3/4 异步任务顺序不一定相信大家很好理解
队列中存在了 异步栅栏函数 它之后的任务将不会得到调度
====== 为队列之外的代码，所以不受 异步栅栏函数 影响，因为其他都是异步的任务，它输出位置不一定但是极大概率在 异步栅栏函数 之前执行

四、同步栅栏函数 + 自定义队列

代码稍作调整：

let queue = DispatchQueue.init(label: "RyukieQueue", qos: .default, attributes: .concurrent, autoreleaseFrequency: .workItem, target: nil)
        
queue.async {
    print("1: \(Thread.current)")
    sleep(1)
}

// 同步栅栏函数
queue.sync(flags: .barrier) {
    print("barrier - sync: \(Thread.current)")
    for _ in 0...100 {
        print("...")
    }
}

queue.async {
    print("2: \(Thread.current)")
}

queue.async {
    print("3: \(Thread.current)")
}

queue.async {
    print("4: \(Thread.current)")
}

print("=========: \(Thread.current)")

这里的代码你觉得会是怎么样的执行结果呢？

输出：

1: <NSThread: 0x6000038b3640>{number = 13, name = (null)}
barrier - sync: <NSThread: 0x6000038f83c0>{number = 1, name = main}
...
...
...
...

...
...
...
=========: <NSThread: 0x6000038f83c0>{number = 1, name = main}
2: <NSThread: 0x6000038b3640>{number = 13, name = (null)}
4: <NSThread: 0x6000038b3640>{number = 13, name = (null)}
3: <NSThread: 0x6000038ddb00>{number = 11, name = (null)}

4.1 流程分析

图中蓝线代表了代码执行的顺序
同步栅栏函数 ，会阻断当前代码区间线程代码的执行
如图所示，只有当 同步栅栏函数 内的任务执行完成，才会继续外部后续代码
所以 ==== & 2/3/4 一定在 同步栅栏函数 后

五、全局并发队列

前面有提到，栅栏函数只能在并发队列中使用，但是上面都是用到了自定义并发队列。那么全局并发队列可以用么？来验证一下吧

5.1 异步栅栏函数 + 全局并发队列

通过反复调试，发现栅栏函数失效了

2: <NSThread: 0x6000026bd280>{number = 7, name = (null)}
=========: <NSThread: 0x6000026f0180>{number = 1, name = main}
3: <NSThread: 0x6000026bc540>{number = 3, name = (null)}
1: <NSThread: 0x6000026be080>{number = 6, name = (null)}
4: <NSThread: 0x6000026f1bc0>{number = 5, name = (null)}
barrier - async: <NSThread: 0x6000026bc540>{number = 3, name = (null)}
...
...
...

下面再试试同步的

5.1 同步栅栏函数 + 全局并发队列

同样失去了原本的效果

barrier - sync: <NSThread: 0x60000156c800>{number = 1, name = main}
...

...
...
...
...
=========: <NSThread: 0x60000156c800>{number = 1, name = main}
1: <NSThread: 0x60000152a280>{number = 9, name = (null)}
2: <NSThread: 0x60000152c4c0>{number = 4, name = (null)}
4: <NSThread: 0x600001528700>{number = 10, name = (null)}
3: <NSThread: 0x60000152ec40>{number = 11, name = (null)}

5.2 思考

全局对列作为全局的对列，会有很多任务，很多是我们不可控的，如果被阻拦下来了会导致很多未知问题。所以这里设计者就将其设计为六不可使用栅栏函数👍。

根据题的逻辑只有源码能够带来答案，有兴趣可以去GCD源码：libdispatch探索下

参考

信号量

Sat, 11 Sep 2021 00:00:00 GMT

前言

一、控制 GCD 最大并发数

let queue = DispatchQueue.init(label: "RyukieQueue", qos: .default, attributes: .concurrent, autoreleaseFrequency: .workItem, target: nil)
let semaphore = DispatchSemaphore(value: 2)

for i in 0...5 {
    queue.async {
        _ = semaphore.wait(timeout: .distantFuture)
        print("<<< 下载开始：\(i) 日期：\(Date())")
        sleep(5)
        print("下载结束：\(i) >>> 日期：\(Date())")
        semaphore.signal()
    }
}

<<< 下载开始：1 日期：2021-09-11 08:28:56 +0000
<<< 下载开始：0 日期：2021-09-11 08:28:56 +0000

下载结束：0 >>> 日期：2021-09-11 08:29:01 +0000
<<< 下载开始：2 日期：2021-09-11 08:29:01 +0000
下载结束：1 >>> 日期：2021-09-11 08:29:01 +0000
<<< 下载开始：3 日期：2021-09-11 08:29:01 +0000

下载结束：2 >>> 日期：2021-09-11 08:29:06 +0000
<<< 下载开始：4 日期：2021-09-11 08:29:06 +0000
下载结束：3 >>> 日期：2021-09-11 08:29:06 +0000
<<< 下载开始：5 日期：2021-09-11 08:29:06 +0000

下载结束：5 >>> 日期：2021-09-11 08:29:11 +0000
下载结束：4 >>> 日期：2021-09-11 08:29:11 +0000

二、源码解读

2.1 dispatch_semaphore_create

/*!
 * @function dispatch_semaphore_create
 *
 * @abstract
 * 用初始值创建新的计数信号量
 *
 * @discussion
 * 当两个线程需要协调时，为该值传递0是有用的 完成某一特定事件。
 * 传递一个大于零的值 用于管理有限的资源池，其中池大小相等 的价值
 * 
 * @param value
 * 信号量的起始值。传递一个小于零的值 导致返回NULL。
 * 
 *
 * @result
 * 新创建的信号量，如果失败则为NULL
 */
API_AVAILABLE(macos(10.6), ios(4.0))
DISPATCH_EXPORT DISPATCH_MALLOC DISPATCH_RETURNS_RETAINED DISPATCH_WARN_RESULT
DISPATCH_NOTHROW
dispatch_semaphore_t
dispatch_semaphore_create(intptr_t value);

2.2 dispatch_semaphore_signal

/*!

 * @function dispatch_semaphore_signal
 *
 * @abstract
 * Signal (increment) a semaphore.
 *
 * @discussion
 * 增加计数信号量。如果之前的值小于零
 * 这个函数在返回之前唤醒一个等待线程
 *
 * @param dsema The counting semaphore.
 * 在这个参数中传递NULL的结果是未定义的
 *
 * @result
 * 如果线程被唤醒，这个函数返回非零值。否则,返回零
 * 
 */


intptr_t
dispatch_semaphore_signal(dispatch_semaphore_t dsema)
{
    // +1 的操作
    long value = os_atomic_inc2o(dsema, dsema_value, release);
    if (likely(value > 0)) {
	return 0;
    }
    
    // wait 操作过多 和signal信号不平衡 抛出异常
    if (unlikely(value == LONG_MIN)) {
	DISPATCH_CLIENT_CRASH(value,
				"Unbalanced call to dispatch_semaphore_signal()");
    }
    //因为是基于pthread下层的封装，为了避免下层的异常，这里做异常处理
    return _dispatch_semaphore_signal_slow(dsema);
}

2.3 dispatch_semaphore_wait

/*!
 * @function dispatch_semaphore_wait
 *
 * @abstract
 * 等待(递减)信号量
 *
 * @discussion
 * 递减计数信号量。如果结果值小于零， 
 * 这个函数在返回之前等待一个信号出现。
 *
 * @param dsema
 * 信号量。在这个参数中传递NULL的结果是未定义的
 *
 * @param timeout
 * 何时超时(参见dispatch_time)。为了方便，
 * 有 DISPATCH_TIME_NOW和DISPATCH_TIME_FOREVER常量。
 *
 * @result
 * 成功时返回零，如果超时则返回非零
 */

intptr_t
dispatch_semaphore_wait(dispatch_semaphore_t dsema, dispatch_time_t timeout)
{
    // -1 操作
    long value = os_atomic_dec2o(dsema, dsema_value, acquire);
    if (likely(value >= 0)) {
        return 0;
    }
    return _dispatch_semaphore_wait_slow(dsema, timeout);
}

_dispatch_semaphore_wait_slow

static intptr_t
_dispatch_semaphore_wait_slow(dispatch_semaphore_t dsema,
		dispatch_time_t timeout)
{
    long orig;

    _dispatch_sema4_create(&dsema->dsema_sema, _DSEMA4_POLICY_FIFO);
        
    //判断timeout
    switch (timeout) {
    default:
	if (!_dispatch_sema4_timedwait(&dsema->dsema_sema, timeout)) {
		break;
	}
	// Fall through and try to undo what the fast path did to
	// dsema->dsema_value
        case DISPATCH_TIME_NOW:
            orig = dsema->dsema_value;
            while (orig < 0) {
		if (os_atomic_cmpxchgv2o(dsema, dsema_value, orig, orig + 1,
					&orig, relaxed)) {
                    // 处理超时
                    return _DSEMA4_TIMEOUT();
		}
            }
            // Another thread called semaphore_signal().
            // Fall through and drain the wakeup.
	case DISPATCH_TIME_FOREVER:
            //等待操作
            _dispatch_sema4_wait(&dsema->dsema_sema);
            break;
	}
	return 0;
}

_dispatch_sema4_wait

void
_dispatch_sema4_wait(_dispatch_sema4_t *sema)
{
	int ret = 0;
	do {
		ret = sem_wait(sema);
	} while (ret == -1 && errno == EINTR);
	DISPATCH_SEMAPHORE_VERIFY_RET(ret);
}

可以看出，内部其实是个 do-while 循环实现的。

三、一个思考题

下面代码会是怎样的执行结果呢？

let queue = DispatchQueue.init(label: "RyukieQueue", qos: .default, attributes: .concurrent, autoreleaseFrequency: .workItem, target: nil)
let semaphore = DispatchSemaphore(value: 0)

queue.async {
    _ = semaphore.wait(timeout: .distantFuture)
    print("<<< 下载开始：\(1) 日期：\(Date())")
    sleep(5)
    print("下载结束：\(1) >>> 日期：\(Date())")
}

queue.async {
    print("<<< 下载开始：\(2) 日期：\(Date())")
    sleep(5)
    print("下载结束：\(2) >>> 日期：\(Date())")
    semaphore.signal()
}

输出：

<<< 下载开始：2 日期：2021-09-11 09:05:24 +0000

下载结束：2 >>> 日期：2021-09-11 09:05:29 +0000
<<< 下载开始：1 日期：2021-09-11 09:05:29 +0000

下载结束：1 >>> 日期：2021-09-11 09:05:34 +0000

参考

复杂链表的复制(无Swift用例)

Tue, 07 Sep 2021 00:00:00 GMT

题目

请实现 copyRandomList 函数，复制一个复杂链表。在复杂链表中，每个节点除了有一个 next 指针指向下一个节点，还有一个 random 指针指向链表中的任意节点或者 null。

示例 1：

输入：head = [[7,null],[13,0],[11,4],[10,2],[1,0]]

输出：[[7,null],[13,0],[11,4],[10,2],[1,0]]

示例 2：

输入：head = [[1,1],[2,1]]

输出：[[1,1],[2,1]]

示例 3：

输入：head = [[3,null],[3,0],[3,null]]

输出：[[3,null],[3,0],[3,null]]

示例 4：

输入：head = []

输出：[]

解释：给定的链表为空（空指针），因此返回 null。

提示：

-10000 <= Node.val <= 10000

Node.random 为空（null）或指向链表中的节点。

节点数目不超过 1000 。

注意：本题与主站 138 题相同：https://leetcode-cn.com/problems/copy-list-with-random-pointer/

来源：力扣（LeetCode）

分析

题解

func copyRandomList2(_ head: ComplexListNode) -> ComplexListNode? {
    var p: ComplexListNode? = head
    
    // A a B b C c D d
    while let current = p {
        let node = ComplexListNode(current.val)
        node.next = current.next
        p?.next = node
        p = current.next?.next
    }
    
    // 处理 random
    p = head
    while let current = p {
        let clone = current.next
        clone?.random = current.random?.next
        p = clone?.next
    }
    
    // 删除原来的节点
    let result: ComplexListNode? = head.next
    p = result
    while let current = p {
        p?.next = current.next?.next
        p = p?.next
    }
    
    return result
}

Swift项目编译速度优化

Tue, 07 Sep 2021 00:00:00 GMT

前言

本文将从代码层面探究如何分析并优化 Swift 代码的编译速度。

一、检查代码中的编译瓶颈

1.1 项目配置

通过警告的形式标识出超出设定值的代码，下面以设置 100ms 为界限为例

在 BuildSettings 中 other swift flags 下添加下面的配置：

-Xfrontend -warn-long-function-bodies=100
-Xfrontend -warn-long-expression-type-checking=100

仅在 DEBUG 下添加就行了，毕竟只是用来检测

1.2 编译检查

Clean 后编译一次，这里就可以看到很多的警告了：

你可能觉得这样检测有点不方便，毕竟项目的警告可能有几百上千个。下面介绍一个工具：BuildTimeAnalyzer-for-Xcode

二、 BuildTimeAnalyzer-for-Xcode 使用说明

首先 Clone 项目代码（或者直接下载代码）

git clone https://github.com/RyukieSama/BuildTimeAnalyzer-for-Xcode.git

2.1 项目配置

在 BuildSettings 中 other swift flags 下添加下面的配置：

-Xfrontend -debug-time-function-bodies

然后 Clean 项目，重新 Build。

2.2 打开 BuildTimeAnalyzer.xcodeproj

这里有三种方式来使用

a. 直接运行

b. 导出App

Product - Archive

导出一个App文件，以后即可直接使用了。

c. 懒人方式-下载即用

这里我搞好了一个包，直接可用。支持 Intel， Apple Silicon。

下载：BuildTimeAnalyzer.zip即可

2.3 查看编译耗时日志

在列表中点击刚才自己的配置完成并编译后的项目，即可查看日志。

显示了整体编译耗时，还标有具体代码的行数与函数名，点击可跳转。

每次时间不一定一样，根据电脑运行情况会有一些变化，但是整体的瓶颈趋势还是基本一致的

三、优化项目

这里个人建议结合上面两种方式来定位。

BuildTimeAnalyzer 用来找到瓶颈更加直观
第一个直接添加警告的方式用来定位具体代码更准确

3.1 项目配置

为了结合两种方式，这里我的配置如下：

BuildTimeAnalyzer 分析结果

最高： DataBaseDataCenter+Overview 耗时 35075ms

案例1：较长的逻辑

这里是使用 WCDB 瓶颈显示的是连续的调用 WCDB 中的范型函数来获得一个 condition 进行数据库操作。

优化：拆分

Clean 后再 Build，查看是否有效：

DataBaseDataCenter+Overview 耗时由 35075ms 下降至 19007ms，减少了近一半的时间。那么再把 DataBaseDataCenter+Overview 其他相同场景的代码也优化一下看看结果吧。

优化了另一处一样的场景后，时间降到了 915ms。

案例2：字符串拼接

这里使用了 + 进行字符串的拼接

此处总耗时 2596ms。

优化：使用 "xx\(xx)xx" 拼接

使用 \(preString)~\(endString) 的方式进行拼接

效果明显，降到了 617ms。

案例3：少用 ??

此处用了较多的 ??。整体耗时 3561ms。

优化：提前 gurad/if let 解包或者减少调用 ?? 次数

整体降到了 855ms。

四、总结

此处列举了一些我在项目中的一些成功优化的点，当然还有一些没有找到合适优化方式的点。再有一些有价值的点结局的话我会再来更新进文中。而且这里是以个人项目作为小白鼠进行的优化，企业项目中一般可优化的地方就更多了。而且我们也不能为了优化而优化，不能影响了源代码的可读性与连贯性。

也欢迎大家交流补充

参考

二叉树中和为某一值的路径

Mon, 06 Sep 2021 00:00:00 GMT

题目

输入一棵二叉树和一个整数，打印出二叉树中节点值的和为输入整数的所有路径。从树的根节点开始往下一直到叶节点所经过的节点形成一条路径。

示例: 给定如下二叉树，以及目标和 target = 22，

               5
              / \
             4   8
            /   / \
           11  13  4
          /  \    / \
         7    2  5   1

 [
    [5,4,11,2],
    [5,8,4,5]
 ]

提示：

节点总数 <= 10000

来源：力扣（LeetCode）

题解

将问题拆解为子树的问题，递归解决

func pathSum(_ root: TreeNode?, _ target: Int) -> [[Int]] {
    guard let rootV = root?.val else {
        return []
    }
    var result: [[Int]] = []
    let deta = target - rootV
    var temp: [TreeNode] = []
    
    if let left = root?.left {
        temp.append(left)
    }
    
    if let right = root?.right {
        temp.append(right)
    }

    if temp.isEmpty { // 到达叶节点了
        if target == rootV {
            result.append([rootV])
        }
    }
    else {
        temp.forEach { tree in
            pathSum(tree, deta).forEach { datas in
                result.append([rootV] + datas)
            }
        }
    }
    
    return result
}

二叉搜索树的后序遍历序列

Sun, 05 Sep 2021 00:00:00 GMT

题目

输入一个整数数组，判断该数组是不是某二叉搜索树的后序遍历结果。如果是则返回 true，否则返回 false。假设输入的数组的任意两个数字都互不相同。

参考以下这颗二叉搜索树：

示例 1：

输入: [1,6,3,2,5]
输出: false

示例 2：

输入: [1,3,2,6,5]
输出: true

提示：数组长度 <= 1000

来源：力扣（LeetCode）

什么是「二叉搜索树」

二叉搜索树（BST，Binary Search Tree），也称 二叉排序树 或 二叉查找树。

一颗二叉树，可以为空；如果不为空，满足以下性质：

非空左子树的所有键值小于其根节点的键值
非空右子树的所有键值大于其根节点的键值
左、右子树都是二叉搜索树

分析

知道了 二叉搜索树 的特性我们可以知道，它的后序遍历的结果结构为

左节点集合A 右节点集合B 根节点 元素这样分布的数组
且 A 的所有元素小于跟节点， B 的所有元素大于跟节点
而 A 、 B 也都是 二叉搜索树，这里就可以通过递归解决了，将问题转化为所有子树的后序遍历结果是否符合要求

解法

func verifyPostorder(_ postorder: [Int]) -> Bool {
    guard let root = postorder.last else {
        return true
    }
    var left: [Int] = []
    var right: [Int] = []
    var flag = false
    
    for offset in 1..<postorder.count {
        let v = postorder[postorder.count - 1 - offset]
        if v < root {
            if flag == false { flag = true }
            left.insert(v, at: 0)
        }
        else if v > root, flag == false {
            right.insert(v, at: 0)
        }
        else {
            return false
        }
    }
    
    return verifyPostorder(left) && verifyPostorder(right)
}

多线程原理与atomic

Sun, 05 Sep 2021 00:00:00 GMT

一、什么是线程

线程也被称为 轻量级进程 ，是程序执行流程的最小单元。一个标准的线程由 线程ID、当前指令指针PC、寄存器集合 和 堆栈 组成。

通常来说，一个进程由一个到多个线程组成，各个线程之间共享程序的内存空间（包括代码段、数据段、堆等）以及一些进程资源（如打开文件和信号）。

大多软件中，线程都不止一个。多个线程可以互不相干扰地并发执行，并共享进程的全局变量和堆数据。那么多线程与单线程的进程相比，又有哪些优势呢？

1.1 使用多线程的原因

某个操作可能会陷入长时间的等待，等待的线程会进入睡眠状态，无法继续执行。多线程执行可以有效利用等待时间。典型的例子是等待网络响应，这可能需要花费数秒甚至数十秒。
某个操作（常常是计算）会消耗大量的时间，如果只有一个线程，程序和用户之间的交互就会中断。多线程可以让一个线程负责交互，另一个负责计算。
程序逻辑本身就要求兵法操作，例如一个多任务下载软件。
多CPU或者多核计算机，本身具备同时执行多个线程的能力，因此单线程程序无法全面发挥计算机的全部计算性能。
相对于多进程应用，多线程在数据共享方面的效率要高很多。

二、线程的访问权限

线程的访问非常自由，它可以访问进程内村里的所有数据，甚至包括其他线程的堆栈（如果知道其他线程的堆栈地址的话，一般不会），线程野拥有自己的私有存储空间，包括以下方面：

栈（尽管并非完全无法被其他线程访问，但一般情况下仍然可以认为是私有的数据）。
线程局部存储（TLS：Thread Local Storage）。线程局部存储是某些操作系统为线程单独提供的私有空间，但通常只有非常有限的容量。
寄存器（包括PC寄存器），寄存器是执行流的基本结构，因此位线程私有。

从 C 程序员的角度看，数据在线程之间是否私有如下：

线程私有
- 局部变量
- 函数的参数
- TLS 数据
线程之间共享（进程所有）
- 全局变量
- 堆上的数据
- 函数里的静态变量
- 程序代码，任何线程都有权利读取并执行任何代码
- 打开的文件，A线程打开的文件可以由B线程读写

三、线程调度

不论是多核还是单核计算机，线程总是“并发”执行的。当线程数小于等于处理器核数时（并且操作系统支持多处理器），线程的并发是真正的并发，不同线程运行在不同处理器上，彼此互不干涉。对于线程数大于处理器数量的情况，线程的并发会受到一些阻碍，因为此时至少有一个处理器会运行多个线程。

在但处理器对应多线程的情况下，并发是一种模拟出来的状态。操作系统会让这些多线程程序轮流执行，每次仅执行一小段时间（通常是几十到几百毫秒），这样每个线程就“看起来”在同时执行。这种在一个处理器上不断切换的线程的行为称为 线程调度（Thread Schedule），有三个主要状态：

运行
- 此时线程正在运行
就绪
- 此时线程可以立即执行，但CPU已经被占用
等待
- 此时线程正在等待某一事件（通常是I/O或同步）发生，无法执行

处于运行中的线程，拥有一段可以执行的时间，称为时间片。

当时间片用尽，该进程将进入就绪状态。
如果在时间片用尽之前进程就开始等待某事件，那么他将进入等待状态。
每当一个线程离开运行状态，调度系统就会选择一个其他的就绪线程继续执行。
在一个处于等待状态的线程多等待的事件发生后，该线程就讲进入就绪状态。

四、优先级

现在主流的调度方式尽管不尽相同，但都有***优先级调度（Priority Schedule）和轮转法（Round Robin）***的痕迹。

优先级调度
- 决定了线程按照什么顺序轮流执行
- 具有高优先级的线程会更早地执行
- 低优先级的线程常常要等到系统中已经没有高优先级的可执行线程存在时才能够执行。
轮转法
- 让每个线程轮流执行一小段时间
- 这决定了线程之间交错执行的特点

线程的优先级布景可以手动设置，系统也会根据线程的表现自动调整优先级，以使得调度更加高效。通常情况下，频繁进入等待状态的线程（进入等待状态，会放弃之后仍然可用的时间份额，例如I/O处理的线程）比频繁进行大量计算，以至于每次都要吧时间片全部用尽的线程要更瘦欢迎。原因很简单，频繁等待的线程通常只占用很少的时间，CPU也喜欢先捏软柿子。

我们一般把频繁等待的线程称之为IO密集型线程，而把很少等待的线程称之为CPU密集型线程。IO密集型总是比CPU密集型容易得到优先级的提升。

4.1 总结优先级的改变方式

用户指定优先级
根据进入等待状态的频繁程度提升或者降低优先级
长时间得不到执行而被提升优先级（防止饿死（Starvation））

五、 atomic的实质

atomic 是我们常用来保证属性线程安全的关键字。保证同一时间只有一个线程能够写入，多线程可读取。

大家可能都知道它是一个自旋锁。那么你怎么知道它是一个自旋锁呢？我们来看下源码（基于：objc4-818.2）

5.1 源码解读

reallySetProperty是属性set方法的实现源码。其中我们可以看到很多熟悉的面孔： atomic、 copy

static inline void reallySetProperty(id self, SEL _cmd, id newValue, ptrdiff_t offset, bool atomic, bool copy, bool mutableCopy)
{
    if (offset == 0) {
        object_setClass(self, newValue);
        return;
    }

    id oldValue;
    id *slot = (id*) ((char*)self + offset);

    // copy 关键字的处理
    if (copy) {
        newValue = [newValue copyWithZone:nil];
    } else if (mutableCopy) {
        newValue = [newValue mutableCopyWithZone:nil];
    } else {
        if (*slot == newValue) return;
        newValue = objc_retain(newValue);
    }

    // atomic 关键字的处理
    if (!atomic) {
        oldValue = *slot;
        *slot = newValue;
    } else {
        spinlock_t& slotlock = PropertyLocks[slot];
        slotlock.lock();
        oldValue = *slot;
        *slot = newValue;        
        slotlock.unlock();
    }

    objc_release(oldValue);
}

我们看到 atomic 用了一个 spinlock_t。它是一个自旋锁么？

它实际上是 mutex_tt C++的自旋锁。

get 方法也做了类似的处理。

六、一定线程安全么

- (void)viewDidLoad {
    [super viewDidLoad];
    
    // 线程1
    dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
        for (int i = 0; i < 1000; i++) {
            self.number = self.number + 1;
            NSLog(@"number: %ld", self.number);
        }
    });
    
    // 线程2
    dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
        for (int i = 0; i < 1000; i++) {
            self.number = self.number + 1;
            NSLog(@"number: %ld", self.number);
        }
    });
}

属性是 atomic 修饰的，按理说应该是线程安全的，两个线程各对 number 做了 1000 次循环 +1，最终 number 的值应该是2000，但输出的值却不是期望的 2000。

// 最后的几行输出
2020-03-07 22:37:21.713683+0800 TestObjC[23813:2171198] number: 1986
2020-03-07 22:37:21.714004+0800 TestObjC[23813:2171198] number: 1987
2020-03-07 22:37:21.714267+0800 TestObjC[23813:2171198] number: 1988
2020-03-07 22:37:21.714541+0800 TestObjC[23813:2171198] number: 1989
2020-03-07 22:37:21.714844+0800 TestObjC[23813:2171198] number: 1990
2020-03-07 22:37:21.715027+0800 TestObjC[23813:2171198] number: 1991
2020-03-07 22:37:21.715442+0800 TestObjC[23813:2171198] number: 1992

以上是输出的最后几行，最终的值只加到1992。

这是因为两个线程在并发的调用setter和getter，在setter和getter内部是加了锁
但是在做+1操作的时候并没有加锁，导致在某一时刻，线程一调用了getter取到值
线程2恰好紧跟着调用了getter，取到相同的值
然后两个线程对取到的值分别+1，再分别调用setter，使得两次setter其实赋值了相等的值

因此使用atomic修饰属性时对属性的操作是否是线程安全的，虽然在内部加了锁，但并不能保证绝对的线程安全。

思考

我们知道 atomic 实际上是对属性的 set/get 方法做了处理，那么如果通过 KVC 直接进行成员变量的读写线程安全么？

任务与队列的几个面试题

Sun, 05 Sep 2021 00:00:00 GMT

一、我们先看个面试题热热身

面试题一 - 串行队列

下面的打印输出会是什么样？

/// 串行队列
dispatch_queue_t queue = dispatch_queue_create("Ryukie.Queue", DISPATCH_QUEUE_SERIAL);

dispatch_async(queue, ^{
    NSLog(@"1");
});

dispatch_async(queue, ^{
    NSLog(@"2");
});

dispatch_sync(queue, ^{
    NSLog(@"3");
});

NSLog(@"0");

dispatch_async(queue, ^{
    NSLog(@"7");
});

dispatch_async(queue, ^{
    NSLog(@"8");
});

dispatch_async(queue, ^{
    NSLog(@"9");
});

A: 1230789
B: 1237890
C: 3120789
D: 2137890

分析

3 的同步任务，阻碍了0 7 8 9 的异步任务，故 3 一定在 0 7 8 9 前。
7 8 9 三个任务的顺序不一定，但在 0 之后。
1 2 3 的顺序不一定。

满足上面几点的答案为：A C

这里很可能会觉得 12 一定在 3 之前，要清楚 3 阻塞的是 3 之后的任务，123 的顺序并不一定。

如果是异步队列呢？

123 789 都是乱序的

面试题二 - while

输出会是多少呢？

__block int num = 0;

while (num < 10) {
    dispatch_async(dispatch_get_global_queue(0, 0), ^{
        num++;
    });
}

printf("%d\n", num);

由于 num++ 是异步的，所以执行的次数大于等于 10
由于 while 循环条件阻塞，打印一定在 num >= 10 条件下输出
输出大于等于 10

面试题三 - for

输出会是多少呢？

__block int num = 0;

for (int i = 0; i < 1000; i++) {
    dispatch_async(dispatch_get_global_queue(0, 0), ^{
        num++;
    });
}

printf("%d\n", num);

for 循环保证了循环次数，一定是1000次
for循环不会阻塞后面的 printf 函数执行
故：打印结果小于等于 1000（可能打印的时候还有 ++ 任务未执行完)

面试题三 - 死锁

下面几个分别输出是什么

- (void)deadLock1 {
    //    dispatch_queue_t queue = dispatch_queue_create("Ryukie", NULL);
    dispatch_queue_t queue = dispatch_queue_create("Ryukie", DISPATCH_QUEUE_SERIAL);
    NSLog(@"1");
    dispatch_async(queue, ^{
        NSLog(@"2");
        dispatch_sync(queue, ^{
            NSLog(@"3");
        });
        NSLog(@"4");
    });
    NSLog(@"5");
}

输出
- 1，5，2 死锁
分析
- 串行队列
- async 放入队列一个 blockA 任务
- blockA 内部又向队列内部添加了一个 blockB 任务
- 队列需要等待 blockA 执行完毕再执行下一个任务
- 但是添加 blockB 时，sync 阻断了 blockA 内部的执行，导致 blockA 无法执行完成
- 所以死锁了

- (void)deadLock2 {
    dispatch_queue_t queue = dispatch_queue_create("Ryukie", DISPATCH_QUEUE_CONCURRENT);
    NSLog(@"1");
    dispatch_async(queue, ^{
        NSLog(@"2");
        dispatch_sync(queue, ^{
            NSLog(@"3");
        });
        NSLog(@"4");
    });
    NSLog(@"5");
}

输出
- 1，5，2，3，4

- (void)deadLock3 {
    //    dispatch_queue_t queue = dispatch_queue_create("Ryukie", NULL);
    dispatch_queue_t queue = dispatch_queue_create("Ryukie", DISPATCH_QUEUE_SERIAL);
    NSLog(@"1");
    dispatch_async(queue, ^{
        NSLog(@"2");
        dispatch_sync(queue, ^{
            NSLog(@"3");
        });
    });
    NSLog(@"5");
}

输出
- 1，5，2 死锁
和第一个一样

- (void)deadLock4 {
    dispatch_queue_t queue = dispatch_queue_create("Ryukie", DISPATCH_QUEUE_SERIAL);
    NSLog(@"1");
    NSLog(@"2");
    dispatch_sync(queue, ^{
        NSLog(@"3");
    });
    NSLog(@"4");
    NSLog(@"5");
}

输出
- 1，2，3，4，5
串行队列
- 同步任务，没有阻塞队列内任务的执行，没有死锁，正常执行
- 所以同步任务 + 串行队列不一定死锁

二、任务与队列

dispatch_once单例实现原理

Sun, 05 Sep 2021 00:00:00 GMT

前言

日常使用单例的时候会这样用，但是你有考虑过内部具体是怎么实现的么？本文将带你通过源码探究 dispatch_once 的实现原理。

+ (instancetype)shared {
    static RYModel *object;
    static dispatch_once_t onceToken;
    dispatch_once(&onceToken, ^{
        object = [[RYModel alloc] init];
    });
    return object;
}

一、 dispatch_once 源码解析

入参：

dispatch_once_t
- 一个静态标记
dispatch_block_t
- 执行的 block

1.1 dispatch_once_f

对 static dispatch_once_t onceToken 进行类型转换
通过 onceToken 判断是否第一次执行

 DISPATCH_NOINLINE
void
dispatch_once_f(dispatch_once_t *val, void *ctxt, dispatch_function_t func)
{
    // onceToken 全局静态变量类型转换
	dispatch_once_gate_t l = (dispatch_once_gate_t)val;

#if !DISPATCH_ONCE_INLINE_FASTPATH || DISPATCH_ONCE_USE_QUIESCENT_COUNTER
    // 通过 onceToken 
	uintptr_t v = os_atomic_load(&l->dgo_once, acquire);
	if (likely(v == DLOCK_ONCE_DONE)) {
        // 已经执行过了
		return;
	}
#if DISPATCH_ONCE_USE_QUIESCENT_COUNTER
	if (likely(DISPATCH_ONCE_IS_GEN(v))) {
		return _dispatch_once_mark_done_if_quiesced(l, v);
	}
#endif
#endif
	if (_dispatch_once_gate_tryenter(l)) {// 判断是否可以执行（原子性）
        // 第一次执行
		return _dispatch_once_callout(l, ctxt, func);
	}
	return _dispatch_once_wait(l);
}

_dispatch_once_gate_tryenter

这里尝试进入，原子性的操作，线程安全。锁在当前的线程空间。

DISPATCH_ALWAYS_INLINE
static inline bool
_dispatch_once_gate_tryenter(dispatch_once_gate_t l)
{
	return os_atomic_cmpxchg(&l->dgo_once, DLOCK_ONCE_UNLOCKED,
			(uintptr_t)_dispatch_lock_value_for_self(), relaxed);
}

1.2 _dispatch_once_callout

第一次执行的相关操作

DISPATCH_NOINLINE
static void
_dispatch_once_callout(dispatch_once_gate_t l, void *ctxt,
		dispatch_function_t func)
{
    // 执行任务
    _dispatch_client_callout(ctxt, func);
    // 广播通知执行完了
	_dispatch_once_gate_broadcast(l);
}

1.3 _dispatch_once_gate_broadcast

DISPATCH_ALWAYS_INLINE
static inline void
_dispatch_once_gate_broadcast(dispatch_once_gate_t l)
{
	dispatch_lock value_self = _dispatch_lock_value_for_self();
	uintptr_t v;
#if DISPATCH_ONCE_USE_QUIESCENT_COUNTER
	v = _dispatch_once_mark_quiescing(l);
#else
	v = _dispatch_once_mark_done(l);
#endif
	if (likely((dispatch_lock)v == value_self)) return;
	_dispatch_gate_broadcast_slow(&l->dgo_gate, (dispatch_lock)v);
}

_dispatch_once_mark_done 改变标识

回头看一下 dispatch_once_f 执行过就会被直接 return 了。

参考

GCD源码：libdispatch

从上到下花式打印二叉树

Wed, 01 Sep 2021 00:00:00 GMT

前言

二叉树的常规便利： 前序遍历 、 中序遍历 、 后序遍历 可能都已经非常熟悉了。

本文将结合一个题目的三种形态来玩一下花式遍历。

一、顺序打印

1.1 题目

从上到下打印出二叉树的每个节点，同一层的节点按照从左到右的顺序打印。

例如:

给定二叉树: [3,9,20,null,null,15,7],

[3,9,20,15,7]

提示：

节点总数 <= 1000

来源：力扣（LeetCode）

1.2 分析

由于二叉树并非一个有序队列，但题目要求我们有序的输出。此时可以考虑借助一个辅助队列进行解题。

通过分析我们可以找到规律：每次打印一个节点的时候，如果该节点存在子节点，则把该节点的子节点插入队列末尾。接下来从队列头部取出节点重复打印操作。直至所有节点打印完成。

当前节点	辅助队列	结果
3	9,20	3
9	20	3,9
20	15,7	3,9,20
15	7	3,9,20,15
7	-	3,9,20,15,7

1.3 编码

func levelOrder(_ root: TreeNode?) -> [Int] {
    guard let r = root else { return [] }
    var result: [Int] = []
    var queue: [TreeNode] = [r]
    
    while queue.isEmpty == false {
        let first = queue[0]
        result.append(first.val)
        
        if let left = first.left {
            queue.append(left)
        }
        
        if let right = first.right {
            queue.append(right)
        }
        
        queue.removeFirst()
    }
        
    return result
}

二、逐行打印

2.1 题目

从上到下按层打印二叉树，同一层的节点按从左到右的顺序打印，每一层打印到一行。

例如:

给定二叉树: [3,9,20,null,null,15,7],

返回其层次遍历结果：

 [
   [3],
   [9,20],
   [15,7]
 ]

2.2 分析

在第一种遍历的基础上，这本题加上了换行的逻辑。我们只需要加上换行的判断逻辑就可以了。

2.3 题解

func levelOrder(_ root: TreeNode?) -> [[Int]] {
    var queue: [TreeNode] = []
    /// 当前行需要继续打印的数量
    var toBePrint = 0
    /// 下一行的数量
    var nextLevelCount = 0
    var result: [[Int]] = []
    var temp: [Int] = []
    
    if let r = root {
        queue.append(r)
        toBePrint += 1
    }

    while queue.isEmpty == false {
        if let first = queue.first {
            temp.append(first.val)
            queue.removeFirst()
            toBePrint -= 1
            
            if let left = first.left {
                queue.append(left)
                nextLevelCount += 1
            }
            
            if let right = first.right {
                queue.append(right)
                nextLevelCount += 1
            }
            
            if toBePrint == 0 {
                result.append(temp)
                temp = []
                
                toBePrint = nextLevelCount
                nextLevelCount = 0
            }
        }
    }

    return result
}

三、之字形打印

3.1 题目

请实现一个函数按照之字形顺序打印二叉树，即第一行按照从左到右的顺序打印，第二层按照从右到左的顺序打印，第三行再按照从左到右的顺序打印，其他行以此类推。

例如:

给定二叉树: [3,9,20,null,null,15,7],

返回其层次遍历结果：

 [
   [3],
   [20,9],
   [15,7]
 ]

3.2 易错点

本题很容易想当然的觉得和第二种差不多，左右换成右左就可以了嘛～于是稍微改一改就写出下面的代码：

func levelOrder(_ root: TreeNode?) -> [[Int]] {
    var queue: [TreeNode] = []
    var toBePrint = 0
    var nextLevelCount = 0
    var result: [[Int]] = []
    var temp: [Int] = []
    
    var flag = false
    
    if let r = root {
        queue.append(r)
        toBePrint += 1
    }
    
    while queue.isEmpty == false {
        if let first = queue.first {
            temp.append(first.val)
            queue.removeFirst()
            toBePrint -= 1
            
            if flag {
                if let left = first.left {
                    queue.append(left)
                    nextLevelCount += 1
                }
                
                if let right = first.right {
                    queue.append(right)
                    nextLevelCount += 1
                }
            }
            else {
                if let right = first.right {
                    queue.append(right)
                    nextLevelCount += 1
                }
                
                if let left = first.left {
                    queue.append(left)
                    nextLevelCount += 1
                }
            }
            
            if toBePrint == 0 {
                result.append(temp)
                temp = []
                
                toBePrint = nextLevelCount
                nextLevelCount = 0
                
                flag.toggle()
            }
        }
    }

    return result
}

然后顺序就乱掉了：

3.3 分析

这里不将思维局限于遍历的方向。这里还是按顺序逐层便利。一个队列A存放当前行，一个队列B存放下一行的。当一行遍历完，将B赋值给A，再用B来存放下一行。而打印结果则根据当前行的方向决定是从头插入还是从末尾插入。

3.4 题解

func levelOrder(_ root: TreeNode?) -> [[Int]] {
    guard let r = root else {
        return []
    }
    
    var queue: [TreeNode] = []
    var queueB: [TreeNode] = []
    var toBePrint = 0
    var nextLevelCount = 0
    var result: [[Int]] = []
    var flag = true
    
    queue.append(r)
    toBePrint += 1
    
    var temp = Array(repeating: 0, count: queue.count)
    
    while queue.isEmpty == false {
        let first = queue.removeFirst()
        temp[flag ? (temp.count - toBePrint) : (toBePrint - 1)] = first.val
        toBePrint -= 1
        
        if let left = first.left {
            queueB.append(left)
            nextLevelCount += 1
        }
        
        if let right = first.right {
            queueB.append(right)
            nextLevelCount += 1
        }
        
        if toBePrint == 0 {
            result.append(temp)
            queue = queueB
            temp = Array(repeating: 0, count: nextLevelCount)
            
            toBePrint = nextLevelCount
            nextLevelCount = 0
            queueB = []
            flag.toggle()
        }
    }
    
    return result
}

II.从上到下打印二叉树II

Wed, 01 Sep 2021 00:00:00 GMT

题目

从上到下按层打印二叉树，同一层的节点按从左到右的顺序打印，每一层打印到一行。

例如:

给定二叉树: [3,9,20,null,null,15,7],

返回其层次遍历结果：

 [
   [3],
   [9,20],
   [15,7]
 ]

提示：

节点总数 <= 1000

注意：本题与主站 102 题相同：https://leetcode-cn.com/problems/binary-tree-level-order-traversal/

来源：力扣（LeetCode）

链接：https://leetcode-cn.com/problems/cong-shang-dao-xia-da-yin-er-cha-shu-ii-lcof

题解

func levelOrder(_ root: TreeNode?) -> [[Int]] {
    var queue: [TreeNode] = []
    var toBePrint = 0
    var nextLevelCount = 0
    var result: [[Int]] = []
    var temp: [Int] = []
    
    if let r = root {
        queue.append(r)
        toBePrint += 1
    }

    while queue.isEmpty == false {
        if let first = queue.first {
            temp.append(first.val)
            queue.removeFirst()
            toBePrint -= 1
            
            if let left = first.left {
                queue.append(left)
                nextLevelCount += 1
            }
            
            if let right = first.right {
                queue.append(right)
                nextLevelCount += 1
            }
            
            if toBePrint == 0 {
                result.append(temp)
                temp = []
                
                toBePrint = nextLevelCount
                nextLevelCount = 0
            }
        }
    }
    
    if temp.isEmpty == false {
        result.append(temp)
    }
    
    return result
}

III.从上到下打印二叉树III

Wed, 01 Sep 2021 00:00:00 GMT

题目

例如:

给定二叉树: [3,9,20,null,null,15,7],

返回其层次遍历结果：

 [
   [3],
   [20,9],
   [15,7]
 ]

提示：

节点总数 <= 1000

来源：力扣（LeetCode）

链接：https://leetcode-cn.com/problems/cong-shang-dao-xia-da-yin-er-cha-shu-iii-lcof

著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

题解

func levelOrder(_ root: TreeNode?) -> [[Int]] {
    guard let r = root else {
        return []
    }
    
    var queue: [TreeNode] = []
    var queueB: [TreeNode] = []
    var toBePrint = 0
    var nextLevelCount = 0
    var result: [[Int]] = []
    var flag = true
    
    queue.append(r)
    toBePrint += 1
    
    var temp = Array(repeating: 0, count: queue.count)
    
    while queue.isEmpty == false {
        let first = queue.removeFirst()
        temp[flag ? (temp.count - toBePrint) : (toBePrint - 1)] = first.val
        toBePrint -= 1
        
        if let left = first.left {
            queueB.append(left)
            nextLevelCount += 1
        }
        
        if let right = first.right {
            queueB.append(right)
            nextLevelCount += 1
        }
        
        if toBePrint == 0 {
            result.append(temp)
            queue = queueB
            temp = Array(repeating: 0, count: nextLevelCount)
            
            toBePrint = nextLevelCount
            nextLevelCount = 0
            queueB = []
            flag.toggle()
        }
    }
    
    return result
}

I.从上到下打印二叉树

Tue, 31 Aug 2021 00:00:00 GMT

题目

从上到下打印出二叉树的每个节点，同一层的节点按照从左到右的顺序打印。

例如:

给定二叉树: [3,9,20,null,null,15,7],

[3,9,20,15,7]

提示：

节点总数 <= 1000

来源：力扣（LeetCode）

题解

func levelOrder(_ root: TreeNode?) -> [Int] {
    guard let r = root else { return [] }
    var result: [Int] = []
    var queue: [TreeNode] = [r]
    
    while queue.isEmpty == false {
        let first = queue[0]
        result.append(first.val)
        
        if let left = first.left {
            queue.append(left)
        }
        
        if let right = first.right {
            queue.append(right)
        }
        
        queue.removeFirst()
    }
        
    return result
}

栈的压入、弹出序列

Thu, 26 Aug 2021 00:00:00 GMT

一、题目

输入两个整数序列，第一个序列表示栈的压入顺序，请判断第二个序列是否为该栈的弹出顺序。假设压入栈的所有数字均不相等。例如，序列 {1,2,3,4,5} 是某栈的压栈序列，序列 {4,5,3,2,1} 是该压栈序列对应的一个弹出序列，但 {4,3,5,1,2} 就不可能是该压栈序列的弹出序列。

示例 1：

输入：pushed = [1,2,3,4,5], popped = [4,5,3,2,1]
输出：true

解释：我们可以按以下顺序执行：

push(1), push(2), push(3), push(4), pop() -> 4,

push(5), pop() -> 5, pop() -> 3, pop() -> 2, pop() -> 1

示例 2：

输入：pushed = [1,2,3,4,5], popped = [4,3,5,1,2]
输出：false

解释：1 不能在 2 之前弹出。

提示：

0 <= pushed.length == popped.length <= 1000

0 <= pushed[i], popped[i] < 1000

pushed 是 popped 的排列。

注意：本题与主站 946 题相同：https://leetcode-cn.com/problems/validate-stack-sequences/

来源：力扣（LeetCode）

链接：https://leetcode-cn.com/problems/zhan-de-ya-ru-dan-chu-xu-lie-lcof

著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

二、分析

本题一上来难以找到思路。对于这样的问题，举例子找规律是比较合适的。这样在面试的时候面试官也更能理解我们的思路，而不是上来直接把答案 默写 出来。

解决这个问题很直观的想法就是建立一个辅助栈，把输入的第一个序列中的元素依次压入，并按照第二个序列的顺序依次冲该栈中弹出元素。

2.1 举例分析

输入一：pushed = [1,2,3,4,5], popped = [4,5,3,2,1]

步骤	操作	栈	弹出数字
1	压入1	1
2	压入2	12
3	压入3	123
4	压入4	1234
5	弹出4	123	4
6	压入5	1235
7	弹出5	123	5
8	弹出3	12	3
9	弹出2	1	2
10	弹出1		1

输入二：pushed = [1,2,3,4,5], popped = [4,3,5,1,2]

步骤	操作	栈	弹出数字
1	压入1	1
2	压入2	12
3	压入3	123
4	压入4	1234
5	弹出4	123	4
6	弹出3	12	3
7	压入5	125
8	弹出5	12	5
尝试弹出下一个1，但是栈顶元素为2，无法弹出

规律总结

从这里我们发现了如下规律：

栈顶元素如果等于下一个弹出元素：可以弹出
栈顶元素不等于下一个弹出元素：可以压入下一个待压入的元素
- 直到将下一个需要弹出的元素入栈
如果所有元素都入栈后，没有下一个能弹出的元素，那么就不是一个弹出序列

三、编码

func validateStackSequences(_ pushed: [Int], _ popped: [Int]) -> Bool {
    if pushed.isEmpty {
        return true
    }
    
    var result: [Int] = [], pA = 0, pB = 0
    
    while pB < popped.count {
        let b = popped[pB]
        
        // 栈顶元素如果等于下一个弹出元素：可以弹出
        if let top = result.last, top == b {
            result.removeLast()
            pB += 1
        }
        // 栈顶元素不等于下一个弹出元素：可以压入下一个待压入的元素
        else if pA < pushed.count {
            let a = pushed[pA]
            result.append(a)
            pA += 1
        }
        // 如果所有元素都入栈后，没有下一个能弹出的元素，那么就不是一个弹出序列
        else {
            return false
        }
    }
    
    return result.isEmpty
}

四、本题考点

考察分析复杂问题的能力。刚听到这个题的时候很多人可能都没有思路。这时候可以通过举一两个例子，一步步分析压栈、弹出的过程，进而寻找规律
考察对栈的理解

数值的整数次方

Thu, 12 Aug 2021 00:00:00 GMT

一、题目

实现 pow(x, n) ，即计算 x 的 n 次幂函数（即，xn）。不得使用库函数，同时不需要考虑大数问题。

示例 1：

输入：x = 2.00000, n = 10
输出：1024.00000

示例 2：

输入：x = 2.10000, n = 3
输出：9.26100

示例 3：

输入：x = 2.00000, n = -2
输出：0.25000
解释：2^(-2) = 1 / (2^(2)) = 1/4 = 0.25

提示：

-100.0 < x < 100.0
-231 <= n <= 231-1
-104 <= xn <= 104

来源：力扣（LeetCode）

链接：https://leetcode-cn.com/problems/shu-zhi-de-zheng-shu-ci-fang-lcof

著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

二、快速幂

幂运算是我们最常用的运算之一。如果我们要求 x 的 N 次幂，那么想当然的就会写出一个 N 次的循环，然后累乘得到结果。这种幂运算的复杂度是O(N)。

var res = 1
for _ in 0..<n {
    res *= x
}
return res

那么有没有更快的运算方式呢？

在计算机领域有一种常用的快速幂算法：蒙哥马利幂（Montgomery reduction）算法。将复杂度从O(N) 降到了 O(logN)

2.1 思路一：递归

若 N 为偶数，可以先求 xN/2，然后再平方。
若 N 为奇数，可以先求 x(N-1)/2，然后再平方，再乘以x

快速幂的最基础思想就是上面两条了。

求解 xN/2，x(N-1)/2 时也可以用到上面的思路，每次将指数除以2，每次都可以将复杂度降低一半，知道最后指数为1。

Swift实现

这里不考虑大数，仅作为思路展示

func quickpow(_ x: Int, _ n: Int) -> Int {
    if n == 0 {// 直到最后指数为0
        return 1
    }
    let res = quickpow(x, n/2)
    if n%2 != 0 {// n 为奇数
        return res * res * x
    }
    // n为偶数
    return res * res
}

2.2 思路二：二进制拆分

我们以 x14 为例进行推导。

换个方向，更直观：

推论：

设 x 的 N 次幂等于 res
- 1: 在指数 N 的二进制形式下，从最低位开始左移一位，x自乘一次（和指数N左移一位保持一致）
- 如果当前位为1
 - 当前位a到最低位，中间位全部置0时表示的值b，xb的累乘
- 如果当前位位0
 - 执行1
- 循环直到指数N等于0

当前位	指数b	res
111`0`	0	x<sup>0<sub>(2)</sub></sup>
11`1`0	10	x<sup>10<sub>(2)</sub></sup>
1`1`10	100	x<sup>10<sub>(2)</sub></sup> * x<sup>100<sub>(2)</sub></sup>
`1`110	1000	x<sup>10<sub>(2)</sub></sup> * x<sup>100<sub>(2)</sub></sup> * x<sup>1000<sub>(2)</sub></sup>

Swift实现

这里不考虑大数，仅作为思路展示

func quickpow(_ x: Int, _ n: Int) -> Int {
    var res = 1
    var x = x
    var n = n
    
    while n > 0 {
        if n & 1 == 1 { // 如果n的当前末位为1
            res *= x // res乘上当前的x
        }
        x *= x// x自乘，当前指数左移一位
        n >>= 1// n右移一位，想当于 n / 2
    }
    
    return res
}

三、解题

本题的条件与上面介绍的快速幂中的例子略有不同，调整一下即可。

3.1 递归

func myPow(_ x: Double, _ n: Int) -> Double {
    // 特殊处理 0 1 -1 可以直接 return 结果
    if x == 0 || x == 1 {
        return x
    }
    else if x == -1 {
        return (n & 1 == 1 ? -1 : 1)
    }
    
    if n == 0 {
        return 1
    }
    else if n < 0 {
        return myPow(1/x, -n)
    }
    else if n == 1 {
        return x
    }
    
    let temp = myPow(x, n >> 1)
    return temp * temp * ((n & 1 == 1) ? x : 1)
}

3.2 非递归

func myPow(_ x: Double, _ n: Int) -> Double {
    // 特殊处理 0 1 -1 可以直接 return 结果
    if x == 0 || x == 1 {
        return x
    }
    else if x == -1 {
        return (n & 1 == 1 ? -1 : 1)
    }
    
    if n == 0 {
        return 1
    }
    
    var ans: Double = 1
    var power = abs(n)
    var newX = x
    while power > 0 {
        if power & 1 == 1 {
            ans *= newX
        }
        newX *= newX
        power = power >> 1
    }
    return n < 0 ? 1 / ans : ans
}

树的子结构

Wed, 11 Aug 2021 00:00:00 GMT

一、题目

输入两棵二叉树A和B，判断B是不是A的子结构。(约定空树不是任意一个树的子结构)

B是A的子结构，即 A中有出现和B相同的结构和节点值。

例如:

给定的树 A:

给定的树 B：

    4
   /
  1

返回 true，因为 B 与 A 的一个子树拥有相同的结构和节点值。

示例 1：

输入：A = [1,2,3], B = [3,1]
输出：false

示例 2：

输入：A = [3,4,5,1,2], B = [4,1]
输出：true

限制：

0 <= 节点个数 <= 10000

来源：力扣（LeetCode）

链接：https://leetcode-cn.com/problems/shu-de-zi-jie-gou-lcof

著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

二、分析

拆分为两个步骤

在 A树 中找到和 B树 的跟节点值一样的 R
判断 A树 中以 R 为根节点的子树是不是包含和 B树 一样的结构

成立条件

满足下面任意一条

条件一：B树 是 A树的左树的子树
条件二：B树 是 A树的右树的子树
- 上面这两个条件明显可以递归了
条件三：A树 某节点为根节点的树包含 B树
- 这个看来需要辅助函数

伪代码： return (三 || 一 || 二)

三、代码

func isSubStructure(_ A: TreeNode?, _ B: TreeNode?) -> Bool {
    guard let treeA = A, let treeB = B else { return false }
    return (isContain(A, treeB) || isSubStructure(treeA.left, treeB) || isSubStructure(treeA.right, treeB))
}

完成 条件三 的辅助函数：

func isContain(_ A: TreeNode?, _ B: TreeNode?) -> Bool {
    if B == nil {
        return true // B遍历完了 不论A还有没有 A已经包含了A了
    }
    if A == nil {
        return false // A遍历完了 B还有 肯定不包含
    }
    
    guard let treeA = A, let treeB = B, treeA.val == treeB.val else { return false }
    
    return isContain(treeA.left, treeB.left) && isContain(treeA.right, treeB.right)
}

复杂度分析

***时间复杂度O(MN)：***其中 M N 分别为 A B 树的节点个数。

空间复杂度O(M)：

二进制重排实践

Tue, 10 Aug 2021 00:00:00 GMT

前言

近两年二进制重排在启动优化上还是经常被提到的，但自己没有尝试过。

继上一次「iOS官方瘦身方案ODR（二）：换肤系统改造｜践行 On-Demand Resources」后，再次拿自己个人项目小白鼠「梦见账本」来实践一下。

一、为什么要二进制重排呢？

虽然听着很厉害的样子，但其实是个老概念了。

1.1 虚拟内存和分页

我们知道，现代操作系统一般都采用虚拟内存管理机制，用分段（segment）和分页（page）管理虚拟内存。

分段即是区分数据段、代码段、堆内存、栈内存等，不同的段数据的读写权限不一样。以 iOS 为例，代码段（_TEXT）是可读可执行但不能写的。

分页则是为了方便高效的进行内存管理。由于采用了虚拟内存管理机制，就要建立虚拟内存到物理内存的映射表，称为页表。如果在设计上将每一个字节的虚拟内存和物理内存一一对应，这样粒度足够细，虽然不会产生内存浪费（内存碎片），但需要维护巨大的页表；但如果一页数据过大，比如5M，那么存储1个字节就要分配一个5M的页面，是非常大的浪费。内存页过大或过小都有弊端，目前大多数系统的页大小都设置在了4096字节，通过页号和页内偏移进行寻址。可以使用pagesize命令查看当前系统的页大小。

1.2 Page Fault

使用虚拟内存的目的之一是解决物理内存资源紧张的问题。dyld 在加载二进制时，会使用 mmap 将 Mach-O 文件映射到虚拟内存地址空间中，此时并不会占用过多的物理内存。当读取一个虚拟内存地址时，如果该地址在物理内存中并不存在，会触发一次缺页中断（Page Fault），这个时候才将文件内容读取至物理内存中。

缺页中断发生时会执行下面的操作：

分配内存 由内存管理单元找到空闲内存并分配。

IO操作 从磁盘中读文件并写入内存中。

解密验签 如果是从 AppStore 上下载的 APP，iOS 系统还有对每一页（仅针对 _TEXT 段的数据，_DATA 段数据不需要）进行解密和签名验证。

以上操作在每一次 Page Fault 时都会发生，如果在启动 APP 时，存在大量的 Page Fault 情况，势必影响启动速度。

二、什么是二进制重排

频繁的发生 Page Fault 会影响启动速度，那么，是否可以干预 Mach-O 的 _TEXT 段函数的映射顺序，将 APP 启动时需要用到的方法集中在一页或几页呢？答案是肯定的，二进制重排的原理就是字面上的理解，通过减少 Page Fault 发生次数，减少启动耗时。

理论上 Page Fault 确实会影响启动速度，但影响的大小要区分看待。一般来说，是要在常规的优化手段都做完之后，再考虑进行二进制重排。且对于小型APP来说，如果本身启动时执行的方法并不算多，那么二进制重排的意义就不是很大。

对于 iOS 13 系统来说，由于启用了 dyld3，Page Fault发生时已经不需要执行解密验签（提前生成了 lauch closure 文件），对性能的影响就更小了。

三、 System Trace 查看耗时

建议重装应用

选中指定的设备，选中安装的 App 点击 [*] 按钮，应用第一个页面（非启动页）显示后停止。
找到自己的项目
选中 Main Thread
选中 Virtual Memory

File Backed Page In 次数就是 Page Fault 的次数。「梦见账本」耗时 341ms。

点击这里的小箭头，可以看到调用堆栈

当然，我们不可能人工的来整理这些。那么有什么办法可以获取到所有调用呢？

四、获取启动时调用的所有方法

现有方案对比

hook objc_msgSend
- 只能捕获基于 objc 的方法调用
静态扫描 MachO 文件里的符号和函数数据 + 解析 Trace 文件
- 容易获取 +load、C++构造函数
- initialize hook不到
- 部分block hook不到
- C++通过寄存器的间接函数调用静态扫描不出来
编译器插桩 Clang
- 可以拿到 OC、 Swift、 C、 block 全部调用

五、 Clang 插桩

5.1 基于 Clang SanitizerCoverage 的方案

SanitizerCoverage 是 Clang 内置的一个代码覆盖工具。它把一系列以 __sanitizer_cov_trace_pc_ 为前缀的函数调用插入到用户定义的函数里，借此实现了全局 AOP。其覆盖了/ Swift/Objective-C/C/C++ 等语言，Method/Function/Block 全支持。

开启 SanitizerCoverage 的方法是：

在 build settings 里的 Other C Flags 中添加 -fsanitize-coverage=func,trace-pc-guard
如果含有 Swift 代码的话
- 需要在 Other Swift Flags 中加入 -sanitize-coverage=func 和 -sanitize=undefined
所有链接到 App 中的二进制都需要开启 SanitizerCoverage，这样才能完全覆盖到所有调用
- 例如Pod库，就要在Target里设置

在SanitizerCoverage中可以看到 LLVM 官方对 SanitizerCoverage 的详细介绍，包含了示例代码。

5.2 获取 order 文件

这里直接使用了AppOrderFiles来进行获取。就不贴代码了，源码也不多，有兴趣可以自行查看。

在 AppDelegate 中调用：

// 我是放在 `func application(_ application: UIApplication, didFinishLaunchingWithOptions launchOptions: [UIApplication.LaunchOptionsKey: Any]?) -> Bool` 最后调用的
AppOrderFiles { path in
    if let path = path { print("AppOrderFiles: \(path)") }
}

安装运行一次后，从 Xcode 获取应用的设备的 .xcappdata 文件中按照路径，取到 app.order 文件。

5.3 设置 order 文件路径

没必要加入 Bundle

5.4 验证顺序 LinkMap

开启 LinkMap 文件输出

编译获取 LinkMap

先在项目的 Product 文件夹中找到 .app 的目录

再按如图所示路径找到 linkmap 文件

对比 linkmap 和 order 文件

搜索 Address Size File Name

发现顺序是一样的了

5.5 System Trace 检查效果

只有 141ms 了，优化了一大半。具体效果根据不同项目会有所不同。

参考

详解KVC

Sun, 08 Aug 2021 00:00:00 GMT

前言

一、 KVC set/get 过程

NSObject 的分类提供了 NSKeyValueCoding协议 的默认实现。

本文中的描述使用<key>或<key>作为键字符串的占位符，该字符串在键值编码协议方法之一中作为参数出现，然后该方法将其用作辅助方法调用或变量名称查找的一部分。映射的属性名称遵循占位符的大小写。例如，对于 getter <key> 和 is<key>，名为 hidden 的属性映射到 hidden 和 isHidden。

1.1 基本 Getter 的搜索过程

valueForKey: 的默认实现，给定一个key参数作为输入，执行以下过程。

1.1.1

在实例中按顺序搜索方法：

get<key>
<key>
is<key>
_<key>

如果找到，则调用它并使用结果继续执行步骤 5，否则继续下一步

验证一下

@interface RYModel : NSObject {
    @public
    NSString *_name;
    NSString *name;
    NSString *isName;
    NSString *_isName;
}
@end

1.1.2

在实例中搜索名称

countOf<key> 和
objectIn<key>AtIndex:
<key>AtIndexes:

对应于 NSArray

如果找到这些中的第一个和其他两个中的至少一个，则创建一个响应所有NSArray方法的集合代理对象并返回该对象。否则，继续执行步骤 3

代理对象随后将任何 NSArray 接收到的一些组合的消息 countOf<key> ， objectIn<key>AtIndex: 和 <key>AtIndexes: 消息给键-值编码创建它兼容的对象。

如果原始对象还实现了一个可选的方法，其名称类似于 get<key>:range: ，则代理对象也会在适当的时候使用它。

实际上，与 KVC 兼容的对象一起工作的代理对象允许底层属性表现得好像它是 NSArray ，即使它不是。

1.1.3

如果没有找到简单的访问方法或阵列访问方法组，寻找：

countOf<key>
enumeratorOf<key>
memberOf<key>

对应于 NSSet 类

如果找到所有三个方法，则创建一个响应所有 NSSet 方法的集合代理对象并返回该对象。否则，继续执行步骤 4

此代理对象随后将任何 NSSet 接收到的一些组合信息 countOf<key> ， enumeratorOf<key> 和 memberOf<key>: 消息以创建它的对象。

实际上，与 KVC 兼容的对象一起工作的代理对象允许底层属性表现得好像它是 NSSet，即使它不是。

1.1.4

如果前面都没有找到，且类方法 accessInstanceVariablesDirectly 返回 YES（默认） ，按顺序查找名为

_<key>
_is<key>
<key>
is<key>

的成员变量，如果找到，直接获取实例变量的值并进行步骤5，否则进行步骤6。

验证

1.1.5

如果检索到的属性值是一个对象指针，只需返回结果即可。

如果该值是 NSNumber 支持的基础数据类型，则将其存储在一个 NSNumber 实例中并返回该实例。

如果结果是 NSNumber 不支持的数据类型，则转换为 NSValue 对象并返回。

1.1.6

如果所有其他方法都失败，请调用 valueForUndefinedKey:。默认情况下，这会引发异常，但NSObject的子类可能会提供特定于Key的处理。

1.2 基本 Setter 的搜索过程

setValue:forKey: 的流程按顺序查找方法：

set<key>:
_set<key>

如果找到，调用。

验证方法查找

如果没有找到，如果类方法 accessInstanceVariablesDirectly 返回 YES（默认） ，按顺序寻找一个实例变量与名称类似：

_<key>
_is<key>
<key>
is<key>

如果找到，设置。

验证变量查找

如果找不到，调用 setValue:forUndefinedKey: 。默认情况下，这会引发异常，但 NSObject 的子类可能会提供特定于Key的处理。

二、关于 accessInstanceVariablesDirectly 的思考

控制是否可以通过 KVC 给成员变量赋值，默认 YES。

如果 NO，会怎样呢？

这里给了我一点启发，如果自己封装的一些东西不希望使用者通过 KVC 修改一些私有成员变量的话可以在这里返回 NO。

参考

Key-Value Coding Programming Guide

KVO几个被忽视的细节

Sun, 08 Aug 2021 00:00:00 GMT

前言

Important: In order to understand key-value observing, you must first understand key-value coding.

上面是 KVO 官方文档中的一句重要提醒：重要：为了能理解 KVO ，必须先理解 KVC。

一、 Options

它影响通知中提供的更改字典的内容以及生成通知的方式。

NSKeyValueObservingOptionOld

更改之前的值

NSKeyValueObservingOptionNew

接收新值

您可以通过这些选项的按位 OR 接收旧值和新值。

NSKeyValueObservingOptionInitial

您指示被观察对象使用选项 NSKeyValueObservingOptionInitial 发送立即更改通知（在 addObserver:forKeyPath:options:context:returns 之前）。您可以使用这个额外的一次性通知来获取初始值。

NSKeyValueObservingOptionPrior

您可以通过包含选项 NSKeyValueObservingOptionPrior 指示被观察对象在属性更改之前发送通知（除了更改之后的通常通知之外）。

变更字典通过包含键 NSKeyValueChangeNotificationIsPriorKey 和包含 YES 的 NSNumber 值来表示预更改通知。

二、 Context

[tool.ryuk addObserver:tool forKeyPath:@"name" options:NSKeyValueObservingOptionNew context:NULL];

在平时使用时，我们一般就传个 NULL 但是他到底是做什么的有想过么？

addObserver:forKeyPath:options:context: 消息中的 Context 指针可以包含任意数据，这些数据将在相应的更改通知中传递回观察者。您可以指定 NULL 并完全依赖键路径字符串来确定更改通知的来源，但是这种方法可能会导致对象的父类由于不同原因也在观察相同的键路径时出现问题。

一种更安全、更可扩展的方法是使用 Context 来确保您收到的通知是发送给您的观察者而不是父类的。

类中唯一命名的静态变量的地址是一个很好的 Context 。在父类或子类中以类似方式选择的 Context 不太可能重叠。您可以为整个类选择一个 Context ，并依靠通知消息中的关键路径字符串来确定发生了什么变化。

或者，您可以为每个观察到的键路径创建一个不同的 Context ，这完全绕过了字符串比较，从而提高了通知解析的效率。

创建 Context 指针

static void *PersonAccountBalanceContext = &PersonAccountBalanceContext;
static void *PersonAccountInterestRateContext = &PersonAccountInterestRateContext;

注册观察者

- (void)registerAsObserverForAccount:(Account*)account {
    [account addObserver:self
              forKeyPath:@"balance"
                 options:(NSKeyValueObservingOptionNew |
                          NSKeyValueObservingOptionOld)
                 context:PersonAccountBalanceContext];
 
    [account addObserver:self
              forKeyPath:@"interestRate"
                 options:(NSKeyValueObservingOptionNew |
                          NSKeyValueObservingOptionOld)
                  context:PersonAccountInterestRateContext];
}

三、对可变数组的观察

相对可变数组进行 KVO 很可能会写出这样的代码。但是明显是没用的。这就不得不提文章开始的那句官方提示 重要：为了能理解 KVO ，必须先理解 KVC。

访问集合属性 Accessing Collection Properties

为了使可变集合内部的变化，能够被监听到需要调整一下 API

mutableArrayValueForKey: and mutableArrayValueForKeyPath:
- return NSMutableArray
mutableSetValueForKey: and mutableSetValueForKeyPath:
- return NSMutableSet
mutableOrderedSetValueForKey: and mutableOrderedSetValueForKeyPath:
- return NSMutableOrderedSet

四、 KVO 开关控制

如果你写了一个库，不希望内部的一些属性被监听到。有没有办法阻止掉呢？

+ (BOOL)automaticallyNotifiesObserversForKey:(NSString *)key;

系统提供了上面的方法，默认是返回 YES，即：所有属性都可以被监听。如果你不希望部分或者全部被监听可以返回 NO。

4.1 全部禁止

没有触发变动的通知

4.2 部分禁止

name 的通知没有触发，books 的通知正常触发了。

4.3 禁止后手动发送通知

虽然 automaticallyNotifiesObserversForKey 禁止了通知，但是手动触发后依旧可以正常监听到

参考

KVO底层原理

Sun, 08 Aug 2021 00:00:00 GMT

一、中间类

一般提到 KVO 底层，大家可能都知道是生成类一个 NSKVONotifying_XXX 的类。但是再往深了问可能就答不出来了。

1.1 中间类是动态生成的还是编译生成的？

在设置观察者之前我们通过调用 objc_getClass("NSKVONotifying_RYModel")，看能否获取到 NSKVONotifying_RYModel 类。

添加观察者之后

***结论：***可见 NSKVONotifying_RYModel 确实是动态生成的，而不是编译完成后就已经存在的。

1.2 中间类和本类的关系

先猜测 NSKVONotifying_RYModel 是否是 RYModel 的子类，来验证一下。

打印自己与所有子类

- (void)logSubClassChain:(Class)cls {
    int count = objc_getClassList(NULL, 0);
    
    NSMutableArray *tempArr = @[cls].mutableCopy;
    Class *classes = (Class*)malloc(sizeof(Class) * count);
    objc_getClassList(classes, count);
    for (int i = 0; i < count; i++) {
        if (cls == class_getSuperclass(classes[i])) {
            [tempArr addObject:classes[i]];
        }
    }
    free(classes);
    NSLog(@"Classes : %@", tempArr);
}

发现添加观察者后输出的多了一个 NSKVONotifying_RYModel 证明了它确实是 RYModel 的子类

***结论：***KVO动态创建的类是本类的一个子类。

1.3 中间类的生命周期是怎样的？是否会移除？

***结论：***移除观察者，观察者释放后并不会 NSKVONotifying_XXX 页依旧存在。

***思考：***由于中间类一旦生成就一直存在，所以理论上也不宜过多使用 KVO。

1.4 中间类的方法列表和本类有什么区别？

添加打印方法的方法：

+ (void)logAllMethodOf:(Class)cls {
    NSLog(@"%s %@", __func__, cls);
    unsigned int count = 0;
    Method *methodList = class_copyMethodList(cls, &count);
    for (int i = 0; i < count; i++) {
        Method method = methodList[i];
        SEL sel = method_getName(method);
        IMP imp = method_getImplementation(method);
        NSLog(@"SEL: %@ IMP: %p", NSStringFromSelector(sel), imp);
    }
    free(methodList);
    NSLog(@"\n");
}

RYModel

SEL: name IMP: 0x100003210
SEL: .cxx_destruct IMP: 0x1000032a0
SEL: setName: IMP: 0x100003170
SEL: books IMP: 0x100003240
SEL: setBooks: IMP: 0x100003260

NSKVONotifying_RYModel

SEL: setBooks: IMP: 0x7fff212b9d2e
SEL: setName: IMP: 0x7fff212b9d2e
SEL: class IMP: 0x7fff2127cc06
SEL: dealloc IMP: 0x7fff212bf9f5
SEL: _isKVOA IMP: 0x7fff213e3e3a

1.5 中间类的方法是继承的还是重写的？

新建一个子类，重写父类的方法：

@implementation RYSubModel

- (void)setBooks:(NSMutableArray<NSString *> *)books {
    [super setBooks:books];
}

@end

输出：

// 子类
+[KVOTool logAllMethodOf:] RYSubModel
SEL: setBooks: IMP: 0x100003240

// 本类
添加观察者之前：RYModel
+[KVOTool logAllMethodOf:] RYModel
SEL: name IMP: 0x100003160
SEL: .cxx_destruct IMP: 0x1000031f0
SEL: setName: IMP: 0x1000030c0
SEL: books IMP: 0x100003190
SEL: setBooks: IMP: 0x1000031b0

// 中间类
添加观察者之后：NSKVONotifying_RYModel
+[KVOTool logAllMethodOf:] NSKVONotifying_RYModel
SEL: setBooks: IMP: 0x7fff212b9d2e
SEL: setName: IMP: 0x7fff212b9d2e
SEL: class IMP: 0x7fff2127cc06
SEL: dealloc IMP: 0x7fff212bf9f5
SEL: _isKVOA IMP: 0x7fff213e3e3a

1.6 KVO 开关对方法列表的影响

+ (BOOL)automaticallyNotifiesObserversForKey:(NSString *)key {
    if ([key isEqualToString:@"name"]) {
        return NO;
    }
    return YES;
}

停止 name 自动发送通知后，中间类的方法列表中就没有类 setName。

二、 ISA 指向变换

上面我们知道被观察的对象类型变成类一个中间类。那么它是怎么变的呢？

2.1 改变

添加观察者之前

添加观察者之后

很明显实例的 ISA 的指向发生了变化。

2.2 恢复

开始移除观察者：

移除最后一个观察者：

观察者全部移除：

恢复了 RYModel

思考：全部Key移除了观察者才ISA恢复的本类，如果不完全移除呢？

剩了一个 Key 没有移除观察者

到最后实例的 ISA 指向还是中间类。

三、触发通知的过程

我们在 KVO 通知接收的地方下个断点，调用堆栈：

tool.ryuk.name = @"Ryukie";
- Foundation`_NSSetObjectValueAndNotify
  - Foundation`-[NSObject(NSKeyValueObservingPrivate) _changeValueForKey:key:key:usingBlock:]
    - Foundation`-[NSObject(NSKeyValueObservingPrivate) _changeValueForKeys:count:maybeOldValuesDict:maybeNewValuesDict:usingBlock:]
      - Foundation`NSKeyValueDidChange
        
        Foundation`NSKeyValueNotifyObserver
        
        -[KVOTool observeValueForKeyPath:ofObject:change:context:]

总结

到此，我们知道了

使用 KVO 过程中动态生成了中间类
中间类和本类是继承关系，同时重写了本类的一些方法
自动监听开关对与中间类的结构是有影响的
被观察者 ISA 的指向会发生变化，完全移除所有观察Key后会恢复。

快速排序

Sat, 07 Aug 2021 00:00:00 GMT

一、什么是快速排序

快速排序由C. A. R. Hoare在1962年提出。它的基本思想是：通过一趟排序将要排序的数据分割成独立的两部分，其中一部分的所有数据都比另外一部分的所有数据都要小，然后再按此方法对这两部分数据分别进行快速排序，整个排序过程可以递归进行，以此达到整个数据变成有序序列。

二、核心流程

选取一个基准元素
以该元素为基准，将比该元素大的放到右侧，小的放在左侧，从而一趟排序就可以确定基准元素的位置
对左右两个分块重复上面的步骤（递归）
直到所有元素都是有序的

三、流程图

来自：MOBIN

四、方案一：辅助空间

func quickSort<T: Comparable>(_ arr: [T]) -> [T] {
    guard let base = arr.first, arr.count > 1 else {
        return arr
    }
    
    var left: [T] = []
    var right: [T] = []
    var result: [T] = []

    for index in 1..<arr.count {
        let value = arr[index]
        if value < base {
            left.append(value)
        }
        else {
            right.append(value)
        }
    }
    
    print("left = \(left)   right = \(right) ")
    
    result = quickSort(left)
    result.append(base)
    result.append(contentsOf: quickSort(right))
    
    return result
}

MethodSwizzing方法交换的坑

Sat, 07 Aug 2021 00:00:00 GMT

前言

MethodSwizzing 方法交换是比较常用的所谓 黑魔法。但正如武侠小说中的绝世武功一般，也存在使用不恰当发生 伤敌一千，自损八百 的情况。

本文就带你来探索一下其中的坑，避免走火入魔。

一、 MethodSwizzingTool

为了方便，我们封装一下常规的方法交换逻辑

@implementation MethodSwizzingTool

+ (void)swizzingClass:(Class)cls oldSEL:(SEL)oldSel toNewSel:(SEL)newSel {
    if (!cls) { return; }
    Method oldM = class_getInstanceMethod(cls, oldSel);
    Method newM = class_getInstanceMethod(cls, newSel);
    method_exchangeImplementations(oldM, newM);
}

@end

1.1 验证是否有效

@implementation RYModel

+(void)load {
    static dispatch_once_t onceToken;
    dispatch_once(&onceToken, ^{
        [MethodSwizzingTool swizzingClass:self oldSEL:@selector(functionA) toNewSel:@selector(functionB)];
    });
}

- (void)functionA {
    NSLog(@"%s", __func__);
}

- (void)functionB {
    NSLog(@"%s", __func__);
    [self functionB];
}

@end

调用：

RYModel *ry = [[RYModel alloc] init];
[ry functionA];

输出：

2021-08-07 17:01:53.954201+0800 MethodSwizzing[72309:15057493] -[RYModel functionB]
2021-08-07 17:01:53.954534+0800 MethodSwizzing[72309:15057493] -[RYModel functionA]

嗯～感觉封装的没问题。

二、子类的坑

2.1 用自类方法替换父类方法，会怎样？

思考：

在子类 RYSubModel 中用 子类 的 subFunctionA 替换 父类 的 functionA ，子类实例和父类实例分别调用 functionA 会是什么样的结果呢？（父类中未做交换）

子类代码如下：

@implementation RYSubModel

+ (void)load {
    static dispatch_once_t onceToken;
    dispatch_once(&onceToken, ^{
        [MethodSwizzingTool swizzingClass:self oldSEL:@selector(functionA) toNewSel:@selector(subFunctionA)];
    });
}

- (void)subFunctionA {
    NSLog(@"%s", __func__);
}

@end

调用：

RYModel *ry = [[RYModel alloc] init];
[ry functionA];

RYSubModel *sub = [[RYSubModel alloc] init];
[sub functionA];

输出：

2021-08-07 17:10:37.990097+0800 MethodSwizzing[72705:15063434] -[RYSubModel subFunctionA]
2021-08-07 17:10:37.990530+0800 MethodSwizzing[72705:15063434] -[RYSubModel subFunctionA]

分析

用子类中的方法 subFunctionA 替换父类中的方法 functionA， functionA 的实现变成了 subFunctionA。

2.2 调用原实现

一般我们交换方法后想要继续调用原本的实现一般会如上文中functionB那样调用一下自己。

那么我们在用子类中的方法 subFunctionA 替换了父类中的方法 functionA 后想要继续调用 functionA 同理应该这么写：

- (void)subFunctionA {
    [self subFunctionA];
    NSLog(@"%s", __func__);
}

调用：

RYModel *ry = [[RYModel alloc] init];
[ry functionA];

RYSubModel *sub = [[RYSubModel alloc] init];
[sub functionA];

输出：

为什么呢？居然找不到了

分析

我们在用子类中的方法 subFunctionA 替换了父类中的方法 functionA 后

父类中：

functionA 调用 subFunctionA

但是父类本身方法列表中并没有 subFunctionA ，所以父类就报了 unrecognized selector 的错误。

修改调用

如果我们只调用子类：

RYSubModel *sub = [[RYSubModel alloc] init];
[sub functionA];

输出：

2021-08-07 17:33:28.874108+0800 MethodSwizzing[73690:15075457] -[RYModel functionA]
2021-08-07 17:33:28.874564+0800 MethodSwizzing[73690:15075457] -[RYSubModel subFunctionA]

这里就是正常的

三、优化 MethodSwizzingTool

我们能不能优化 MethodSwizzingTool 来防止这样的问题出现呢？

可以！

3.1 优化思路

出现上面找不到方法的原因是：子类用自己的实现直接替换了父类的方法
那么我们能不能为子类动态添加一个和父类一样的方法呢？子类中进行替换的时候就不会影响父类了

3.2 编写优化代码

+ (void)swizzingClassB:(Class)cls oldSEL:(SEL)oldSel toNewSel:(SEL)newSel {
    if (!cls) { return; }
    Method oldM = class_getInstanceMethod(cls, oldSel);
    Method newM = class_getInstanceMethod(cls, newSel);
    
    // 先尝试给 cls 添加方法（SEL: oldSel  IMP: newM），防止子类直接替换父类中的方法
    BOOL addSuccess = class_addMethod(cls, oldSel, method_getImplementation(newM), method_getTypeEncoding(oldM));
    
    if (addSuccess) { // 添加成功即：原本没有 oldSel，成功为子类添加了一个 oldSel - newM 的方法
        // 这里将原 newSel的imp替换为 oldM 的 IMP
        class_replaceMethod(cls, newSel, method_getImplementation(oldM), method_getTypeEncoding(oldM));
    }
    else {
        method_exchangeImplementations(oldM, newM);
    }
}

3.3 优化代码流程分析

本案例子类调用流程分析：

调用方法，准备用子类中的方法 subFunctionA 替换的方法 functionA
Method oldM 是从父类获取到的方法 （SEL: functionA, IMP: functionA）
Method newM 是从子类自己获取到的方法 （SEL: subFunctionA, IMP: subFunctionA）
是否可以成功添加方法：（SEL: functionA, IMP: subFunctionA）
- 否：已存在 SEL: functionA 的方法
- 是：不存在 SEL: functionA 的方法
  - 将子类的 （SEL: subFunctionA, IMP: subFunctionA） 替换为 （SEL: subFunctionA, IMP: functionA）

父类实例
- [ry functionA]
- 调用没有受子类方法交换的影响
子类实例
- [sub functionA]
- 没有出现父类调用找不到方法的情况

四、父类的 functionA 也没有实现呢？

4.1 分析

由于并不存在 functionA 的实现，所以这里的替换方法并没有成功。 subFunctionA 的调用就直接递归死循环了。

4.2 再优化

通过设置默认实现的方式来避免死循环，新实现也为空的情景可以类似处理，这里就不赘述了。

+ (void)swizzingClassB:(Class)cls oldSEL:(SEL)oldSel toNewSel:(SEL)newSel {
    if (!cls) { return; }
    Method oldM = class_getInstanceMethod(cls, oldSel);
    Method newM = class_getInstanceMethod(cls, newSel);
    
    if (!oldM) {
        // 先用新的实现来，临时添加一个（这里忽略新实现也为空的情况，可以类似的处理）
        class_addMethod(cls, oldSel, method_getImplementation(newM), method_getTypeEncoding(newM));
        // 对 oldM 变量重新赋值
        oldM = class_getInstanceMethod(cls, oldSel);
        // 创建默认实现，可以进行一些日志收集之类的
        IMP defaultIMP = imp_implementationWithBlock(^(id self, SEL _cmd){
            NSLog(@"一些处理");
        });
        // 为 oldM 设置 IMP
        method_setImplementation(oldM, defaultIMP);
    }
    
    // 先尝试给 cls 添加方法（SEL: oldSel  IMP: newM），防止子类直接替换父类中的方法
    BOOL addSuccess = class_addMethod(cls, oldSel, method_getImplementation(newM), method_getTypeEncoding(oldM));
    
    if (addSuccess) { // 添加成功即：原本没有 oldSel，成功为子类添加了一个 oldSel - newM 的方法
        // 这里将原 newSel的imp替换为 oldM 的 IMP
        class_replaceMethod(cls, newSel, method_getImplementation(oldM), method_getTypeEncoding(oldM));
    }
    else {
        method_exchangeImplementations(oldM, newM);
    }
}

总结

黑魔法虽好，使用也得倍加小心！

尤其要对方法的本质以及方法调用的流程烂熟于心才能随心所欲，内功到家，进阶武功才不会伤及自身。

Form

Sat, 07 Aug 2021 00:00:00 GMT

Form相较于List更适合用于类似设置页面这样的场景下面的图和代码可以直观感受一下

01.Form预览

02.List预览

03.List Group 预览

04.修改背景色

想要修改Form的背景色，第一反应会这样写：

Form {
    Section {
        Text("VIP")
    }

    Section {
        Text("Coin")
    }
}
.background(Color.red)
.scaledToFill()

然鹅并没有效果

为什么呢？

实际上Form是基于TableView的。这里需要进行以下操作：

init() {
        UITableView.appearance().backgroundColor = .clear
    }

05.隐藏滑块

依旧需要通过UITableView实现，可见现在SwiftUI完成度还不高。总是通过使用UIKit来进行一些常用属性的设置。

init() {
        UITableView.appearance().showsVerticalScrollIndicator = false
    }

Navigation

Sat, 07 Aug 2021 00:00:00 GMT

LargeTitle

默认情况下，在SwiftUI中创建的Navigation都是开启LargeTitle样式的。如果不想使用改样式可以用过下面的方式调整：

var body: some View {
        Form {
            Section {
                Text("Hello World 1")
                Text("Hello World 2")
                Text("Hello World 3")
                Text("Hello World 4")
                Text("Hello World 5")
            }
        }
        .navigationBarTitle("Add pose", displayMode: .large)
    }

隐藏导航栏

.navigationBarHidden(true)

ViewBuilder参数10个限制

Sat, 07 Aug 2021 00:00:00 GMT

看看下面的代码，发现当ViewBuilder中超过10个元素的时候会报错，10个就没问题，代码逻辑本身是没问题的具体可以看下下面的文档，其实是将参数的个数做了限制

Apple文档：ViewBuilder

static func buildBlock<C0, C1, C2, C3, C4, C5, C6, C7, C8, C9>(C0, C1, C2, C3, C4, C5, C6, C7, C8, C9) -> TupleView<(C0, C1, C2, C3, C4, C5, C6, C7, C8, C9)>

不清楚苹果这样做的具体原因，但这样可以强迫咱们注意封装拆分。强行解释一波<_<

UIKit混编时Dismiss掉HostController

Sat, 07 Aug 2021 00:00:00 GMT

场景：在主UIKit的项目中Present出一个包含SwiftUI的UIHostingController 当需要Dismiss该控制器的时候遇到了麻烦

一：在SwiftUI中Dismiss一个页面的正常操作

下面的实现方式在正常的SwiftUI体系下是可以正常工作的但是在UIKit混编时就失效了

struct ContentView: View, SwiftUIBridgeProtocol {
    @Environment(\.presentationMode) var presentationMode: Binding<PresentationMode>
    
    var body: some View {
        ZStack {
            VStack {
                StoreTopView(dismissClosure: {
                    presentationMode.wrappedValue.dismiss()
                })
                .padding()
            }
        }
    }
}

我们看下打印的信息：

(lldb) po presentationMode
▿ Binding<PresentationMode>
  ▿ transaction : Transaction
    ▿ plist : []
      - elements : nil
  ▿ location : <LocationBox<FunctionalLocation<PresentationMode>>: 0x2838313c0>
  ▿ _value : PresentationMode
    - isPresented : false

(lldb) po presentationMode.wrappedValue
▿ PresentationMode
  - isPresented : false

二：如何才能获取到`HostController`呢

方案1. 一些方案

下面的文正提供了一些尝试的方案，但不够SwiftUI风格

Controlling UIHostingController with SwiftUI View

方案2.@Environment

通过一段时间的SwiftUI学习，发现通过@Environment可以获取到很多当前页面的一些有用信息。但是通过观察可用的字段并没有发现有关HostController的线索。

那是否可以添加自定义字段呢？

可以！查看EnvironmentKey相关的文档或者注释我们可以发现，其中已经提供了自定义的示例代码：

You can create custom environment values by extending the EnvironmentValues structure with new properties. First declare a new environment key type and specify a value for the required defaultValue property:

private struct MyEnvironmentKey: EnvironmentKey {
    static let defaultValue: String = "Default value"
}

The Swift compiler automatically infers the associated Value type as the type you specify for the default value. Then use the key to define a new environment value property:

extension EnvironmentValues {
    var myCustomValue: String {
        get { self[MyEnvironmentKey.self] }
        set { self[MyEnvironmentKey.self] = newValue }
    }
}

Clients of your environment value never use the key directly. Instead, they use the key path of your custom environment value property. To set the environment value for a view and all its subviews, add the environment(::) view modifier to that view:

MyView()
    .environment(\.myCustomValue, "Another string")

As a convenience, you can also define a dedicated view modifier to apply this environment value:

extension View {
    func myCustomValue(_ myCustomValue: String) -> some View {
        environment(\.myCustomValue, myCustomValue)
    }
}

This improves clarity at the call site:

MyView()
    .myCustomValue("Another string")

To read the value from inside MyView or one of its descendants, use the Environment property wrapper:

struct MyView: View {
    @Environment(\.myCustomValue) var customValue: String

    var body: some View {
        Text(customValue) // Displays "Another value".
    }
}

三：下面按照上面的思路实现一下

3.1 用以承载`ViewController`的容器

public struct ViewControllerHolder {
    public weak var value: UIViewController?
    init(_ value: UIViewController?) {
        self.value = value
    }
}

3.2 EnvironmentKey

public struct ViewControllerKey: EnvironmentKey {
    public static var defaultValue: ViewControllerHolder { return ViewControllerHolder(nil) }
}

3.3 Extension

extension EnvironmentValues {
    public var viewController: ViewControllerHolder {
        get { return self[ViewControllerKey.self] }
        set { self[ViewControllerKey.self] = newValue }
    }
}

3.4 打开页面


extension UIViewController {
    public func present<Content: View>(presentationStyle: UIModalPresentationStyle = .automatic, transitionStyle: UIModalTransitionStyle = .coverVertical, animated: Bool = true, completion: @escaping () -> Void = {}, @ViewBuilder builder: () -> Content) {
        let toPresent = UIHostingController(rootView: AnyView(EmptyView()))
        toPresent.modalPresentationStyle = presentationStyle
        toPresent.rootView = AnyView(
            builder()
                .environment(\.viewController, ViewControllerHolder(toPresent))
        )
        if presentationStyle == .overCurrentContext {
            toPresent.view.backgroundColor = .clear
        }
        self.present(toPresent, animated: animated, completion: completion)
    }
}

3.5 关闭页面

struct ShopContentView: View {
...
    // MARK: - Body
    var body: some View {
        ZStack(alignment: .top) {
            ...
            viewControllerHolder.value?.dismiss(animated: false, completion: nil)
            ...
        })
    }
    
...
    // MARK: -  Var: Environment
    @Environment(\.viewController) var viewControllerHolder
...
}

3.6 SwiftUIEx

这里进行了封装SwiftUIEx，觉得有用欢迎留下一颗⭐️~

思考

通过@Environment实现Dismiss，了解了其更灵活的使用方式。也为解决之后开发中遇到的问题提供了一点思路。同时也使解决方式更加SwiftUI风格

如何在SwiftUI中使用ImagePicker？

Sat, 07 Aug 2021 00:00:00 GMT

一：问题

我的新项目中尝试性的使用了SwiftUI进行了一部分功能的构建。但当我需要访问相册选择图片的时候，缺犯难了。报出了下面的错误: 因为原有的一些代理需要要求NSObjectProtocol而我们SwifUI中的视图用的是Struct 而系统并没有提供在SwiftUI下调用相册的相关API，所以这里只能考虑自己去封装了。

二：SwiftUIImagePicker

struct SwiftUIImagePicker {
    @Environment(\.presentationMode) var presentationMode
    @Binding var image: UIImage?
}

extension SwiftUIImagePicker: UIViewControllerRepresentable {
    func makeUIViewController(context: Context) -> some UIViewController {
        let picker = UIImagePickerController()
                return picker
    }
    
    func updateUIViewController(_ uiViewController: UIViewControllerType, context: Context) {
        
    }
}

2.1 UIViewControllerRepresentable

这里使用了UIViewControllerRepresentable，我们的SwiftUIImagePicker就已经是一个标准的SwiftUI的View了。

当创建一个SwiftUIImagePicker，SwiftUI会自动调用makeUIViewController()并返回一个UIImagePickerController.

2.2 Coordinator 代理中间件

由于SwiftUIImagePicker作为一个SwiftUI的View依旧不能使用NSObjectProtocol，所以我们需要一个中间件来完成代理。

UIViewControllerRepresentable中贴心的提供了这样一个中间件的定义，我们只要提供实现即可~

/// A type to coordinate with the view controller.
    associatedtype Coordinator = Void

    /// Creates the custom instance that you use to communicate changes from
    /// your view controller to other parts of your SwiftUI interface.
    ///
    /// Implement this method if changes to your view controller might affect
    /// other parts of your app. In your implementation, create a custom Swift
    /// instance that can communicate with other parts of your interface. For
    /// example, you might provide an instance that binds its variables to
    /// SwiftUI properties, causing the two to remain synchronized. If your view
    /// controller doesn't interact with other parts of your app, providing a
    /// coordinator is unnecessary.
    ///
    /// SwiftUI calls this method before calling the
    /// ``UIViewControllerRepresentable/makeUIViewController(context:)`` method.
    /// The system provides your coordinator either directly or as part of a
    /// context structure when calling the other methods of your representable
    /// instance.
    func makeCoordinator() -> Self.Coordinator

我们来实现一下下：

internal func makeCoordinator() -> SwiftUIImagePickerCoordinator {
    SwiftUIImagePickerCoordinator(self)
}

顺便实现一下选择完图片的代理方法吧：

func imagePickerController(_ picker: UIImagePickerController, didFinishPickingMediaWithInfo info: [UIImagePickerController.InfoKey : Any]) {
    if let uiImage = info[.originalImage] as? UIImage {
        parent.image = uiImage
    }
    parent.presentationMode.wrappedValue.dismiss()
}

别忘了设置一下代理：

picker.delegate = context.coordinator

三：参考

Importing an image into SwiftUI using UIImagePickerController

从some看Swift不透明类型

Sat, 07 Aug 2021 00:00:00 GMT

Hi 👋

Wechat: RyukieW
📦 技术文章归档
🐙 Github

我的个人项目	扫雷Elic 无尽天梯	梦见账本
类型	游戏	财务
AppStore	Elic	Umemi

一、我遇到的问题

今天在写一个 SwiftUI 的demo的时候，准备用一个 枚举 来作为列表的数数据源。

1.1 列表的主体

struct ContentView: View {
    var body: some View {
        NavigationView {
            Form {
                ForEach(ContentTypes.allCases, content: { item in
                    NavigationLink(destination: item.destinationView) {
                        Text(item.rawValue)
                    }
                })
            }
            .navigationBarTitle("SwiftUITourDemos", displayMode: .automatic)
        }
    }
}

1.2 枚举

enum ContentTypes: String, CaseIterable, Identifiable {
    var id: String { rawValue }
    
    case StateAndStructClass = "@State & struct/class"

    var destinationView: View {
        switch self {
        case .StateAndStructClass:
            return StateAndStructClassView()
        }
    }
}

1.3 问题

代码乍一看好像没什么问题，然而：

Protocol 'View' can only be used as a generic constraint because it has Self or associated type requirements

一个使用协议时 protocol 经典的报错。

1.4 View 是什么

通过点进 View 的定义，可以看到，它是一个协议。

二、解决问题

在 SwiftUI 默认生产的代码中有这样一段

既然这里的 body (View协议中定义的) 是用 some View 来做为类型，那么我在 ContentTypes 的 destinationView 是否也可以使用 some View 呢？

2.1 试一试

诶嘿～可以了

那么 some 究竟是什么呢？它代表 不透明类型，通常与协议搭配使用。其实并不是 SwiftUI 的特性，而是 Swift 的特性。只不过是我平时没见过而已😂。

三、不透明类型

具有不透明返回类型的函数或方法会隐藏返回值的类型信息。函数不再提供具体的类型作为返回类型，而是根据它支持的协议来描述返回值。在处理模块和调用代码之间的关系时，隐藏类型信息非常有用，因为返回的底层数据类型仍然可以保持私有。而且不同于返回协议类型，不透明类型能保证类型一致性：编译器能获取到类型信息，同时模块使用者却不能获取到。

3.1 需要解决的问题

举个例子，假设你正在写一个模块，用来绘制 ASCII 符号构成的几何图形。它的基本特征是有一个 draw() 方法，会返回一个代表最终几何图形的字符串，你可以用包含这个方法的 Shape 协议来描述：

protocol Shape {
    func draw() -> String
}

struct Triangle: Shape {
    var size: Int
    func draw() -> String {
        var result: [String] = []
        for length in 1...size {
            result.append(String(repeating: "*", count: length))
        }
        return result.joined(separator: "\n")
    }
}
let smallTriangle = Triangle(size: 3)
print(smallTriangle.draw())

你可以利用泛型来实现垂直翻转之类的操作，就像下面这样。然而，这种方式有一个很大的局限：翻转操作的结果会暴露我们用于构造结果的泛型类型：

struct FlippedShape<T: Shape>: Shape {
    var shape: T
    func draw() -> String {
        let lines = shape.draw().split(separator: "\n")
        return lines.reversed().joined(separator: "\n")
    }
}
let flippedTriangle = FlippedShape(shape: smallTriangle)
print(flippedTriangle.draw())

如下方代码所示，用同样的方式定义了一个 JoinedShape<T: Shape, U: Shape> 结构体，能将几何图形垂直拼接起来。如果拼接一个翻转三角形和一个普通三角形，它就会得到类似于 JoinedShape<FlippedShape<Triangle>, Triangle> 这样的类型。

struct JoinedShape<T: Shape, U: Shape>: Shape {
    var top: T
    var bottom: U
    func draw() -> String {
        return top.draw() + "\n" + bottom.draw()
    }
}
let joinedTriangles = JoinedShape(top: smallTriangle, bottom: flippedTriangle)
print(joinedTriangles.draw())

暴露构造所用的具体类型会造成类型信息的泄露，因为 ASCII 几何图形模块的部分公开接口必须声明完整的返回类型，而实际上这些类型信息并不应该被公开声明。输出同一种几何图形，模块内部可能有多种实现方式，而外部使用时，应该与内部各种变换顺序的实现逻辑无关。诸如 JoinedShape 和 FlippedShape 这样包装后的类型，模块使用者并不关心，它们也不应该可见。模块的公开接口应该由拼接、翻转等基础操作组成，这些操作也应该返回独立的 Shape 类型的值。

3.2 返回不透明类型

你可以认为不透明类型和泛型相反。泛型允许调用一个方法时，为这个方法的形参和返回值指定一个与实现无关的类型。举个例子，下面这个函数的返回值类型就由它的调用者决定：

func max<T>(_ x: T, _ y: T) -> T where T: Comparable { ... }

x 和 y 的值由调用 max(_:_:) 的代码决定，而它们的类型决定了 T 的具体类型。调用代码可以使用任何遵循了 Comparable 协议的类型，函数内部也要以一种通用的方式来写代码，才能应对调用者传入的各种类型。max(_:_:) 的实现就只使用了所有遵循 Comparable 协议的类型共有的特性。

而在返回不透明类型的函数中，上述角色发生了互换。不透明类型允许函数实现时，选择一个与调用代码无关的返回类型。比如，下面的例子返回了一个梯形，却没直接输出梯形的底层类型：

struct Square: Shape {
    var size: Int
    func draw() -> String {
        let line = String(repeating: "*", count: size)
        let result = Array<String>(repeating: line, count: size)
        return result.joined(separator: "\n")
    }
}

func makeTrapezoid() -> some Shape {
    let top = Triangle(size: 2)
    let middle = Square(size: 2)
    let bottom = FlippedShape(shape: top)
    let trapezoid = JoinedShape(
        top: top,
        bottom: JoinedShape(top: middle, bottom: bottom)
    )
    return trapezoid
}
let trapezoid = makeTrapezoid()
print(trapezoid.draw())

这个例子中，makeTrapezoid() 函数将返回值类型定义为 some Shape；因此，该函数返回遵循 Shape 协议的给定类型，而不需指定任何具体类型。这样写 makeTrapezoid() 函数可以表明它公共接口的基本性质：返回的是一个几何图形，而不是部分的公共接口生成的特殊类型。上述实现过程中使用了两个三角形和一个正方形，还可以用其他多种方式重写画梯形的函数，都不必改变返回类型。

这个例子凸显了不透明返回类型和泛型的相反之处。makeTrapezoid() 中代码可以返回任意它需要的类型，只要这个类型是遵循 Shape 协议的，就像调用泛型函数时可以使用任何需要的类型一样。这个函数的调用代码需要采用通用的方式，就像泛型函数的实现代码一样，这样才能让 makeTrapezoid() 返回的任何 Shape 类型的值都能被正常使用。

你也可以将不透明返回类型和泛型结合起来，下面的两个泛型函数也都返回了遵循 Shape 协议的不透明类型。

func flip<T: Shape>(_ shape: T) -> some Shape {
    return FlippedShape(shape: shape)
}
func join<T: Shape, U: Shape>(_ top: T, _ bottom: U) -> some Shape {
    JoinedShape(top: top, bottom: bottom)
}

let opaqueJoinedTriangles = join(smallTriangle, flip(smallTriangle))
print(opaqueJoinedTriangles.draw())

这个例子中 opaqueJoinedTriangles 的值和前文中关于泛型的那个例子中的 joinedTriangles 完全一样。不过和前文不一样的是，flip(-:) 和 join(-:-:) 将对泛型参数的操作后的返回结果包装成了不透明类型，这样保证了在结果中泛型参数类型不可见。两个函数都是泛型函数，因为他们都依赖于泛型参数，而泛型参数又将 FlippedShape 和 JoinedShape 所需要的类型信息传递给它们。

如果函数中有多个地方返回了不透明类型，那么所有可能的返回值都必须是同一类型。即使对于泛型函数，不透明返回类型可以使用泛型参数，但仍需保证返回类型唯一。比如，下面就是一个非法示例 —— 包含针对 Square 类型进行特殊处理的翻转函数。

func invalidFlip<T: Shape>(_ shape: T) -> some Shape {
    if shape is Square {
        return shape // 错误：返回类型不一致
    }
    return FlippedShape(shape: shape) // 错误：返回类型不一致
}

如果你调用这个函数时传入一个 Square 类型，那么它会返回 Square 类型；否则，它会返回一个 FlippedShape 类型。这违反了返回值类型唯一的要求，所以 invalidFlip(_:) 不正确。修正 invalidFlip(_:) 的方法之一就是将针对 Square 的特殊处理移入到 FlippedShape 的实现中去，这样就能保证这个函数始终返回 FlippedShape：

struct FlippedShape<T: Shape>: Shape {
    var shape: T
    func draw() -> String {
        if shape is Square {
            return shape.draw()
        }
        let lines = shape.draw().split(separator: "\n")
        return lines.reversed().joined(separator: "\n")
    }
}

返回类型始终唯一的要求，并不会影响在返回的不透明类型中使用泛型。比如下面的函数，就是在返回的底层类型中使用了泛型参数：

func `repeat`<T: Shape>(shape: T, count: Int) -> some Collection {
    return Array<T>(repeating: shape, count: count)
}

这种情况下，返回的底层类型会根据 T 的不同而发生变化：但无论什么形状被传入，repeat(shape:count:) 都会创建并返回一个元素为相应形状的数组。尽管如此，返回值始终还是同样的底层类型 [T]，所以这符合不透明返回类型始终唯一的要求。

3.3 不透明类型和协议类型的区别

虽然使用不透明类型作为函数返回值，看起来和返回协议类型非常相似，但这两者有一个主要区别，就在于是否需要保证类型一致性。一个不透明类型只能对应一个具体的类型，即便函数调用者并不能知道是哪一种类型；协议类型可以同时对应多个类型，只要它们都遵循同一协议。总的来说，协议类型更具灵活性，底层类型可以存储更多样的值，而不透明类型对这些底层类型有更强的限定。

比如，这是 flip(_:) 方法不采用不透明类型，而采用返回协议类型的版本：

func protoFlip<T: Shape>(_ shape: T) -> Shape {
    return FlippedShape(shape: shape)
}

这个版本的 protoFlip(_:) 和 flip(_:) 有相同的函数体，并且它也始终返回唯一类型。但不同于 flip(_:)，protoFlip(_:) 返回值其实不需要始终返回唯一类型 —— 返回类型只需要遵循 Shape 协议即可。换句话说，protoFlip(_:) 比起 flip(_:) 对 API 调用者的约束更加松散。它保留了返回多种不同类型的灵活性：

func protoFlip<T: Shape>(_ shape: T) -> Shape {
    if shape is Square {
        return shape
    }

    return FlippedShape(shape: shape)
}

修改后的代码根据代表形状的参数的不同，可能返回 Square 实例或者 FlippedShape 实例，所以同样的函数可能返回完全不同的两个类型。当翻转相同形状的多个实例时，此函数的其他有效版本也可能返回完全不同类型的结果。protoFlip(_:) 返回类型的不确定性，意味着很多依赖返回类型信息的操作也无法执行了。举个例子，这个函数的返回结果就不能用 == 运算符进行比较了。

let protoFlippedTriangle = protoFlip(smallTriangle)
let sameThing = protoFlip(smallTriangle)
protoFlippedTriangle == sameThing  // 错误

上面的例子中，最后一行的错误来源于多个原因。最直接的问题在于，Shape 协议中并没有包含对 == 运算符的声明。如果你尝试加上这个声明，那么你会遇到新的问题，就是 == 运算符需要知道左右两侧参数的类型。这类运算符通常会使用 Self 类型作为参数，用来匹配符合协议的具体类型，但是由于将协议当成类型使用时会发生类型擦除，所以并不能给协议加上对 Self 的实现要求。

将协议类型作为函数的返回类型能更加灵活，函数只要返回遵循协议的类型即可。然而，更具灵活性导致牺牲了对返回值执行某些操作的能力。上面的例子就说明了为什么不能使用 == 运算符 —— 它依赖于具体的类型信息，而这正是使用协议类型所无法提供的。

这种方法的另一个问题在于，变换形状的操作不能嵌套。翻转三角形的结果是一个 Shape 类型的值，而 protoFlip(_:) 方法的则将遵循 Shape 协议的类型作为形参，然而协议类型的值并不遵循这个协议；protoFlip(_:) 的返回值也并不遵循 Shape 协议。这就是说 protoFlip(protoFlip(smallTriange)) 这样的多重变换操作是非法的，因为经过翻转操作后的结果类型并不能作为 protoFlip(_:) 的形参。

相比之下，不透明类型则保留了底层类型的唯一性。Swift 能够推断出关联类型，这个特点使得作为函数返回值，不透明类型比协议类型有更大的使用场景。比如：

protocol Container {
    associatedtype Item
    var count: Int { get }
    subscript(i: Int) -> Item { get }
}
extension Array: Container { }

你不能将 Container 作为方法的返回类型，因为此协议有一个关联类型。你也不能将它用于对泛型返回类型的约束，因为函数体之外并没有暴露足够多的信息来推断泛型类型。

// 错误：有关联类型的协议不能作为返回类型。
func makeProtocolContainer<T>(item: T) -> Container {
    return [item]
}

// 错误：没有足够多的信息来推断 C 的类型。
func makeProtocolContainer<T, C: Container>(item: T) -> C {
    return [item]
}

而使用不透明类型 some Container 作为返回类型，就能够明确地表达所需要的 API 契约 —— 函数会返回一个集合类型，但并不指明它的具体类型：

func makeOpaqueContainer<T>(item: T) -> some Container {
    return [item]
}
let opaqueContainer = makeOpaqueContainer(item: 12)
let twelve = opaqueContainer[0]
print(type(of: twelve))
// 输出 "Int"

twelve 的类型可以被推断出为 Int，这说明了类型推断适用于不透明类型。在 makeOpaqueContainer(item:) 的实现中，底层类型是不透明集合 [T]。在上述这种情况下，T 就是 Int 类型，所以返回值就是整数数组，而关联类型 Item 也被推断出为 Int。Container 协议中的 subscipt 方法会返回 Item，这也意味着 twelve 的类型也被能推断出为 Int。

四、总结

了解了 some 不透明类型 后，突然想起之前遇到的一些协议使用时的问题可以更优雅的解决了。嘿嘿😄

参考

包含min函数的栈（容易被误导的一题）

Thu, 05 Aug 2021 00:00:00 GMT

Hi 👋

Wechat: RyukieW
📦 技术文章归档
🐙 Github

我的个人项目	扫雷Elic 无尽天梯	梦见账本
类型	游戏	财务
AppStore	Elic	Umemi

一、题目

定义栈的数据结构，请在该类型中实现一个能够得到栈的最小元素的 min 函数在该栈中，调用 min、push 及 pop 的时间复杂度都是 O(1)。

示例:

MinStack minStack = new MinStack();
minStack.push(-2);
minStack.push(0);
minStack.push(-3);
minStack.min();   --> 返回 -3.
minStack.pop();
minStack.top();      --> 返回 0.
minStack.min();   --> 返回 -2.

提示：

各函数的调用总次数不超过 20000 次

注意：本题与主站 155 题相同：https://leetcode-cn.com/problems/min-stack/

来源：力扣（LeetCode）

链接：https://leetcode-cn.com/problems/bao-han-minhan-shu-de-zhan-lcof

著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

二、分析

本题难点在于：调用 min、push 及 pop 的时间复杂度都是 O(1)

并且本题很容易走进一个误区：以为MinStack内部是有序的（不要问我为什么知道有这个误区😂）

既然要满足 O(1) 的条件，一个有序集合必定是不可能完成的。

那要不考虑一下使用一个辅助的集合？

2.1 Top & Min

本题的示例对我来说也很有误导性...

通过这个我以为：Top 是最大值，整个 MinStack 是有序的...

然后整个思路就被带偏了🙈

2.2 辅助栈

我们需要准备两个栈 A：存放所有元素 & B：辅助集合。

2.3 push 入栈

每当有元素入栈，正常入 A栈。

然后判断 B栈 的 栈顶元素 是否 >= 当前入栈元素 ，如果满足条件，也将元素入 B栈。

这样就保证了 B栈 的栈顶元素始终是 最小的。

2.4 pop 出栈

A栈 正常出栈，同时对比一下 B栈 的栈顶，如果相等，那么 B栈 也出栈。这样来保证 B栈 与 A栈 的同步性。

2.5 top 栈顶元素

正常返回 A栈 栈顶元素即可。

2.6 min 最小元素

B栈 栈顶既是最小元素。

三、代码

class MinStack {
    
    var elements: [Int] = []
    
    var smaller: [Int] = []
    
    init() {
        
    }
    
    func push(_ x: Int) {
        elements.append(x)
        if smaller.last == nil || smaller.last ?? 0 >= x {
            smaller.append(x)
        }
    }
    
    func pop() {
        if elements.removeLast() == smaller.last {
            smaller.removeLast()
        }
    }
    
    func top() -> Int {
        return elements.last ?? 0
    }
    
    func min() -> Int {
        return smaller.last ?? 0
    }
}

Apple官方资源瘦身方案ODR（二）：践行｜换肤系统改造

Wed, 04 Aug 2021 00:00:00 GMT

前言

如果你还不太清楚 ODR: On-Demand Resources 是什么，可以看看Apple官方资源瘦身方案ODR（一）：初见

既然知道了 ODR 能干什么了，那就拿自己的项目开个刀。

这里使用我的个人项目梦见账本，由于项目中有多套皮肤可以更换，所以存了很多套图标，这些图标就很适合使用 ODR 来优化。

关于 ODR 除了官方文档，也没找到很多实践的资料，这里就结合文档手摸手一起来实践一波吧。

先来个卖家秀

使用 ODR 之前

使用 ODR 之后！

TestFlight 上看的大小，写文这会儿 2.7.1 还没提审发布，不过和真实下载的不会有多少差别。

一、启用ODR

从 iOS9 开始就是默认开启的了

二、创建标签

标签用于识别和管理一组 ODR。将一个或多个标签分配给项目中的资源可将其标识为 ODR。在运行时，所有 ODR 的访问都与标签（而非单个资源）配合工作。

在 Target 的 Resource tags 可以看到添加标签的入口，这里可以选择项目中的资源，以添加到标签下。

项目之前的资源组织方式：

这里为了方便标签管理，进行一下资源包的拆分：

2.1 为 Assets 添加标签

将 Assets 添加到 Tag 下：

2.2 确认资源标签设置成功

打开资源包查看资源信息，就可以看到这里匹配的资源标签了。（一个资源可以设置多个标签）

在构建项目时，Xcode 会检查项目中的所有标记项目，并生成供操作系统使用的资源包。

2.3 为单个资源快速添加标签

也可以通过直接输入联想，快速为单个资源添已有标签，或者快速创建一个标签。

三、标签分类

通过切换到 Prefetched 我们看到了三种分类：

创建的标签的默认类别是仅按需下载ODR。标签可以在类别之间拖动。

***Initial install tags. ***
- 资源与应用程序同时下载。资源的大小包含在应用商店中应用的总大小中。当没有任何 NSBundleResourceRequest 访问时，可能会被清除。
***Prefetch tag order. ***
- 安装应用后，资源开始下载。按标签顺序下载。
***Dowloaded only on demand. ***
- 按需加载。当应用请求时，将下载这些标签。

当操作系统下载标签时，它只会下载设备上没有的资源。

3.1 设置标签分类

设置标签分类很简单，从默认的 ODR 列表中拖到相应的分类下即可。

这里我把默认的两个皮肤的资源设置为：Initial install

四、大小限制

应用剪切后，标签中资源的总大小不得超过 512 MB。应用商店中存储的按需资源的总大小不得超过 20 GB。

标签的理想大小不大于 64 MB。此大小在下载速度和本地存储之间提供了良好的平衡，以便在设备的本地存储处于低位时可以清除。

Slicing.
- 复选标记（✓）表示大小反映的是应用剪切后的大小。
App bundle.
- 下载到设备的剪切后的应用程序包的大小。
Asset packs.
- 资产包由 Xcode 生成。
***Initial install tags. ***
- 标记为初始安装的标记的总剪切后的大小。
***Initial install and prefetched tags.. ***
- 标记为 Initial install 和 Prefetch tag 的资源剪切后的总大小
***In use on-demand resources. ***
- 一次行最多可用 ODR 的剪切后的大小。
***Hosted on-demand resources. ***
- 所有 ODR 大小，不剪切的大小。

五、管理ODR

配置了标签后，直接运行项目。可以看出所有的 ODR 资源均没有下载。

5.1 ODR 更新时机确定

这里先描述下 梦见账本 的换肤逻辑，来帮助确定 ODR 的更新时机:

皮肤分为两种模式：普通模式、暗黑模式。
- 即：用户可以为两种模式分别设置皮肤，切换系统暗黑模式开关即可无缝切换
设置皮肤后会重新设置根控制器
- 这里是需要更新 ODR 的一个节点
另一个检查更新的节点是应用启动的时候
- 检查当前的两种皮肤，准备相关标签的资源

5.1 NSBundleResourceRequest 请求资源

一个标签可以被多个实例管理，下面列举三个重要的 API。

初始化

tags: 标签集合
bundle: 一般是 main

public init(tags: Set<String>, bundle: Bundle)

检查状态

检查请求的标签的资源是否全部都已经在设备中保存了。

open func conditionallyBeginAccessingResources(completionHandler: @escaping (Bool) -> Void)

开始请求资源

请求不在本地的标签资源。

open func beginAccessingResources(completionHandler: @escaping (Error?) -> Void)

六、改造「梦见账本」

6.1 封装 OdrTool

protocol OdrTagProtocol {
    var tagName: String { get }
}

struct OdrTool {
    static func requestODR(of tags: OdrTagProtocol..., in bundle: Bundle = Bundle.main) {
        var tagsSet: Set<String> = []
        tags.forEach { tagsSet.insert($0.tagName) }
        let request = NSBundleResourceRequest(tags: tagsSet, bundle: bundle)
        request.conditionallyBeginAccessingResources { hasCache in
            if hasCache == false {
                // 这些资源不全在本地
                request.beginAccessingResources { error in
                    if let _ = error {
                        // 下载失败
                    }
                    else {
                        // 下载成功
                    }
                }
            }
            else {
                // 这些资源已经在本地了
            }
        }
    }
}

6.2 为皮肤系统 AppearanceStyle 拓展 Odr

AppearanceStyle 是真个换肤系统的核心，主体是一个 枚举。

这里让原先的皮肤都匹配一下自己的标签名就好了。
然后添加一个 reloadOdr 方法来更新当前两个皮肤的 ODR

extension AppearanceStyle: OdrTagProtocol {
    static func reloadOdr() {
        OdrTool.requestODR(of: currentLightStyle, currentDarkStyle)
    }
    
    var tagName: String {
        switch self {
        case .Charge, .ChargeMain:
            return "Charge"
        case .ChargeLight:
            return "ChargeLight"
        case .Eternal, .Hachimitsu:
            return "Eternal"
        case .Spark:
            return "Sakura"
        case .SparkMain:
            return "Spark"
        case .NYXL:
            return "NYXL"
        case .Justice, .Dream, .Phoenix:
            return "Justice"
        case .Kiwi:
            return "Kiwi"
        case .Banshee:
            return "Banshee"
        case .Punk:
            return "Punk"
        }
    }
}

6.3 在合适节点更新Odr资源

节点一：应用启动

AppearanceStyle.reloadOdr()

节点二：设置皮肤

static func reloadApp() {
    guard let tabVC = UIStoryboard(name: "Home", bundle: nil).instantiateInitialViewController() else {
        return
    }
    UIApplication.shared.windows.filter { $0.isKeyWindow }.first?.rootViewController = tabVC
    reloadOdr()
}

6.4 运行项目，检查效果

Xcode 中显示我设置的两个皮肤的资源已经下载完成了。

但是打开 App，发现还是空白？

6.5 解决问题

通过之前的了解，如果 ODR 资源没有被任何 NSBundleResourceRequest 使用的话就会被清理。而上面的封装并没有持有 NSBundleResourceRequest。对代码进行一下调整。

OdrTool

struct OdrTool {
    static func requestODR(of tags: OdrTagProtocol..., in bundle: Bundle = Bundle.main) -> NSBundleResourceRequest {
        ...
        let request = NSBundleResourceRequest(tags: tagsSet, bundle: bundle)
        ...
        // 把 NSBundleResourceRequest 抛出
        return request
    }
}

AppearanceStyle

extension AppearanceStyle: OdrTagProtocol {
    // 添加一个静态变量保存
    static var odrRequest: NSBundleResourceRequest?
    
    static func reloadOdr() {
        odrRequest = OdrTool.requestODR(of: currentLightStyle, currentDarkStyle)
    }
    
    var tagName: String {
        switch self {
            ...
        }
    }
}

6.6 检查修改后的效果

完美～又测了下切换皮肤的功能也是没问题的

再看 Xcode 发现，标签的状态不一样了，两个正在使用中的标签成了 In use 正在使用。

6.7 使用资源的地方需要改动么？

不用

七、问题

7.1 覆盖安装的问题

我遇到了这样的问题：

设备安装了线上发布的版本（ODR优化过的），运行展示都没问题
准备进行下个版本的开发，直接运行，覆盖正式包，无法展示资源
尝试一：猜测和版本号有关，修改版本号，依旧无效
尝试二：删除旧包再运行，有效

上面的问题均可以 100% 复现

总结

体验下来还是很顺滑的，感觉接入成本不高。个人项目自己比较熟，而且换肤体系封的比较好😜也为接入 ODR 带来了很大便利。而且我单个皮肤的资源自由 2M 左右下载也挺快。如果是一些较大的资源加载可能就不能像我处理的这么简单了。而且 NSBundleResourceRequest 还有很多设置我没用，想深入了解的可以看下官方文档，这里我就抛个砖🧱。

而且任何优化方案的选择还是要结合实际项目来，能一股脑照搬的方案是不存在的。苹果的这个 ODR 挺好的，却感觉一直没有进入到广大 iOSer 的视野中，感觉挺可惜，如果感觉合适你的项目真的可以用起来哦～

👋 Bye～

Wechat: RyukieW
📦 技术文章归档
🐙 Github

我的个人项目	扫雷Elic 无尽天梯	梦见账本
类型	游戏	财务
AppStore	Elic	Umemi

参考

Apple官方资源瘦身方案ODR（一）：初见

Mon, 02 Aug 2021 00:00:00 GMT

Hi 👋

Wechat: RyukieW
📦 技术文章归档
🐙 Github

我的个人项目	扫雷Elic 无尽天梯	梦见账本
类型	游戏	财务
AppStore	Elic	Umemi

前言

应用瘦身是个老生常谈的话题。苹果其实对于应用瘦身也有着自己的一些说明。本文就将结合官方文档进行阐述。

一、什么是应用瘦身？

在 iOS, tvOS, watchOS 上 AppStore 和操作系统根据用户设备和操作系统的性能对App进行裁剪优化。这个优化的过程就是 应用瘦身。

你可以用最少的空间创建功能齐全持续更新的应用
更快的下载速度
更多的空间安装其他App
带来更好的用户体验

二、剪切 Slicing (iOS, tvOS)

Slicing 是针对不同设备不同系统创建部署变体应用包的过程。每个变体只包含当前设备和操作系统所需要的资源和可执行文件。你只需要打包上传完整版本的应用到 AppConnect。AppStore 将会根据不同的设备及操作系统版本创建分发不同的变体。

用 asset 储存图片资源以便 AppStore 为不同的变体选择资源加载。当用户安装应用时，将会下载安装一个针对其设备系统版本的变体。

Xcode 将会在本地 build 和 run 的时候模拟进行 Slicing。当你 archive 的时候 Xcode 将会包含所有构建版本并允许你导出变体包。

下图很好的演示了这个过程

思考

这里提到 asset 会根据架构不同进行资源加载，所以我们平时不要把资源直接放到 Bundle 中，而跳过了这个优化的过程。

三、 Bitcode

Bitcode 是编译器的一层间接。你上传到 AppConnect 的打开了Bitcode的 App 将会在 AppStore 被 编译 和 链接。包含了 Bitcode 将会使Apple 可以在未来再优化你的应用包而不用再重新上传。

对于 iOS 应用 Bitcode 是默认非必须选的。watchOS 和 tvOS 是必选的。如果想要支持 Bitcode 那么你所有用到的库都要支持 Bitcode。

符号表

Xcode 默认会隐藏你的应用的符号表，所以对于 Apple 它是不可见的。当你上传你的 App 到 AppConnect 的时候你可以选择包含符号表``。包含符号表会使Apple 为你提供崩溃日志。

如果你想要自己收集崩溃日志，那么你可以不上传符号表。你可以在发布应用后下载 Bitcode 编译后的符号表。

四、 ODR: On-Demand Resources (iOS, tvOS)

这些资源主要是图片和声音。AppStore 将其保存管理在苹果的服务器。AppStore 将会按需使用资源优化变体包。后面将以 ODR 进行简称。

ODR 提供了更好的用户体验：

应用体积更小，下载更快，提升初次启动速度
资源会在后台下载
操作系统将会在磁盘资源不够的时候清理 ODR

想要支持ODR，可以阅读文档：
- On-Demand Resources Guide
- NSBundleResourceRequest

4.1 使用须知

App 负责请求这些资源，操作系统负责 下载 和 存储。应用使用资源，然后请求。下载后，资源可能会通过多个启动周期保留在设备上，使访问速度更快。

资源可以是 Bundle 支持的任何类型的资源，但 可执行程序 除外。Table 1-1 显示支持按需资源类型，并指示这些类型是否以 文件 或 Asset 包含在项目中。

Table 1-1: On-demand resource types

Type	Asset catalog	File
Data file	✓	✓
Image	✓	✓
OpenGL shader	x	✓
SpriteKit particle	x	✓
SpriteKit scene	x	✓
SpriteKit texture atlas	✓	✓
Apple TV Image Stack	✓	✓

数据文件可以包含任何类型的数据，但可执行的 Swift、 Objective-C、 C 或 C++ 代码除外。脚本语言生成的文件 可以是按需加载的。

4.2 ODR 的好处

较小的应用程序大小。
- 用户下载的应用捆绑包的大小较小，因此下载速度更快，设备上的存储空间更大。
应用资源懒加载。
- 该应用程序的资源仅在某些状态下使用。当应用可能进入适当的状态时，需要资源。
- 例如，在具有多个级别的游戏中，用户只需要与当前和下一个级别相关的资源。
远程存储很少使用的资源。
- 该资源很少使用。根据需要要求提供资源。
- 例如，应用教程通常在第一次打开应用后显示一次，可能永远不会再次使用。该应用程序要求在第一次启动时请求教程，然后仅在需要或添加新功能时再请求教程。
应用内购买资源的远程存储。
- 如果应用程序提供应用内购买，包括其他资源。应用启动后会请求购买模块的资源。
- 例如，用户在键盘应用中购买表情包。应用程序在启动完成后请求该包。

五、 ODR 标签的工作原理

通过分配 一个或多个标签 来识别开发过程中的按需加载资源。标签 是您创建的字符串标识符。您可以使用 标签的名称 来识别应用中如何使用包含的资源。例如在游戏中，使用标记 level-5 来处理与 level-5 相关的每个资源。

在运行时
- 通过指定一组标签请求访问远程资源。操作系统下载标记为这些标签的资源，然后存储，直到应用使用完为止。
当操作系统需要更多存储时
- 它会清除不被使用的一个或多个标签相关的本地缓存。
- 标记的资源集可能会在设备上保留一段时间，然后才被清除。

5.1 游戏举例

继续使用游戏示例，在分为多个级别的游戏中，用户只需要与用户正在玩的水平和下一个可能级别相关的资源。

下图显示一个应用，其中包含所有级别的所有资源。

通过为不同级别以及不需要包含在应用中的其他共享资源创建标签，可以缩小应用包的大小。

下图显示了一个更小的应用，其标记的资源集托管在 App Store 上。

5.2 额外设置

您可以指定

应用从应用商店安装时必须加载的标签
为资源请求设置加载优先级
跟踪下载进度
以及为不再使用的下载标签设置保存优先级

六、 ODR 的生命周期

用户首次启动该应用程序时，设备上唯一的按需资源是用于预匹配的资源。
当用户与应用交互时，应用请求代表一组资源的标签，使用与标签相关的资源，然后通知操作系统它已使用完标签。
操作系统会在之后的某个合适的时间，清除一个或多个标签。

应用按标签请求，而不是特定的资源。

6.1 共享 ODR

当您使用 ODR 开发应用时，您可能会注意到请求一个标签会同时下载的其他标签相关的资源。这是因为操作系统与用于下载共享资源的优化资产包配合使用。一个标签可能存在多个 Asset 中。构建应用时，Asset 由 Xcode 生成。

一个例子是一个游戏，其中级别1和级别2标签共享一些资源。Xcode 生成三个 Asset：
- Level 1. 只有 Level1 标签
- Level 2. 只有 Level2 标签
- Level 1 + Level 2. 同时有 Level1 标签和 Level2 标签

6.2 流程

1.应用程序从操作系统请求标签。操作系统将所要求的标签转换为包含相关资源的一组资产包。

在下图中应用请求与 Level1 和 Forest 标签相关的资源。

2.标签的 Asset 位于本地存储中，则生命周期移动到第6步。

3.标签的一个或多个 Asset 托管在 App Store 上，原因要么是它是应用的第一次发布，要么是之前加载在设备上的资源被清除（参见下面的 第9步）。

在下图中，所有 ODR 都在应用商店中。

4.操作系统开始下载与尚未存储在本地存储中的相关的资源。

5.与所要求的标签相关的 Asset 资源完成下载到设备。

在下图中，与 Level1 和 Forest 标签相关的资源将下载到了设备中。

6.如果成功下载了与所要求的标签相关的资源，或者如果资源已在设备存储中，则操作会增加 Asset 的引用计数，并通知应用所请求的标签可用。

在下图中，应用程序被告知与 Level1 和 Forest 标签相关的资源是可用的。

标签可用后，应用将使用与这些标签相关的资源。ODR 的访问方式与与下载的应用捆绑的资源相同。下图显示下载的资源作为应用程序的虚拟成员。

7.应用程序通知操作系统，它已经完成了对请求标签的使用。

8.操作系统在本地存储中释放标签。这是通过减少与标签相关的 Asset 的引用计数来完成的。

对设备上已使用的标签进行另一个请求将移动到 第1步。

9.操作系统从本地存储中清除与 Asset 相关的缓存资源。

当任何请求不再关联标签时，Asset 就可以进行清除。与标签相关的资源可能会在设备上保留一段时间，然后才清除，包括跨应用（AppGroup）。
对标签提出另一个请求会将生命周期移回 第1步。
可以通过为标签设置保存优先级来影响清除顺序。

七、总结

本文只是初步的对 ODR 有了一个整体初步的了解。很多细节还并没有涉及比如项目怎么配置，代码怎么写。我将在后续文章中继续深入探索。

欢迎点赞关注收藏～

参考

What is app thinning? (iOS, tvOS, watchOS)

在个人站点配置app-ads

Sun, 01 Aug 2021 00:00:00 GMT

Hi 👋

Wechat: RyukieW
📦 技术文章归档
🐙 Github

我的个人项目	扫雷Elic 无尽天梯	梦见账本
类型	游戏	财务
AppStore	Elic	Umemi

前言

扫雷Elic 无尽天梯的广告接的是 Google 的 AdMob。国内的没有公司主体基本没法儿接。后台也一直警告我要添加 app-ads.txt 但是没有个人站点就一直没加。广告量也明显感觉和早期差得很远。

但是前段时间买了域名用 Wordpress 简单建了个站。就准备把这个 app-ads.txt 加下。

一、什么是 app-ads.txt

授权应用卖方（或 app-ads.txt）是一项 IAB Tech Lab 计划，有助于确保只通过您认定的授权渠道销售您的应用广告资源。创建 app-ads.txt 文件后，您可以更好地掌控哪些卖方有权销售您应用上的广告空间，并可防止向广告客户展示仿冒广告资源。

app-ads.txt 文件是公开的，可供广告交易平台、供应方平台 (SSP) 以及其他买方和第三方供应商抓取。

授权应用卖方 (app-ads.txt) 是授权数字卖方 (ads.txt) 计划的延伸和扩展，后者最初设计用于保护网络广告资源。app-ads.txt 在 ads.txt 的基础上扩展了兼容性，使之支持移动应用中展示的广告。

为避免损失大量广告收入，您需要实施 app-ads.txt 文件。

app-ads.txt 简介

二、如何为应用设置 app-ads.txt

如果您还没有创建 app-ads.txt 文件，请使用 IAB Tech Lab 提供的规范进行创建。
将后台提供的代码段复制并粘贴到您的 app-ads.txt 文件中
在开发者网站的根目录（例如：sampledomain.com/app-ads.txt）上发布您的 app-ads.txt 文件。请确保您输入的域名与 Google Play 或 App Store 中列出的域名完全一致。
请等待至少 24 小时，以便 AdMob 抓取并验证您的 app-ads.txt 文件。
返回 AdMob 检查您的 app-ads.txt 状态。

三、 www域名

我的域名是 www.xxx.com，通过 www.xxx.com/app-ads.txt，是可以正常获取到数据的。

但是 AdMob，是通过 xxx.com/app-ads.txt 来抓取的。而 xxx.com 是无法解析我的域名的。

3.1 DNS配置无www域名解析

我是在 GoDaddy 上买的域名，DNS 也是在上面配的但是它不支持 无www 域名的解析。这里参考，将 DNS 解析迁移到了 DNSPod 上。完成了 xxx.com 的解析。

3.2 域名端口映射

完成了 xxx.com 的解析后，访问 xxx.com/app-ads.txt 时，直接 404 了。

并且任何子页面也都访问不了。

这里就需要到网站后台添加映射了，和 www 的域名指向同一个就行了：

再尝试 xxx.com/app-ads.txt，就可以正常抓取到了。

深入探究属性

Sun, 01 Aug 2021 00:00:00 GMT

@interface RYModel : NSObject

@property (nonatomic, copy) NSString *name;
@property (nonatomic, assign) NSInteger age;
@property (nonatomic, assign) float height;
@property (nonatomic, strong) RYModel *father;
@property (nonatomic, assign) BOOL isBoy;

- (void)dosomething;

- (void)dosomethingWith:(NSString *)title;

+ (void)classDoSomething;

- (NSString *)sayMyName;

@end

一、成员变量和属性

我们知道，属性会生成带下划线的成员变量和对应的set、get方法。我们将上面用到的RYModel，编译成C++看下。

static NSString * _I_RYModel_name(RYModel * self, SEL _cmd) { return (*(NSString **)((char *)self + OBJC_IVAR_$_RYModel$_name)); }
extern "C" __declspec(dllimport) void objc_setProperty (id, SEL, long, id, bool, bool);

static void _I_RYModel_setName_(RYModel * self, SEL _cmd, NSString *name) { objc_setProperty (self, _cmd, __OFFSETOFIVAR__(struct RYModel, _name), (id)name, 0, 1); }

static NSInteger _I_RYModel_age(RYModel * self, SEL _cmd) { return (*(NSInteger *)((char *)self + OBJC_IVAR_$_RYModel$_age)); }
static void _I_RYModel_setAge_(RYModel * self, SEL _cmd, NSInteger age) { (*(NSInteger *)((char *)self + OBJC_IVAR_$_RYModel$_age)) = age; }

static float _I_RYModel_height(RYModel * self, SEL _cmd) { return (*(float *)((char *)self + OBJC_IVAR_$_RYModel$_height)); }
static void _I_RYModel_setHeight_(RYModel * self, SEL _cmd, float height) { (*(float *)((char *)self + OBJC_IVAR_$_RYModel$_height)) = height; }

static RYModel * _I_RYModel_father(RYModel * self, SEL _cmd) { return (*(RYModel **)((char *)self + OBJC_IVAR_$_RYModel$_father)); }
static void _I_RYModel_setFather_(RYModel * self, SEL _cmd, RYModel *father) { (*(RYModel **)((char *)self + OBJC_IVAR_$_RYModel$_father)) = father; }

static BOOL _I_RYModel_isBoy(RYModel * self, SEL _cmd) { return (*(BOOL *)((char *)self + OBJC_IVAR_$_RYModel$_isBoy)); }
static void _I_RYModel_setIsBoy_(RYModel * self, SEL _cmd, BOOL isBoy) { (*(BOOL *)((char *)self + OBJC_IVAR_$_RYModel$_isBoy)) = isBoy; }

8.1 copy 修饰符

name 属性用的是 copy 来修饰的。很容易发现它的set方法明显有不同。

他用的是 objc_setProperty ，而其他的都是直接通过内存平移对成员变量进行赋值操作。

二、objc_setProperty

我们看下 objc_setProperty 的源码：

/// 对象 sel 偏移量 值 原子性 是否copy
void objc_setProperty(id self, SEL _cmd, ptrdiff_t offset, id newValue, BOOL atomic, signed char shouldCopy) 
{
    // 是否是 Copy
    bool copy = (shouldCopy && shouldCopy != MUTABLE_COPY);
    // 是否是 可变的Copy
    bool mutableCopy = (shouldCopy == MUTABLE_COPY);
    reallySetProperty(self, _cmd, newValue, offset, atomic, copy, mutableCopy);
}

发现他实际调用了 reallySetProperty

2.1 reallySetProperty

static inline void reallySetProperty(id self, SEL _cmd, id newValue, ptrdiff_t offset, bool atomic, bool copy, bool mutableCopy)
{
    if (offset == 0) { 
        // 修改 ISA
        object_setClass(self, newValue);
        return;
    }

    id oldValue;
    // 定位（首地址+偏移量）
    id *slot = (id*) ((char*)self + offset);

    // Copy相关操作
    if (copy) {
        newValue = [newValue copyWithZone:nil];
    } else if (mutableCopy) {
        newValue = [newValue mutableCopyWithZone:nil];
    } else {
        if (*slot == newValue) return;// 相同的话不做操作
        // 引用计数+1
        newValue = objc_retain(newValue); 
    }

    // 原子性相关
    if (!atomic) {
        oldValue = *slot;
        *slot = newValue;
    } else {
      // 加锁
        spinlock_t& slotlock = PropertyLocks[slot];
        slotlock.lock();
        oldValue = *slot;
        *slot = newValue;        
        slotlock.unlock();
    }

    // release 旧值 引用计数 -1
    objc_release(oldValue);
}

三、 Set 流程图

四、Type Encodings 类型编码

我们会看到这样一些 objc_selector，其中有 v24@0:8@16 类似这样的一些看不懂的字符串。他们叫类型编码

具体可以对照官方文档这里就不展开聊了

以 setName 为例分析一次：

v	24	@	0	:	8	@	16
返回值类型-void	占用大小-24	参数-id	从偏移量0开始	SEL	从偏移量8开始	参数-id	从偏移量16开始

static struct /*_method_list_t*/ {
	unsigned int entsize;  // sizeof(struct _objc_method)
	unsigned int method_count;
	struct _objc_method method_list[21];
} _OBJC_$_INSTANCE_METHODS_RYModel __attribute__ ((used, section ("__DATA,__objc_const"))) = {
	sizeof(_objc_method),
	21,
	{{(struct objc_selector *)"ry_protocolDoSomething", "v16@0:8", (void *)_I_RYModel_ry_protocolDoSomething},
	{(struct objc_selector *)"name", "@16@0:8", (void *)_I_RYModel_name},
	{(struct objc_selector *)"setName:", "v24@0:8@16", (void *)_I_RYModel_setName_},
	{(struct objc_selector *)"age", "q16@0:8", (void *)_I_RYModel_age},
	{(struct objc_selector *)"setAge:", "v24@0:8q16", (void *)_I_RYModel_setAge_},
	{(struct objc_selector *)"height", "f16@0:8", (void *)_I_RYModel_height},
	{(struct objc_selector *)"setHeight:", "v20@0:8f16", (void *)_I_RYModel_setHeight_},
	{(struct objc_selector *)"father", "@16@0:8", (void *)_I_RYModel_father},
	{(struct objc_selector *)"setFather:", "v24@0:8@16", (void *)_I_RYModel_setFather_},
	{(struct objc_selector *)"isBoy", "c16@0:8", (void *)_I_RYModel_isBoy},
	{(struct objc_selector *)"setIsBoy:", "v20@0:8c16", (void *)_I_RYModel_setIsBoy_},
    ...
	{(struct objc_selector *)"isBoy", "c16@0:8", (void *)_I_RYModel_isBoy},
	{(struct objc_selector *)"setIsBoy:", "v20@0:8c16", (void *)_I_RYModel_setIsBoy_}}
};

Class-cache_t

Sun, 01 Aug 2021 00:00:00 GMT

Class之cache_t

之前进行类的结构的分析的时候，我们还有一个重要的东西没有进行研究，就是 cache_t。

一、cache_t 的基本结构

和之前一样，我们在源码环境下编译调试。

回顾一下class的基础结构：

-	ISA	superClass	cache	bits
说明	ISA（结构体指针）	父类（结构体指针）	方法缓存	类的具体信息
大小（字节）	8	8	16	8

1.1 源码

其核心数据结构如下

struct cache_t {

// <<<< 主要数据结构
private:
    explicit_atomic<uintptr_t> _bucketsAndMaybeMask;
    union {
        struct {
            explicit_atomic<mask_t>    _maybeMask;
#if __LP64__
            uint16_t                   _flags;
#endif
            uint16_t                   _occupied;
        };
        explicit_atomic<preopt_cache_t *> _originalPreoptCache;
    };
    ...
};

_bucketsAndMaybeMask
- _bucketsAndMaybeMask is a buckets_t pointer
- 它是一个 buckets_t 类型的指针
_maybeMask
- _maybeMask is the buckets mask
_occupied
_originalPreoptCache

1.2 LLDB调试

(lldb) p/x RYModel.class
(Class) $10 = 0x00000001000087c8 RYModel

// 平移取 cache
(lldb) p (cache_t *)(0x00000001000087c8 + 0x10)
(cache_t *) $11 = 0x00000001000087d8
(lldb) p $11
(cache_t *) $11 = 0x00000001000087d8

// 取出 cache 内容
(lldb) p *$11
(cache_t) $12 = {
  _bucketsAndMaybeMask = {
    std::__1::atomic<unsigned long> = {
      Value = 4314911728
    }
  }
   = {
     = {
      _maybeMask = {
        std::__1::atomic<unsigned int> = {
          Value = 3
        }
      }
      _flags = 32820
      _occupied = 1
    }
    _originalPreoptCache = {
      std::__1::atomic<preopt_cache_t *> = {
        Value = 0x0001803400000003
      }
    }
  }
}

我们无法直接输出相关成员内容了，为了继续输出相关属性我们继续看源码

1.3、bucket_t的数据结构

包含了 SEL 和 IMP

struct bucket_t {
private:
    // IMP-first is better for arm64e ptrauth and no worse for arm64.
    // SEL-first is better for armv7* and i386 and x86_64.
#if __arm64__
    explicit_atomic<uintptr_t> _imp;
    explicit_atomic<SEL> _sel;
#else
    explicit_atomic<SEL> _sel;
    explicit_atomic<uintptr_t> _imp;
#endif
...
};

二、自己实现 cache_t 数据结构

使用LLDB进行调试感觉到太麻烦了，为了更方便的进行调试我们尝试对数据结构进行模仿。

#import <objc/runtime.h>

typedef uint32_t mask_t;  // x86_64 & arm64 asm are less efficient with 16-bits

struct lw_bucket_t {
    SEL _sel;
    IMP _imp;
};
struct lw_cache_t {
    struct lw_bucket_t *_bukets;
    mask_t    _maybeMask;
    uint16_t  _flags;
    uint16_t  _occupied;
};

struct lw_class_data_bits_t {
    uintptr_t bits;
};

// cache class
struct lw_objc_class {
    Class isa;
    Class superclass;
    struct lw_cache_t cache;
    struct lw_class_data_bits_t bits;
};

2.1 调试代码

RYModel *obj = [RYModel alloc];
[obj dosomethingA];
[obj dosomethingB];
struct lw_objc_class *lw_class = (__bridge struct lw_objc_class *)(RYModel.class);
NSLog(@"缓存数量：%hu - 容量：%u",lw_class->cache._occupied,lw_class->cache._maybeMask);

for (mask_t i = 0; i<lw_class->cache._maybeMask; i++) {
    struct lw_bucket_t bucket = lw_class->cache._bukets[i];
    NSLog(@"SEL:%@ - IMP:%pf",NSStringFromSelector(bucket._sel),bucket._imp);
}

输出：

-[RYModel dosomethingA]
-[RYModel dosomethingB]
缓存数量：2 - 容量：3
SEL:dosomethingA - IMP:0xb300f
SEL:dosomethingB - IMP:0xb330f
EL:(null) - IMP:0x0f

2.2 扩容

我们调整一下代码

[obj dosomethingA];
[obj dosomethingB];
[obj dosomethingC];

输出：
2021-06-27 16:00:51.939958+0800 LWCacheT[73396:867351] -[RYModel dosomethingA]
2021-06-27 16:00:51.940352+0800 LWCacheT[73396:867351] -[RYModel dosomethingB]
2021-06-27 16:00:51.940441+0800 LWCacheT[73396:867351] -[RYModel dosomethingC]
2021-06-27 16:00:51.940602+0800 LWCacheT[73396:867351] 缓存数量：1 - 容量：7
2021-06-27 16:00:51.940668+0800 LWCacheT[73396:867351] SEL:(null) - IMP:0x0f
2021-06-27 16:00:51.940742+0800 LWCacheT[73396:867351] SEL:(null) - IMP:0x0f
2021-06-27 16:00:51.940780+0800 LWCacheT[73396:867351] SEL:(null) - IMP:0x0f
2021-06-27 16:00:51.940814+0800 LWCacheT[73396:867351] SEL:(null) - IMP:0x0f
2021-06-27 16:00:51.940900+0800 LWCacheT[73396:867351] SEL:(null) - IMP:0x0f
2021-06-27 16:00:51.941025+0800 LWCacheT[73396:867351] SEL:(null) - IMP:0x0f
2021-06-27 16:00:51.941124+0800 LWCacheT[73396:867351] SEL:dosomethingC - IMP:0xbcd8f

我们发现这里进行了扩容。这里又是什么逻辑呢？

三、insert 与扩容

为了更好的理解扩容，我们先了解一下方法缓存是怎么插入的。

3.1 核心源码解读

void cache_t::insert(SEL sel, IMP imp, id receiver)
{

    ...

    // Use the cache as-is if until we exceed our expected fill ratio.
    // 计数 + 1
    mask_t newOccupied = occupied() + 1;
    unsigned oldCapacity = capacity(), capacity = oldCapacity;
    if (slowpath(isConstantEmptyCache())) {
        // 判空，没有缓存创建缓存，根据架构不同，通过位运算初始化一个一定大小的容器
        // Cache is read-only. Replace it.
        if (!capacity) capacity = INIT_CACHE_SIZE;
        reallocate(oldCapacity, capacity, /* freeOld */false);
    }
    else if (fastpath(newOccupied + CACHE_END_MARKER <= cache_fill_ratio(capacity))) {
        // Cache is less than 3/4 or 7/8 full. Use it as-is.
        // 未达到扩容临界点
    }
#if CACHE_ALLOW_FULL_UTILIZATION
    else if (capacity <= FULL_UTILIZATION_CACHE_SIZE && newOccupied + CACHE_END_MARKER <= capacity) {
        // Allow 100% cache utilization for small buckets. Use it as-is.

        // Allow 100% cache utilization for smaller cache sizes. This has the same
        // advantages and disadvantages as the fill ratio. A very large percentage
        // of caches end up with very few entries and the worst case of collision
        // chains in small tables is relatively small.
        // NOTE: objc_msgSend properly handles a cache lookup with a full cache.

        // 
    }
#endif
    else {
      // 扩容操作
        capacity = capacity ? capacity * 2 : INIT_CACHE_SIZE;
        if (capacity > MAX_CACHE_SIZE) {
            capacity = MAX_CACHE_SIZE;
        }
        reallocate(oldCapacity, capacity, true);
    }

    bucket_t *b = buckets();
    mask_t m = capacity - 1;
    mask_t begin = cache_hash(sel, m);
    mask_t i = begin;

    // Scan for the first unused slot and insert there.
    // There is guaranteed to be an empty slot.
    // 循环找到合适的下标
    do {
        if (fastpath(b[i].sel() == 0)) {
            incrementOccupied();
            /// 插入逻辑
            b[i].set<Atomic, Encoded>(b, sel, imp, cls());
            return;
        }
        if (b[i].sel() == sel) {
            // The entry was added to the cache by some other thread
            // before we grabbed the cacheUpdateLock.
            return;
        }
    } while (fastpath((i = cache_next(i, m)) != begin));

    // 未找到合适的下标 crash
    bad_cache(receiver, (SEL)sel);
#endif // !DEBUG_TASK_THREADS
}

a. INIT_CACHE_SIZE 初始化缓存

通过源码发现，这里是通过位运算进行的缓存空间大小初始化。

如，当前我们的是 1 << 2 = 4。同时我们还能发现最大值为 1 << 16。

/* Initial cache bucket count. INIT_CACHE_SIZE must be a power of two. */
enum {
#if CACHE_END_MARKER || (__arm64__ && !__LP64__)
    // When we have a cache end marker it fills a bucket slot, so having a
    // initial cache size of 2 buckets would not be efficient when one of the
    // slots is always filled with the end marker. So start with a cache size
    // 4 buckets.
    INIT_CACHE_SIZE_LOG2 = 2,
#else
    // Allow an initial bucket size of 2 buckets, since a large number of
    // classes, especially metaclasses, have very few imps, and we support
    // the ability to fill 100% of the cache before resizing.
    INIT_CACHE_SIZE_LOG2 = 1,
#endif
    INIT_CACHE_SIZE      = (1 << INIT_CACHE_SIZE_LOG2),
    MAX_CACHE_SIZE_LOG2  = 16,
    MAX_CACHE_SIZE       = (1 << MAX_CACHE_SIZE_LOG2),
    FULL_UTILIZATION_CACHE_SIZE_LOG2 = 3,
    FULL_UTILIZATION_CACHE_SIZE = (1 << FULL_UTILIZATION_CACHE_SIZE_LOG2),
};

b. 扩容临界点

newOccupied + CACHE_END_MARKER <= cache_fill_ratio(capacity)

// Cache is less than 3/4 or 7/8 full. Use it as-is.

真机为 7/8

// objc_msgSend has few registers available.
// Cache scan increments and wraps at special end-marking bucket.
#define CACHE_END_MARKER 1

// Historical fill ratio of 75% (since the new objc runtime was introduced).
static inline mask_t cache_fill_ratio(mask_t capacity) {
    return capacity * 3 / 4;
}

#elif __arm64__ && !__LP64__
#define CACHE_END_MARKER 0

// Historical fill ratio of 75% (since the new objc runtime was introduced).
static inline mask_t cache_fill_ratio(mask_t capacity) {
    return capacity * 3 / 4;
}

#elif __arm64__ && __LP64__

// objc_msgSend has lots of registers available.
// Cache scan decrements. No end marker needed.
#define CACHE_END_MARKER 0

// Allow 87.5% fill ratio in the fast path for all cache sizes.
// Increasing the cache fill ratio reduces the fragmentation and wasted space
// in imp-caches at the cost of potentially increasing the average lookup of
// a selector in imp-caches by increasing collision chains. Another potential
// change is that cache table resizes / resets happen at different moments.
static inline mask_t cache_fill_ratio(mask_t capacity) {
    return capacity * 7 / 8;
}

c. 扩容操作

扩容按 x2 进行扩容

capacity = capacity ? capacity * 2 : INIT_CACHE_SIZE;
if (capacity > MAX_CACHE_SIZE) {
    capacity = MAX_CACHE_SIZE;
}
reallocate(oldCapacity, capacity, true);

d. 扩容后

我们看一下触发扩容的那次Log：

2021-06-27 16:00:51.940602+0800 LWCacheT[73396:867351] 缓存数量：1 - 容量：7
2021-06-27 16:00:51.940668+0800 LWCacheT[73396:867351] SEL:(null) - IMP:0x0f
2021-06-27 16:00:51.940742+0800 LWCacheT[73396:867351] SEL:(null) - IMP:0x0f
2021-06-27 16:00:51.940780+0800 LWCacheT[73396:867351] SEL:(null) - IMP:0x0f
2021-06-27 16:00:51.940814+0800 LWCacheT[73396:867351] SEL:(null) - IMP:0x0f
2021-06-27 16:00:51.940900+0800 LWCacheT[73396:867351] SEL:(null) - IMP:0x0f
2021-06-27 16:00:51.941025+0800 LWCacheT[73396:867351] SEL:(null) - IMP:0x0f
2021-06-27 16:00:51.941124+0800 LWCacheT[73396:867351] SEL:dosomethingC - IMP:0xbcd8f

这次扩容后，我们发现。除了最新的，之前的缓存都没有了。

这是因为 扩容 并不是真正意义上的扩展之前的空间，而是重新开辟一块空间。

3.2 cache_hash 计算哈希下标

static inline mask_t cache_hash(SEL sel, mask_t mask) 
{
    uintptr_t value = (uintptr_t)sel;
#if CONFIG_USE_PREOPT_CACHES
    value ^= value >> 7;// 真机 & m1
#endif
    return (mask_t)(value & mask);
}

3.3 cache_next 寻找插入位置

#if CACHE_END_MARKER
static inline mask_t cache_next(mask_t i, mask_t mask) {
    return (i+1) & mask; // 向后找
}
#elif __arm64__
static inline mask_t cache_next(mask_t i, mask_t mask) {
    return i ? i-1 : mask; // 反复横跳
}
#else
#error unexpected configuration
#endif

3.4 set 差入逻辑

template<Atomicity atomicity, IMPEncoding impEncoding>
void bucket_t::set(bucket_t *base, SEL newSel, IMP newImp, Class cls)
{
...
    // objc_msgSend uses sel and imp with no locks.
    // It is safe for objc_msgSend to see new imp but NULL sel
    // (It will get a cache miss but not dispatch to the wrong place.)
    // It is unsafe for objc_msgSend to see old imp and new sel.
    // Therefore we write new imp, wait a lot, then write new sel.
    
    /// 对 IMP 进行编码操作
    uintptr_t newIMP = (impEncoding == Encoded
                        ? encodeImp(base, newImp, newSel, cls)
                        : (uintptr_t)newImp);
...
  保存
}

将方法插入缓存，并不是直接插入的。而是进行了编码。(uintptr_t)newImp ^ (uintptr_t)cls;

3.5 流程图

关于类型转换的思考

这里使用自己定义的类型进行转换，感觉是不是很懵，感觉这也行？

我们抛开代码，思考一下：我们为什么要定义各种数据结构？为了能读写数据。

而能正确读写数据的前提是，计算机能认识这些数据。而我们定义的数据结构，就是计算机认识他们的基准。

只要两个数据结构的内存结构一致，那么进行转换就没有问题。

参考

HashMap的负载因子为什么默认是0.75

源码解读objc_msgSend

Sun, 01 Aug 2021 00:00:00 GMT

前言

本文基于
- objc4-818.2源码
- iOS14.6 iPhoneX
源码版本、系统版本、设备不同的话，真机调试的汇编会和源码有不同。自行调试的时候需要注意
源码中对于重要部分做了注释，...表示省略了一些其他架构或者无关紧要的代码
为了方便阅读，汇编代码中的做了缩进调整和分块注释，阅读起来应该会轻松不少
电脑端阅读体验更佳哦
本文看着会比较累，用了个看着比较轻松愉悦的主题。
- 配上一杯 ☕️ 体验更佳
objc_msgSend 相关的内容很多，此文会持续更新、修正
- 具体更新内容可以查看更新记录

欢迎收藏、交流、抓虫

更新记录

更新日期	变更
20210701	首次发布

一、平时我们是如何调用方法的？

有三种方式进行调用： OC Method

[model doSomething]

NSObject API

[model isKindOfClass:[NSString class]]

objc API。

class_getSuperclass([RYModel class])

API的层级结构如下：

1.1 实验三种方式

RYModel *obj = [[RYModel alloc] init];
[obj dosomethingA];

[obj performSelector:NSSelectorFromString(@"dosomethingA")];

// < Xcode 12
//    objc_msgSend((id)obj, sel_registerName("dosomethingA"));

// Xcode 12 需要转类型，只改Build setting不行
((void (*)(id, SEL))(void *)objc_msgSend)(obj, sel_registerName("dosomethingA"));

需要注意的点：

#import <objc/message.h>
Xcode 12 以下
- Build setting -> objc_msgSend -> Enable Strict Checking of objc_msgSend Calls -> NO
Xcode 12 以上
- 需要对 objc_msgSend 转类型，才能正常调用

输出：都能够正常调用

ObjcMsgSend[17313:6255181] -[RYModel dosomethingA]
ObjcMsgSend[17313:6255181] -[RYModel dosomethingA]
ObjcMsgSend[17313:6255181] -[RYModel dosomethingA]

1.2 调用父类方法

@interface RYSubModel : RYModel

- (BOOL)isSub;

@end

@implementation RYSubModel

- (BOOL)isSub {
    NSLog(@"%s",__FUNCTION__);
    [super dosomethingA];
    return  YES;
}

@end

RYSubModel 继承 RYModel ，我们看看C++文件中 isSub 的情况。

static BOOL _I_RYSubModel_isSub(RYSubModel * self, SEL _cmd) {
    NSLog((NSString *)&__NSConstantStringImpl__var_folders_py_7v1wvf813z5bmw0hr97yplwc0000gn_T_RYModel_c52934_mi_6,__FUNCTION__);
    ((void (*)(__rw_objc_super *, SEL))(void *)objc_msgSendSuper)((__rw_objc_super){(id)self, (id)class_getSuperclass(objc_getClass("RYSubModel"))}, sel_registerName("dosomethingA"));
    return ((bool)1);
}

这里 [super dosomethingA] 转成C++后，发现一个 objc_msgSendSuper 方法，通过它来调用父类的方法。

1.3 objc_msgSendSuper

我们试试能不能直接调用 objc_msgSendSuper。

objc_msgSendSuper(struct objc_super * _Nonnull super, SEL _Nonnull op, ...)
- super
  - objc_super 结构体指针
- op
  - selector

/// Specifies the superclass of an instance. 
struct objc_super {
    /// Specifies an instance of a class.
    __unsafe_unretained _Nonnull id receiver;

    /// Specifies the particular superclass of the instance to message. 
#if !defined(__cplusplus)  &&  !__OBJC2__
    /* For compatibility with old objc-runtime.h header */
    __unsafe_unretained _Nonnull Class class;
#else
    __unsafe_unretained _Nonnull Class super_class;
#endif
    /* super_class is the first class to search */
};

objc_super

/// Specifies the superclass of an instance. 
struct objc_super {
    /// Specifies an instance of a class.
    __unsafe_unretained _Nonnull id receiver;

    /// Specifies the particular superclass of the instance to message. 
#if !defined(__cplusplus)  &&  !__OBJC2__ // 
    /* For compatibility with old objc-runtime.h header */
    __unsafe_unretained _Nonnull Class class;
#else
    __unsafe_unretained _Nonnull Class super_class;
#endif
    /* super_class is the first class to search */
};

代码

struct objc_super ry_super;
ry_super.receiver = obj;
ry_super.super_class = [RYModel class];
((void (*)(id, SEL))(void *)objc_msgSendSuper)((__bridge id)(&ry_super), sel_registerName("dosomethingA"));

输出：
ObjcMsgSend[17330:6265149] -[RYModel dosomethingA] // 调用父类方法成功

修改父类参数

我们将父类修改成它自己的类对象试试。 ry_super.super_class = [RYSubModel class];，输出依然正确。内部有个查找的链条。

1.4 源码

我们找一下 objc_msgSend 的源码。

ARM64版的源码都在 objc-msg-arm64.s 中，是 汇编 的。

通过添加符号断点也可以查看到汇编代码。

二、汇编说明

2.1 这里用到的主要的的汇编指令备注

指令	示例	备注
cmp	cmp x0, #0x0	作差值计算，结果丢弃，只调整状态寄存器`CPSR`标志位
b.le	b.le 0x1afad2b98;	意为`less than or equal to`，结果`<=0`，的时候跳转指令 `0x1afad2b98`
b.eq	b.eq 0x1afad2b68	意为`equal`，结果`==0`，时跳转指令`0x1afad2b68`
and	and x16, x13	x16 & x13 与操作
ldr	ldr x13, [x0]	将地址x0的储存器的数据，放入x13寄存器
lsr	lsr #48	逻辑右移48位
lsl	lsl #4	逻辑左移4位
ldp	ldp x17, x9, [x12]	取出x12的值存入x17,x9
b.ne	b.ne 0x1afad2b54	不相等，跳转指令`0x1afad2b54`
tbnz	tbnz p11, #0, LLookupPreopt\Function	`Test and branch Not zero`，即：如果p11的第0位不为0就执行`LLookupPreopt\Function`
TBZ	-	为0，和`tbnz`类似
adrp	adrp x0, 1	1. 将1的值,左移12位 `1 0000 0000 0000 == 0x1000`;\n 2.将PC寄存器的低12位清零 `0x1045228b0 ==> 0x104522000`; 3.将将1 和 2 的结果相加给 X0 寄存器
eor	-	异或

2.2 寄存器说明

寄存器

x0-x7，是用来传参的。
- x0：消息接收者
- x1：sel

☕️ 休息一下吧，后面开始会有点累

三 _objc_msgSend 源码汇编

ENTRY _objc_msgSend
UNWIND _objc_msgSend, NoFrame

// 判断是否存在消息接收者
cmp	p0, #0			// nil check and tagged pointer check 比较P0寄存器和0

#if SUPPORT_TAGGED_POINTERS 
// 支持Taggedpointer ARM64下 SUPPORT_TAGGED_POINTERS = 1，
// 根据状态寄存器结果 p0 - 0 <= 0 跳转执行 LNilOrTagged
b.le	LNilOrTagged		//  (MSB tagged pointer looks negative)
#else
// 等于0，即接收者为nil，LReturnZero
b.eq	LReturnZero
#endif

// ISA 存入p13
ldr	p13, [x0]		// p13 = isa

// 从ISA中获取 Class，p16存的是Class的指针
GetClassFromIsa_p16 p13, 1, x0	// p16 = class

// 获取ISA完成后执行：
LGetIsaDone:
// calls imp or objc_msgSend_uncached
// 调用IMP或者查缓存
CacheLookup NORMAL, _objc_msgSend, __objc_msgSend_uncached

END_ENTRY _objc_msgSend

3.1 GetClassFromIsa_p16

获取Class存入p16

/********************************************************************
 * GetClassFromIsa_p16 src, needs_auth, auth_address
 * src is a raw isa field. Sets p16 to the corresponding class pointer.
 * The raw isa might be an indexed isa to be decoded, or a
 * packed isa that needs to be masked.
 *
 * On exit:
 *   src is unchanged
 *   p16 is a class pointer
 *   x10 is clobbered
 ********************************************************************/
.macro GetClassFromIsa_p16 src, needs_auth, auth_address /* note: auth_address is not required if !needs_auth */

#if SUPPORT_INDEXED_ISA
...
#elif __LP64__
.if \needs_auth == 0 // _cache_getImp takes an authed class already
	mov	p16, \src
.else // needs_auth == 1
	// 64-bit packed isa
	ExtractISA p16, \src, \auth_address
.endif
#else
	// 32-bit raw isa
	mov	p16, \src

#endif

.endmacro

3.2 ExtractISA 获取ClassISA

// XS/XS Max/XR A12处理器开始
#if __has_feature(ptrauth_calls)
// JOP
...
.macro ExtractISA
    // ISA($1) & ISA_MASK 存入 p16p16($0)，即 class
	and	$0, $1, #ISA_MASK
#if ISA_SIGNING_AUTH_MODE == ISA_SIGNING_STRIP
	xpacd	$0
#elif ISA_SIGNING_AUTH_MODE == ISA_SIGNING_AUTH
	mov	x10, $2
	movk	x10, #ISA_SIGNING_DISCRIMINATOR, LSL #48
	autda	$0, x10
#endif
.endmacro
...

// JOP
#else
// not JOP

...
.macro ExtractISA
    // ISA($1) & ISA_MASK 存入 p16($0)，即 class
	and    $0, $1, #ISA_MASK
.endmacro

// not JOP
#endif

3.3 CacheLookup 查找缓存

参数：

Mode：缓存命中模式
- CacheHit
Function
- 命中缓存后调用
MissLabelDynamic
- 未命中调用
MissLabelConstant
- MissLabelConstant is only used for the GETIMP variant

官方注释

建议查看一下，有助于理解

/********************************************************************
 *
 * CacheLookup NORMAL|GETIMP|LOOKUP <function> MissLabelDynamic MissLabelConstant
 *
 * MissLabelConstant is only used for the GETIMP variant.
 *
 * Locate the implementation for a selector in a class method cache.
 *
 * When this is used in a function that doesn't hold the runtime lock,
 * this represents the critical section that may access dead memory.
 * If the kernel causes one of these functions to go down the recovery
 * path, we pretend the lookup failed by jumping the JumpMiss branch.
 *
 * Takes:
 *	 x1 = selector
 *	 x16 = class to be searched
 *
 * Kills:
 * 	 x9,x10,x11,x12,x13,x15,x1
 *
 * Untouched:
 * 	 x14
 *
 * On exit: (found) calls or returns IMP
 *                  with x16 = class, x17 = IMP
 *                  In LOOKUP mode, the two low bits are set to 0x3
 *                  if we hit a constant cache (used in objc_trace)
 *          (not found) jumps to LCacheMiss
 *                  with x15 = class
 *                  For constant caches in LOOKUP mode, the low bit
 *                  of x16 is set to 0x1 to indicate we had to fallback.
 *          In addition, when LCacheMiss is __objc_msgSend_uncached or
 *          __objc_msgLookup_uncached, 0x2 will be set in x16
 *          to remember we took the slowpath.
 *          So the two low bits of x16 on exit mean:
 *            0: dynamic hit
 *            1: fallback to the parent class, when there is a preoptimized cache
 *            2: slowpath
 *            3: preoptimized cache hit
 *
 ********************************************************************/

源码

.macro CacheLookup Mode, Function, MissLabelDynamic, MissLabelConstant
	//
	// Restart protocol:
	//
	//   As soon as we're past the LLookupStart\Function label we may have
	//   loaded an invalid cache pointer or mask.
	//
	//   When task_restartable_ranges_synchronize() is called,
	//   (or when a signal hits us) before we're past LLookupEnd\Function,
	//   then our PC will be reset to LLookupRecover\Function which forcefully
	//   jumps to the cache-miss codepath which have the following
	//   requirements:
	//
	//   GETIMP:
	//     The cache-miss is just returning NULL (setting x0 to 0)
	//
	//   NORMAL and LOOKUP:
	//   - x0 contains the receiver
	//   - x1 contains the selector
	//   - x16 contains the isa
	//   - other registers are set as per calling conventions
	//

    // 将x16(class)移动到x15
	mov	x15, x16			// stash the original isa

LLookupStart\Function:
...


.endmacro

源码较长，我们分部分看

3.4 LLookupStart\Function 开始查找

获取当前 bucket_t 和 HashIndex，用来查找缓存
- 这里对源码的if-else缩进进行调整，方便查看

LLookupStart\Function:
	// p1 = _cmd, p16 = isa
#if CACHE_MASK_STORAGE == CACHE_MASK_STORAGE_HIGH_16_BIG_ADDRS
// ARM64 && __LP64__: MacOS 或 模拟器
...
#elif CACHE_MASK_STORAGE == CACHE_MASK_STORAGE_HIGH_16
// ARM64 && __LP64__
    // ClassISA + #CACHE(0x10) 存入 p11，即cache_t(p11)
	ldr	p11, [x16, #CACHE]			// p11 = mask|buckets
    #if CONFIG_USE_PREOPT_CACHES
        // 真机
        #if __has_feature(ptrauth_calls)
        // > X 的机型
            // 判断 cache_t(p11) 第0位是否不为0，如果为0，是否有共享缓存（first_shared_cache_sel）
            // 没缓存：继续走
            // 有缓存：跳转 LLookupPreopt\Function
            tbnz	p11, #0, LLookupPreopt\Function
            // cache_t(p11) & #0x0000ffffffffffff -> p10(buckets)
            // 取低 48 位
            and	p10, p11, #0x0000ffffffffffff	// p10 = buckets
        #else
            and	p10, p11, #0x0000fffffffffffe	// p10 = buckets
            tbnz	p11, #0, LLookupPreopt\Function
        #endif

        // (_cmd ^ _cmd >> 7) -> p12
        eor	p12, p1, p1, LSR #7
        // ((cache_t & p12) >> 48) -> p12(HashIndex)
        and	p12, p12, p11, LSR #48		// x12 = (_cmd(p1) ^ (_cmd(p1) >> 7)) & mask
    #else
        and	p10, p11, #0x0000ffffffffffff	// p10 = buckets
        and	p12, p1, p11, LSR #48		// x12 = _cmd & mask
    #endif // CONFIG_USE_PREOPT_CACHES

#elif CACHE_MASK_STORAGE == CACHE_MASK_STORAGE_LOW_4
// ARM64 && !__LP64__：真机
略
#else
#error Unsupported cache mask storage for ARM64.
#endif
    // ((buckets + HashIndex) << 1+PTRSHIFT) -> p13(bucket_t)
    // 通过偏移找到 bucket_t 存入p13
    // p12(HashIndex)
    // `buckets`是`buckets`的首地址，HashIndex为Hash表的下标
    // 如：HashIndex为1那就偏移1个`bucket_t`的长度，即：16（sel8+imp8）
    // 左移`(1+PTRSHIFT))`是为了到`HashIndex-1`位置，这里和cache_t插入缓存的逻辑保持一致，否则找不到的。
    // 此时p13存的的是目标bucket_t地址
	add	p13, p10, p12, LSL #(1+PTRSHIFT)
						// p13 = buckets + ((_cmd & mask) << (1+PTRSHIFT))
// #define PTRSHIFT 3  // 1<<PTRSHIFT == PTRSIZE

// 遍历缓存

// 第一次循环结束后

3.5 循环遍历（上）

						// do {
// #define BUCKET_SIZE      (2 * __SIZEOF_POINTER__) 即 (sel + imp 指针的大小)
// 取出x13 放入 p17(imp) p9(sel)
// 然后 `*bucket--` 向前移动2个指针的长度
// 即：一个bucket_t的长度
// *bucket--: 先取值，再--
1:	ldp	p17, p9, [x13], #-BUCKET_SIZE	//     {imp, sel} = *bucket--
    // 对比 p1(传入的sel) 和 p9(p13的sel)
	cmp	p9, p1				//     if (sel != _cmd) {
	b.ne	3f				//         scan more
						//     } else {
// 命中调用 CacheHit \Mode
2:	CacheHit \Mode				// hit:    call or return imp
						//     }
3:	cbz	p9, \MissLabelDynamic		//     if (sel == 0) goto Miss;
	cmp	p13, p10			// } while (bucket >= buckets)
    // 未命中 回到 1 继续循环
	b.hs	1b

3.6 CacheHit

// CacheHit: x17 = cached IMP, x10 = address of buckets, x1 = SEL, x16 = isa
.macro CacheHit
.if $0 == NORMAL
    // 调用缓存IMP
	TailCallCachedImp x17, x10, x1, x16	// authenticate and call imp
.elseif $0 == GETIMP
	mov	p0, p17
	cbz	p0, 9f			// don't ptrauth a nil imp
	AuthAndResignAsIMP x0, x10, x1, x16	// authenticate imp and re-sign as IMP
9:	ret				// return IMP
.elseif $0 == LOOKUP
	// No nil check for ptrauth: the caller would crash anyway when they
	// jump to a nil IMP. We don't care if that jump also fails ptrauth.
	AuthAndResignAsIMP x17, x10, x1, x16	// authenticate imp and re-sign as IMP
	cmp	x16, x15
	cinc	x16, x16, ne			// x16 += 1 when x15 != x16 (for instrumentation ; fallback to the parent class)
	ret				// return imp via x17
.else
.abort oops
.endif
.endmacro

3.7 TailCallCachedImp 执行缓存IMP

#if __has_feature(ptrauth_calls)
// JOP
...

.macro TailCallCachedImp
	// $0 = cached imp, $1 = address of cached imp, $2 = SEL, $3 = isa
    // (addressOfCachedIMP ^ SEL) -> addressOfCachedIMP
	eor	$1, $1, $2	// mix SEL into ptrauth modifier
    // (addressOfCachedIMP ^ isa) -> addressOfCachedIMP
	eor	$1, $1, $3  // mix isa into ptrauth modifier
    // 这个指令还没搞明白
	brab	$0, $1
.endmacro

// JOP
#else
// not JOP
...

.macro TailCallCachedImp
	// $0 = cached imp, $1 = address of cached imp, $2 = SEL, $3 = isa
    // (cachedIMP ^ isa) -> cachedIMP
	eor	$0, $0, $3
    // 跳转执行 cachedIMP
	br	$0
.endmacro

...

// not JOP
#endif

3.8 循环遍历（下）

当循环回到第一个bucket的时候就停止。
将p13移到 buckets + (mask << 1+PTRSHIFT)
继续遍历，直到遍历完
如果仍然没有命中，_objc_msgSend_uncached

// wrap-around:
//   p10 = first bucket
//   p11 = mask (and maybe other bits on LP64)
//   p12 = _cmd & mask
//
// A full cache can happen with CACHE_ALLOW_FULL_UTILIZATION.
// So stop when we circle back to the first probed bucket
// rather than when hitting the first bucket again.
//
// Note that we might probe the initial bucket twice
// when the first probed slot is the last entry.

...
	add	p13, p10, p11, LSR #(48 - (1+PTRSHIFT))
						// p13 = buckets + (mask << 1+PTRSHIFT)
						// see comment about maskZeroBits
...

	add	p12, p10, p12, LSL #(1+PTRSHIFT)
						// p12 = first probed bucket

						// do {
4:	ldp	p17, p9, [x13], #-BUCKET_SIZE	//     {imp, sel} = *bucket--
	cmp	p9, p1				//     if (sel == _cmd)
	b.eq	2b				//         goto hit
	cmp	p9, #0				// } while (sel != 0 &&
	ccmp	p13, p12, #0, ne		//     bucket > first_probed)
	b.hi	4b

3.9 LLookupPreopt\Function: 查找共享缓存内的数据

#if CONFIG_USE_PREOPT_CACHES
...
    LLookupPreopt\Function:
    #if __has_feature(ptrauth_calls)
        // cache_t(p11) & #0x007ffffffffffffe 存入 p10
        and	p10, p11, #0x007ffffffffffffe	// p10 = buckets
        // 验证？没找到这个指令的具体作用
        autdb	x10, x16			// auth as early as possible
    #endif
        // 查找共享缓存内的数据
        // x12 = (_cmd - first_shared_cache_sel)
        adrp	x9, _MagicSelRef@PAGE
        ldr	p9, [x9, _MagicSelRef@PAGEOFF]
        sub	p12, p1, p9

        // w9  = ((_cmd - first_shared_cache_sel) >> hash_shift & hash_mask)
    #if __has_feature(ptrauth_calls)
        // bits 63..60 of x11 are the number of bits in hash_mask
        // bits 59..55 of x11 is hash_shift

        lsr	x17, x11, #55			// w17 = (hash_shift, ...)
        lsr	w9, w12, w17			// >>= shift

        lsr	x17, x11, #60			// w17 = mask_bits
        mov	x11, #0x7fff
        lsr	x11, x11, x17			// p11 = mask (0x7fff >> mask_bits)
        and	x9, x9, x11			// &= mask
    #else
        // bits 63..53 of x11 is hash_mask
        // bits 52..48 of x11 is hash_shift
        lsr	x17, x11, #48			// w17 = (hash_shift, hash_mask)
        lsr	w9, w12, w17			// >>= shift
        and	x9, x9, x11, LSR #53		// &=  mask
    #endif

        ldr	x17, [x10, x9, LSL #3]		// x17 == sel_offs | (imp_offs << 32)
        cmp	x12, w17, uxtw

    .if \Mode == GETIMP
    ...
    .else
        b.ne    5f                // cache miss
        sub    x17, x16, x17, LSR #32        // imp = isa - imp_offs

    .if \Mode == NORMAL
        br	x17
    .elseif \Mode == LOOKUP
    ...

    5:	ldursw	x9, [x10, #-8]			// offset -8 is the fallback offset
        add	x16, x16, x9			// compute the fallback isa
        b	LLookupStart\Function		// lookup again with a new isa
    .endif
#endif // CONFIG_USE_PREOPT_CACHES

3.10 GetTaggedClass

if SUPPORT_TAGGED_POINTERS

// Look up the class for a tagged pointer in x0, placing it in x16.
.macro GetTaggedClass

	and	x10, x0, #0x7		// x10 = small tag
	asr	x11, x0, #55		// x11 = large tag with 1s filling the top (because bit 63 is 1 on a tagged pointer)
	cmp	x10, #7		// tag == 7?
	csel	x12, x11, x10, eq	// x12 = index in tagged pointer classes array, negative for extended tags.
					// The extended tag array is placed immediately before the basic tag array
					// so this looks into the right place either way. The sign extension done
					// by the asr instruction produces the value extended_tag - 256, which produces
					// the correct index in the extended tagged pointer classes array.

	// x16 = _objc_debug_taggedpointer_classes[x12]
	adrp	x10, _objc_debug_taggedpointer_classes@PAGE
	add	x10, x10, _objc_debug_taggedpointer_classes@PAGEOFF
	ldr	x16, [x10, x12, LSL #3]

.endmacro

3.11 LNilOrTagged

#if SUPPORT_TAGGED_POINTERS
LNilOrTagged:
b.eq	LReturnZero		// nil check
GetTaggedClass
b	LGetIsaDone
// SUPPORT_TAGGED_POINTERS
#endif

3.12 LReturnZero

LReturnZero:
// x0 is already zero
mov	x1, #0
movi	d0, #0
movi	d1, #0
movi	d2, #0
movi	d3, #0
ret

☕️ 看到这里，再休息一下吧。真机汇编看着更带劲儿~

四、真机汇编调试

个人觉得看符号断点的汇编更直观，但是源码中有注释。

真机符号断点的作为参考，和源码对照着再看一遍会更加清晰。

libobjc.A.dylib`objc_msgSend:
/*** Start
判断接收者是否为空 
***/
->  0x197b05140 <+0>:   cmp    x0, #0x0                  ; =0x0 
    0x197b05144 <+4>:   b.le   0x197b051e8               ; <+168>
/***************************/

/*** Start
将接收者存入 x13 
即：x13 = isa 
***/
    0x197b05148 <+8>:   ldr    x13, [x0]
/***************************/

/*** Start
GetClassFromIsa_p16 -> 
ExtractISA: 
isa & ISA_MASK -> x16
即：x16 = class的isa 
***/
    0x197b0514c <+12>:  and    x16, x13, #0xffffffff8
/***************************/

/*** Start
CacheLookup NORMAL, _objc_msgSend, __objc_msgSend_uncached
查找缓存
***/
    0x197b05150 <+16>:  mov    x15, x16 // LGetIsaDone

    /*** Start
    LLookupStart\Function:
    ClassISA + #CACHE(0x10) 存入 p11，即cache_t(p11)
    判断 cache_t 第0位是否不为0，如果为0，是否有共享缓存。有就跳转 LLookupPreopt
    ***/
    0x197b05154 <+20>:  ldr    x11, [x16, #0x10]
    0x197b05158 <+24>:  and    x10, x11, #0xfffffffffffe
    0x197b0515c <+28>:  tbnz   w11, #0x0, 0x197b051b0    ; <+112>

        /*** Start
        计算 cache_hash 
        (sel ^ sel >> 7) -> p12
        ((cache_t & p12) >> 48) -> p12(HashIndex)
        ***/
        0x197b05160 <+32>:  eor    x12, x1, x1, lsr #7
        0x197b05164 <+36>:  and    x12, x12, x11, lsr #48
        /***************************/

    /***************************/

    /*** Start
    通过偏移找到 bucket_t 存入x13
    x12(HashIndex)
    `buckets`是`buckets`的首地址，HashIndex为Hash表的下标
    如：HashIndex为1那就偏移1个`bucket_t`的长度，即：16（sel8+imp8）
    左移`(1+PTRSHIFT))`是为了到`HashIndex-1`位置，这里和cache_t插入缓存的逻辑保持一致，否则找不到的。
    (buckets + HashIndex << 1+PTRSHIFT) -> p13(bucket_t)
    此时x13存的的是目标bucket_t地址
    ***/
    0x197b05168 <+40>:  add    x13, x10, x12, lsl #4
    /***************************/

    /*** Start
    遍历查缓存
    #define BUCKET_SIZE      (2 * __SIZEOF_POINTER__) 即 (sel + imp 指针的大小)
    取出 x13 - 0x10 放入 p17(imp) p9(sel)
    0x10 = 2，即2个单位
    `*bucket--` 向前移动2个指针的长度（sel + imp）
    即：前移一个bucket_t的长度，将x13指向上一个缓存
    对比缓存和_cmd
    ***/
    0x197b0516c <+44>:  ldp    x17, x9, [x13], #-0x10
    0x197b05170 <+48>:  cmp    x9, x1
    0x197b05174 <+52>:  b.ne   0x197b05180               ; <+64>

        /*** Start
        命中缓存 TailCallCachedImp
        (cachedIMP ^ isa) -> cachedIMP
        ***/ 
        0x197b05178 <+56>:  eor    x17, x17, x16
        0x197b0517c <+60>:  br     x17
        /***************************/

    /*** Start
    while 循环条件判断
    if (sel(x9) == 0) goto Miss;
    while (bucket >= buckets) 满足条件回到 +44 指令行继续循环
    ***/
    0x197b05180 <+64>:  cbz    x9, 0x197b054c0           ; _objc_msgSend_uncached
    0x197b05184 <+68>:  cmp    x13, x10// 
    0x197b05188 <+72>:  b.hs   0x197b0516c               ; <+44>
    /***************************/


    /*** Start
    当循环回到第一个bucket的时候就停止循环后：
    
    * 将p13移到 buckets + (mask << 1+PTRSHIFT)
    * 继续遍历，直到遍历完
    * 如果仍然没有命中，_objc_msgSend_uncached
    ***/
    0x197b0518c <+76>:  add    x13, x10, x11, lsr #44
    0x197b05190 <+80>:  add    x12, x10, x12, lsl #4

        /*** Start
        第二次遍历
        ***/
        0x197b05194 <+84>:  ldp    x17, x9, [x13], #-0x10

            /*** Start
            命中缓存 跳转 56指令行：TailCallCachedImp
            ***/ 
            0x197b05198 <+88>:  cmp    x9, x1
            0x197b0519c <+92>:  b.eq   0x197b05178               ; <+56>
            /***************************/
        
        // 循环条件判断
        0x197b051a0 <+96>:  cmp    x9, #0x0                  ; =0x0 
        0x197b051a4 <+100>: ccmp   x13, x12, #0x0, ne
        //     bucket > first_probed)
        0x197b051a8 <+104>: b.hi   0x197b05194               ; <+84>
        /***************************/

        0x197b051ac <+108>: b      0x197b054c0               ; _objc_msgSend_uncached
    /***************************/

    /*** Start
    LLookupPreopt\Function
    查找共享缓存内的数据
    ***/

    // x12 = (_cmd - first_shared_cache_sel)
    0x197b051b0 <+112>: adrp   x9, 227000
    0x197b051b4 <+116>: add    x9, x9, #0x47b            ; =0x47b 
    0x197b051b8 <+120>: sub    x12, x1, x9

    // bits 63..53 of x11 is hash_mask
    // bits 52..48 of x11 is hash_shift
    0x197b051bc <+124>: lsr    x17, x11, #48
    0x197b051c0 <+128>: lsr    w9, w12, w17
    0x197b051c4 <+132>: and    x9, x9, x11, lsr #53

    // x17 == sel_offs | (imp_offs << 32)
    0x197b051c8 <+136>: ldr    x17, [x10, x9, lsl #3]
    0x197b051cc <+140>: cmp    x12, w17, uxtw

    0x197b051d0 <+144>: b.ne   0x197b051dc               ; <+156>
    0x197b051d4 <+148>: sub    x17, x16, x17, lsr #32

    0x197b051d8 <+152>: br     x17

        /*** Start
        5.
        ***/
        // offset -8 is the fallback offse
        0x197b051dc <+156>: ldursw x9, [x10, #-0x8]
        // compute the fallback isa
        0x197b051e0 <+160>: add    x16, x16, x9
        // lookup again with a new isa
        0x197b051e4 <+164>: b      0x197b05154               ; <+20>
        /***************************/

    /***************************/


    /*** Start
    接收者为空时调用 LNilOrTagged
    ***/
    0x197b051e8 <+168>: b.eq   0x197b0520c               ; <+204>

        /*** Start
        GetTaggedClass
        ***/
        0x197b051ec <+172>: and    x10, x0, #0x7
        0x197b051f0 <+176>: asr    x11, x0, #55
        0x197b051f4 <+180>: cmp    x10, #0x7                 ; =0x7 
        0x197b051f8 <+184>: csel   x12, x11, x10, eq
        0x197b051fc <+188>: adrp   x10, 255422
        0x197b05200 <+192>: add    x10, x10, #0xb60          ; =0xb60 
        0x197b05204 <+196>: ldr    x16, [x10, x12, lsl #3]
        /***************************/

    0x197b05208 <+200>: b      0x197b05150               ; <+16> // LGetIsaDone
    /***************************/

    /*** Start
    LReturnZero
    ***/
    0x197b0520c <+204>: mov    x1, #0x0
    0x197b05210 <+208>: movi   d0, #0000000000000000
    0x197b05214 <+212>: movi   d1, #0000000000000000
    0x197b05218 <+216>: movi   d2, #0000000000000000
    0x197b0521c <+220>: movi   d3, #0000000000000000
    0x197b05220 <+224>: ret    
    /***************************/

🎉 感谢能耐心看到这里，不错不错

看汇编是真的费劲儿

objc_msgSend 汇编流程图

五、未命中缓存的处理 __objc_msgSend_uncached

STATIC_ENTRY __objc_msgSend_uncached
UNWIND __objc_msgSend_uncached, FrameWithNoSaves

// THIS IS NOT A CALLABLE C FUNCTION
// Out-of-band r10 is the searched class

// r10 is already the class to search
MethodTableLookup NORMAL	// r11 = IMP
jmp	*%r11			// goto *imp

END_ENTRY __objc_msgSend_uncached

这里会调用 MethodTableLookup。

5.1 查找方法列表 MethodTableLookup

.macro MethodTableLookup
	// 创建一个栈，为调用方法做准备，存储寄存器中的值
	SAVE_REGS MSGSEND

	// lookUpImpOrForward(obj, sel, cls, LOOKUP_INITIALIZE | LOOKUP_RESOLVER)
	// receiver and selector already in x0 and x1
	mov	x2, x16
	mov	x3, #3

	bl	_lookUpImpOrForward

	// IMP in x0
	mov	x17, x0

    // 复原 SAVE_REGS用到的寄存器，出栈
	RESTORE_REGS MSGSEND

.endmacro

5.2 慢速查找 _lookUpImpOrForward

参数	说明
`id inst`	receiver(x0)
`SEL sel`	selector(x1)
`Class cls`	ClassISA
`int behavior`	method lookup

behavior: LOOKUP_INITIALIZE | LOOKUP_RESOLVER)

流程图

源码解析

IMP lookUpImpOrForward(id inst, SEL sel, Class cls, int behavior)
{
    const IMP forward_imp = (IMP)_objc_msgForward_impcache;
    IMP imp = nil;
    Class curClass;

    runtimeLock.assertUnlocked();

    /**
    发给Class的第一个消息通常是通过了objc_opt_*或各种优化的入口：
    + new
    + alloc
    + self
    但是，此时Class尚未初始化
    */
    if (slowpath(!cls->isInitialized())) { 
        behavior |= LOOKUP_NOCACHE;
     }

    /** 
    加锁
    保证 method-lookup + cache-fill 的原子性。
    否则
    可能分类添加后会被永久忽略，因为缓存被旧的数据覆盖
    */
    runtimeLock.lock();

    /**
    为防止 CFI攻击
    检查是否是已注册的类
    确保Class编译进了二进制文件
    或者是使用 
    objc_duplicateClass, objc_initializeClassPair or objc_allocateClassPair
    合法的注册过的
    */
    checkIsKnownClass(cls);

    // 如果需要的话初始化class
    cls = realizeAndInitializeIfNeeded_locked(inst, cls, behavior & LOOKUP_INITIALIZE);

    // runtimeLock may have been dropped but is now locked again
    runtimeLock.assertLocked();
    curClass = cls;

    /**
    死循环。通过goto和break跳出
    */
    for (unsigned attempts = unreasonableClassCount();;) {
        if (curClass->cache.isConstantOptimizedCache(/* strict */true)) {
            ...
        } else {
            // curClass method list.
            // 用二分法查找sel
            Method meth = getMethodNoSuper_nolock(curClass, sel);
            if (meth) {
                imp = meth->imp(false);
                goto done;
            }

            // 这里将获取了父类并赋值给 curClass
            if (slowpath((curClass = curClass->getSuperclass()) == nil)) {
                // 父类都找完了（superClass == nil）也没有就进行消息转发了
                // No implementation found, and method resolver didn't help.
                // Use forwarding.
                imp = forward_imp;
                break;
            }
        }
        ...

        // Superclass cache. 这里的 curClass 已经是父类了
        imp = cache_getImp(curClass, sel);
        if (slowpath(imp == forward_imp)) {
            // 需要进行消息转发
            break;
        }
        if (fastpath(imp)) {
            // Found the method in a superclass. Cache it in this class.
            goto done;
        }
    }

    ...

 done:
    if (fastpath((behavior & LOOKUP_NOCACHE) == 0)) {
#if CONFIG_USE_PREOPT_CACHES
    // iOS真机
        while (cls->cache.isConstantOptimizedCache(/* strict */true)) {
            cls = cls->cache.preoptFallbackClass();
        }
#endif
        // 插入缓存
        log_and_fill_cache(cls, imp, sel, inst, curClass);
    }
...
}

5.3 二分查找赏析

这里的算法比较精妙，值得学习。

/***********************************************************************
 * search_method_list_inline
 **********************************************************************/
template<class getNameFunc>
ALWAYS_INLINE static method_t *
findMethodInSortedMethodList(SEL key, const method_list_t *list, const getNameFunc &getName)
{
    ASSERT(list);

    auto first = list->begin();
    auto base = first;
    decltype(first) probe;

    uintptr_t keyValue = (uintptr_t)key;
    uint32_t count;
    
    /**
    count >>= 1，右移一位，即二分一次
    */
    for (count = list->count; count != 0; count >>= 1) {
        // 居中的下标
        probe = base + (count >> 1);
        
        uintptr_t probeValue = (uintptr_t)getName(probe);
        
        if (keyValue == probeValue) {
            // `probe` is a match.
            // Rewind looking for the *first* occurrence of this value.
            // This is required for correct category overrides.
            /**
            probe > first
            开始遍历一直把同名的遍历完，因为有分类的存在，所以可能会有同名的。
            会掉分类的。
            */
            while (probe > first && keyValue == (uintptr_t)getName((probe - 1))) {
                probe--;
            }
            return &*probe;
        }
        
        if (keyValue > probeValue) {
            base = probe + 1;
            count--;
        }
    }
    
    return nil;
}

六、动态决议与消息转发

动态决议与消息转发

附：知识点补充

1. 取 buckets 过程的补充说明

// 判断 cache_t(p11) 第0位是否不为0，如果为0，是否有共享缓存（first_shared_cache_sel）
// 没缓存：继续走
// 有缓存：跳转 LLookupPreopt\Function
tbnz	p11, #0, LLookupPreopt\Function
// cache_t(p11) & #0x0000ffffffffffff -> p10(buckets)
// 取低 48 位
and	p10, p11, #0x0000ffffffffffff	// p10 = buckets

这里的第0位，是指低位的0位

2. OBJC2

我们在进行源码学习的时候时常会见到__OBJC2__这个宏定义。

因为runtime有两个版本
- 1.0：用于早期系统上，32位的MacOS上
- 2.0（现行版本）：iOS和MacOS X 10.5以后的64位系统上
想要了解更多可以查看下面的官方文档：
- Objective-C Runtime Programming Guide
- Objective-C Runtime

3. cache_t

【Lawliet玩iOS源码】Class: cache_t

4. Class的实现（Realize）和初始化（Initialize）

类的实现与初始化

类的实现与初始化源码解读

Sun, 01 Aug 2021 00:00:00 GMT

前言

在上一文中runtime-objc_msgSend中我们有遇到这样一个重要的流程

cls = realizeAndInitializeIfNeeded_locked(inst, cls, behavior & LOOKUP_INITIALIZE);

本文就将对类的实现与初始化，结合源码作深入探究。

/***********************************************************************
* realizeAndInitializeIfNeeded_locked
如果类未实现就实现，如果未初始化就初始化
inst：是cls或者其子类的一个实例对象，或者nil
cls：需要初始化或者实现的类
initialize：true会初始化class，false跳过初始化
**********************************************************************/
static Class
realizeAndInitializeIfNeeded_locked(id inst, Class cls, bool initialize)
{
    runtimeLock.assertLocked();
    if (slowpath(!cls->isRealized())) {
        cls = realizeClassMaybeSwiftAndLeaveLocked(cls, runtimeLock);
    }

    if (slowpath(initialize && !cls->isInitialized())) {
        cls = initializeAndLeaveLocked(cls, inst, runtimeLock);
    }
    return cls;
}

本文基于 objc4-818.2源码

一、实现初始化的区别

这里你肯定和我一样有疑问：

初始化我大概知道是啥，实现是个什么鬼？有什么区别？

1.1 isRealized()

bool isRealized() const {
    return !isStubClass() && (data()->flags & RW_REALIZED);
}

实际是判断当前类的class_rw_t *data()是否存在，及是否有标志位RW_REALIZED

1.2 isInitialized()

bool isInitialized() {
    return getMeta()->data()->flags & RW_INITIALIZED;
}

实际是判断metaClass的class_rw_t *data()是否存在，及是否有标志位RW_INITIALIZED

一、实现类：realizeClassMaybeSwiftAndLeaveLocked

流程图

搭配源码及注释食用更加

1.1 实现OC类

static Class realizeClassWithoutSwift(Class cls, Class previously)
{
    runtimeLock.assertLocked();

    class_rw_t *rw;
    Class supercls;
    Class metacls;

    if (!cls) return nil;
    if (cls->isRealized()) {
        // 已经实现了的话，验证一下没问题就return
        validateAlreadyRealizedClass(cls);
        return cls;
    }
    ASSERT(cls == remapClass(cls));

    // fixme verify class is not in an un-dlopened part of the shared cache?
    auto ro = (const class_ro_t *)cls->data();
    // 是否是元类
    auto isMeta = ro->flags & RO_META;
    
    if (ro->flags & RO_FUTURE) {
        // TODO: 不太知道这个是啥意思
        // This was a future class. rw data is already allocated.
        rw = cls->data();
        ro = cls->data()->ro();
        ASSERT(!isMeta);
        cls->changeInfo(RW_REALIZED|RW_REALIZING, RW_FUTURE);
    } else {
        // 一般Class。创建rw
        // Normal class. Allocate writeable class data.
        rw = objc::zalloc<class_rw_t>();
        // 设置ro
        rw->set_ro(ro);
        // 设置标志位
        rw->flags = RW_REALIZED|RW_REALIZING|isMeta;
        // 设置rw
        cls->setData(rw);
    }

    // 创建 cache
    cls->cache.initializeToEmptyOrPreoptimizedInDisguise();

#if FAST_CACHE_META
    if (isMeta) cls->cache.setBit(FAST_CACHE_META);
#endif

    /**
    选取在Class数组中的下标
    有个全局变量 objc_indexed_classes_count会递增
    全局数组用来保存Class Class objc_indexed_classes[1] = { nil };

    放入 objc_indexed_classes 是在
     */
    cls->chooseClassArrayIndex();

。。。
    
    // 父类
    supercls = realizeClassWithoutSwift(remapClass(cls->getSuperclass()), nil);
    // 元类
    metacls = realizeClassWithoutSwift(remapClass(cls->ISA()), nil);

#if SUPPORT_NONPOINTER_ISA
    。。。
// SUPPORT_NONPOINTER_ISA
#endif

    // Update superclass and metaclass in case of remapping
    // 设置父类
    cls->setSuperclass(supercls);
    // 设置类的ISA为metaClass
    cls->initClassIsa(metacls);

    // Reconcile instance variable offsets / layout.
    // This may reallocate class_ro_t, updating our ro variable.
    /**
     存在父类并且不是元类
     调整成员变量偏移量/布局，可能会重新创建 ro，并更新成员变量
     */
    if (supercls  &&  !isMeta) reconcileInstanceVariables(cls, supercls, ro);

    // Set fastInstanceSize if it wasn't set already.
    cls->setInstanceSize(ro->instanceSize);

    // Copy some flags from ro to rw
    // 将一些标志位从ro复制到rw
    if (ro->flags & RO_HAS_CXX_STRUCTORS) {
        cls->setHasCxxDtor();
        if (! (ro->flags & RO_HAS_CXX_DTOR_ONLY)) {
            cls->setHasCxxCtor();
        }
    }
    
    // Propagate the associated objects forbidden flag from ro or from
    // the superclass.
    if ((ro->flags & RO_FORBIDS_ASSOCIATED_OBJECTS) ||
        (supercls && supercls->forbidsAssociatedObjects()))
    {
        rw->flags |= RW_FORBIDS_ASSOCIATED_OBJECTS;
    }

    // Connect this class to its superclass's subclass lists
    if (supercls) {
        // 如果存在父类，添加到其子类列表中
        addSubclass(supercls, cls);
    } else {
        /**
         设置根类：全局变量 _firstRealizedClass
         
         ***********************************************************************
         * _firstRealizedClass
         * The root of all realized classes
         **********************************************************************
         static Class _firstRealizedClass = nil;
         
         */
        addRootClass(cls);
    }

    // Attach categories
    /***********************************************************************
    添加分类
    * Fixes up cls's method list, protocol list, and property list.
    **********************************************************************/
    methodizeClass(cls, previously);

    return cls;
}

1.2 实现Swift类

注意点
- Metaclasses never have a Swift initializer.
- Root classes never have a Swift initializer.
- (These two together avoid initialization order problems at the root.)
  - 这两条避免了初始化的顺序错乱的问题
- 没有initializer的Swift类也不存在拥有initializer的父类
  - 在realizeClassWithoutSwift()内无须扫描父类

static Class realizeSwiftClass(Class cls)
{
。。。

    if (auto init = cls->swiftMetadataInitializer()) {
        // 有Swift元数据初始化方法
        。。。
        Class newcls = init(cls, nil);

        if (cls != newcls) {
            mutex_locker_t lock(runtimeLock);
            addRemappedClass(cls, newcls);
        }
        return newcls;
    }
    else {
        // 没有Swift初始化方法，直接调用OC的
        mutex_locker_t lock(runtimeLock);
        return realizeClassWithoutSwift(cls, nil);
    }
}

二、初始化类：initializeAndLeaveLocked

相比Realize的流程，初始化的流程相对简单。我画了个流程图。

三、总结

Realize
- 主要完成类的基础结构的搭建
  - 如ISA链和继承链，rw，ro
Initialize
- 找到非元类的Class
- 标志位处理
- +initialize方法调用

动态决议与消息转发

Sun, 01 Aug 2021 00:00:00 GMT

前言

在上一文中我们有探究到objc_msgSend相关的一些底层原理。

我们发现在慢速查找的过程中有这样
- forward_imp 消息转发
- resolveMethod_locked 动态决议
本文就将对这两个地方做深入探究

IMP lookUpImpOrForward(id inst, SEL sel, Class cls, int behavior)
{
    const IMP forward_imp = (IMP)_objc_msgForward_impcache;
    IMP imp = nil;
    Class curClass;
    
    ...

    for (unsigned attempts = unreasonableClassCount();;) {
        if (curClass->cache.isConstantOptimizedCache(/* strict */true)) {
            ...
        } else {
            ...
            if (slowpath((curClass = curClass->getSuperclass()) == nil)) {
                // No implementation found, and method resolver didn't help.
                // Use forwarding.
                imp = forward_imp;
                break;
            }
        }

        ...
    }

    // No implementation found. Try method resolver once.
    if (slowpath(behavior & LOOKUP_RESOLVER)) {
        behavior ^= LOOKUP_RESOLVER;
        return resolveMethod_locked(inst, sel, cls, behavior);
    }

    ...

 done_unlock:
    runtimeLock.unlock();
    if (slowpath((behavior & LOOKUP_NIL) && imp == forward_imp)) {
        return nil;
    }
    return imp;
}

先附上一张流程图

仅从源码分析会很困难，结合代码调试各种情况，和这张流程图可以更好的理解整个流程的细节
我自己也反复调试了很多次才理的差不多，以前知道这些东西，但没有深入底层去理解细节
这张图也改了好几次

一、 _objc_msgForward_impcache

通过在源码objc-msg-arm64.s中搜索我们一步步找到核心代码

__objc_msgForward_impcache

STATIC_ENTRY __objc_msgForward_impcache

// No stret specialization.
b	__objc_msgForward

END_ENTRY __objc_msgForward_impcache

__objc_msgForward

ENTRY __objc_msgForward

adrp	x17, __objc_forward_handler@PAGE
ldr	p17, [x17, __objc_forward_handler@PAGEOFF]
TailCallFunctionPointer x17

END_ENTRY __objc_msgForward

__objc_forward_handler

我们并没有找到 __objc_forward_handler
- 怀疑不是汇编代码，去掉_试试

objc_defaultForwardHandler

找到了下面的代码。

// Default forward handler halts the process.
__attribute__((noreturn, cold)) void
objc_defaultForwardHandler(id self, SEL sel)
{
    /**
    打印一些信息
    这里就有我们常看到的 unrecognized selector 的相关崩溃新系了
    */ 
    _objc_fatal("%c[%s %s]: unrecognized selector sent to instance %p "
                "(no message forward handler is installed)", 
                class_isMetaClass(object_getClass(self)) ? '+' : '-', 
                object_getClassName(self), sel_getName(sel), self);
}
void *_objc_forward_handler = (void*)objc_defaultForwardHandler;

二、 resolveMethod_locked

static NEVER_INLINE IMP
resolveMethod_locked(id inst, SEL sel, Class cls, int behavior)
{
    ...

    if (! cls->isMetaClass()) {
        // 对象方法（cls不是元类），理解ISA关系图这里就会比较清楚的
        // try [cls resolveInstanceMethod:sel]
        resolveInstanceMethod(inst, sel, cls);
    } 
    else {
        // 类方法
        // try [nonMetaClass resolveClassMethod:sel]
        // and [cls resolveInstanceMethod:sel]
        resolveClassMethod(inst, sel, cls);
        if (!lookUpImpOrNilTryCache(inst, sel, cls)) {
            resolveInstanceMethod(inst, sel, cls);
        }
    }

    // chances are that calling the resolver have populated the cache
    // so attempt using it
    return lookUpImpOrForwardTryCache(inst, sel, cls, behavior);
}

三、实例方法动态决议

这里声明一个实例方法，但不做实现。触发调用

- (void)noIMP;

[obj noIMP];

会见到我们常见的一个崩溃信息：

libc++abi: terminating with uncaught exception of type NSException
*** Terminating app due to uncaught exception 'NSInvalidArgumentException', reason: '-[RYModel noIMP]: unrecognized selector sent to instance 0x100677a40'
terminating with uncaught exception of type NSException

3.1 动态添加Method

重写 + (BOOL)resolveInstanceMethod:(SEL)sel 添加method

- (void)callNoIMPSel {
    NSLog(@"调用了没IMP的SEL");
}

+ (BOOL)resolveInstanceMethod:(SEL)sel {
    if (sel == @selector(noIMP)) {
        IMP safeIMP = class_getMethodImplementation(self, @selector(callNoIMPSel));
        Method method =  class_getInstanceMethod(self, @selector(callNoIMPSel));
        const char *type = method_getTypeEncoding(method);
        NSLog(@"对%@进行动态决议", NSStringFromSelector(sel));
        return class_addMethod(self, sel, safeIMP, type);
    }
    return [super resolveInstanceMethod:sel];
}

输出：

对noIMP进行动态决议
调用了没IMP的SEL

3.2 如果再次调用，还会不会进行动态决议呢？

理论分析：第一次添加了Method后，会同步插入到方法缓存中，所以第二次执行就不会再次添加。

实际运行结果也验证了刚才的分析。

对noIMP进行动态决议
调用了没IMP的SEL
调用了没IMP的SEL

3.3 源码解析

static void resolveInstanceMethod(id inst, SEL sel, Class cls)
{
    ...
    SEL resolve_sel = @selector(resolveInstanceMethod:);

    ...

    BOOL (*msg)(Class, SEL, SEL) = (typeof(msg))objc_msgSend;
    // 直接调用 objc_msgSend 调用 resolveInstanceMethod:
    bool resolved = msg(cls, resolve_sel, sel);

    // 动态决议处理后来到这里
    // Cache the result (good or bad) so the resolver doesn't fire next time.
    // +resolveInstanceMethod adds to self a.k.a. cls
    IMP imp = lookUpImpOrNilTryCache(inst, sel, cls);

        if (resolved  &&  PrintResolving) {
            if (imp) {
                ...
            }
            else {
                // Method resolver didn't add anything?
                ...
            }
        }
}

static IMP _lookUpImpTryCache(id inst, SEL sel, Class cls, int behavior)
{
    ...

    IMP imp = cache_getImp(cls, sel);
    if (imp != NULL) goto done;
#if CONFIG_USE_PREOPT_CACHES
    。。。
#endif
    if (slowpath(imp == NULL)) {
        // 再查找
        return lookUpImpOrForward(inst, sel, cls, behavior);
    }

done:
    if ((behavior & LOOKUP_NIL) && imp == (IMP)_objc_msgForward_impcache) {
        // 需要转发
        return nil;
    }
    return imp;
}

四、类方法动态决议

4.1 动态添加Method

+ (BOOL)resolveClassMethod:(SEL)sel {
    if (sel == @selector(noClassIMP)) {
        IMP safeIMP = class_getMethodImplementation(self, @selector(callClassNoIMPSel));
        Method method =  class_getClassMethod(self, @selector(callClassNoIMPSel));
        const char *type = method_getTypeEncoding(method);
        NSLog(@"对%@进行动态决议（类方法）", NSStringFromSelector(sel));
        return class_addMethod(self, sel, safeIMP, type);
    }
    return [super resolveClassMethod:sel];
}

如果你写成上面的样子，你会发现依旧会崩溃。根本没生效。
为什么呢？
如果你不知道为什么，你需要首先搞明白 类方法存在哪里
- 深入探索Class的结构这篇文章可以带你了解

正确的实现方式：

+ (BOOL)resolveClassMethod:(SEL)sel {
    if (sel == @selector(noClassIMP)) {
        Class meta = objc_getMetaClass("RYModel");
        IMP safeIMP = class_getMethodImplementation(meta, @selector(callClassNoIMPSel));
        Method method =  class_getClassMethod(meta, @selector(callClassNoIMPSel));
        const char *type = method_getTypeEncoding(method);
        NSLog(@"对%@进行动态决议（类方法）", NSStringFromSelector(sel));
        return class_addMethod(meta, sel, safeIMP, type);
    }
    return [super resolveClassMethod:sel];
}

输出：

对noClassIMP进行动态决议（类方法）
调用了Class没IMP的SEL

4.2 类方法动态决议的特殊处理

在源码中及流程图中可以发现，在 resolveClassMethod 之后如果缓存中还没有对应的Method的话就会再去调用 resolveInstanceMethod。

// try [nonMetaClass resolveClassMethod:sel]
// and [cls resolveInstanceMethod:sel]
resolveClassMethod(inst, sel, cls);
if (!lookUpImpOrNilTryCache(inst, sel, cls)) {
    resolveInstanceMethod(inst, sel, cls);
}

可见苹果工程师也是操碎了心啊，给了好多机会来让我们不要崩溃

五、消息转发

在 lookUpImpOrForward 中我们找到 _objc_msgForward_impcache

IMP lookUpImpOrForward(id inst, SEL sel, Class cls, int behavior)
{
    const IMP forward_imp = (IMP)_objc_msgForward_impcache;
    ...
}

5.1 寻找切入点

发现其实现在 objc-msg-arm64.s 中

__objc_msgForward_impcache

STATIC_ENTRY __objc_msgForward_impcache

// No stret specialization.
b	__objc_msgForward

END_ENTRY __objc_msgForward_impcache

__objc_msgForward

ENTRY __objc_msgForward

adrp	x17, __objc_forward_handler@PAGE
ldr	p17, [x17, __objc_forward_handler@PAGEOFF]
TailCallFunctionPointer x17

END_ENTRY __objc_msgForward

_objc_forward_handler

我们有进一步找到了 _objc_forward_handler
- 拥有一个默认的实现： objc_defaultForwardHandler
- 以及一个set方法：objc_setForwardHandler

#if !__OBJC2__

...

#else
    // Default forward handler halts the process.
    __attribute__((noreturn, cold)) void
    objc_defaultForwardHandler(id self, SEL sel)
    {
        _objc_fatal("%c[%s %s]: unrecognized selector sent to instance %p "
                    "(no message forward handler is installed)", 
                    class_isMetaClass(object_getClass(self)) ? '+' : '-', 
                    object_getClassName(self), sel_getName(sel), self);
    }
    void *_objc_forward_handler = (void*)objc_defaultForwardHandler;

    #if SUPPORT_STRET (ARM64 = 0)
    ...
    #endif

#endif

void objc_setForwardHandler(void *fwd, void *fwd_stret)
{
    _objc_forward_handler = fwd;
#if SUPPORT_STRET
    _objc_forward_stret_handler = fwd_stret;
#endif
}

进一步搜索 setForwardHandler 并未发现相关调用，推测调用处不在OC源码中。

分析Log

发现调用了 CoreFoundation 中的 ___forwarding___ 方法。

*** First throw call stack:
(
    ...
	3   CoreFoundation                      0x00007fff203f790b ___forwarding___ + 1448
	4   CoreFoundation                      0x00007fff203f72d8 _CF_forwarding_prep_0 + 120
    ...
)

那么怎么去进一步分析呢？

5.2 汇编分析 CoreFoundation`forwarding:

forwardingTargetForSelector:

0x7fff203f741b <+184>: mov r14, qword ptr [rip + 0x604ed906] ; "forwardingTargetForSelector:"

通过这条指令我们发现一个 forwardingTargetForSelector:

我们找下源码，根据命名推测这个方法用来是转发消息给某个对象的。

我们下个断点：

+ (id)forwardingTargetForSelector:(SEL)sel {
    return nil;
}

- (id)forwardingTargetForSelector:(SEL)sel {
    return nil;
}

发现断点确实走到了这里，输出堆栈信息：

(lldb) bt
* thread #1, queue = 'com.apple.main-thread', stop reason = breakpoint 3.1
  * frame #0: 0x00000001003548f2 libobjc.A.dylib`-[NSObject forwardingTargetForSelector:](self=0x000000010132f350, _cmd="forwardingTargetForSelector:", sel="noIMP") at NSObject.mm:2451:5
    frame #1: 0x00007fff203f7444 CoreFoundation`___forwarding___ + 225
    frame #2: 0x00007fff203f72d8 CoreFoundation`_CF_forwarding_prep_0 + 120
    frame #3: 0x00000001000033d0 KCObjcBuild`main(argc=1, argv=0x00007ffeefbff4a0) at main.m:23:9 [opt]
    frame #4: 0x00007fff20337f5d libdyld.dylib`start + 1

接下来我们试着在这里返回一个对象来接收消息看看效果。

@implementation RYModel
- (id)forwardingTargetForSelector:(SEL)sel {
    return [[RYSubModel alloc] init];
}
@end

@implementation RYSubModel
- (void)noIMP {
    NSLog(@"%s",__func__);
}
@end

运行后执行正常，输出了 -[RYSubModel noIMP]。

5.3 转发对象为空的情况

当不实现 forwardingTargetForSelector 的时候，我们发现，经过一次动态决议默认返回 nil 后，又一次进入了 动态决议

// 一次动态决议
+[RYModel resolveInstanceMethod:]--noIMP

// 打印堆栈信息
(lldb) bt
* thread #1, queue = 'com.apple.main-thread', stop reason = breakpoint 6.1
  * frame #0: 0x000000010031682a libobjc.A.dylib`lookUpImpOrForward(inst=0x0000000000000000, sel="noIMP", cls=RYModel, behavior=2) at objc-runtime-new.mm:6536:9
    frame #1: 0x00000001002edcb9 libobjc.A.dylib`class_getInstanceMethod(cls=RYModel, sel="noIMP") at objc-runtime-new.mm:6192:5
    frame #2: 0x00007fff2040d653 CoreFoundation`__methodDescriptionForSelector + 276
    frame #3: 0x00007fff20426fa0 CoreFoundation`-[NSObject(NSObject) methodSignatureForSelector:] + 30
    frame #4: 0x00007fff203f74ef CoreFoundation`___forwarding___ + 396
    frame #5: 0x00007fff203f72d8 CoreFoundation`_CF_forwarding_prep_0 + 120
    frame #6: 0x00000001000034d0 KCObjcBuild`main + 64
    frame #7: 0x00007fff20337f5d libdyld.dylib`start + 1

// 打印变量信息
(lldb) po inst
 nil
(lldb) po sel
"noIMP"

(lldb) po cls
objc[3185]: mutex incorrectly locked
objc[3185]: mutex incorrectly locked
RYModel

(lldb) po behavior
2

behavior == 2 == LOOKUP_RESOLVER
- 满足动态决议的条件，再次进行动态决议
- behavior ^= LOOKUP_RESOLVER
  - behavior变成0了

六、总结

这部分的理解还是需要结合调试，单纯看源码很难理清楚，有太多嵌套调用。

希望我的流程图能帮助理解，有不对的地方也欢迎指出。

iOS应用启动（四）：分类的加载

Sun, 01 Aug 2021 00:00:00 GMT

前言

我们在12.类的实现与初始化中实现类 realizeClass 的流程最后一步发现是处理分类 methodizeClass。本文就将以此为入口，深入探索 什么是分类。

一、 methodizeClass

处理方法列表、协议列表、属性列表，添加分类。

重要部分见注释：

1.1 attachToClass 将分类添加到类

继续调用 attachCategories，通过初步阅读源码，发现此处为核心步骤，下面进行具体分析

二、 attachCategories

这里对源码中两处重要的注释做翻译：

添加分类的方法列表、属性、协议到类
最早加载的分类在最顶部
只有很少的类在运行时会有超过64个分类
这里使用一个小容量的栈
分类必须按照合适的顺序添加，这里会从前向后读取，从后向前创建本地缓存，并调用 attachLists。所以最后的顺序是对的。

// Attach method lists and properties and protocols from categories to a class.
// Assumes the categories in cats are all loaded and sorted by load order, 
// oldest categories first.
static void
attachCategories(Class cls, const locstamped_category_t *cats_list, uint32_t cats_count,
                 int flags)
{
。。。
    /*
     * Only a few classes have more than 64 categories during launch.
     * This uses a little stack, and avoids malloc.
     *
     * Categories must be added in the proper order, which is back
     * to front. To do that with the chunking, we iterate cats_list
     * from front to back, build up the local buffers backwards,
     * and call attachLists on the chunks. attachLists prepends the
     * lists, so the final result is in the expected order.
     */
    constexpr uint32_t ATTACH_BUFSIZ = 64;
    method_list_t   *mlists[ATTACH_BUFSIZ];
    property_list_t *proplists[ATTACH_BUFSIZ];
    protocol_list_t *protolists[ATTACH_BUFSIZ];

    uint32_t mcount = 0;
    uint32_t propcount = 0;
    uint32_t protocount = 0;
    bool fromBundle = NO;
    bool isMeta = (flags & ATTACH_METACLASS);
    // 创建 rwe
    auto rwe = cls->data()->extAllocIfNeeded();

    // 循环添加方法、属性、协议
    for (uint32_t i = 0; i < cats_count; i++) {
        auto& entry = cats_list[i];

        method_list_t *mlist = entry.cat->methodsForMeta(isMeta);
        if (mlist) {
            if (mcount == ATTACH_BUFSIZ) {
                prepareMethodLists(cls, mlists, mcount, NO, fromBundle, __func__);
                rwe->methods.attachLists(mlists, mcount);
                mcount = 0;
            }
            mlists[ATTACH_BUFSIZ - ++mcount] = mlist;
            fromBundle |= entry.hi->isBundle();
        }

        property_list_t *proplist =
            entry.cat->propertiesForMeta(isMeta, entry.hi);
        if (proplist) {
            if (propcount == ATTACH_BUFSIZ) {
                rwe->properties.attachLists(proplists, propcount);
                propcount = 0;
            }
            proplists[ATTACH_BUFSIZ - ++propcount] = proplist;
        }

        protocol_list_t *protolist = entry.cat->protocolsForMeta(isMeta);
        if (protolist) {
            if (protocount == ATTACH_BUFSIZ) {
                rwe->protocols.attachLists(protolists, protocount);
                protocount = 0;
            }
            protolists[ATTACH_BUFSIZ - ++protocount] = protolist;
        }
    }

    if (mcount > 0) {
        prepareMethodLists(cls, mlists + ATTACH_BUFSIZ - mcount, mcount,
                           NO, fromBundle, __func__);
        rwe->methods.attachLists(mlists + ATTACH_BUFSIZ - mcount, mcount);
        if (flags & ATTACH_EXISTING) {
            flushCaches(cls, __func__, [](Class c){
                // constant caches have been dealt with in prepareMethodLists
                // if the class still is constant here, it's fine to keep
                return !c->cache.isConstantOptimizedCache();
            });
        }
    }

    rwe->properties.attachLists(proplists + ATTACH_BUFSIZ - propcount, propcount);

    rwe->protocols.attachLists(protolists + ATTACH_BUFSIZ - protocount, protocount);
}

2.1 流程

extAllocIfNeeded 创建 rwe
循环添加方法、属性、协议

三、分类加载的时机

我们直到类添加分类的核心逻辑是 attachCategories。我们全局搜索一下 attachCategories。

attachToClass

load_categories_nolock

有上面两处进行了调用。

3.1 测试代码准备

自定义类

@interface RYCat : NSObject

@property (nonatomic, copy) NSString *nick;
@property (nonatomic, assign) NSInteger age;

- (void)yeah;
- (void)yeah2;
- (void)yeah3;

@end

分类

@interface RYCat (CateA)

- (void)funcA;
- (void)funcA2;
- (void)funcA3;

@end

main函数

RYCat *cat = [RYCat alloc];
[cat funcA];

3.1 添加断点及日志

3.2 场景一：分类有Load✅ 主类有Load✅ （非懒加载）

Log如下：

_read_images -- RYCat
realizeClassWithoutSwift -- RYCat
attachToClass -- RYCat
realizeClassWithoutSwift -- RYCat
attachToClass -- RYCat
load_categories_nolock -- RYCat -- CateA
attachCategories -- RYCat -- CateA
attachCategories -- RYCat -- CateA
+[RYCat load]
+[RYCat(CateA) load]
-[RYCat(CateA) funcA]
Program ended with exit code: 0

流程：

_read_images
- realizeClassWithoutSwift
  - attachToClass
    - load_categories_nolock
      - attachCategories

3.3 场景二：分类有Load✅ 主类无Load❌ （非懒加载）

Log如下：

_read_images -- RYCat
realizeClassWithoutSwift -- RYCat
attachToClass -- RYCat
realizeClassWithoutSwift -- RYCat
attachToClass -- RYCat
+[RYCat(CateA) load]
-[RYCat(CateA) funcA]
Program ended with exit code: 0

流程：

_read_images
- realizeClassWithoutSwift
  - attachToClass

注意到：并没有调用 attachCategories。

非懒加载

虽然主类未实现+load方法，但是分类实现了，那么主类也是非懒加载的。

3.4 场景三：分类无Load❌ 主类有Load✅ （非懒加载）

Log如下：

_read_images -- RYCat
realizeClassWithoutSwift -- RYCat
attachToClass -- RYCat
realizeClassWithoutSwift -- RYCat
attachToClass -- RYCat
+[RYCat load]
-[RYCat(CateA) funcA]
Program ended with exit code: 0

流程：

_read_images
- realizeClassWithoutSwift
  - attachToClass

注意到：和 分类有Load✅ 主类无Load❌ 一样，没有调用 attachCategories。

3.5 场景四：分类无Load❌ 主类无Load错❌ （懒加载）

Log如下：

realizeClassWithoutSwift -- RYCat
attachToClass -- RYCat
realizeClassWithoutSwift -- RYCat
attachToClass -- RYCat
Program ended with exit code: 0

注意到：和 3.3和3.4 一样，没有调用 attachCategories。

思考：为什么没有调用 `attachCategories`

编译器优化了，直接把分类的数据合并到了主类中。

四、多分类 `+load` 执行顺序

如果有多个分类，执行的顺序是什么样的呢？

如图创建两个分类，分别实现 +load 方法。思考一下执行的顺序是什么样的呢？为什么呢？

4.1 顺序

按顺序输出如下：

+[RYCat load]
+[RYCat(CateA) load]
+[RYCat(CateB) load]

我们先看下编译顺序：

调整一下编译顺序看有没有影响：

调整编译顺序后输出如下：

+[RYCat load]
+[RYCat(CateB) load]
+[RYCat(CateA) load]

4.2 结论

多分类的情况下，+load 的执行顺序是和编译的顺序有关的。

五、多分类同名方法执行顺序

如果多个分类由同名的方法，又会是怎样的顺序呢？

在两个分类中声明实现同名的 funcA

在多分类 +load 执行顺序中我们知道，编译的顺序影响了各个分类的表现，这里我们也进行一下区分

5.1 CateA 比 CateB 先编译

+[RYCat load]
+[RYCat(CateA) load]
+[RYCat(CateB) load]
-[RYCat(CateB) funcA]

5.2 CateB 比 CateA 先编译

+[RYCat load]
+[RYCat(CateA) load]
+[RYCat(CateB) load]
-[RYCat(CateA) funcA]

5.3 在主类中也声明并实现 funcA （CateB 比 CateA 先编译）

+[RYCat load]
+[RYCat(CateA) load]
+[RYCat(CateB) load]
-[RYCat(CateA) funcA]

5.4 总结

可见：多个分类拥有同名方法时，先编译的分类的方法会被后编译的分类覆盖掉。如果主类中也有同名方法也会被覆盖掉。

思考

对启动速度的影响

在 3.2 主类分类都有实现 Load方法 的时候可见整个流程流程会复杂一下，所以减少这种场景的出现，是有助于提升应用启动速度。

关联对象源码解析

Sun, 01 Aug 2021 00:00:00 GMT

前言

为分类添加关联对象是我们比较常用的，但是你真的了解关联对象么？

本文基于 objc4-818.2 源码

一、关联对象

由于分类的属性不会生产相关的成员变量，所以我们需要自己实现 set/get 方法。如下：

// .h

@property (nonatomic, copy) NSString *cateName;


// .m
- (void)setCateName:(NSString *)cateName {
    objc_setAssociatedObject(self, "cateName", cateName, OBJC_ASSOCIATION_COPY_NONATOMIC);
}

- (NSString *)cateName {
    return  objc_getAssociatedObject(self, "cateName");
}

那么，objc_setAssociatedObject 和 objc_getAssociatedObject，究竟做了什么呢？

二、 objc_setAssociatedObject

实际调用了 _object_set_associative_reference

2.1 AssociationsHashMap

通过断点我们发现了一个 AssociationsHashMap。

可以看出它是一个 全局静态 的 Storage 类型的 HashMap。用来保存运行时所有的关联对象的关联关系。

2.2 try_emplace

如果表中没有的话，就将键值对插入表中。

Inserts key,value pair into the map if the key isn't already in the map. The value is constructed in-place if the key is not in the map, otherwise it is not moved.

一次 set 两次调用了 try_emplace

通过代码可以看出，一次set关联值，会调用两次 try_emplace。

auto refs_result = associations.try_emplace(disguised, ObjectAssociationMap{});
- 只用来检查是否存在关联对象的 key ObjectAssociationMap{} 是个空的不做处理
auto result = refs.try_emplace(key, std::move(association));
- 这里才是真的设置 value

触发set

通过调用 LookupBucketFor 查找表中是否已经存在了对应的关联对象。

第一次调用set方法

第二次调用set方法

2.3 LookupBucketFor

和查找方法缓存的算法基本一致。

2.4 InsertIntoBucket

插入表中

template <typename KeyArg, typename... ValueArgs>
BucketT *InsertIntoBucket(BucketT *TheBucket, KeyArg &&Key,
                        ValueArgs &&... Values) {
TheBucket = InsertIntoBucketImpl(Key, Key, TheBucket);

// first 就是 key
TheBucket->getFirst() = std::forward<KeyArg>(Key);

// second 是Value
::new (&TheBucket->getSecond()) ValueT(std::forward<ValueArgs>(Values)...);
return TheBucket;
}

三、关联对象释放

思考：在对象 dealloc 的时候，会自动清理管理那对象么？

3.1 dealloc

我们从 dealloc 开始找：

dealloc
- _objc_rootDealloc
  - rootDealloc
    - 如果有关联对象
    - object_dispose
      - objc_destructInstance
        
        _object_remove_assocations
        
        来释放关联对象

void
_object_remove_assocations(id object, bool deallocating)
{
    ObjectAssociationMap refs{};
    
    {
        AssociationsManager manager;
        AssociationsHashMap &associations(manager.get());
        AssociationsHashMap::iterator i = associations.find((objc_object *)object);
        if (i != associations.end()) {
            refs.swap(i->second);

            // If we are not deallocating, then SYSTEM_OBJECT associations are preserved.
            bool didReInsert = false;
            if (!deallocating) {
                for (auto &ref: refs) {
                    if (ref.second.policy() & OBJC_ASSOCIATION_SYSTEM_OBJECT) {
                        i->second.insert(ref);
                        didReInsert = true;
                    }
                }
            }
            if (!didReInsert)
                associations.erase(i);
        }
    }

    // Associations to be released after the normal ones.
    SmallVector<ObjcAssociation *, 4> laterRefs;

    // release everything (outside of the lock).
    for (auto &i: refs) {
        if (i.second.policy() & OBJC_ASSOCIATION_SYSTEM_OBJECT) {
            // If we are not deallocating, then RELEASE_LATER associations don't get released.
            if (deallocating)
                laterRefs.append(&i.second);
        } else {
            i.second.releaseHeldValue();
        }
    }
    for (auto *later: laterRefs) {
        later->releaseHeldValue();
    }
}

删除链表的节点

Thu, 29 Jul 2021 00:00:00 GMT

本题较为简单，熟悉链表应该达到随手就能解出的程度

题目

给定单向链表的头指针和一个要删除的节点的值，定义一个函数删除该节点。

返回删除后的链表的头节点。

注意：此题对比原题有改动

示例 1:

输入: head = [4,5,1,9], val = 5
输出: [4,1,9]
解释: 给定你链表中值为 5 的第二个节点，那么在调用了你的函数之后，该链表应变为 4 -> 1 -> 9.

示例 2:

输入: head = [4,5,1,9], val = 1
输出: [4,5,9]
解释: 给定你链表中值为 1 的第三个节点，那么在调用了你的函数之后，该链表应变为 4 -> 5 -> 9.

说明：

题目保证链表中节点的值互不相同若使用 C 或 C++ 语言，你不需要 free 或 delete 被删除的节点

来源：力扣（LeetCode）

链接：https://leetcode-cn.com/problems/shan-chu-lian-biao-de-jie-dian-lcof

著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

一、思路

本题意在移除一个节点，即：

1 -> 2 -> 3 -> 4 -> 5

如果要移除3节点，就要将2节点的next指向4。所以在遍历链表的时候我们在找到移除目标的时候，需要直到上个节点是什么。

这里引入一个指针 lastNode 保存上个节点，遍历时 currentNode 作为指向当前节点的指针。

遇到目标节点后，将当前节点的 next 赋值给 lastNode 的 next，返回 head。

二、双指针解法

func deleteNode(_ head: ListNode?, _ val: Int) -> ListNode? {
    var lastNode: ListNode?
    var currentNode = head
    
    while let node = currentNode {
        if node.val == val {
            if let last = lastNode {
                last.next = node.next
                return head
            }
            else {
                return node.next
            }
        }
        
        lastNode = node
        currentNode = node.next
    }
    
    return head
}

三、单指针解法

func deleteNode2(_ head: ListNode?, _ val: Int) -> ListNode? {
    if head?.val == val {
        return head?.next
    }
    var currentNode = head
    while let node = currentNode?.next {
        if node.val == val {
            currentNode?.next = node.next
            return head
        }
        else {
            currentNode = currentNode?.next
        }
    }
    return head
}

最小的k个数

Thu, 29 Jul 2021 00:00:00 GMT

题目

输入整数数组 arr ，找出其中最小的 k 个数。例如，输入4、5、1、6、2、7、3、8这8个数字，则最小的4个数字是1、2、3、4。

示例 1：

输入：arr = [3,2,1], k = 2
输出：[1,2] 或者 [2,1]

示例 2：

输入：arr = [0,1,2,1], k = 1
输出：[0]

限制：

0 <= k <= arr.length <= 10000
0 <= arr[i] <= 10000

来源：力扣（LeetCode）

链接：https://leetcode-cn.com/problems/zui-xiao-de-kge-shu-lcof

著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

一、暴力解法

先排序，然后直接取。

func getLeastNumbers(_ arr: [Int], _ k: Int) -> [Int] {
    if k == 0 { return [] }
    if arr.count <= k { return arr }
    let rearr: [Int] = arr.sorted { $0 <= $1 }
    return Array(rearr[0...k-1])
}

作为优秀的程序员，虽然可以这么解，但是不应该。虽然从结果看，Swift的排序算法效率非常高。

二、快速排序

func getLeastNumbers(_ arr: [Int], _ k: Int) -> [Int] {
    if k == 0 { return [] }
    if arr.count <= k { return arr }
    let result = quickSort(arr)
    return Array(result[0...k-1])
}

2.1 辅助空间

此法较为容易理解

func quickSort<T: Comparable>(_ arr: [T]) -> [T] {
    guard let base = arr.first, arr.count > 1 else {
        return arr
    }
    
    var left: [T] = []
    var right: [T] = []
    var result: [T] = []

    for index in 1..<arr.count {
        let value = arr[index]
        if value < base {
            left.append(value)
        }
        else {
            right.append(value)
        }
    }
        
    result = quickSort(left)
    result.append(base)
    result.append(contentsOf: quickSort(right))
    
    return result
}

2.2 原地快排

func getLeastNumbers(_ arr: [Int], _ k: Int) -> [Int] {
    if k == 0 { return [] }
    if arr.count <= k { return arr }
    var result = arr
    quickSort(&result, 0, arr.count - 1, k)
    return Array(result[0...k-1])
}

原地快速排序

func quickSort<T: Comparable>(_ arr: inout [T], _ low: Int, _ high: Int, _ k: Int) {
    let res = partition(&arr, low: low, high: high)
    if res == k {
        return
    }
    else if res > k {
        quickSort2(&arr, low, res-1, k)
    }
    else {
        quickSort2(&arr, res+1, high, k)
    }
}

确定基准元素的下标

func partition<T: Comparable>(_ arr: inout [T], low: Int, high: Int) -> Int {
    let root = arr[high]
    var index = low
    for i in low...high {
        if arr[i] < root {
            if i != index {
                arr.swapAt(i, index)
            }
            index = index+1
        }
    }
    
    if high != index {
        arr.swapAt(high, index)
    }
    return index
}

三、优先队列

什么是优先队列
- 按照一定条件给定的条件
- 每次加入元素都会进行排序
- 优先级最高的元素上浮到首位

本题我们可以：

限制队列元素数量
更大的元素具有更高优先级
当队列达到k值后
移除最高优先级的元素
最后剩下的就是最小的k个元素了

首先我们需要实现一下优先队列

优先队列实现

public struct SwiftPriorityQueue<Element> {
    private let _hasHigherPriority: (Element, Element) -> Bool
    private let _isEqual: (Element, Element) -> Bool

    private var _elements = [Element]()

    public init(hasHigherPriority: @escaping (Element, Element) -> Bool, isEqual: @escaping (Element, Element) -> Bool) {
        _hasHigherPriority = hasHigherPriority
        _isEqual = isEqual
    }

    public mutating func enqueue(_ element: Element) {
        _elements.append(element)
        bubbleToHigherPriority(_elements.count - 1)
    }

    public func peek() -> Element? {
        return _elements.first
    }
    
    public func array() -> [Element] {
        return _elements
    }

    public var isEmpty: Bool {
        return _elements.count == 0
    }
    
    public var count: Int {
        return _elements.count
    }

    public mutating func dequeue() -> Element? {
        guard let front = peek() else {
            return nil
        }

        removeAt(0)

        return front
    }

    public mutating func remove(_ element: Element) {
        for i in 0 ..< _elements.count {
            if _isEqual(_elements[i], element) {
                removeAt(i)
                return
            }
        }
    }

    private mutating func removeAt(_ index: Int) {
        let removingLast = index == _elements.count - 1
        if !removingLast {
            _elements.swapAt(index, _elements.count - 1)
        }

        _ = _elements.popLast()

        if !removingLast {
            bubbleToHigherPriority(index)
            bubbleToLowerPriority(index)
        }
    }

    private mutating func bubbleToHigherPriority(_ initialUnbalancedIndex: Int) {
        precondition(initialUnbalancedIndex >= 0)
        precondition(initialUnbalancedIndex < _elements.count)

        var unbalancedIndex = initialUnbalancedIndex

        while unbalancedIndex > 0 {
            let parentIndex = (unbalancedIndex - 1) / 2
            guard _hasHigherPriority(_elements[unbalancedIndex], _elements[parentIndex]) else { break }
            _elements.swapAt(unbalancedIndex, parentIndex)
            unbalancedIndex = parentIndex
        }
    }

    private mutating func bubbleToLowerPriority(_ initialUnbalancedIndex: Int) {
        precondition(initialUnbalancedIndex >= 0)
        precondition(initialUnbalancedIndex < _elements.count)

        var unbalancedIndex = initialUnbalancedIndex
        while true {
            let leftChildIndex = unbalancedIndex * 2 + 1
            let rightChildIndex = unbalancedIndex * 2 + 2

            var highestPriorityIndex = unbalancedIndex

            if leftChildIndex < _elements.count && _hasHigherPriority(_elements[leftChildIndex], _elements[highestPriorityIndex]) {
                highestPriorityIndex = leftChildIndex
            }

            if rightChildIndex < _elements.count && _hasHigherPriority(_elements[rightChildIndex], _elements[highestPriorityIndex]) {
                highestPriorityIndex = rightChildIndex
            }

            guard highestPriorityIndex != unbalancedIndex else { break }
            _elements.swapAt(highestPriorityIndex, unbalancedIndex)

            unbalancedIndex = highestPriorityIndex
        }
    }
}

extension SwiftPriorityQueue : CustomDebugStringConvertible {
    public var debugDescription: String {
        return _elements.debugDescription
    }
}

题解

func getLeastNumbers(_ arr: [Int], _ k: Int) -> [Int] {
    var stack = SwiftPriorityQueue<Int>(hasHigherPriority: { $0 > $1 }, isEqual: { $0 == $1 })
    
    arr.forEach { item in
        stack.enqueue(item)
        if stack.count > k {
            stack.dequeue()// 最高优先级的出列（最大的出去）
        }
    }
    
    return stack.array()
}

四、逻辑冒泡

创建固定容量的容器
遍历元素
存满后冒泡排序
继续插入到头
遍历直到遇到大于等于自己的就停止
移除最后一个元素

func getLeastNumbers5(_ arr: [Int], _ k: Int) -> [Int] {
    var result: [Int] = []
    
    guard k > 0 else {
        return result
    }
    
    arr.forEach { item in
        if result.count == k, let min = result.first {
            
            if item <= min {
                result.insert(item, at: 0)
                result.removeLast()
            }
            else {
                result.insert(item, at: 0)
                
                for i in 0..<(result.count - 1) {
                    if result[i] > result[i+1] {
                        result.swapAt(i, i+1)
                    }
                    else {
                        break
                    }
                }
                
                result.removeLast()
            }
        }
        else {
            result.append(item)
            if result.count == k {
                result = result.sorted()
            }
        }
    }
    
    return result
}

基于iCloud构建游戏内排行榜

Wed, 28 Jul 2021 00:00:00 GMT

前言

昨天晚上打开我的扫雷游戏，发现排行榜出Bug了：无尽榜单显示不出来了。

虽然很快改好发版了。觉得有必要整理一下我的排行榜的实现思路。以为后续优化提供方向。

推荐阅读：基于iCloud构建用户体系

一、榜单基础内容

排序逻辑：

游戏等级：越高越靠前
完成时间：越短越靠前

显示元素：

等级
时间
用户昵称
头像

二、数据流

基础数据中除了 游戏等级 完成时间 是在 Rank record 中，Nickname Avatar 都是要二次查找的。由于不存在服务端，所以这些数据处理都要客户端自行包装。

2.1 Rank Table 无尽游戏记录表

2.2 User Table 用户表

2.3 数据逻辑

下面描述一下榜单的数据逻辑吧。

玩家成功完成一场无尽模式游戏
- 前提是 CloudKit 可用
如果 Rank table 中已有该用户创建的记录
- 如果成绩更好：更新最新游戏记录
- 否则丢弃本次游戏记录
如果 Rank table 中没有该用户创建的记录
- 创建一条记录，保存到 Rank table 中
用户进入榜单列表拉取数据 Rank record 数组
- 由于并不存在后端，所以数据关联的逻辑需要自己处理
遍历榜单数据获取用户ID数组
- 遍历用户ID数组，从UserTable中批量查询出对应的 User record 数组。
合并 Rank record & User record 为 Rank item data
- Rank item data 为 Cell 展示的数据
Cell 展示数据

三、用户头像

3.1 Avatar Table

3.2 图片资源加载

虽然 CloudKit 提供了保存资源的能力，但我们去请求资源的时候，它就是直接完整的返回整个数据了。

所以如果将头像数据直接保存在 User record 中的话，列表的请求速度就很恶心了。（虽然一开始我就是这么做的😂）

在上一步的图中可以看到，Avatar 是独立有一张表来存的。这样就为我的 异步加载图片 创造了可能。

参考主流图片缓存框架的思路简单封装了一下。在 Cell 复用的时候异步加载图片资源。

由于不存在URL这种唯一标识，我采用了 User record id + Avatar modificationDate 为图片的唯一标识。

当然用图床URL的形式更方便。但是曾经用七牛做博客图床，然后现在图全挂了，还要自己绑域名（虽然我有）。想想算了还是苹果靠谱点（不要钱）。

四、违规控制

由于榜单内的内容包含了用户自定义的部分如：Nickname Avatar。而且有人的地方就有人搞事。

如果有不好的用户用了一些不好的文案或者头像，对于项目来说是有风险的。平时可能还好，你要是审核的时候被看到那不是妥妥要把你拒掉。

但作为独立开发者（想省钱），我又不可能去接什么审核服务。况且场景本身就把违规的范围控制的很小了，最多两个榜单200条数据。我没事刷一刷看看就行了。

4.1 管理员

为了能快速获得违规用户的ID，我设置了用户角色的字段 manager。拥有该权限的用户直接点击榜单 Cell 就可以复制 User record id。然后进行下一步处理。

4.2 违规内容处理

昵称违规
- 直接置空
头像违规
- 删除头像

最开始这里是直接删除 Avatar Table 中由该用户创建的记录，但是有问题的。思考一下欢迎在评论中回复你想到的问题。其实挺简单的。

4.3 屏蔽用户

在 User Table 中有个 blocked 字段，用以屏蔽用户。

这种用户可以正常用 App，游戏记录也会正常记录，但是在榜单列表中会被过滤掉。

到现在为止，只屏蔽过一个用户，用💛图片，我给他删除一次，还继续上传，然后我就把他屏蔽了🤷‍♂️

五、优化空间

5.1 违规处理

现在违规处理是复制了 User record id 去后台处理。感觉可以直接把处理的动作直接放在App里，处理起来也更高效。

5.2 异步加载图片

现在的封装还挺简单，有空了完善一下开源出来，也方便自己后续项目使用。

5.3 CloudKit 请求

现在在请求方面做了简单的封装，但主要是基于业务的。难以直接套用，还是抽空封装一下把。

前缀和

Tue, 27 Jul 2021 00:00:00 GMT

一、什么是前缀和？

1.1 一维前缀和

一个一维数组X，和它的前缀和数组Y。
那么满足：
- Y[0] = X[0]
- Y[1] = X[0] + X[1]
- Y[2] = X[0] + X[1] + X[2]
- ...
- Y[n] = X[0] + X[1] + ... + X[n]

1.2 二维前缀和

一个二维数组A，和他的前缀和数组B
那么满足：
- B[0,0] = A[0,0]
- B[0,1] = A[0,0] + A[0,1]
- B[1,0] = A[0,0] + A[1,0]
- B[1,1] = A[0,0] + A[0,1] + A[1,0] + A[1,1]
- ...
- 简单描述就是一片矩形区域内的和

二、计算前缀和

2.1 一维前缀和

let nums: [Int] = [...]
// 前缀和数组
var pSum: [Int] = Array(repeating: 0, count: nums.count)

for i in 0..<nums.count {
    if i == 0 {
        pSum[0] = nums[0]
    }
    else {
        pSum[i] = pSum[i - 1] + nums[i]
    }
}

2.2 二维前缀和

二维前缀和其实就是一个矩阵内值的和，而矩阵又可以由两个列数或行数少一的子矩阵组合后，去除重复的部分，然后再加上右下角的值来构成。
即
- B[x,y] = B[x-1,y] + B[x,y-1] - B[x-1, y-1] + A[x,y]

let nums: [[Int]] = [...]
var pSum: [[Int]] = Array(repeating: Array(repeating: 0, count: nums.first?.count ?? 0),
                            count: nums.count)

for y in 0..<nums.count {
    for x in 0..<nums[y].count {
        if x == 0 && y == 0 {
            pSum[0][0] = nums[0][0]
        }
        else if x == 0 {
            pSum[0][y] = pSum[0][y-1] + nums[x][y]
        }
        else if y == 0 {
            pSum[x][0] = pSum[x-1][0] + nums[x][y]
        }
        else {
            pSum[x][y] = pSum[x-1][y] + pSum[x][y-1] - pSum[x-1][y-1] + nums[x][y]
        }
    }
}

三、前缀和的应用

前缀和是一种预处理，用来降低数据查询的时间复杂度。
例如：
- 一个n长度的数组，进行m次查询，每次随机长度，输出每次的和
上面的例子如果暴力解的话，每次都要重头开始到指定下标进行遍历
如果使用前缀和，进行了预处理之后，可以直接查出结果
- 假设l r 为给定的区间，计算区间内的和
- result = x[r] - x[l-1]
- 时间复杂度为O(n+m)

参考

前缀和技巧

【朝夕的ACM笔记】算法基础-前缀和

同余性质

Tue, 27 Jul 2021 00:00:00 GMT

一、题目：⭐️⭐️523. 连续的子数组和

 给你一个整数数组 nums 和一个整数 k ，编写一个函数来判断该数组是否含有同时满足下述条件的连续子数组：
 
 子数组大小 至少为 2 ，且
 子数组元素总和为 k 的倍数。
 如果存在，返回 true ；否则，返回 false 。
 
 如果存在一个整数 n ，令整数 x 符合 x = n * k ，则称 x 是 k 的一个倍数。
 
 示例 1：
 
 输入：nums = [23,2,4,6,7], k = 6
 输出：true
 解释：[2,4] 是一个大小为 2 的子数组，并且和为 6 。
 示例 2：
 
 输入：nums = [23,2,6,4,7], k = 6
 输出：true
 解释：[23, 2, 6, 4, 7] 是大小为 5 的子数组，并且和为 42 。
 42 是 6 的倍数，因为 42 = 7 * 6 且 7 是一个整数。
 示例 3：
 
 输入：nums = [23,2,6,4,7], k = 13
 输出：false
  
 
 提示：
 
 1 <= nums.length <= 10^5
 0 <= nums[i] <= 10^9
 0 <= sum(nums[i]) <= 2^31 - 1
 1 <= k <= 2^31 - 1

二、「同余性质」

在看题解的时候发现了一个非常简便的解法，用到了「同余性质」

想要A-B为k的倍数，只需要a、b模k相同即可

证明

假设 A = xk + a, B = yk + b，A-B为k的倍数
A - B = (xk + a) - (yk + b) = (x+y)k + (a-b) = zk
a-b也为k的倍数，而a、b为A、B模k的值，故两者都在[0,k)区间内
所以：a=b

三、使用同余性质解决上面的题目

3.1 转化

连续子数组元素和转化为求两个下标从0开始连续子数组和的差值问题。

3.2 分析

元素依次累加，创建一个数组用来存下标和模k的值
得到的值模k
- 如果map中不存在该值，根据同余性质，也就是不满足A-B为k的倍数，继续查找
- 如果存在，则说明满足条件，可以return了

3.3 编码

func checkSubarraySum4(_ nums: [Int], _ k: Int) -> Bool {
    if nums.count < 2 {
        return false
    }
    var moMap: [Int : Int] = [:]
    moMap[0] = -1 // 这样才能正确的吧从0开始复合条件的找出来
    var sum: Int = 0
    for (index, n) in nums.enumerated() {
        sum += n
        let mo = sum % k
        print("sum\(sum) > \(mo)")
        if moMap.keys.contains(mo) {
            if let sameMoIndex = moMap[mo], index - sameMoIndex > 1 { // 长度至少为2
                return true
            }
        }
        else {
            moMap[mo] = index
        }
    }
    return false
}

快速幂

Tue, 27 Jul 2021 00:00:00 GMT

前言

幂运算是我们最常用的运算之一。如果我们要求 x 的 N 次幂，那么想当然的就会写出一个 N 次的循环，然后累乘得到结果。这种幂运算的复杂度是O(N)。

var res = 1
for _ in 0..<n {
    res *= x
}
return res

一、快速幂

那么有没有更快的运算方式呢？

在计算机领域有一种常用的快速幂算法：蒙哥马利幂（Montgomery reduction）算法。将复杂度从O(N) 降到了 O(logN)

1.1 思路一：递归

若 N 为偶数，可以先求 xN/2，然后再平方。
若 N 为奇数，可以先求 x(N-1)/2，然后再平方，再乘以x

快速幂的最基础思想就是上面两条了。

求解 xN/2，x(N-1)/2 时也可以用到上面的思路，每次将指数除以2，每次都可以将复杂度降低一半，知道最后指数为1。

Swift实现

这里不考虑大数，仅作为思路展示

func quickpow(_ x: Int, _ n: Int) -> Int {
    if n == 0 {// 直到最后指数为0
        return 1
    }
    let res = quickpow(x, n/2)
    if n%2 != 0 {// n 为奇数
        return res * res * x
    }
    // n为偶数
    return res * res
}

1.2 思路二：二进制拆分

我们以 x14 为例进行推导。

换个方向，更直观：

推论：

设 x 的 N 次幂等于 res
- 1: 在指数 N 的二进制形式下，从最低位开始左移一位，x自乘一次（和指数N左移一位保持一致）
- 如果当前位为1
 - 当前位a到最低位，中间位全部置0时表示的值b，xb的累乘
- 如果当前位位0
 - 执行1
- 循环直到指数N等于0

当前位	指数b	res
111`0`	0	x<sup>0<sub>(2)</sub></sup>
11`1`0	10	x<sup>10<sub>(2)</sub></sup>
1`1`10	100	x<sup>10<sub>(2)</sub></sup> * x<sup>100<sub>(2)</sub></sup>
`1`110	1000	x<sup>10<sub>(2)</sub></sup> * x<sup>100<sub>(2)</sub></sup> * x<sup>1000<sub>(2)</sub></sup>

Swift实现

这里不考虑大数，仅作为思路展示

func quickpow(_ x: Int, _ n: Int) -> Int {
    var res = 1
    var x = x
    var n = n
    
    while n > 0 {
        if n & 1 == 1 { // 如果n的当前末位为1
            res *= x // res乘上当前的x
        }
        x *= x// x自乘，当前指数左移一位
        n >>= 1// n右移一位，想当于 n / 2
    }
    
    return res
}

1.3 参考

Pecco-算法学习笔记(4)：快速幂

【朝夕的ACM笔记】杂项-快速幂

二、快速幂取模

2.1 模运算规律

(a + b) % p = (a % p + b % p) % p
(a - b) % p = (a % p - b % p + p) % p
(a * b) % p = (a % p * b % p) % p
ab % p = ((a % p)b) % p

根据这个规律，可以推导出同余性质

2.2 常见问题场景

我们经常会看到 输出结果对x取模。这种题目一般考察两点：

在原算法的基础上，多一个取模运算来考察你对取模运算规律的掌握
大数据时数据增长太快，64 位甚至 128 位的整形无法表示
- 「剑指Offer」14-II.剪绳子是个典型问题
  - 题解

2.3 利用快速幂，控制数据范围

14-II.剪绳子 中通过快速幂，结合模运算规律，控制了幂运算结果的范围不会超过 1_000_000_007。

func modPow(_ x: Int, _ n: Int) -> Int {
    var res = 1
    var x = x
    var n = n
    
    while n > 0 {
        if n & 1 == 1 {
            res *= x
            res %= 1_000_000_007 // 限制了数据范围
        }
        x *= x
        x %= 1_000_000_007 // 限制了数据范围
        n >>= 1
    }
    
    return res
}

II.剪绳子

Tue, 27 Jul 2021 00:00:00 GMT

一、题目

给你一根长度为 n 的绳子，请把绳子剪成整数长度的 m 段（m、n都是整数，n>1并且m>1），每段绳子的长度记为 k[0],k[1]...k[m - 1] 。请问 k[0]k[1]...*k[m - 1] 可能的最大乘积是多少？例如，当绳子的长度是8时，我们把它剪成长度分别为2、3、3的三段，此时得到的最大乘积是18。

答案需要取模 1e9+7（1000000007），如计算初始结果为：1000000008，请返回 1。

示例 1：

输入: 2
输出: 1
解释: 2 = 1 + 1, 1 × 1 = 1

示例 2:

输入: 10
输出: 36
解释: 10 = 3 + 3 + 4, 3 × 3 × 4 = 36

提示：

2 <= n <= 1000

注意：本题与主站 343 题相同

来源：力扣（LeetCode）

著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

二、常规思路与问题

咋一看，和14-I.剪绳子没什么区别嘛～不就是结果要取模嘛～

2.1 一般思路

那你就上当了

我们用动态规划的解法来试试：

func cuttingRope(_ n: Int) -> Int {
    if n < 4 {
        return n - 1
    }
    var dp = [Int](repeating: 1, count: n + 1)
    for i in 3...n {
        for j in 2..<i {
            dp[i] = max(dp[i], max(j * (i - j), j * dp[i - j]))
        }
    }
    return dp[n] % 1_000_000_007
}

试试两个测试用例：

10 - 36
2 - 1

很正常没问题嘛～🤷‍♂️

2.2 试试120

居然出错了？

2.3 数据长度问题

请注意本题的数据范围 2 <= n <= 1000 和第一题的 2 <= n <= 58，差别很大。

上面报错就是因为数据超出了范围了。

那你可能会想到，那我换 Int64 ？我换 long ？

然鹅并不行

那我每次纯数据都取一下模？

更不行，中间数据都变了，结果当然更错

我们用 `Decimal` 来接收看看`120`时到底是多大：

120 时就已经 20位 了，更何况本题的范围最大1000。

我们就不要再数据类型的选择上进行纠结了

2.4 `Decimal` 解法

这里将元素使用 Decimal 进行承载

let base = NSDecimalNumber(decimal: Decimal(1_000_000_007))

func cuttingRope(_ n: Int) -> Int {
    if n < 4 {
        return n - 1
    }

    var dp = [Decimal](repeating: 1, count: n + 1)
    for i in 3...n {
        for j in 2..<i {
            dp[i] = max(dp[i], max(Decimal(j) * Decimal(i - j), Decimal(j) * dp[i - j]))
        }
    }
    
    let handler = NSDecimalNumberHandler(roundingMode: .down, scale: 0, raiseOnExactness: false, raiseOnOverflow: false, raiseOnUnderflow: false, raiseOnDivideByZero: false)

    let result = NSDecimalNumber(decimal: dp[n])
    let baseCount = result.dividing(by: base).rounding(accordingToBehavior: handler)

    let tp = result.subtracting(base.multiplying(by: baseCount))
    
    return Int(truncating: tp)
}

结果到 255 的时候还是错了，还是丢失了精度。毕竟 NSDecimalNumber 也是有范围的

感觉想继续用动态规划不太现实了

2.5 补充 Java 的 BigInteger 可以动态规划

import java.math.BigInteger;
class Solution {
    public int cuttingRope(int n) {
        BigInteger[] dp = new BigInteger[n + 1];
         Arrays.fill(dp, BigInteger.valueOf(1));
        // dp[1] = BigInteger.valueOf(1);
        for(int i = 3; i < n + 1; i++){
            for(int j = 1; j < i; j++){
                dp[i] = dp[i].max(BigInteger.valueOf(j * (i - j))).max(dp[i - j].multiply(BigInteger.valueOf(j)));
            }
        }
        return dp[n].mod(BigInteger.valueOf(1000000007)).intValue();
    }
}

链接：作者：ollieq

这里就不再纠结数据类型了

三、贪心-循环求余

尽可能多的切成长度为3的，乘积最大

3.1 解法

func cuttingRope(_ n: Int) -> Int {
    if n < 4 {
        return n - 1
    }
    var res = 1
    var n = n
    while n > 4 {
        res = res * 3 % 1_000_000_007
        n -= 3
    }
    return res * n % 1_000_000_007
}

时间复杂度	空间复杂度
O(n)	O(1)

真快

3.2 循环求余

详细可以移步这个题解

四、贪心-快速幂

核心是通过 快速幂 算法及模运算规律，控制数据范围。详细了解可以移步快速幂

LeetCode

4.1 解法

func cuttingRope(_ n: Int) -> Int {
    if n < 4 {
        return n - 1
    }
    let a = n / 3, b = n % 3
    
    if b == 0 {
        return modPow(3, a) % 1_000_000_007
    }
    else if b == 1 {
        return modPow(3, a - 1) * 4 % 1_000_000_007
    }
    else {
        return modPow(3, a) * 2 % 1_000_000_007
    }
}

func modPow(_ x: Int, _ n: Int) -> Int {
    var res = 1
    var x = x
    var n = n
    
    while n > 0 {
        if n & 1 == 1 {
            res *= x
            res %= 1_000_000_007 // 限制了数据范围
        }
        x *= x
        x %= 1_000_000_007 // 限制了数据范围
        n >>= 1
    }
    
    return res
}

解密被加密的数据库文件

Sat, 24 Jul 2021 00:00:00 GMT

前言

进来有一个个人项目的灵感，于是找到了有提供类似功能的产品，准备逆向研究一波。拿到了IPA包，也找到了数据库文件。但是在准备看下数据库文件的时候遇到了问题。

数据库加密了🤷‍♂️

作为一个秃头的逆向工程师（并不是），我们怎么能轻言放弃呢？

确定本次逆向目标：

[X] 获取数据库密码
[X] 清除数据库密码

开森～都完成了👌

一、定位数据库SDK

先看看IPA中framework文件夹中有什么吧

难道用了 CoreData ？我们再进一步分析

分析 MachO

我们使用 Hopper 进行分析，将 IPA 中的可执行文件（MachO）丢进 Hopper。

哦吼～很明显用的 FMDB。

二、定位密码函数

查看 FMDB 的 API 寻找切入点。找到了 - (BOOL)setKey:(NSString*)key;，准备 Hook。

@interface FMDatabase : NSObject {
    /** Set encryption key.
 
    @param key The key to be used.

    @return `YES` if success, `NO` on error.

    @see http://www.sqlite-encrypt.com/develop-guide.htm
    
    @warning You need to have purchased the sqlite encryption extensions for this method to work.
    */

    - (BOOL)setKey:(NSString*)key;
}

三、寻找Hook目标函数

砸壳、重签名这里就不再赘述，不是本文的重点。

应用砸壳（一定要有越狱手机）

下面使用 Logos 简单进行 Hook。

@interface FMDatabase : NSObject

@end

%hook FMDatabase
- (void)setKey:(NSString*)key {
    NSLog(@"🔓获取到了数据库密码 %@", key);
    %orig;
}

%end

运行后在应用中触发数据库操作，日志输出：

2021-07-24 12:26:26.561085+0800 xx[16475:3222446] 🔓拦截到了数据库密码 xxxx

成功拦截到了密码👏

四、移除密码

我们先将数据库文件拷贝出来一份。

使用我的 小工具-RemoveDataBasePassword 即可获取无密码的数据库文件了～

获取移除密码的数据库文件。就可以正常打开了

4.1 RemoveDataBasePassword 使用说明

GitHub-RemoveDataBasePassword

如果有帮助到你，留下一颗小星星吧⭐️～

将你的数据库文件拖进工程
修改 YourDataBasePassWord 为密码
修改 YourDataBaseName 为你的数据库文件名称
运行程序，模拟器即可
当看到屏幕出现 Click 点击屏幕
查看 Log，就可以获取路径
Enjoy it!

4.2 Navicat 报错

我一直用的 Navicat 来查看数据库的，但是打开移除密码的数据库时报错了。

虽然报错了，其实没问题。

双击 main，就可以继续访问数据了。

五、总结思考

整个研究的过程还是比较顺利的，同时也提醒了自己：

如果本地数据库信息比较重要的话，仅仅为数据库添加密码时远远不够的
对于懂一些逆向的玩家来说还是很容易就能获取到的
感觉也是时候和大家分享一下一些防护手段了
欢迎点赞、评论、交流

I.剪绳子

Thu, 22 Jul 2021 00:00:00 GMT

一、题目

给你一根长度为 n 的绳子，请把绳子剪成整数长度的 m 段（m、n都是整数，n>1并且m>1），每段绳子的长度记为 k[0],k[1]...k[m-1] 。

请问 k[0]k[1]...*k[m-1] 可能的最大乘积是多少？

例如，当绳子的长度是8时，我们把它剪成长度分别为2、3、3的三段，此时得到的最大乘积是18。

示例 1：

输入: 2
输出: 1
解释: 2 = 1 + 1, 1 × 1 = 1

示例 2:

输入: 10
输出: 36
解释: 10 = 3 + 3 + 4, 3 × 3 × 4 = 36

提示：

2 <= n <= 58

注意：本题与主站 343 题相同：https://leetcode-cn.com/problems/integer-break/

来源：力扣（LeetCode）

著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

二、动态规划

动态规划是面试中的热门话题。

2.1 什么样的场景适合动态规划呢？

如果题目是：
- 求一个问题的最优解（通常是最大值或者最小值）
- 而且改问题能够分解为若干个子问题
- 并且字问题之间还有重叠的更小的子问题
就可以考虑使用动态规划来解决这个问题

2.2 本题是否适合动态规划？

我们把长度为n的绳子剪成若干段后得到的乘积的最大值定义为函数f(n)。
假设我们把第一刀剪在了长度为i（0 < i < n）的位置，于是把绳子剪成了长度为i和n-i的两段。
我们想要得到整个问题的最优解f(n)那么要同样用最优化的方法把长度为i和n-i的两段分别剪成若干段，使得各自剪出的每段绳子的乘积最大。
也就是说整体问题的最优解是依赖各个子问题的最优解。

2.3 动态规划的过程

由于子问题在分解大问题的过程中重复出现，为了避免重复求解子问题，我们可以：
- 从下往上的顺序先计算小问题的最优解并存储下来
- 再以此为基础求取大问题的最优解
这种从上往下分析问题，从下往上解决问题也是动态规划的一大特征。

2.4 应用在本题中

在应用动态规划的时候，我们每一步都可能面临若干个选择。

本题中：

第一刀有n-1种选择。我们可以剪再 1,2...n-1 的任意位置。
由于我们事先不知道那个位置是最优解，只好把所有可能的额都尝试一遍，然后比较出最优解。
用数学表示就是
- f(n) = max(f(i), f(n-i))
- 0 < i < n

代码

func cuttingRope(_ n: Int) -> Int {
    if n < 4 {
        return n - 1
    }
    var dp = [Int](repeating: 1, count: n + 1)
    for i in 3...n {
        for j in 2..<i {
            dp[i] = max(dp[i], max(j * (i - j), j * dp[i - j]))
        }
    }
    return dp[n]
}

时间复杂度	空间复杂度
O(n^2)	O(n)

三、贪婪算法

贪婪算法和动态规划不一样。当我们应用贪婪算法解决问题的时候，每一步都可以做出一个贪婪的选择，基于这个选择，我们确定能够得到最优解。

至于为什么这样的贪婪选择能够得到最优解。这就需要使用数学方式来证明了。

3.1 应用再本题中

如果绳子长度大于5，则每次都剪出一段长度为3的绳子。
如果剩下的长度仍然大于5，则接着剪出一段长度为3的绳子。
循环
直到剩下的绳子长度小于5。
- 当绳子长度为4时，剪成 2x2=4
- 当绳子长度为3时，剪成 1x2=2
- 当绳子长度为2时，剪成 1x1=1
  - 其实不剪最大，但要求至少剪一刀那就剪呗

剪出一段长度为3的绳子就是我们在每一步做出的贪婪选择。

3.2 证明上面思路的正确性

当n>=5时
- 2(n-2)>n && 3(n-3)>n
- 也就是说当绳子的长度大于或等于5时，我们可以把它剪成3或2的绳子段
另外当n>=5
- 3(n-3)>=2(n-2)
- 因此我们应该尽可能多的剪长度为3的绳子

上面时原书中的解释，更详细专业的证明Krahets

代码

func cuttingRope(_ n: Int) -> Int {
    if n < 2 {
        return 0
    }
    if n == 2 {
        return 1
    }
    if n == 3 {
        return 2
    }
        
    // 3长度的最大段数
    var threeCount = n / 3
     
    // 当绳子剩下4的时候 不能再剪3长度，更优的方式是剪成长度为2的，因为 2x2 > 3x1
    if n - threeCount * 3 == 1 {
        threeCount -= 1
    }
    let twoCount = (n - threeCount * 3) / 2
    
    return Int(truncating: NSDecimalNumber(decimal: pow(3, threeCount))) * Int(truncating: NSDecimalNumber(decimal: pow(2, twoCount)))
}

时间复杂度	空间复杂度
O(1)	O(1)

iOS应用启动（一）：dyld与main函数

Wed, 21 Jul 2021 00:00:00 GMT

本文基于 dyld-832.7.3 与 objc4-818.2 源码

前言

每个应用程序都会依赖很多的库，每当应用程序启动，都会将MachO中的可执行文件加载到内存中。那么这个过程是怎样的呢？

一、切入点

应用程序的入口是 main 函数，那么 main 函数之前做了什么呢？

我们在 main 函数下个断点：

(lldb) bt
* thread #1, queue = 'com.apple.main-thread', stop reason = breakpoint 1.1
* frame #0: 0x00000001001f9ef8 ObjcMsgSend`main(argc=1, argv=0x000000016fc0b878) at main.m:17:50
  frame #1: 0x00000001a2d56140 libdyld.dylib`start + 4

发现并没有有用的信息。那么在main之前下断点试试吧。

通过分析堆栈信息发现切入点 _dyld_start

二、 dyld-动态链接器

2.1 _dyld_start

在dyld源码中找到了对应实现，为汇编代码，我们找到一处重要的注释：

dyldbootstrap::start

前面都是进行一些配置，最后一个看名字就很重要的 dyld::_main 我们进去看看

2.2 dyld::_main

一千多行代码，果然很重要。

通过注释我们也可以看出：

这里是 dyld 的入口
最终返回程序的 main() 函数

因为代码非常长，我对于关键点做了一些注释方便大家对照源码进行查看

源码流程注释对照

只要设置了这两个环境变量参数，在App启动时就会打印相关参数、环境变量信息

加载共享缓存

为主程序初始化 ImageLoader

现在共享缓存已经加载完毕了，设置版本化的dylib覆盖

加载所有插入的库，越狱插件在这里加入
记录插入的库的数量，以便统一搜索将先查看插入的库，然后是main，然后是其他。

链接主程序

链接所有插入的库。链接主可执行文件后执行此操作，以使插入的dylib（例如libSystem）不在程序使用的dylib的前面

只有插入的库可以插入。绑定所有插入的库后，注册插入信息，以便链接工作

绑定并通知主要可执行文件，现在插入的已被注册
绑定并通知现在已插入的已插入image已被注册

执行所有初始化方法
通知任何监视过程此过程即将进入main()

查找main指针

2.3 sMainExecutable

从上面的流程分析中可以看出，最终return的main函数指针来自于 sMainExecutable。

定位 sMainExecutable 的初始化

2.4 initializeMainExecutable 初始化主程序

核心源码及流程注释

void initializeMainExecutable()
{
#pragma mark - Ryukie 记录一下，进入初始化流程了
	// record that we've reached this step
	gLinkContext.startedInitializingMainExecutable = true;
#pragma mark - Ryukie 初始化所有插入的库
	// run initialzers for any inserted dylibs
	ImageLoader::InitializerTimingList initializerTimes[allImagesCount()];
	initializerTimes[0].count = 0;
	const size_t rootCount = sImageRoots.size();
	if ( rootCount > 1 ) {
		for(size_t i=1; i < rootCount; ++i) {
			sImageRoots[i]->runInitializers(gLinkContext, initializerTimes[0]);
		}
	}
#pragma mark - Ryukie 运行主要可执行文件的初始化程序及其依赖的
	// run initializers for main executable and everything it brings up 
	sMainExecutable->runInitializers(gLinkContext, initializerTimes[0]);

    ...
}

结合前面我们在 +load 处断点的堆栈信息可以得到验证：

主线历程我们就分析到这里，细节的流程后面的文章会继续进行分析

三、总结&流程图

程序执行从 _dyld_start 开始
进入 dyld_main 函数
配置环境变量以及 rebase_dyld
加载共享缓存
- 系统的动态库都在这里了
dyld2/dyld(ClosureMode) 决定以哪种模式继续进行
实例化主程序ImageLoaderMachO，加入到allImages中
到此共享缓存加载完毕，设置版本化的dylib覆盖
- Now that shared cache is loaded, setup an versioned dylib overrides
加载插入的库
- 越狱插件在这里加入
记录插入的库的数量，以便统一搜索将先查看插入的库，然后是main，然后是其他。
- record count of inserted libraries so that a flat search will look at inserted libraries, then main, then others.
链接主程序
- 绑定符号（非懒加载、弱符号）等
链接所有插入的库
- 链接主可执行文件后执行此操作，以使插入的dylib（例如libSystem）不在程序使用的dylib的前面
- 只有插入的库可以插入。绑定所有插入的库后，注册插入信息，以便链接工作
绑定并通知主程序可执行文件，现在插入的已被注册
绑定并通知现在已插入的库已插入的Image已被注册
执行所有初始化方法：ImageLoader
- 初始化所有插入的库、运行主要可执行文件的初始化程序及其依赖
- ImageLoader:
  - runInitializers:
    - processInitializers:
      - ecursiveInitialization:
        
        notifySingle:
        
        此函数执行一个回调，此回调是_objc_init初始化时服饰的一个函数load_images
        
        load_images里执行class_load_metgods函数
        
        class_load_metgods里调用call_class_loads函数：循环调用各个类的load函数
        
        doModInitFunction
        
        内部会调用全局C++对象的构造函数__attribute__((constructor))的C函数
通知任何监视过程此过程即将进入main()
得到main()指针并return

iOS应用启动（二）：环境配置与runtime初始化

Wed, 21 Jul 2021 00:00:00 GMT

本文基于 dyld-832.7.3 与 objc4-818.2 源码

前言

结合上一文iOS应用启动（一）：_dyld_start及符号断点我们找到了 _objc_init 的调用栈

dyld`ImageLoaderMachO::doModInitFunctions
libSystem.B.dylib`libSystem_initializer
libdispatch.dylib`libdispatch_init
libdispatch.dylib`_os_object_init
libobjc.A.dylib`_objc_init

一、 _objc_init 做了什么

引导初始化，使用 dyld 注册 images。
在库初始化时间之前由 libSystem 调用

/***********************************************************************
* _objc_init
* Bootstrap initialization. Registers our image notifier with dyld.
* Called by libSystem BEFORE library initialization time
**********************************************************************/

1.1 源码分析

void _objc_init(void)
{
    static bool initialized = false;
    if (initialized) return;
    initialized = true;
    
    // fixme defer initialization until an objc-using image is found?
    /// 初始化环境变量
    environ_init();

    /// 关于线程`key`的绑定：比如线程数据的析构函数
    tls_init();
    
    /// 调用全局静态C++构造函数
    static_init();
    
    /// runtime 运行时环境初始化
    runtime_init();
    
    /// 初始化 `libobjc` 的异常处理系统
    exception_init();

#if __OBJC2__
    /// 缓存条件初始化
    cache_t::init();
#endif
    /// 启动回调机制
    _imp_implementationWithBlock_init();

    _dyld_objc_notify_register(&map_images, load_images, unmap_image);

#if __OBJC2__
    didCallDyldNotifyRegister = true;
#endif
}

下面我们将对一些重要步骤进行说明：

environ_init
- 初始化环境变量
tls_init
- 关于线程key的绑定：比如线程数据的析构函数
static_init
- 调用全局静态C++构造函数
runtime_init
- runtime 运行时环境初始化
exception_init
- 初始化 libobjc 的异常处理系统
cache_t::init()
- 缓存条件初始化
_imp_implementationWithBlock_init
- 启动回调机制
_dyld_objc_notify_register *

二、 environ_init

初始化环境变量

修改环境变量能够有效帮助我们进行开发调试

修改环境变量进行调试

如这样一个场景，项目代码较多，引用的SDK也很多，想要知道哪些类实现了 +load 方法该怎么办？

修改一个环境变量即可打印出来
- 打开 Edit Scheme - Run - Argument 添加环境变量 OBJC_PRINT_LOAD_METHODS = YES 即可打印所有 +load 方法

效果：

objc[58337]: LOAD: category 'NSObject(NSObject)' scheduled for +load
objc[58337]: LOAD: +[NSObject(NSObject) load]

objc[58337]: LOAD: category 'NSObject(NSObject)' scheduled for +load
objc[58337]: LOAD: +[NSObject(NSObject) load]

objc[58337]: LOAD: class 'NSColor' scheduled for +load
objc[58337]: LOAD: class 'NSApplication' scheduled for +load
objc[58337]: LOAD: class 'NSBinder' scheduled for +load
objc[58337]: LOAD: class 'NSColorSpaceColor' scheduled for +load
objc[58337]: LOAD: class 'NSNextStepFrame' scheduled for +load
objc[58337]: LOAD: +[NSColor load]

objc[58337]: LOAD: +[NSApplication load]

objc[58337]: LOAD: +[NSBinder load]

objc[58337]: LOAD: +[NSColorSpaceColor load]

objc[58337]: LOAD: +[NSNextStepFrame load]

objc[58337]: LOAD: category 'NSError(FPAdditions)' scheduled for +load
objc[58337]: LOAD: +[NSError(FPAdditions) load]

objc[58337]: LOAD: class '_DKEventQuery' scheduled for +load
objc[58337]: LOAD: +[_DKEventQuery load]

objc[58337]: LOAD: class 'RYModel' scheduled for +load
objc[58337]: LOAD: +[RYModel load]

自定义模型实现了+load方法被打印了出来，+[RYModel load]。

获取可用环境变量

在任意终端输入指令 export OBJC_HELP=1 即可获取环境变量列表，选择自己需要的进行使用，可以提高开发调试的效率哦。

➜  RyukieDevGitBook git:(master) ✗ export OBJC_HELP=1
objc[57485]: Objective-C runtime debugging. Set variable=YES to enable.
objc[57485]: OBJC_HELP: describe available environment variables
objc[57485]: OBJC_PRINT_OPTIONS: list which options are set
objc[57485]: OBJC_PRINT_IMAGES: log image and library names as they are loaded
objc[57485]: OBJC_PRINT_IMAGE_TIMES: measure duration of image loading steps
objc[57485]: OBJC_PRINT_LOAD_METHODS: log calls to class and category +load methods
objc[57485]: OBJC_PRINT_INITIALIZE_METHODS: log calls to class +initialize methods
...

三、 static_init

调用全局静态C++构造函数

执行全局静态 C++ 构造函数
libc 在 dyld 调用构造函数之前调用 _objc_init()
所以我们要自己处理

/***********************************************************************
* static_init
* Run C++ static constructor functions.
* libc calls _objc_init() before dyld would call our static constructors, 
* so we have to do it ourselves.
**********************************************************************/

static void static_init()
{
    size_t count;
    auto inits = getLibobjcInitializers(&_mh_dylib_header, &count);
    for (size_t i = 0; i < count; i++) {
        inits[i]();
    }
    auto offsets = getLibobjcInitializerOffsets(&_mh_dylib_header, &count);
    for (size_t i = 0; i < count; i++) {
        UnsignedInitializer init(offsets[i]);
        init();
    }
}

3.1 验证

在我的代码中添加一个C++构造函数

__attribute__((constructor)) void ryFunc() {
    printf("我的constructor：%s \n", __func__);
}

发现并没有在这一步骤中执行我的C++构造函数

3.2 思考

这里其实调用的并非所有C++构造函数，而是在底层objc库中的构造函数。

在objc源码中添加一个构造函数：

__attribute__((constructor)) void ryFuncInObjc() {
    printf("我的constructor：%s \n", __func__);
}

此处正常没有输出日志

日志输出：

我的constructor：ryFuncInObjc

4.3 总结

这里调用的C++构造函数特指 objc源码中定义的一系列构造函数
因为全局构造函数非常重要，为了保证全局构造函数调用的及时性，所以这里自己进行了调用。

四、 runtime_init

runtime 运行时环境初始化

void runtime_init(void)
{
    objc::unattachedCategories.init(32);
    objc::allocatedClasses.init();
}

通过查看这里的两个 init 方法我们发现，这两个是集合类型

public:
    template <typename... Ts>
    void init(Ts &&... Args) {
        new (_storage) Type(std::forward<Ts>(Args)...);
    }

    Type &get() {
        return *reinterpret_cast<Type *>(_storage);
    }
};

4.1 unattachedCategories

static UnattachedCategories unattachedCategories;

} // namespace objc

4.2 allocatedClasses

一个存储所有已经被 allocated 的类和元类的表

/***********************************************************************
* allocatedClasses
* A table of all classes (and metaclasses) which have been allocated
* with objc_allocateClassPair.
**********************************************************************/
namespace objc {
static ExplicitInitDenseSet<Class> allocatedClasses;
}

五、 exception_init

初始化 libobjc 的异常处理系统

/***********************************************************************
* exception_init
* Initialize libobjc's exception handling system.
* Called by map_images().
**********************************************************************/
void exception_init(void)
{
    old_terminate = std::set_terminate(&_objc_terminate);
}

需要的话也可以自定义一异常捕捉回调

FOUNDATION_EXPORT void NSSetUncaughtExceptionHandler(NSUncaughtExceptionHandler * _Nullable);

六、 _imp_implementationWithBlock_init

启动回调机制。通常不会做什么，因为所有的初始化都是懒加载的，但是对于某些进程，会迫不及待的加载 trampolines dylib。

七、 _dyld_objc_notify_register

这里进行了镜像文件的读取与加载，后面会单独进行分析

iOS应用启动（三）：镜像文件的读取和加载

Wed, 21 Jul 2021 00:00:00 GMT

本文基于 dyld-832.7.3 与 objc4-818.2 源码

前言

在上一文iOS应用启动（二）：环境配置与runtime初始化我们提到了 _dyld_objc_notify_register，本文就将深入对镜像文件的读取map_images与加载loadClass进行解读。

一、 _dyld_objc_notify_register

_dyld_objc_notify_register(&map_images, load_images, unmap_image);

这里有两个重要的函数：
- map_images
  - 管理文件中和动态库中的所有符号：class protocol selector category
- load_images
  - 执行 +load 方法
进行了镜像文件的读取与加载

这里有个一个小细节

我们看到这里调用 &map_images 这里用了函数的地址，因为这里非常重要，为了保持整个过程的同步。

二、 map_images

/***********************************************************************
* map_images
* Process the given images which are being mapped in by dyld.
* Calls ABI-agnostic code after taking ABI-specific locks.
*
* Locking: write-locks runtimeLock
**********************************************************************/
void
map_images(unsigned count, const char * const paths[],
           const struct mach_header * const mhdrs[])
{
    mutex_locker_t lock(runtimeLock);
    return map_images_nolock(count, paths, mhdrs);
}

2.1 map_images_nolock

void 
map_images_nolock(unsigned mhCount, const char * const mhPaths[],
                  const struct mach_header * const mhdrs[])
{
    ...

    if (hCount > 0) {
        _read_images(hList, hCount, totalClasses, unoptimizedTotalClasses);
    }

    ...
    
    // Call image load funcs after everything is set up.
    for (auto func : loadImageFuncs) {
        for (uint32_t i = 0; i < mhCount; i++) {
            func(mhdrs[i]);
        }
    }
}

2.2 _read_images

这里的源码非常长，但是Apple贴心的加了Log我们可以从Log找下线索

ts.log("IMAGE TIMES: fix up selector references");

ts.log("IMAGE TIMES: discover classes");

ts.log("IMAGE TIMES: remap classes");

ts.log("IMAGE TIMES: fix up objc_msgSend_fixup");

ts.log("IMAGE TIMES: discover protocols");

ts.log("IMAGE TIMES: fix up @protocol references");

ts.log("IMAGE TIMES: discover categories");

ts.log("IMAGE TIMES: realize non-lazy classes");

ts.log("IMAGE TIMES: realize future classes");

整体流程：
- 条件控制进行第一次加载
- 修复预编译阶段的 @selector 混乱问题
- 错误混乱的类处理
- 修复重映射一些没有被镜像文件加再进来的类
- 修复一些消息
- 当类中有协议的时候，readProtocol
- 修复没有被加载的协议
- 处理分类
- 类的加载相关处理

修复：主要是指对地址进行修复，将MachO中的地址修复为dyld处理后的地址

2.3 循环调用 readClass 加载类

在这里添加Log可以发现，自定义的类是最后加载的：

... // 一系列系统类加载
readClass -- RYModel
readClass -- RYSubModel

这里如果想过滤系统的可以参考下面的代码：

const char *myClassName = "RYModel";
const char *mangledName = cls->nonlazyMangledName();

if (strcmp(mangledName, myClassName) == 0) {
    printf("%s -- %s\n", __func__, myClassName);
}

2.4 readClass 源码中的坑

下图中的代码，看似进行了Class的ro rw的操作但实际运行断点的时候根本不会执行，千万不要被源码误导了。

如图三个断点：

跳过了中间的断点

2.5 寻找类相关的流程

在源码中找到了可能的地方，添加断点：

实现 非懒加载类（实现类+load方法或者静态实例）

Realize non-lazy classes (for +load methods and static instances)

Realize newly-resolved future classes

运行后只输出了：

Realize non-lazy classes _read_images -- RYModel

而在其中也发现来到了另一个重要的流程：realizeClassWithoutSwift

关于这部分内容之前在研究msgSend的过程中有顺便进行了探索，可以在类的实现与初始化一文中进行深入了解。

补充：懒加载类 & 非懒加载类

在2.5中提到了 非懒加载类，那么什么是 非懒加载类，什么是 懒加载类？

懒加载类

数据加载推迟到第一次接收第一次消息的时候

非懒加载类

map_image 的时候加载所有类数据。

三、 load_images

这里流程就比较简单了
- 加载分类
- 查找所有 load 方法
- 调用 load 方法

void
load_images(const char *path __unused, const struct mach_header *mh)
{
    if (!didInitialAttachCategories && didCallDyldNotifyRegister) {
        didInitialAttachCategories = true;
        // 加载分类
        loadAllCategories();
    }

    // Return without taking locks if there are no +load methods here.
    if (!hasLoadMethods((const headerType *)mh)) return;

    recursive_mutex_locker_t lock(loadMethodLock);

    // Discover load methods
    // 查找所有 load 方法
    {
        mutex_locker_t lock2(runtimeLock);
        prepare_load_methods((const headerType *)mh);
    }

    /// 调用 load 方法
    // Call +load methods (without runtimeLock - re-entrant)
    call_load_methods();
}

流程图

机器人的运动范围

Sun, 18 Jul 2021 00:00:00 GMT

题目

地上有一个m行n列的方格，从坐标 [0,0] 到坐标 [m-1,n-1] 。

一个机器人从坐标 [0, 0] 的格子开始移动，它每次可以向左、右、上、下移动一格（不能移动到方格外），也不能进入行坐标和列坐标的数位之和大于k的格子。

例如，当k为18时，机器人能够进入方格 [35, 37] ，因为3+5+3+7=18。但它不能进入方格 [35, 38]，因为3+5+3+8=19。请问该机器人能够到达多少个格子？

示例 1：

输入：m = 2, n = 3, k = 1
输出：3

示例 2：

输入：m = 3, n = 1, k = 0
输出：1

提示：

1 <= n,m <= 100
0 <= k <= 20

来源：力扣（LeetCode）

链接：https://leetcode-cn.com/problems/ji-qi-ren-de-yun-dong-fan-wei-lcof

著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

一、分析

矩阵搜索问题一般有两种思路：

通过递归实现的深度优先DFS
- 朝一个方向走到底，再回退
用过队列实现的广度优先BFS
- 按照“平推”的方式向前搜索

二、解法一：深度优先及优化

func movingCount(_ m: Int, _ n: Int, _ k: Int) -> Int {
    if m <= 0 || n <= 0 || k < 0 {
        return 0
    }
    var flags: [[Bool]] = Array(repeating: Array(repeating: false, count: n), count: m)
    return moveTo(0, 0, k, flags: &flags)
}

2.1 核心递归逻辑

func moveTo(_ x: Int, _ y: Int, _ k: Int, flags: inout [[Bool]]) -> Int {
    if (x < 0 || x >= flags.first?.count ?? 0) ||
        (y < 0 || y >= flags.count) ||
        (flags[y][x] == true) ||
        (digitSum(x) + digitSum(y) > k)
    {
        return 0
    }
    
    flags[y][x] = true
    
    let count = 1
        + moveTo(x + 1, y, k, flags: &flags)
        + moveTo(x - 1, y, k, flags: &flags)
        + moveTo(x, y + 1, k, flags: &flags)
        + moveTo(x, y - 1, k, flags: &flags)
    
    return count
}

2.2 数位和函数

func digitSum(_ num: Int) -> Int {
    var temp = num
    var result = 0
    while temp > 0 {
        result += temp % 10
        temp = Int(floor(Double(temp) / 10.0))
    }
    return result
}

2.3 总结

时间复杂度
- 最差O(m*n)
空间复杂度
- 最差O(m*n)

三、深度优先算法优化

在深度优先的解法中，我们才拆分为了上下左右四个方向的子问题。

但实际上本题只需要右下两个方向就可以，因为上左一定是走过的。

优化后的核心 moveTo 代码：

func moveTo(_ x: Int, _ y: Int, _ k: Int, flags: inout [[Bool]]) -> Int {
    if (x < 0 || x >= flags.first?.count ?? 0) ||
        (y < 0 || y >= flags.count) ||
        (flags[y][x] == true) ||
        (digitSum(x) + digitSum(y) > k)
    {
        return 0
    }
    
    flags[y][x] = true
    
    let count = 1
        + moveTo(x + 1, y, k, flags: &flags)
        + moveTo(x, y + 1, k, flags: &flags)
    
    return count
}

可以发现减少了多余的计算效率提升了不少，这点如果在面试中注意到的话是个很好的加分项哦

思路回顾

设 fn(x, y) 代表从 (x, y) 开始能到的格子数
从左上角开始的那么我们可以转化一下
即：fn(x, y) = fn(x + 1, y) + fn(x, y + 1)

四、解法二：广度优先

广度优先解法理解相比深度优先不够直观

func movingCount_bfs(_ m: Int, _ n: Int, _ k: Int) -> Int {
    var visited = Array(repeating: Array(repeating: false, count: n), count: m)
    var result = 0
    var queue:Array = [(0,0,0,0)]

    while !queue.isEmpty {
        let (y,x,si,sj) = queue.removeFirst()
        if y >= m || x >= n || k < si + sj || visited[y][x]{
            continue
        }
        visited[y][x] = true
        result = result + 1
        queue.append((y + 1, x, digitSum(y + 1), sj))
        queue.append((y, x + 1, si, digitSum(x + 1)))
    }
    return result
}

4.1 图解

来源Krahets

链表中倒数第k个节点

Wed, 14 Jul 2021 00:00:00 GMT

题目

输入一个链表，输出该链表中倒数第k个节点。为了符合大多数人的习惯，本题从1开始计数，即链表的尾节点是倒数第1个节点。

例如，一个链表有 6 个节点，从头节点开始，它们的值依次是 1、2、3、4、5、6。这个链表的倒数第 3 个节点是值为 4 的节点。

示例：

 给定一个链表: 1->2->3->4->5, 和 k = 2.

 返回链表 4->5.
 通过次数193,790提交次数246,166

来源：力扣（LeetCode）

链接：https://leetcode-cn.com/problems/lian-biao-zhong-dao-shu-di-kge-jie-dian-lcof

著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

GitHub

解法一：栈

func getKthFromEnd(_ head: ListNode?, _ k: Int) -> ListNode? {
    var node = head
    
    var temp: [ListNode] = []
    
    while let currentNode = node {
        temp.insert(currentNode, at: 0)
        if temp.count > k {
            temp.removeLast()
        }
        node = currentNode.next
    }
    
    return temp.last
}

解法二：差速双指针

func getKthFromEnd(_ head: ListNode?, _ k: Int) -> ListNode? {
   var right: ListNode? = head, left: ListNode? = head
   
   // 移动到 第 k 个节点
   for _ in 0..<k-1 {
       right = right?.next
   }
   
   while let _ = right?.next {
       right = right?.next
       left = left?.next
   }
   
   return left
}

反转链表

Wed, 14 Jul 2021 00:00:00 GMT

题目

定义一个函数，输入一个链表的头节点，反转该链表并输出反转后链表的头节点。

示例:

 输入: 1->2->3->4->5->NULL
 输出: 5->4->3->2->1->NULL

限制：

 0 <= 节点个数 <= 5000

注意：本题与主站 206 题相同：https://leetcode-cn.com/problems/reverse-linked-list/

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/fan-zhuan-lian-biao-lcof
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

解法

GitHub

func reverseList(_ head: ListNode?) -> ListNode? {
    var node: ListNode?
    var temp: ListNode? = head
    
    while let current = temp {
        let n = ListNode(current.val)
        n.next = node
        node = n
        temp = current.next
    }
    
    return node
}

顺时针打印矩阵

Tue, 13 Jul 2021 00:00:00 GMT

题目描述

输入一个矩阵，按照从外向里以顺时针的顺序依次打印出每一个数字。

示例 1：

输入：matrix = [[1,2,3],[4,5,6],[7,8,9]]
输出：[1,2,3,6,9,8,7,4,5]

示例 2：

输入：matrix = [[1,2,3,4],[5,6,7,8],[9,10,11,12]]
输出：[1,2,3,4,8,12,11,10,9,5,6,7]
``` 

限制：

```C++
0 <= matrix.length <= 100
0 <= matrix[i].length <= 100

注意：本题与主站 54 题相同：https://leetcode-cn.com/problems/spiral-matrix/

来源：力扣（LeetCode）

链接：https://leetcode-cn.com/problems/shun-shi-zhen-da-yin-ju-zhen-lcof

题解链接

GitHub

著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

解题思路

出现需要变更方向的点的拐向是一定的：
- 当前向➡️扫描，拐点一定向↓
- 当前向↓扫描，拐点一定向←
- 当前向←扫描，拐点一定向↑
- 当前向↑扫描，拐点一定向➡️

flags为标记数组，用来标识已经扫描过的下标

在一个方向上：扫描到边界 或者 扫描到已标记的坐标 则触发转向

代码

class Solution {
    enum Dirction {
        /// x + 1
        case Right
        /// y + 1
        case Down
        /// x - 1
        case Left
        /// y - 1
        case Up
    }

    func spiralOrder(_ matrix: [[Int]]) -> [Int] {
        var result: [Int] = []
        let height = matrix.count
        
        guard let first = matrix.first, height > 0 else {
            return result
        }
        
        let width = first.count
        var x = 0, y = 0
        var dir: Dirction = .Right
        
        var flags: [[Bool]] = Array(repeating: Array(repeating: false, count: width), count: height)
        
        while x >= 0, y >= 0, x < width, y < height, result.count < width * height {
            flags[y][x] = true
            result.append(matrix[y][x])
            
            switch dir {
            case .Right:
                if x + 1 < width, flags[y][x + 1] == false {
                    x += 1
                }
                else {
                    dir = .Down
                    y += 1
                }
            case .Down:
                if y + 1 < height, flags[y + 1][x] == false {
                    y += 1
                }
                else {
                    dir = .Left
                    x -= 1
                }
            case .Left:
                if x - 1 >= 0, x - 1 < width, flags[y][x - 1] == false {
                    x -= 1
                }
                else {
                    dir = .Up
                    y -= 1
                }
            case .Up:
                if y - 1 >= 0, y - 1 < height, flags[y - 1][x] == false {
                    y -= 1
                }
                else {
                    dir = .Right
                    x += 1
                }
            }
        }
        
        return result
    }
}

一套iOS底层试卷

Tue, 13 Jul 2021 00:00:00 GMT

一套iOS底层试卷

一、选择题 ⚠️ 有单选有多选哦⚠️

1.1 在LP64下,一个指针的有多少个字节

[ ] A: 4
[X] B: 8
[ ] C: 16
[ ] D: 64

1.2 一个实例对象的内存结构存在哪些元素

[X] A:成员变量
[X] B: supClass
[X] C: cache_t
[X] D: bit

A

1.3 下面sizeof(struct3) 大小等于

struct Struct1 {
    char b;// 1
    int c; // 4
    double a; // 8
    short d; // 2
}struct1;

struct Struct2 {
    double a;
    int b;
    char c;
    short d;
}struct2;

struct Struct3 {
    double a;
    int b;
    char c;
    struct Struct1 str1;
    short d;
    int e;
    struct Struct2 str2;
}struct3;

[ ] A: 48
[X] B: 56
[ ] C: 64
[ ] D: 72

<!-- * Struct1

0 1-4 7-14 15-16
总 24
Struct2
- 0-7 11-14 15 16-17
- 总 24
Struct3
- 0-7 8-11 12 15
- 16-19 23-30 31-32
- 33-34 35-38
- 39-46 47-50 51 53-54
- 总 56
B -->

C

1.4 下列代码: re1 re2 re3 re4 re5 re6 re7 re8输出结果

BOOL re1 = [(id)[NSObject class] isKindOfClass:[NSObject class]];     
BOOL re2 = [(id)[NSObject class] isMemberOfClass:[NSObject class]];   
BOOL re3 = [(id)[LGPerson class] isKindOfClass:[LGPerson class]];     
BOOL re4 = [(id)[LGPerson class] isMemberOfClass:[LGPerson class]];  
NSLog(@" re1 :%hhd\n re2 :%hhd\n re3 :%hhd\n re4 :%hhd\n",re1,re2,re3,re4);

BOOL re5 = [(id)[NSObject alloc] isKindOfClass:[NSObject class]];      
BOOL re6 = [(id)[NSObject alloc] isMemberOfClass:[NSObject class]];    
BOOL re7 = [(id)[LGPerson alloc] isKindOfClass:[LGPerson class]];     
BOOL re8 = [(id)[LGPerson alloc] isMemberOfClass:[LGPerson class]];   
NSLog(@" re5 :%hhd\n re6 :%hhd\n re7 :%hhd\n re8 :%hhd\n",re5,re6,re7,re8);

[ ] A: 1011 1111
[ ] B: 1100 1011
[X] C: 1000 1111
[ ] D: 1101 1111

1.5 (x + 7) & ~7 这个算法是几字节对齐

[ ] A: 7
[X] B: 8
[ ] C: 14
[ ] D: 16

1.6 判断下列数据结构大小

union kc_t {
    uintptr_t bits;// 8
    struct {
        int a;// 4
        char b;// 1
    };
}

[X] A: 8
[ ] B: 12
[ ] C: 13
[ ] D: 16

1.7 元类的 isa 指向谁, 根元类的父类是谁

[ ] A: 自己 , 根元类
[B] B: 自己 , NSObject
[ ] C: 根元类 , 根元类
[X] D: 根元类 , NSObject

1.8 查找方法缓存的时候发现是乱序的, 为什么? 哈希冲突怎么解决的

[ ] A: 哈希函数原因 , 不解决
[X] B: 哈希函数原因 , 再哈希
[ ] C: 他存他的我也布吉岛 , 再哈希
[ ] D: 他乱由他乱,清风过山岗 , 不解决

1.9 消息的流程是

[X] A: 先从缓存快速查找
[X] B: 慢速递归查找methodlist (自己的和父类的,直到父类为nil)
[X] C: 动态方法决议
[X] D: 消息转发流程

1.10 类方法动态方法决议为什么在后面还要实现 resolveInstanceMethod

[ ] A: 类方法存在元类(以对象方法形式存在), 元类的父类最终是 NSObject 所以我们可以通过resolveInstanceMethod 防止 NSObject 中实现了对象方法!
[ ] B: 因为在oc的底层最终还是对象方法存在
[X] C: 类方法存在元类以对象方法形式存在.
[ ] D: 咸吃萝卜,淡操心! 苹果瞎写的不用管

A

二、判断题

2.1 光凭我们的对象地址,无法确认对象是否存在关联对象

[ ] 对
[X] 错

2.2 int c[4] = {1,2,3,4}; int d = c; c[2] = (d+2)

[X] 对
[ ] 错

2.3 @interface LGPerson : NSObject{ UIButton *btn } 其中 btn 是实例变量

[X] 对
[ ] 错

2.4 NSObject 除外元类的父类 = 父类的元类

[X] 对
[ ] 错

2.5 对象的地址就是内存元素的首地址

[ ] 对
[X] 错

对

2.6 类也是对象

[X] 对
[ ] 错

三、简单题

3.1 怎么将上层OC代码还原成 C++代码分值10分

xcrun 或 clang

3.2 怎么打开汇编查看流程,有什么好处 ? 分值10分

debug - DebugWorkflow - Always show disassembly
查看汇编可以从更深层次了解当前函数的汇编层面的执行，为OBJC源码分析提供信息，部分源码的执行被LLDB进行了改动，结合会变查看可以避免方向性错误，结合memory read可以更清楚的看到寄存器之间是如何让互相配合处理配合的。使用汇编查看流程可以再不确定源码出处和执行流程的情况下，跟踪内部代码，并找到出处。同时，结合符号断点的方式能够更清楚的跟踪源码实现。

3.3 x/4gx 和 p/x 以及 p *$0 代表什么意思分值10分

从首地址开始，1️以8字节的形式打印4段地址
打印地址
取出$0地址中的数据

3.4 类方法存在哪里? 为什么要这么设计? 分值10分

实例方法保存在类的方法列表中
类方法保存在元类的方法列表中
这样设计的好处：
- 底层不用区分类方法和对象方法，本质上都是对象方法。方法调用都可以理解为消息发送，只不过消息的接收者不一样。
- 这样设计更加的面向对象，类的一切信息都存储在元类中，对象的一切信息都存储在类中。类是元类实例化出的对象，实例对象是类实例化出的对象。存储也更符合面向对象的特点。
- OC语言早期借鉴了另一种 SmallTalk的语言，其中也是这么设计的。

3.5 方法慢速查找过程中的二分查找流程,请用伪代码实现分值10分

3.6 ISA_MASK = 0x00007ffffffffff8ULL 那么这个 ISA_MASK 的算法意义是什么? 分值10分

ISA包含在ISA_BITFIELD中， & ISA_MASK是为了去除ISA地址两边的数据（标志位、引用计数等），拿到正确的ISA地址。

3.7 类的结构里面为什么会有 rw 和 ro 以及 rwe ? 分值10分

class_ro_t
- read only
- 类名、方法、协议、成员变量等
- Clean memory
  - 运行时不会改变
class_rw_t
- read write
- 使用来读写数据的，在这个数据结构中存储了只有在运行时才会生成的信息。
- 可读可写
- Dirty memory
  - 运行时会改变
class_rw_ext_t
- read write extension
- 动态添加的
  - 方法
  - 属性
  - 协议等
- 这将 class_rw_t 的体积减少了进 50%。在有需要的时候将 class_rw_ext_t 插入其中，约 90% 的类用不到这些拓展数据

Dirty memory 要比 Clean memory 昂贵的多，只要进程在运行，他就一直存在。Clean memory 可以进行移除，以节省空间；如果需要可以再从磁盘中加载。

之所以将Class的数据分成两部分，是为了尽可能的节省空间

3.8 cache 在什么时候开始扩容 , 为什么? 分值10分

一般情况
- 3/4
真机Arm64
- 7/8
小缓存特殊情况
- 100%
为什么
- 效率

3.9 objc_msgSend 为什么用汇编写 , objc_msgSend 是如何递归找到imp? 分值10分

效率高

3.10 一个类的类方法没有实现为什么可以调用 NSObject 同名对象方法分值10分

ISA

矩阵中的路径（回溯法）

Sat, 10 Jul 2021 00:00:00 GMT

一、回溯法

回溯法可以看做蛮力法的升级版，它从解决问题每一步的所有可能选项里系统地选择出一个可行的解决方案。回溯法非常适合有多个步骤组成的问题，并且每个步骤都有多个选项。当我们在某一步选择了其中一个选项时，就进入下一步，然后有面临新的选择。我们这样重复选择，直至达到最终状态。

用回溯法解决的问题的所有选项可以形象的用树状结构表示。在某一步有n个可能的选项，那么该步骤可以看成是树状结构的一个节点，每个选项可以看做树中节点的联线，经过这些联线到达该节点的n个子节点。树的叶节点对应着终结状态。

流程：

如果在叶节点的状态满足题目的越苏条件时，那么我们找到了一个可行的解决方案。
如果在叶节点的状态不满足约束条件，那么只好回溯到它的上一个节点，在尝试其他的选项。
如果上一个节点，所有可能的选项多已经试过了，并且不能达到满足条件的最终状态，则再次回溯到上一个节点。
如果所有节点的所有选项都已经尝试过，仍然不能达到满足约束条件的终结状态，则无解。

二、典型题目

给定一个 m x n 二维字符网格 board 和一个字符串单词 word 。如果 word 存在于网格中，返回 true ；否则，返回 false 。

单词必须按照字母顺序，通过相邻的单元格内的字母构成，其中“相邻”单元格是那些水平相邻或垂直相邻的单元格。同一个单元格内的字母不允许被重复使用。例如，在下面的 3×4 的矩阵中包含单词 "ABCCED"（单词中的字母已标出）。

|A|B|C|E|
|S|F|C|S|
|A|D|E|E|

示例 1：

 输入：board = [["A","B","C","E"],["S","F","C","S"],["A","D","E","E"]], word = "ABCCED"
 输出：true

示例 2：

 输入：board = [["a","b"],["c","d"]], word = "abcd"
 输出：false

提示：

1 <= board.length <= 200
1 <= board[i].length <= 200
board 和 word 仅由大小写英文字母组成

注意：本题与主站 79 题相同：https://leetcode-cn.com/problems/word-search/

来源：力扣（LeetCode）链接：https://leetcode-cn.com/problems/ju-zhen-zhong-de-lu-jing-lcof 著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

三、解法

⭐GitHub

 func exist(_ board: [[Character]], _ word: String) -> Bool {
    let maxY = board.count
    let chars: [Character] = Array(word)
    
    guard let maxX = board.first?.count, maxY > 0, maxX > 0 else {
        return false
    }
    
    // 用于保存访问状态
    var visited: [[Bool]] = Array(repeating: Array(repeating: false, count: maxX), count: maxY)
    
    var pathLength = 0
    
    for y in 0..<maxY {
        for x in 0..<maxX {
            if hasPathCore(board, chars, maxX: maxX, maxY: maxY, pathLength: &pathLength, x: x, y: y, visted: &visited) {
                return true
            }
        }
    }
    
    return false
}

func hasPathCore(_ board: [[Character]], _ chars: [Character], maxX: Int, maxY: Int, pathLength: inout Int, x: Int, y: Int, visted: inout [[Bool]]) -> Bool {
    if pathLength == chars.count {
        return true
    }
    
    var result = false
    if x >= 0, y >= 0,
       x < maxX, y < maxY,
       visted[y][x] == false,
       board[y][x] == chars[pathLength]
    {
        pathLength += 1
        visted[y][x] = true
        
        result =
            hasPathCore(board, chars, maxX: maxX, maxY: maxY, pathLength: &pathLength, x: x - 1, y: y, visted: &visted) ||
            hasPathCore(board, chars, maxX: maxX, maxY: maxY, pathLength: &pathLength, x: x + 1, y: y, visted: &visted) ||
            hasPathCore(board, chars, maxX: maxX, maxY: maxY, pathLength: &pathLength, x: x, y: y - 1, visted: &visted) ||
            hasPathCore(board, chars, maxX: maxX, maxY: maxY, pathLength: &pathLength, x: x, y: y + 1, visted: &visted)
        
        if result == false {
            pathLength -= 1
            visted[y][x] = false
        }
    }
    
    return result
}

四、本题考点

考察对回溯法的理解。通常在二维矩阵上找路径都可以使用回溯法解决
考察对数组的编程能力。我们一般都把矩阵看成是儿歌二维数组。只有对数组的特性充分了解，才能快速、正确地实现回溯法的代码。

二进制中1的个数（含一个拓展问题）

Fri, 09 Jul 2021 00:00:00 GMT

一、题目

编写一个函数，输入是一个无符号整数（以二进制串的形式），返回其二进制表达式中数字位数为 '1' 的个数（也被称为汉明重量).）。

提示：

请注意，在某些语言（如 Java）中，没有无符号整数类型。在这种情况下，输入和输出都将被指定为有符号整数类型，并且不应影响您的实现，因为无论整数是有符号的还是无符号的，其内部的二进制表示形式都是相同的。在 Java 中，编译器使用二进制补码记法来表示有符号整数。因此，在上面的示例 3 中，输入表示有符号整数 -3。

示例 1：

 输入：n = 11 (控制台输入 00000000000000000000000000001011)
 输出：3
 解释：输入的二进制串 00000000000000000000000000001011 中，共有三位为 '1'。

示例 2：

 输入：n = 128 (控制台输入 00000000000000000000000010000000)
 输出：1
 解释：输入的二进制串 00000000000000000000000010000000 中，共有一位为 '1'。

示例 3：

 输入：n = 4294967293 (控制台输入 11111111111111111111111111111101，部分语言中 n = -3）
 输出：31
 解释：输入的二进制串 11111111111111111111111111111101 中，共有 31 位为 '1'。

提示：

输入必须是长度为 32 的二进制串。

注意：本题与主站 191 题相同：https://leetcode-cn.com/problems/number-of-1-bits/

来源：力扣（LeetCode）链接：https://leetcode-cn.com/problems/er-jin-zhi-zhong-1de-ge-shu-lcof 著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

解法

一位一位右移，每次判断最后一位

func hammingWeight(_ n: Int) -> Int {
    var count = 0
    var temp = n
    
    while temp > 0 {
        count += (temp & 1 == 1) ? 1 : 0
        temp >>= 1
    }

    return count
}

思考一

这个解法很容易就可以想出来。那么面试官可能会问了，右移一位和除以2是在数学上是等价的，那么这里可以换成除以2么？

最好不要。因为除法的效率比位运算效率低得多，在实际编码过程中也尽量使用位运算代替乘除法，尤其是高频调用的代码。

二、拓展问题

如果题目中的 无符号整数 换成 有符号整数，上面的解法是否还有效？

0x80000000 是一个负数，右移就不是 0x40000000了，是0xC0000000

右移会以符号位填补空白，负数补1，正数补0

如果单存的右移的话就会死循环

这里换个思路，移动1的位置

知识补充：
- 负数在计算机中二进制用补码标识
- 负数的补码：除符号位其余各位取反，然后+1

解法

func hammingWeight2(_ n: Int) -> Int {
    var count: Int = 0
    var flag: Int = 1
    
    while (flag != 0) {
        count += (n & flag == flag) ? 1 : 0
        if flag < 0 {// 最高位为1
            return count
        }
        flag <<= 1
    }

    return count
}

没钱推广？这忘了这100美元

Thu, 08 Jul 2021 00:00:00 GMT

一、前言

对于独立开发者而言，推广一般来说是个难事儿。（人脉广的大佬就请忽略了，这里说的是一般情况，比如我自己。）

我就以我比较浅薄的见识聊一下我对于推广的了解吧。

一般用户增长有这么几个途径
- 广告平台投放
  - 国内环境对于个人开发者不友好，基本都需要公司主体
- KOL推广
  - 要自己联系，定价和效果不一定
  - 如果你自己就是KOL再好不过了
- 个人推广
  - 主要是通过个人的朋友圈等自己的社交媒体推广
  - 效果一般
- 应用商店浏览
  - 自然用户主要来源
  - 如果能上苹果推荐的话带来的用户量就很可观了
- 应用商店搜索
  - 自然用户主要来源
  - 搜索的权重和你App的销售状况也是有关的，这里就不暂开讲了

通过上面的分析，其实留给国内独立开发者的低成本的推广其实选项不多，看起来一般人来说只能靠自然增长了。

某天，我发现 Apple 给了开发者一个不大不小的福利：$100 推广费。（哇！比年费还多1美元呢~）

这里就教你怎么用这 $100 推广费，以及我自己的使用体验。

二、Apple Search Ads

SearchAds是Apple自己的App Store广告系统。

2.1 两种广告模式

Basic🔗
- 最简单的广告
- 设置投放地区、预估单价、每月预算即可投放
- 这里主要聊到的就是这个模式的
Advanced🔗
- 更多专业的选项
- 我不专业没太多研究

三、Basic的使用

我们只需要关注下面三个点即可

3.1 投放地区

不包括中国大陆地区。很遗憾，大陆政策比较特别。
- 虽然最近有开中国大陆的，看了下，是需要公司主体的。这里就忽略掉。
- 港澳台是可以投放的
所以想要使用SearchAds达到有效的推广的话，本地化还是简单做下比较好，至少搞个中英吧。
地区不要全选
- 我最开始投放的时候就全选了
- 但是投放一段时间后发现个别地区的单价过高，十几倍的情况也是有的

我的投放案例

这里是某段时间内投放效果
- 在SearchAds后台可以下载
- 梦见账本做了中、英、日的多语言
- 这次分析之后我只留下了下载量与单价较为合适的几个
- 感觉因为地区全选了浪费了好多额度

3.2 最高每次安装费用 (CPI)

别怕，实际平均会比这个值低很多，看我上面的记录其实单价超过$1的不多。这里苹果也会给你一个推荐值，我就用的推荐值$2.20。

3.3 每月预算

很好理解了，超过这个数就暂停投放了，我就可怜的设了个$10...

四、总结

SearchAds有局限性，比如国内不能用。但是对于独立开发者而言，却是一个门槛极低的并且可靠的推广途径。

投放期间的下载量和停止投放对比起来还是挺明显更的，要是觉得效果不错，而且应用本地化做的也OK的话，其实完全可以持续在上面投放的，要绑定信用卡。

这里Apple提供了$100，我早就用完了。现在想想觉得挺可惜的，最早因为乱选地区浪费了很多用户。也希望看到这篇文章的你能够让这$100花的更有效。

调整数组顺序使奇数位于偶数前面

Thu, 08 Jul 2021 00:00:00 GMT

题目描述

输入一个整数数组，实现一个函数来调整该数组中数字的顺序，使得所有奇数位于数组的前半部分，所有偶数位于数组的后半部分。

示例：

输入：nums = [1,2,3,4] 输出：[1,3,2,4] 注：[3,1,2,4] 也是正确的答案之一。

提示：

0 <= nums.length <= 50000 1 <= nums[i] <= 10000

来源：力扣（LeetCode）链接：https://leetcode-cn.com/problems/diao-zheng-shu-zu-shun-xu-shi-qi-shu-wei-yu-ou-shu-qian-mian-lcof 著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

解法一

最容易想到的

func exchange(_ nums: [Int]) -> [Int] {
    var temp: [Int] = []
    nums.forEach {
        if $0 & 1 == 1 {
            temp.insert($0, at: 0)
        }
        else {
            temp.append($0)
        }
    }
    return temp
}

解法二：差速双指针

配上这个动图食用更佳来源

func exchange1(_ nums: [Int]) -> [Int] {
    var fastP: Int = 0
    var slowP: Int = 0
    var temp = nums

    while fastP < nums.count {
        if temp[fastP] & 1 == 1 {
            temp.swapAt(fastP, slowP)
            slowP += 1
        }
        fastP += 1
    }

    return temp
}

合并两个排序的链表

Thu, 08 Jul 2021 00:00:00 GMT

题目描述

输入两个递增排序的链表，合并这两个链表并使新链表中的节点仍然是递增排序的。

示例1：

输入：1->2->4, 1->3->4 输出：1->1->2->3->4->4 限制：

0 <= 链表长度 <= 1000

注意：本题与主站 21 题相同：https://leetcode-cn.com/problems/merge-two-sorted-lists/

来源：力扣（LeetCode）

链接：https://leetcode-cn.com/problems/he-bing-liang-ge-pai-xu-de-lian-biao-lcof 著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

题解

func mergeTwoLists(_ l1: ListNode?, _ l2: ListNode?) -> ListNode? {
    var line1 = l1
    var line2 = l2
    var firstNode: ListNode?
    var lastNode: ListNode?
    
    while let temp1 = line1, let temp2 = line2 {
        let isL1VSmaller = temp1.val < temp2.val
        let node = ListNode(isL1VSmaller ? temp1.val : temp2.val)
        if firstNode == nil {
            firstNode = node
        }
        else {
            lastNode?.next = node
        }
        lastNode = node
        isL1VSmaller ? (line1 = temp1.next) : (line2 = temp2.next)
    }
    
    if line1 == nil {
        lastNode?.next = line2
    }
    else {
        lastNode?.next = line1
    }

    return firstNode != nil ? firstNode : (l1 != nil ? l1 : l2)
}

二叉树的镜像

Thu, 08 Jul 2021 00:00:00 GMT

题目描述

请完成一个函数，输入一个二叉树，该函数输出它的镜像。

例如输入：

      4
    /   \
   2     7
  / \   / \
 1   3 6   9

镜像输出：

      4
    /   \
   7     2
  / \   / \
 9   6 3   1

示例 1：

输入：root = [4,2,7,1,3,6,9] 输出：[4,7,2,9,6,3,1]

限制：

0 <= 节点个数 <= 1000

注意：本题与主站 226 题相同：https://leetcode-cn.com/problems/invert-binary-tree/

来源：力扣（LeetCode）链接：https://leetcode-cn.com/problems/er-cha-shu-de-jing-xiang-lcof 著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

题解一

递归

func mirrorTree(_ root: TreeNode?) -> TreeNode? {
    if root == nil {
        return nil
    }
    let left = root?.left
    let right = root?.right
    root?.left = mirrorTree(right)
    root?.right = mirrorTree(left)
    return root
}

题解二

stack

func mirrorTree2(_ root: TreeNode?) -> TreeNode? {
   var stack: [TreeNode?] = [root]
   
   while stack.last != nil {
       let node = stack.removeLast()
       let right = node?.right
       let left = node?.left
       
       if let rn = right {
           stack.append(rn)
       }
       if let ln = left {
           stack.append(ln)
       }
       
       node?.left = right
       node?.right = left
   }
   
   return root
}

对称的二叉树

Thu, 08 Jul 2021 00:00:00 GMT

题目

请实现一个函数，用来判断一棵二叉树是不是对称的。如果一棵二叉树和它的镜像一样，那么它是对称的。

例如，二叉树 [1,2,2,3,4,4,3] 是对称的。

但是下面这个 [1,2,2,null,3,null,3] 则不是镜像对称的:

示例 1：

输入：root = [1,2,2,3,4,4,3] 输出：true 示例 2：

输入：root = [1,2,2,null,3,null,3] 输出：false

限制：

0 <= 节点个数 <= 1000

注意：本题与主站 101 题相同：https://leetcode-cn.com/problems/symmetric-tree/

来源：力扣（LeetCode）链接：https://leetcode-cn.com/problems/dui-cheng-de-er-cha-shu-lcof 著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

题解

递归

func isSymmetric(_ root: TreeNode?) -> Bool {
    func compare(tree1: TreeNode?, tree2: TreeNode?) -> Bool {
        if tree1 == nil && tree2 == nil {
            return true
        }
        else if tree1 == nil || tree2 == nil {
            return false
        }
        else if tree1?.val != tree2?.val {
            return false
        }
        return compare(tree1: tree1?.left, tree2: tree2?.right) && compare(tree1: tree1?.right, tree2: tree2?.left)
    }
    
    return compare(tree1: root?.left, tree2: root?.right)
}

open与public

Mon, 05 Jul 2021 00:00:00 GMT

在对自己的项目进行组件化的时候遇到这样一个问题

UI组件中

public class LedgerNavigationViewController: UINavigationController, StoryboardInitializable {
    public override func viewDidLoad() {
        super.viewDidLoad()
        setupUI()
    }
}

项目中（报错）

Cannot inherit from non-open class 'LedgerNavigationViewController' outside of its defining module
Overriding non-open instance method outside of its defining module

class MapNavigationController: LedgerNavigationViewController {

    override func viewDidLoad() {
        super.viewDidLoad()
        // Do any additional setup after loading the view.
    }
    
    weak var selector: LocationSelector?
}

修改

根据提示，将组件库中的 public 改成 open ，就可以了。

open class LedgerNavigationViewController: UINavigationController, StoryboardInitializable {
    open override func viewDidLoad() {
        super.viewDidLoad()

        setupUI()
    }
}

总结

平时每台用到 open，这里遇到问题才很清楚get到他俩的不同，主要区别在继承的控制上。

public
- 只能在模块内部被继承
open
- 可以再其他模块被继承

isKindOfClass的底层实现

Sun, 27 Jun 2021 00:00:00 GMT

BOOL result1 = [[NSObject class] isKindOfClass:[NSObject class]];
BOOL result2 = [[NSObject class] isMemberOfClass:[NSObject class]];
BOOL result3 = [[RYModel class] isKindOfClass:[RYModel class]];
BOOL result4 = [[RYModel class] isMemberOfClass:[RYModel class]];

NSLog(@"Class\n %hhd \n %hhd \n %hhd \n %hhd", result1, result2, result3, result4);

BOOL result5 = [[NSObject alloc] isKindOfClass:[NSObject class]];
BOOL result6 = [[NSObject alloc] isMemberOfClass:[NSObject class]];
BOOL result7 = [[RYModel alloc] isKindOfClass:[RYModel class]];
BOOL result8 = [[RYModel alloc] isMemberOfClass:[RYModel class]];

NSLog(@"Instacne\n %hhd \n %hhd \n %hhd \n %hhd", result5, result6, result7, result8);

思考一下，会输出什么？

结果：

2021-06-27 08:29:10.567002+0800 IsKindOf[62355:691675] Class
 1 
 0 
 0 
 0
2021-06-27 08:29:10.567836+0800 IsKindOf[62355:691675] Instacne
 1 
 1 
 1 
 1

如果仅从字面上去理解代码，那么你的答案应该会是不一样的的。我们从源码层面来理解一下吧，源码不长，很容易理解。

一、isKindOfClass

+ (BOOL)isKindOfClass:(Class)cls {
    for (Class tcls = self->ISA(); tcls; tcls = tcls->getSuperclass()) {
        if (tcls == cls) return YES;
    }
    return NO;
}

- (BOOL)isKindOfClass:(Class)cls {
    for (Class tcls = [self class]; tcls; tcls = tcls->getSuperclass()) {
        if (tcls == cls) return YES;
    }
    return NO;
}

1.1 流程图-Class

[NSObject class] 即 RootClass
- RootClass -(ISA)> RootMetaClass -(superClass)> RootClass
- true
[RYModel class]
- [RYModel class] -(ISA)> RYModelMetaClass -(superClass)> RootMetaClass -(superClass)> RootClass -(superClass)> nil
- false

1.2 流程图-Instance

NSObjectInstance
- NSObjectInstance -(class)> RootClass
- true
RYModelInstance
- RYModelInstance -(class)> RYModelClass
- true

二、isMemberOfClass

+ (BOOL)isMemberOfClass:(Class)cls {
    return self->ISA() == cls;
}

- (BOOL)isMemberOfClass:(Class)cls {
    return [self class] == cls;
}

这里就很简单了，就不展开说了。

三、你以为这就完了？

如果你看到这里觉得没啥问题？那就有问题了。。。

我们运行下OC源码，两个断点。

运行之后发现 +/- (Bool)isKindOfClass:(Class)cls 居然根本没有调用。

3.1 汇编

通过断点汇编，我们在调用 isKindOfClass 的地方发现了这样的指令 objc_opt_isKindOfClass

->  0x10000381c <+332>: mov    rdi, qword ptr [rip + 0x4f7d] ; (void *)0x0000000100008808: RYModel
    0x100003823 <+339>: call   0x100003b42               ; symbol stub for: objc_opt_class
    0x100003828 <+344>: mov    rbx, rax
    0x10000382b <+347>: mov    rdi, qword ptr [rip + 0x4f6e] ; (void *)0x0000000100008808: RYModel
    0x100003832 <+354>: call   0x100003b42               ; symbol stub for: objc_opt_class
    0x100003837 <+359>: mov    rdi, rbx
    0x10000383a <+362>: mov    rsi, rax
    0x10000383d <+365>: call   0x100003b48               ; symbol stub for: objc_opt_isKindOfClass

3.2 objc_opt_isKindOfClass

// Calls [obj isKindOfClass]
BOOL
objc_opt_isKindOfClass(id obj, Class otherClass)
{
#if __OBJC2__
    // 判空
    if (slowpath(!obj)) return NO;
    Class cls = obj->getIsa();
    if (fastpath(!cls->hasCustomCore())) {
        for (Class tcls = cls; tcls; tcls = tcls->getSuperclass()) {
            if (tcls == otherClass) return YES;
        }
        return NO;
    }
#endif
    // 这里可以忽略
    return ((BOOL(*)(id, SEL, Class))objc_msgSend)(obj, @selector(isKindOfClass:), otherClass);
}

在这里下断点，我们发现的确进到了这里。并且 Class 和 Instance 的方法都走到了这里。

编译器对这里进行的优化，用更高效的 objc_opt_isKindOfClass 代替了原有的方法。

四、参考

slowpath & fastpath

slowpath和fastpath

Sun, 27 Jun 2021 00:00:00 GMT

slowpath & fastpath

在日常阅读OC源码的过程中经常会遇到这两个宏定义。它是什么意思呢？

//x很可能为真， fastpath 可以简称为 真值判断
#define fastpath(x) (__builtin_expect(bool(x), 1)) 
//x很可能为假，slowpath 可以简称为 假值判断
#define slowpath(x) (__builtin_expect(bool(x), 0))

其中的 __builtin_expect 指令是由 gcc 引入的

目的：编译器可以对代码进行优化，以减少指令跳转带来的性能下降。即性能优化
作用：允许程序员将最有可能执行的分支告诉编译器。
指令的写法为：__builtin_expect(EXP, N) 。表示 EXP==N的概率很大。
fastpath 定义中 __builtin_expect((x),1) 表示 x 的值为真的可能性更大；即执行if 里面语句的机会更大
slowpath 定义中的 __builtin_expect((x),0) 表示 x 的值为假的可能性更大。即执行 else 里面语句的机会更大
在日常的开发中，也可以通过设置来优化编译器，达到性能优化的目的，设置的路径为：Build Setting --> Optimization Level --> Debug --> 将None 改为 fastest 或者 smallest

深入探索Class的结构

Sat, 26 Jun 2021 00:00:00 GMT

一、内存平移

我们先通过下面的例子了解一下内存平移

int nums[4] = {1, 2, 3, 4};

NSLog(@"数组nums的地址：%p\n", &nums);

for (int i = 0; i < 4; i++) {
    NSLog(@"第%d个元素是%d地址是%p", i + 1, nums[i], &nums[i]);
}

NSLog(@"\n");

int *numsPointer = nums;
NSLog(@"数组nums的指针：%p\n", numsPointer);

for (int i = 0; i < 4; i++) {
    NSLog(@"偏移%d，取值%d，地址是%p", i, *(numsPointer + i), (numsPointer + i));
}

输出：

2021-06-22 23:27:02.344397+0800 Class[15488:5517067] 数组nums的地址：0x16f00d3a0

2021-06-22 23:27:02.344734+0800 Class[15488:5517067] 第1个元素是11地址是0x16f00d3a0
2021-06-22 23:27:02.344910+0800 Class[15488:5517067] 第2个元素是12地址是0x16f00d3a4
2021-06-22 23:27:02.345776+0800 Class[15488:5517067] 第3个元素是13地址是0x16f00d3a8
2021-06-22 23:27:02.346025+0800 Class[15488:5517067] 第4个元素是14地址是0x16f00d3ac
2021-06-22 23:27:02.346173+0800 Class[15488:5517067] 
2021-06-22 23:27:02.346328+0800 Class[15488:5517067] 数组nums的指针：0x16f00d3a0

2021-06-22 23:27:02.347933+0800 Class[15488:5517067] 偏移0，取值11，地址是0x16f00d3a0
2021-06-22 23:27:02.348115+0800 Class[15488:5517067] 偏移1，取值12，地址是0x16f00d3a4 // 4字节
2021-06-22 23:27:02.348425+0800 Class[15488:5517067] 偏移2，取值13，地址是0x16f00d3a8 // 4字节
2021-06-22 23:27:02.349788+0800 Class[15488:5517067] 偏移3，取值14，地址是0x16f00d3ac // 4字节

nums一个元素4字节，指针偏移1次4字节。所以这里可以通过从数组首地址开始偏移的方式进行取值操作。

同理对Class的内存结构我们是否也能进行内存平移来取值呢？

二、Class的结构内存计算

在Class的源码中我们发现核心的数据结构是这样的，暂时忽略其中的方法，因为不影响Class的内存结构。

方法都存在方法区

struct objc_class : objc_object {
    ...

    // Class ISA; objc_object 中的 ISA
    Class superclass;
    cache_t cache;             // formerly cache pointer and vtable
    class_data_bits_t bits;    // class_rw_t * plus custom rr/alloc flags

    ...
}

-	ISA	superClass	cache	bits
说明	ISA（结构体指针）	父类（结构体指针）	方法缓存	类的具体信息
大小（字节）	8	8	16	8

三、objc_class: cache_t 的内存结构

我们忽略掉方法，剩下的核心数据结构如下

struct cache_t {
private:
    explicit_atomic<uintptr_t> _bucketsAndMaybeMask;
    union {
        struct {
            explicit_atomic<mask_t>    _maybeMask;
#if __LP64__
            uint16_t                   _flags;
#endif
            uint16_t                   _occupied;
        };
        explicit_atomic<preopt_cache_t *> _originalPreoptCache;
    };
}

3.1 小补充：LP64数据模型

在里面我们可以看到 __LP64__，这里代表的是LP64数据模型。现今所有64位的类Unix平台均使用LP64数据模型。

TYPE	LP32	ILP32	LP64	ILP64	LLP64
含义	指long和pointer是32位的	指int，long和pointer是32位的	指long和pointer是64位	指int，long，pointer是64位	指long long和pointer是64位的
CHAR	8	8	8	8	8
SHORT	16	16	16	16	16
INT	16	32	32	64	32
LONG	32	32	64	64	32
LONG LONG	64	64	64	64	64
POINTER	32	32	64	64	64

3.2 内部联合体的内存结构

联合体包含了两部分：结构体、指针。我们已知arm64下指针占用8字节。我们来看下结构体需要占用多少

-	_maybeMask	_flags
类型	uint32_t	uint16_t
大小（字节）	4	2

结构体大小 8 字节，联合体大小为8字节

3.3 结构总结

-	_bucketsAndMaybeMask	union
说明	指针(做什么的还需要研究)	联合体
大小（字节）	long类型 8	8

cache_t大小为16字节

四、objc_class : class_data_bits_t 的内存结构

核心数据结构如下

struct class_data_bits_t {
  ...
  // Values are the FAST_ flags above.
  uintptr_t bits;
  ...
}

我们发现内部只有一个指针bits，那么如何通过它获取到类的详细信息呢？

我们发现这样一个函数，通过bits与上FAST_DATA_MASK可以获得class_rw_t。和我们找ISA的过程比较类似。

那么它是做什么的呢？

class_rw_t* data() const {
    return (class_rw_t *)(bits & FAST_DATA_MASK);
}

FAST_DATA_MASK在LP64下的定义

#if __LP64__
...
// data pointer
#define FAST_DATA_MASK          0x00007ffffffffff8UL

五、class_data_bits_t : class_rw_t

rw: read-write

5.1 class_rw_t的内存结构

struct class_rw_t {
  // Be warned that Symbolication knows the layout of this structure.
  // 标志位，如是否是元类，是否实现了等
  uint32_t flags;
  uint16_t witness;

  explicit_atomic<uintptr_t> ro_or_rw_ext; //

  Class firstSubclass;
  Class nextSiblingClass;

}

5.2 一些重要函数

这里我们会看到一些眼熟的函数，在methods() properties() protocols()中我们发现了另一个重要的类型class_rw_ext_t

class_rw_ext_t *deepCopy(const class_ro_t *ro) {
    return extAlloc(ro, true);
}

const method_array_t methods() const {
    auto v = get_ro_or_rwe();
    if (v.is<class_rw_ext_t *>()) {
        return v.get<class_rw_ext_t *>(&ro_or_rw_ext)->methods;
    } else {
        return method_array_t{v.get<const class_ro_t *>(&ro_or_rw_ext)->baseMethods()};
    }
}

const property_array_t properties() const {
    ...
}

const protocol_array_t protocols() const {
    ...
}

六、class_data_bits_t : class_rw_t : class_rw_ext_t

struct class_rw_ext_t {
    DECLARE_AUTHED_PTR_TEMPLATE(class_ro_t)
    class_ro_t_authed_ptr<const class_ro_t> ro;// 成员变量
    method_array_t methods;
    property_array_t properties;
    protocol_array_t protocols;
    char *demangledName;
    uint32_t version;
};

6.1 list_array_tt

method_array_t/property_array_t/protocol_array_t 都是继承于 list_array_tt 的，通过泛型来完成不同的定义。

源码核心部分：

template <typename Element, typename List, template<typename> class Ptr>
class list_array_tt {
  ...
  private:
    union {
        Ptr<List> list;
        uintptr_t arrayAndFlag;
    };
  ...
}

method_array_t

class method_array_t : 
    public list_array_tt<method_t, method_list_t, method_list_t_authed_ptr> {...}

property_array_t

class property_array_t : 
    public list_array_tt<property_t, property_list_t, RawPtr> {...}

protocol_array_t

class protocol_array_t : 
    public list_array_tt<protocol_ref_t, protocol_list_t, RawPtr> {...}

6.2 class_ro_t

源码核心部分：

struct class_ro_t {
  ...
  const ivar_list_t * ivars; // 成员变量
  ...
}

七、LLDB调试Class内存结构

结构图

有这样的一个类

@interface RYModel : NSObject

@property (nonatomic, copy) NSString *name;
@property (nonatomic, assign) NSInteger age;
@property (nonatomic, assign) float height;
@property (nonatomic, strong) RYModel *father;
@property (nonatomic, assign) BOOL isBoy;

- (void)dosomething;

- (void)dosomethingWith:(NSString *)title;

+ (void)classDoSomething;

- (NSString *)sayMyName;

@end

7.1 成员变量

获取class_data_bits_t

这里通过内存偏移的方式找到class_data_bits_t，如前文所述：bits所在位置的偏移为8+8+16=32字节。

那么我们理论上可以通过对象地址+0x20计算出它的位置。

(lldb) p/x RYModel.class
(Class) $0 = 0x00000001000083e0 RYModel

(lldb) x/4gx 0x00000001000083e0
0x1000083e0: 0x00000001000083b8 0x000000010036a140
0x1000083f0: 0x000000010073c2d0 0x0004803400000007

// 计算bits
(lldb) p/x 0x1000083e0 + 0x20 
(long) $1 = 0x0000000100008400

// 这里转换一下类型便于后面继续调试
(lldb) p (class_data_bits_t *)0x0000000100008400 
(class_data_bits_t *) $2 = 0x0000000100008400

通过 data() 方法获取 class_rw_t

(lldb) p (class_data_bits_t *)0x0000000100008400
(class_data_bits_t *) $4 = 0x0000000100008400

(lldb) p $4->data()
(class_rw_t *) $5 = 0x000000010073c040

通过 properties 获取属性列表容器

(lldb) p $5->properties
(const property_array_t) $6 = {
  list_array_tt<property_t, property_list_t, RawPtr> = {
     = {
      list = {
        ptr = 0x0000000100008280
      }
      arrayAndFlag = 4295000704
    }
  }
}
  Fix-it applied, fixed expression was: 
    $5->properties()

取出 list

(lldb) p $6.list
(const RawPtr<property_list_t>) $7 = {
  ptr = 0x0000000100008280
}

取出 ptr

(lldb) p $7.ptr
(property_list_t *const) $8 = 0x0000000100008280

取出 ptr 内的值

(lldb) p *$8
(property_list_t) $9 = {
  entsize_list_tt<property_t, property_list_t, 0, PointerModifierNop> = (entsizeAndFlags = 16, count = 5)
}

通过下标取出属性

(lldb) p $9.get(0)
(property_t) $10 = (name = "name", attributes = "T@\"NSString\",C,N,V_name")
(lldb) p $9.get(1)
(property_t) $11 = (name = "age", attributes = "Tq,N,V_age")
(lldb) p $9.get(2)
(property_t) $12 = (name = "height", attributes = "Tf,N,V_height")
(lldb) p $9.get(3)
(property_t) $13 = (name = "father", attributes = "T@\"RYModel\",&,N,V_father")
(lldb) p $9.get(4)
(property_t) $14 = (name = "isBoy", attributes = "Tc,N,V_isBoy")

7.2 实例方法列表

前面一些相似的步骤我们省略掉

从 class_rw_t -> methods 获取 方法列表容器

(lldb) p $5->methods
(const method_array_t) $6 = {
  list_array_tt<method_t, method_list_t, method_list_t_authed_ptr> = {
     = {
      list = {
        ptr = 0x00000001000080e8
      }
      arrayAndFlag = 4295000296
    }
  }
}
  Fix-it applied, fixed expression was: 
    $5->methods()

取出 list

(lldb) p $6.list
(const method_list_t_authed_ptr<method_list_t>) $14 = {
  ptr = 0x00000001000080e8
}

取出 ptr

(lldb) p $14.ptr
(method_list_t *const) $15 = 0x00000001000080e8

取出 ptr 中的数据 method_list_t

(lldb) p *$15
(method_list_t) $16 = {
  entsize_list_tt<method_t, method_list_t, 4294901763, method_t::pointer_modifier> = (entsizeAndFlags = 27, count = 14)
}

获取方法数量

(lldb) p $16.count
(uint32_t) $29 = 14

通过c++函数get()与big()单个获取类的实例方法

这里除了我们自己定义的一些实例方法，还看到了一些列属性自动生成的set、get方法，以及析构函数

(lldb) p $16.get(0).big()
(method_t::big) $19 = {
  name = "setFather:"
  types = 0x0000000100003f60 "v24@0:8@16"
  imp = 0x0000000100003cc0 (ObjcBuild`-[RYModel setFather:])
}
(lldb) p $16.get(1).big()
(method_t::big) $20 = {
  name = "father"
  types = 0x0000000100003f6b "@16@0:8"
  imp = 0x0000000100003ca0 (ObjcBuild`-[RYModel father])
}

... // 省略一些Set、get

(lldb) p $16.get(3).big()
(method_t::big) $22 = {
  name = "dosomething"
  types = 0x0000000100003f3b "v16@0:8"
  imp = 0x0000000100003b30 (ObjcBuild`-[RYModel dosomething])
}
(lldb) p $16.get(4).big()
(method_t::big) $23 = {
  name = "dosomethingWith:"
  types = 0x0000000100003f60 "v24@0:8@16"
  imp = 0x0000000100003b40 (ObjcBuild`-[RYModel dosomethingWith:])
}

...

(lldb) p $16.get(8).big()
(method_t::big) $27 = {
  name = ".cxx_destruct"
  types = 0x0000000100003f3b "v16@0:8"
  imp = 0x0000000100003d30 (ObjcBuild`-[RYModel .cxx_destruct])
}

... // 省略一些Set、get

7.3 协议列表

前面一些相似的步骤我们省略掉

从 class_rw_t -> protocols 获取 协议列表容器

(lldb) p $2->protocols()
(const protocol_array_t) $3 = {
  list_array_tt<unsigned long, protocol_list_t, RawPtr> = {
     = {
      list = {
        ptr = 0x00000001000083b8
      }
      arrayAndFlag = 4295001016
    }
  }
}

取出 list

(lldb) p $3.list
(const RawPtr<protocol_list_t>) $4 = {
  ptr = 0x00000001000083b8
}

取出 ptr

(lldb) p $4.ptr
(protocol_list_t *const) $5 = 0x00000001000083b8

取出 ptr 中的数据 protocol_list_t

(lldb) p *$5
(protocol_list_t) $6 = (count = 1, list = protocol_ref_t [] @ 0x00007f9a62cb8778)

这里可以发现，里面的list中存了一个指针，并不是完整的一个数据结构。我们找到了这样的定义：

typedef uintptr_t protocol_ref_t; // protocol_t *, but unremapped

获取 protocol_t *

(lldb) p (protocol_t *)$6.list[0]
(protocol_t *) $7 = 0x00000001000088a0

读取数据

(lldb) p *$7
(protocol_t) $8 = {
  objc_object = {
    isa = {
      bits = 4298547400
      cls = Protocol
       = {
        nonpointer = 0
        has_assoc = 0
        has_cxx_dtor = 0
        shiftcls = 537318425
        magic = 0
        weakly_referenced = 0
        unused = 0
        has_sidetable_rc = 0
        extra_rc = 0
      }
    }
  }
  mangledName = 0x0000000100003e71 "RYProtocol"
  protocols = 0x0000000100008310
  instanceMethods = 0x0000000100008328
  classMethods = nil
  optionalInstanceMethods = nil
  optionalClassMethods = nil
  instanceProperties = nil
  size = 96
  flags = 0
  _extendedMethodTypes = 0x0000000100008348
  _demangledName = 0x0000000000000000
  _classProperties = nil
}

7.4 成员变量

前面一些相似的步骤我们省略掉

从 class_rw_t -> ro() 获取 成员变量列表容器

(lldb) p $4->ro()
(const class_ro_t *) $18 = 0x00000001000083d0

class_ro_t -> ivars 获取成员变量列表

(lldb) p $18->ivars
(const ivar_list_t *const) $19 = 0x0000000100008570

(lldb) p *$19
(const ivar_list_t) $20 = {
  entsize_list_tt<ivar_t, ivar_list_t, 0, PointerModifierNop> = (entsizeAndFlags = 32, count = 5)
}

从成员变量列表中获取成员变量


(lldb) p $20.count
(const uint32_t) $21 = 5

(lldb) p $20.get(0)
(ivar_t) $22 = {
  offset = 0x0000000100008770
  name = 0x0000000100003de7 "_isBoy"
  type = 0x0000000100003f47 "c"
  alignment_raw = 0
  size = 1
}
(lldb) p $20.get(1)
(ivar_t) $23 = {
  offset = 0x0000000100008778
  name = 0x0000000100003dee "_height"
  type = 0x0000000100003f49 "f"
  alignment_raw = 2
  size = 4
}
(lldb) p $20.get(2)
(ivar_t) $24 = {
  offset = 0x0000000100008780
  name = 0x0000000100003df6 "_name"
  type = 0x0000000100003f4b "@\"NSString\""
  alignment_raw = 3
  size = 8
}
(lldb) p $20.get(3)
(ivar_t) $25 = {
  offset = 0x0000000100008788
  name = 0x0000000100003dfc "_age"
  type = 0x0000000100003f57 "q"
  alignment_raw = 3
  size = 8
}
(lldb) p $20.get(4)
(ivar_t) $26 = {
  offset = 0x0000000100008790
  name = 0x0000000100003e01 "_father"
  type = 0x0000000100003f59 "@\"RYModel\""
  alignment_raw = 3
  size = 8
}

7.5 类方法

类方法我们需要到元类中进行查找

获取元类类信息

(lldb) p/x RYModel.class
(Class) $67 = 0x00000001000087c0 RYModel
(lldb) x/4gx 0x00000001000087c0
0x1000087c0: 0x0000000100008798 0x000000010036a140
0x1000087d0: 0x00000001010695c0 0x0004803400000007
(lldb) p/x 0x0000000100008798 & 0x00007ffffffffff8ULL
(unsigned long long) $68 = 0x0000000100008798
(lldb) p 0x0000000100008798 + 0x20
(long) $70 = 4295002040
(lldb) p/x 0x0000000100008798 + 0x20
(long) $71 = 0x00000001000087b8
(lldb) p (class_data_bits_t *)0x00000001000087b8
(class_data_bits_t *) $72 = 0x00000001000087b8

(lldb) p $72->data()
(class_rw_t *) $73 = 0x0000000101069510
(lldb) p $73->methods()
(const method_array_t) $74 = {
  list_array_tt<method_t, method_list_t, method_list_t_authed_ptr> = {
     = {
      list = {
        ptr = 0x0000000100008398
      }
      arrayAndFlag = 4295000984
    }
  }
}

获取元类方法列表（类方法）

(lldb) p $74.list
(const method_list_t_authed_ptr<method_list_t>) $75 = {
  ptr = 0x0000000100008398
}
(lldb) p $75.ptr
(method_list_t *const) $76 = 0x0000000100008398
(lldb) p *$76
(method_list_t) $77 = {
  entsize_list_tt<method_t, method_list_t, 4294901763, method_t::pointer_modifier> = (entsizeAndFlags = 27, count = 1)
}

输出方法信息

(lldb) p $77.get(0).big()
(method_t::big) $78 = {
  name = "classDoSomething"
  types = 0x0000000100003f3f "v16@0:8"
  imp = 0x0000000100003920 (ObjcBuild`+[RYModel classDoSomething])
}

WWDC20-runtime优化

Sat, 26 Jun 2021 00:00:00 GMT

官网链接WWDC20-Advancements in the Objective-C runtime

其中主要提到了三点优化

Class数据结构的变化
方法列表的变化
Tagged pointer 格式变化

一、Class数据结构与运行时

1.1 class_ro_t

在二进制文件中，Class的结构是这样的

首先Class对象包含了最常用的信息：指向元类、父类、方法缓存的指针

他还有一个指向更多数据的指针，存储这些额外信息的地方是：class_ro_t

RO 代表 Read only，它包含：

类名
方法
协议
实例变量信息等

Swift Class 和 OC Class 共享这一数据结构

当类第一次从磁盘加载到内存中时，他的结构是这样的,但是一经使用，他就会发生变化

1.2 Clean memory & Dirty memory

Clean memory
- 是指加载后不会发生改变的内存
- class_ro_t 就是这种
Dirty memory
- 是指进程运行时会发生改变的内存
- Class对象 就是这种，应为它在运行时会发生变化

Dirty memory 要比 Clean memory 昂贵的多，只要进程在运行，他就一直存在。Clean memory 可以进行移除，以节省空间；如果需要可以再从磁盘中加载。

之所以将Class的数据分成两部分，是为了尽可能的节省空间

1.3 class_ro_t

运行时需要追踪每个类的更多信息，当一个类首次被使用时，运行时会为他分配额外的存储空间。 class_rw_t

class_rw_t 使用来读写数据的，在这个数据结构中存储了只有在运行时才会生成的信息。

方法、属性、协议也在 class_rw_t 中，是因为运行时可以通过 Category 动态添加。因为 class_ro_t 是只读的所以我们就在 class_rw_t 管理这些。

但是这样会占用很多的内存。那么 如何缩小这部分的体积呢？

二、优化 class_rw_t

虽然每个类有这样的数据结构，但是真正用到这部分读写功能的却只占很少一部分。

只有 Swift 有 Demangled name，并且只有需要访问 Swift类 的 Objective-c 名称时才会用到它。

我们将 class_rw_t 分为了两部分：

class_rw_t
- 常用的
class_rw_ext_t
- 不常用的

这将 class_rw_t 的体积减少了进 50%

在有需要的时候将 class_rw_ext_t 插入其中，约 90% 的类用不到这些拓展数据。

三、方法列表

3.1 方法列表元素的结构

selector 方法名

Type Encodings 类型编码

这是一个表示参数类型的字符串。官方文档

指向方法实现的指针

3.2 方法列表元素的大小

在64位系统下，占用24字节。

3.3 寻址

下面的图模拟了内存的分布

方法元素的三个指针指向了App内存空间的相对位置，并在加载时修正为实际的位置。由于在内存中，这三个元素的内存地址是连续的。所以我们可以对寻址进行优化。

3.4 优化：Relative method lists

2020年runtime做了优化，通过32位内存偏移来进行寻址，简化了寻址操作。

偏移量始终是相同的
- 无论image从哪里加载到内存中，它们从磁盘加载到内存后无需进行修正
将方法列表存入只读的空间，安全节省内存
使用32位来存储，节省了一半的空间

3.5 Swizzling relative method lists

现在的imp不能引用完整的地址空间，但如果你Swizzle一个方法，他就可以在任何地方实现。

由于方法列表放入了只读的空间，我们并不能直接修改方法列表。这里提供了一个全局表。这个全局表将方法映射到他们被Swizzle的实现上。

在实际情况下，只会有少量的Swizzle所以这个表不会很大。

四、兼容性

4.1 系统要求

支持版本
macOS Big Sur
iOS 14
tvOS 14
watchOS 7

Xcode会对支持更低版本的包按老的方式进行处理。兼容Swift。

4.2 一些SDK

如果我们使用了在其他地方编译好的SDK，但是他又没有兼容 Related method lists。

在老的OS下运行，如果它通过地址去访问方法，它会将两个段32位数据作为一个64位去进行读取，两个指针粘连在一起，那么就会发生崩溃。

为保证不会出现这样的问题，请使用系统API。

五、Tagged pointer format changes (ARM64)

5.1 Tagged pointer

以前一个对象的指针是这样的结构。我们只用到了中间的部分。

由于低位对齐的原则低三位为0，由于地址空间有限，高位为0。

Tagged pointer，将第一位设为了1。这是区别它和原始指针的最简单的方式。以 NSNumber 为例：

5.2 Tagged pointer On Intel

最低位1
- 代表它是 Tagged pointer
接下来3位是：标签位
- 表示了指针的类型，例如3代表它是 NSNumber
- 这里有3位，这里最多能有8种类型
剩下的是 Payload 是特定类型可以随意使用的数据
- 对于NSNumber来说，这里就是实际的数字

对于 `标签7` 有特殊情况

它表示一个拓展标签
使用接下来的8位来编码类型
这允许多出256个标签类型
但是代价是减少了 Payload 的可用区域
这使得我们可以将 Tagged pointer 用于更多类型，只要 Payload 能够装入。
- 如：UIColor 、 NSIndexSet

注意

开发者无法添加 Tagged pointer 类型。（OC）
Swift中带有关联值的枚举就是一个类似 Tagged pointer 的类。
- Swift运行时将枚举判别器存储在关联值的 Payload 的备用位中。
- 而且Swift值类型的运用，使得 Tagged pointer 没有那么重要了。
- If you've ever used an enum with an associated value that's a class, that's like a tagged pointer. The Swift runtime stores the enum discriminator in the spare bits of the associated value payload.

5.3 Tagged pointer On ARM

ARM 下，结构使反过来的。为什么不合Intel上保持一致呢？

优化 objc_msgSend

目的是加快 objc_msgSend 最常见的分支路径。

只用通过最高位是否为1，就可以区分同时检查它是 （nil || 非Tagged pointer），节省了条件分支。

优化： iOS 14

在新版系统中，将标签为移到了后3位。

在ARM64下，会忽略指针的前8位
- Top byte ignore 的 ARM特性

注意：以前这样的判断是OK的，但是在iOS14后就不行了。

老老实实使用系统API，它会帮你处理一切。不要为了看起来牛逼而写一些这种危机四伏的代码。

ISA与Class

Wed, 23 Jun 2021 00:00:00 GMT

ISA与Class的继承

本文基于 objc4-818.2 源码

本文较长，建议吃饱喝足再进行阅读。由于很多内容关联性很强，本来准备拆分一下的。但还是决定放在一起，逐步深入。避免发生 这里一个知识点在另一篇文章，那我晚点再看（根本不会再看） 的情况。

其中 协议列表 的探究过程中遇到了一些问题，无法进行下去，有解决办法的欢迎交流~

一、类对象

在上一文中我们初步探究了，obj和isa.

通过下面的步骤我们可以找到类对象

(lldb) p/x obj1
(RYObject *) $8 = 0x000000028026c340
(lldb) x/4gx 0x000000028026c340
0x28026c340: 0x000001a1042194f1 0x0000000000000000
0x28026c350: 0x0000b6106e0ac350 0x000000028356012e
(lldb) p/x 0x000001a1042194f1 & 0x0000000ffffffff8ULL
(unsigned long long) $14 = 0x00000001042194f0
(lldb) po 0x000001a1042194f1 & 0x0000000ffffffff8ULL
RYObject

1.1 类对象ISA

Class其实也是一个对象，那么我很好奇。类对象是不是也有个ISA呢？

我们以同样的步骤进行调试：

(lldb) p/x 0x000001a1042194f1 & 0x0000000ffffffff8ULL
(unsigned long long) $11 = 0x00000001042194f0
(lldb) x/4gx 0x00000001042194f0
0x1042194f0: 0x00000001042194c8 0x00000001fc942218
0x104219500: 0x00030002815641c0 0x0003801000000000
(lldb) po 0x00000001042194c8
RYObject

居然也有一个RYObject，并且内存地址和第一步生成的0x00000001042194f0 不一样，是0x00000001042194c8。

这里的0x00000001042194c8其实就是元类。

二、元类

我们将刚才编译过的MachO丢进MachoView中解析。

打开符号表，搜索RYObject：

_OBJC_METACLASS_RO$_RYObject
- 元类
_OBJC_CLASS_RO$_RYObject
- 类

三、ISA与Class的关系

我们使用下面的代码进行验证，其中RYSubObject继承RYObject

    RYObject *rySubObject = [[RYSubObject alloc] init];
    NSLog(@"实例%@ 的地址是 %p", rySubObject, rySubObject);
    Class rySubObjectClass = object_getClass(rySubObject);
    NSLog(@"实例%@ 的类对象是 %@ 地址是 %p", rySubObject, rySubObjectClass, rySubObjectClass);
    Class rySubObjectMetaClass = object_getClass(rySubObjectClass);
    NSLog(@"实例%@ 的元类是 %@ 地址是 %p", rySubObject, rySubObjectMetaClass, rySubObjectMetaClass);
    Class rySubObjectRootMetaClass = object_getClass(rySubObjectMetaClass);
    NSLog(@"实例%@ 的根元类是 %@ 地址是 %p", rySubObject, rySubObjectRootMetaClass, rySubObjectRootMetaClass);
    
    NSLog(@"\n");
    
    RYObject *ryObject = [[RYObject alloc] init];
    NSLog(@"实例%@ 的地址是 %p", ryObject, ryObject);
    Class ryObjectClass = object_getClass(ryObject);
    NSLog(@"实例%@ 的类对象是 %@ 地址是 %p", ryObject, ryObjectClass, ryObjectClass);
    Class ryObjectMetaClass = object_getClass(ryObjectClass);
    NSLog(@"实例%@ 的元类是 %@ 地址是 %p", ryObject, ryObjectMetaClass, ryObjectMetaClass);
    Class ryObjectRootMetaClass = object_getClass(ryObjectMetaClass);
    NSLog(@"实例%@ 的根元类是 %@ 地址是 %p", ryObject, ryObjectRootMetaClass, ryObjectRootMetaClass);

    NSLog(@"\n");
    
    NSObject *nsObject = [[NSObject alloc] init];
    NSLog(@"实例%@ 的地址是 %p", nsObject, nsObject);
    Class nsObjectClass = object_getClass(nsObject);
    NSLog(@"实例%@ 的类对象是 %@ 地址是 %p", nsObject, nsObjectClass, nsObjectClass);
    Class nsObjectMetaClass = object_getClass(nsObjectClass);
    NSLog(@"实例%@ 的元类是 %@ 地址是 %p", nsObject, nsObjectMetaClass, nsObjectMetaClass);
    Class nsObjectRootMetaClass = object_getClass(nsObjectMetaClass);
    NSLog(@"实例%@ 的根元类是 %@ 地址是 %p", nsObject, nsObjectRootMetaClass, nsObjectRootMetaClass);
    
    NSLog(@"\n");
    
    Class rySubSuperClass = class_getSuperclass(rySubObjectClass);
    NSLog(@"子类%@（地址%p）的父类是%@ 地址是%p",rySubObjectClass,rySubObjectClass, rySubSuperClass, rySubSuperClass);
    Class rySuperClass = class_getSuperclass(ryObjectClass);
    NSLog(@"父类%@（地址%p）的父类是%@ 地址是%p",ryObjectClass,ryObjectClass, rySuperClass, rySuperClass);
    Class nsSuperClass = class_getSuperclass(nsObjectClass);
    NSLog(@"根类%@（地址%p）的父类是%@ 地址是%p",nsObjectClass,nsObjectClass, nsSuperClass, nsSuperClass);
    
    NSLog(@"\n");
    
    Class rySubMetaSuperClass = class_getSuperclass(rySubObjectMetaClass);
    NSLog(@"元类%@（地址%p）的父类是%@ 地址是%p",rySubObjectMetaClass,rySubObjectMetaClass, rySubMetaSuperClass, rySubMetaSuperClass);
    Class ryMetaSuperClass = class_getSuperclass(ryObjectMetaClass);
    NSLog(@"元类%@（地址%p）的父类是%@ 地址是%p",ryObjectMetaClass,ryObjectMetaClass, ryMetaSuperClass, ryMetaSuperClass);
    Class nsMetaSuperClass = class_getSuperclass(nsObjectMetaClass);
    NSLog(@"根元类%@（地址%p）的父类是%@ 地址是%p",nsObjectMetaClass,nsObjectMetaClass, nsMetaSuperClass, nsMetaSuperClass);

依次得到输出如下

3.1 子类ISA

2021-06-22 21:21:53.685253+0800 Class[15467:5499656] 实例<RYSubObject: 0x282af0700> 的地址是 0x282af0700
2021-06-22 21:21:53.685426+0800 Class[15467:5499656] 实例<RYSubObject: 0x282af0700> 的类对象是 RYSubObject 地址是 0x10227d648
2021-06-22 21:21:53.685717+0800 Class[15467:5499656] 实例<RYSubObject: 0x282af0700> 的元类是 RYSubObject 地址是 0x10227d620
2021-06-22 21:21:53.685782+0800 Class[15467:5499656] 实例<RYSubObject: 0x282af0700> 的根元类是 NSObject 地址是 0x1fc9421f0

子类实例对象 -isa- 子类 -isa- 子类元类 -isa- 根元类

3.2 父类ISA

2021-06-22 21:21:53.685876+0800 Class[15467:5499656] 实例<RYObject: 0x282afc490> 的地址是 0x282afc490
2021-06-22 21:21:53.685929+0800 Class[15467:5499656] 实例<RYObject: 0x282afc490> 的类对象是 RYObject 地址是 0x10227d5a8
2021-06-22 21:21:53.686703+0800 Class[15467:5499656] 实例<RYObject: 0x282afc490> 的元类是 RYObject 地址是 0x10227d580
2021-06-22 21:21:53.686760+0800 Class[15467:5499656] 实例<RYObject: 0x282afc490> 的根元类是 NSObject 地址是 0x1fc9421f0

实例对象 -isa- 类 -isa- 元类 -isa- 根元类

3.3 根类ISA

2021-06-22 21:21:53.687198+0800 Class[15467:5499656] 实例<NSObject: 0x282afdae0> 的地址是 0x282afdae0
2021-06-22 21:21:53.687245+0800 Class[15467:5499656] 实例<NSObject: 0x282afdae0> 的类对象是 NSObject 地址是 0x1fc942218
2021-06-22 21:21:53.687291+0800 Class[15467:5499656] 实例<NSObject: 0x282afdae0> 的元类是 NSObject 地址是 0x1fc9421f0
2021-06-22 21:21:53.687384+0800 Class[15467:5499656] 实例<NSObject: 0x282afdae0> 的根元类是 NSObject 地址是 0x1fc9421f0

根类实例对象 -isa- 根类 -isa- 根元类 -isa- 根元类

3.4 ISA关系图

我们将上面的三组关系整合一下

3.5 类继承关系

2021-06-22 21:21:53.687691+0800 Class[15467:5499656] 子类RYSubObject（地址0x10227d648）的父类是RYObject 地址是0x10227d5a8
2021-06-22 21:21:53.687822+0800 Class[15467:5499656] 父类RYObject（地址0x10227d5a8）的父类是NSObject 地址是0x1fc942218
2021-06-22 21:21:53.688283+0800 Class[15467:5499656] 根类NSObject（地址0x1fc942218）的父类是(null) 地址是0x0

子类 -继承- 父类 -继承- 根类 -继承- 空

3.6 元类继承关系

2021-06-22 21:21:53.688982+0800 Class[15467:5499656] 元类RYSubObject（地址0x10227d620）的父类是RYObject 地址是0x10227d580
2021-06-22 21:21:53.689029+0800 Class[15467:5499656] 元类RYObject（地址0x10227d580）的父类是NSObject 地址是0x1fc9421f0
2021-06-22 21:21:53.689075+0800 Class[15467:5499656] 根元类NSObject（地址0x1fc9421f0）的父类是NSObject 地址是0x1fc942218

这里发现 根元类NSObject（地址0x1fc9421f0） 的父类是 根类（地址0x1fc942218）

子类的元类 -继承- 父类的元类 -继承- 根元类 -继承- 根类

3.7 ISA与Class的继承关系图梳理

Swift轻量级网络封装：SwiftyServiceProtocol（适用于混编或纯Swift项目）

Wed, 23 Jun 2021 00:00:00 GMT

一、前言

随着Swift越来越成熟，越来越多的项目也开始使用Swift了。很多朋友应该都有遇到和OC混编的情况。

我自己的话，纯Swift和混编的都做过。在爽过纯Swift后，在混编时经常会有被困住手脚的感觉。

尤其这两年的公司项目，很多老代码和必须依赖的基础库都是OC。特别是网络库（基于AFN），又不能不用公司的。

但是在使用过Swift的Moya框架后，对于在混编的Swift中不能写出很Swift的网络请求这件事尤为难受。

于是有了想解决这点痛苦的想法。就有了 SwiftyServiceProtocol

对Swift 的 协议 枚举 泛型等有一定了解的话会很便于理解

二、封装目标

不依赖任何三方网络库
便于更换底层网络库（AFN? Alamofire? 自研网络库？无痛切换。极端一点你甚至可以不同模块使用不同网络库)
用起来很Moya很Swifty
兼容多模块多域名
轻量
用于纯Swift项目或者混编项目（不考虑OC调用。原因：单纯的不喜欢）
便于模块化处理

三、SwiftyServiceProtocol

源码在此：GitHub_SwiftyServiceProtocol_喜欢的话点个小星星吧⭐️

这个协议十分轻量，不算注释也就12行代码。

3.1 在项目中对 SwiftyServiceProtocol 进行拓展

public protocol MyServiceProtocol: SwiftyServiceProtocol where SwiftyServiceCallBackType == 你的网络库的回调 {

}

extension MyServiceProtocol {
    /// 如果你的项目只有一个域名，在这里写死就好。如果不同模块有不同的域名，那么在对应的Service中实现这个get就行，测试环境生产环境的逻辑也可以放在这里
    var base: String {
        return "你的域名"
    }
    
    var urlString: String {
        return base + "/" + path
    }
    
    func request(completion: SwiftyServiceCallBackType?) {
        switch method {
        case .GET:
            get(completion: completion)
        case .POST:
            post(completion: completion)
        }
    }
    
    // MARK: - Private
    private func post(completion: 你的网络库的回调?) {
        // 你的POST实现
    }
    
    private func get(completion: 你的网络库的回调?) {
        // 你的GET实现
    }
}

3.2 实际使用

这里以用户模块的一些请求为例

定义相关Service

enum YourUserService { // 定义你需要的接口
    /// 获取用户信息
    case Info(uid: Int64)
    /// 关注某人
    case Follow(uid: Int64)
    /// 取消关注某人
    case UnFollow(uid: Int64)
}

extension YourUserService: MyServiceProtocol {
    // var base: String {
    //     return "如果这个模块有不同模块有不同的域名，在这里实现这个get就行"
    // }

    /// 接口参数
    var parameters: [AnyHashable : Any]? {
        switch self {
        case let .Info(uid):
            return ["uid" : uid]
        case .Follow(let uid):
            return ["id" : uid]
        case .UnFollow(let uid):
            return ["id" : uid]
        }
    }
    
    /// 接口路径
    var path: String {
        switch self {
        case .Info:
            return "info的path"
        case .Follow:
            return "follow的path"
        case .UnFollow:
            return "unfollow的path"
        }
    }
    
    /// 请求方法选择
    var method: SwiftyServiceMethod {
        switch self {
        case .Info:
            return .GET
        default:
            return .POST
        }
    }
}

调用场景

UserService
    .Info(yourUser.uid)
    .request { (response) in
        // 处理网络回调
    }

四、总结

这个协议我自己已经在两个混编项目中使用了，如果你也喜欢的话，欢迎来点个小星星⭐️GitHub_SwiftyServiceProtocol

参考： Moya

对象本质探究与isa

Mon, 14 Jun 2021 00:00:00 GMT

一、结构分析

我们知道，OC底层是C++，我们先将下面的代码还原成C++代码再进行下一步。

新建一个空项目在main函数中写入测试代码。

@interface RKObject : NSObject

@property (nonatomic, copy) NSString *name;
@property (nonatomic, assign) int age;

@end

@implementation RKObject

@end


int main(int argc, const char * argv[]) {
    @autoreleasepool {
        // insert code here...
        NSLog(@"Hello, World!");
    }
    return 0;
}

1.1 还原成C++

执行clang -rewrite-objc main.m -o main.cpp，就能得到C++文件。

或者：

// 模拟器
xcrun -sdk iphonesimulator clang -arch arm64 -rewrite-objc main.m -o main-arm64.cpp 
// 真机
xcrun -sdk iphoneos clang -arch arm64 -rewrite-objc main.m -o mainarm64.cpp

我们找到和我们定义的对象相关的地方：

1.2 一些关键内容

a. 定义

这里是一些类型定义

#ifndef _REWRITER_typedef_RKObject
#define _REWRITER_typedef_RKObject
typedef struct objc_object RKObject;
typedef struct {} _objc_exc_RKObject;
#endif

b. 结构体

这里我们可以看到，是一个结构体。

而我们知道，结构体是不能继承的。这里通过一个NSObject_IVARS，实现了OC的继承。

同样也可以看到我们定义的属性相对应的成员变量。

extern "C" unsigned long OBJC_IVAR_$_RKObject$_name;
extern "C" unsigned long OBJC_IVAR_$_RKObject$_age;
struct RKObject_IMPL {
	struct NSObject_IMPL NSObject_IVARS;
	int _age;
	NSString *_name;
};


// @property (nonatomic, copy) NSString *name;
// @property (nonatomic, assign) int age;

/* @end */

c. 函数

这里是成员变量相关的set/get方法：

// @implementation RKObject


static NSString * _I_RKObject_name(RKObject * self, SEL _cmd) { return (*(NSString **)((char *)self + OBJC_IVAR_$_RKObject$_name)); }
extern "C" __declspec(dllimport) void objc_setProperty (id, SEL, long, id, bool, bool);

static void _I_RKObject_setName_(RKObject * self, SEL _cmd, NSString *name) { objc_setProperty (self, _cmd, __OFFSETOFIVAR__(struct RKObject, _name), (id)name, 0, 1); }

static int _I_RKObject_age(RKObject * self, SEL _cmd) { return (*(int *)((char *)self + OBJC_IVAR_$_RKObject$_age)); }
static void _I_RKObject_setAge_(RKObject * self, SEL _cmd, int age) { (*(int *)((char *)self + OBJC_IVAR_$_RKObject$_age)) = age; }
// @end

静态的实例方法

我们发现它是static的，他不是实例方法么？
我们再看，它包含了两个参数，这两个参数在我们使用的时候是隐含的：
- 对象
- Selector
这样我们知道，实例方法本身也是静态的，只不过有两个隐藏的参数罢了。

get方法如何获取成员变量的

在name的get方法的实现中看到
- return (*(NSString **)((char *)self + OBJC_IVAR_$_RKObject$_name));
实例首地址 + 成员变量的offset = 成员变量的指针

d. isa

在上面我们知道，struct NSObject_IMPL NSObject_IVARS，是OC继承关系的核心。

那么NSObject_IMPL是什么呢？

我们很快就能在文件中找到：

struct NSObject_IMPL {
	Class isa;
};

它就是isa！

e. Class

在文件中我们找到，Class的定义。本质是一个objc_class结构体指针的别名。

typedef struct objc_class *Class;

struct objc_object {
    Class _Nonnull isa __attribute__((deprecated));
};

f. id类型

再往下我们还能发现一个，它也是一个objc_object *，结构体指针。

这也解答了，为什么我们平时使用id类型的时候没有*。

typedef struct objc_object *id;

二、isa

在alloc与字节对齐一文中我们有聊到initInstanceIsa，将isa和class进行绑定。

我们从这里开始继续研究isa

2.1 源码

inline void 
objc_object::initIsa(Class cls, bool nonpointer, UNUSED_WITHOUT_INDEXED_ISA_AND_DTOR_BIT bool hasCxxDtor)
{ 
    ASSERT(!isTaggedPointer()); 
    
    isa_t newisa(0);

    if (!nonpointer) {
        newisa.setClass(cls, this);
    } else {
        ASSERT(!DisableNonpointerIsa);
        ASSERT(!cls->instancesRequireRawIsa());


#if SUPPORT_INDEXED_ISA
        ASSERT(cls->classArrayIndex() > 0);
        newisa.bits = ISA_INDEX_MAGIC_VALUE;
        // isa.magic is part of ISA_MAGIC_VALUE
        // isa.nonpointer is part of ISA_MAGIC_VALUE
        newisa.has_cxx_dtor = hasCxxDtor;
        newisa.indexcls = (uintptr_t)cls->classArrayIndex();
#else
        newisa.bits = ISA_MAGIC_VALUE;
        // isa.magic is part of ISA_MAGIC_VALUE
        // isa.nonpointer is part of ISA_MAGIC_VALUE
#   if ISA_HAS_CXX_DTOR_BIT
        newisa.has_cxx_dtor = hasCxxDtor;
#   endif
        newisa.setClass(cls, this);
#endif
        newisa.extra_rc = 1;
    }

    // This write must be performed in a single store in some cases
    // (for example when realizing a class because other threads
    // may simultaneously try to use the class).
    // fixme use atomics here to guarantee single-store and to
    // guarantee memory order w.r.t. the class index table
    // ...but not too atomic because we don't want to hurt instantiation
    isa = newisa;
}

2.2 isa的本质 isa_t

从源码中我们看到isa的类型为isa_t，我们找到isa_t的源码：

union isa_t {
    // 构造方法
    isa_t() { }
    isa_t(uintptr_t value) : bits(value) { }

    uintptr_t bits;

private:
    // Accessing the class requires custom ptrauth operations, so
    // force clients to go through setClass/getClass by making this
    // private.
    Class cls;

public:
#if defined(ISA_BITFIELD)
    struct {
        ISA_BITFIELD;  // defined in isa.h
    };

    bool isDeallocating() {
        return extra_rc == 0 && has_sidetable_rc == 0;
    }
    void setDeallocating() {
        extra_rc = 0;
        has_sidetable_rc = 0;
    }
#endif

    void setClass(Class cls, objc_object *obj);
    Class getClass(bool authenticated);
    Class getDecodedClass(bool authenticated);
};

破案了，他是个联合体！

2.3 ISA_BITFIELD isa的位域

arm64下的ISA_BITFIELD:

#     define ISA_BITFIELD                                                      \
        uintptr_t nonpointer        : 1;                                       \
        uintptr_t has_assoc         : 1;                                       \
        uintptr_t has_cxx_dtor      : 1;                                       \
        uintptr_t shiftcls          : 33; /*MACH_VM_MAX_ADDRESS 0x1000000000*/ \
        uintptr_t magic             : 6;                                       \
        uintptr_t weakly_referenced : 1;                                       \
        uintptr_t unused            : 1;                                       \
        uintptr_t has_sidetable_rc  : 1;                                       \
        uintptr_t extra_rc          : 19

nonpointer
- 是否是纯isa指针
  - 0：纯isa指针，只包含类对象地址
  - 1：还包含了类的信息、对象的引用计数
has_assoc
- 是否存在关联对象的标志位
has_cxx_dtor
- 该对象是否有C++或者Objc的析构器
  - 如果有析构函数，则需要做析构逻辑
  - 如果没有，就可以快速的释放对象
shiftcls
- 类指针的值
  - 开启指针优化的情况下，arm64中用33位来存
magic
- 用于判断当前对象是已经初始化的对象
- 还是没有初始化的空间
weakly_referenced
- 是否被弱引用
- 没有弱引用的对象可以更快的释放
unused *
has_sidetable_rc
- 当引用计数大于10时，需要借用该变量存储进位
extra_rc
- 引用计数
- 实际的值是引用计数-1，即：
  - 引用计数为10，extra_rc = 9

2.4 获取class对象: getClass

inline Class
isa_t::getClass(MAYBE_UNUSED_AUTHENTICATED_PARAM bool authenticated) {
#if SUPPORT_INDEXED_ISA
    return cls;
#else

    uintptr_t clsbits = bits;

#   if __has_feature(ptrauth_calls)
#       if ISA_SIGNING_AUTH_MODE == ISA_SIGNING_AUTH
    // Most callers aren't security critical, so skip the
    // authentication unless they ask for it. Message sending and
    // cache filling are protected by the auth code in msgSend.
    if (authenticated) {
        // Mask off all bits besides the class pointer and signature.
        clsbits &= ISA_MASK;
        if (clsbits == 0)
            return Nil;
        clsbits = (uintptr_t)ptrauth_auth_data((void *)clsbits, ISA_SIGNING_KEY, ptrauth_blend_discriminator(this, ISA_SIGNING_DISCRIMINATOR));
    } else {
        // If not authenticating, strip using the precomputed class mask.
        clsbits &= objc_debug_isa_class_mask;
    }
#       else
    // If not authenticating, strip using the precomputed class mask.
    clsbits &= objc_debug_isa_class_mask;
#       endif

#   else
    clsbits &= ISA_MASK;
#   endif

    return (Class)clsbits;
#endif
}

分析源码实现，我们知道了。是通过isa的bits再与上一个掩码ISA_MASK来获取到类对象的地址的。

ARM64: define ISA_MASK 0x0000000ffffffff8ULL
__x86_64__: define ISA_MASK 0x00007ffffffffff8ULL

a.验证

用我们上面的demo进行验证，注意是Mac环境，不是arm64。

(lldb) p/x RKObject.class
(Class) $0 = 0x00000001000081f8 RKObject
(lldb) x/4gx obj
0x1007576a0: 0x011d8001000081fd 0x0000000000000000
0x1007576b0: 0x0000000000000000 0x0000000000000000
(lldb) p/x 0x011d8001000081fd & 0x00007ffffffffff8ULL
(unsigned long long) $2 = 0x00000001000081f8

这里我们发现计算的结果和直接获取的结果一致。

b. 不使用掩码，通过位运算计算出Class

以Mac下为例，isa指针的结构是一定的。在一个isa指针的空间内，class的位置是相对固定的。

#   define ISA_BITFIELD                                                        \
      uintptr_t nonpointer        : 1;                                         \
      uintptr_t has_assoc         : 1;                                         \
      uintptr_t has_cxx_dtor      : 1;                                         \
      uintptr_t shiftcls          : 44; /*MACH_VM_MAX_ADDRESS 0x7fffffe00000*/ \
      uintptr_t magic             : 6;                                         \
      uintptr_t weakly_referenced : 1;                                         \
      uintptr_t unused            : 1;                                         \
      uintptr_t has_sidetable_rc  : 1;                                         \
      uintptr_t extra_rc          : 8

结构如下： B + Class + A（小端模式，从右向左）

A：1+1+1 = 3
Class：44
B：6+1+1+1+8 = 17

(lldb) x/4gx obj
0x1007576a0: 0x011d8001000081fd 0x0000000000000000
0x1007576b0: 0x0000000000000000 0x0000000000000000

(lldb) p/t 0x011d8001000081fd
(long) $11 = 0b00000001000111011 00000000000000100000000000000001000000111111 101

计算：

左移3位，使A从右边溢出，左边多的位会补0
- 现在的结构：000 + B + Class

(lldb) p/x 0x011d8001000081fd >> 3
(long) $7 = 0x0023b0002000103f

(lldb) p/t 0x0023b0002000103f
(long) $12 = 0b000 00000001000111011 00000000000000100000000000000001000000111111

现在需要去掉B，右移3+17=20位
- 现在的结构：Class + 20个0

(lldb) p/x 0x0023b0002000103f << 20
(long) $8 = 0x0002000103f00000

(lldb) p/t 0x0002000103f00000
(long) $13 = 0b00000000000000100000000000000001000000111111 00000000000000000000

回到原位，右移17位：
- 现在的结构：17个0 + Class + 3个0

(lldb) p/x 0x0002000103f00000 >> 17
(long) $9 = 0x00000001000081f8

(lldb) p/t 0x00000001000081f8
(long) $14 = 0b00000000000000000 00000000000000100000000000000001000000111111 000

三、isa和类对象的绑定

这里是objc_object::initIsa

inline void 
objc_object::initIsa(Class cls, bool nonpointer, UNUSED_WITHOUT_INDEXED_ISA_AND_DTOR_BIT bool hasCxxDtor)
{ 
    ASSERT(!isTaggedPointer()); 
    
    isa_t newisa(0);

    if (!nonpointer) { // 如果是纯isa就直接setClass
        newisa.setClass(cls, this);
    } else {
        ASSERT(!DisableNonpointerIsa);
        ASSERT(!cls->instancesRequireRawIsa());


#if SUPPORT_INDEXED_ISA
        ASSERT(cls->classArrayIndex() > 0);
        newisa.bits = ISA_INDEX_MAGIC_VALUE;
        // isa.magic is part of ISA_MAGIC_VALUE
        // isa.nonpointer is part of ISA_MAGIC_VALUE
        newisa.has_cxx_dtor = hasCxxDtor;
        newisa.indexcls = (uintptr_t)cls->classArrayIndex();
#else
        newisa.bits = ISA_MAGIC_VALUE;
        // isa.magic is part of ISA_MAGIC_VALUE
        // isa.nonpointer is part of ISA_MAGIC_VALUE
#   if ISA_HAS_CXX_DTOR_BIT
        newisa.has_cxx_dtor = hasCxxDtor;
#   endif
        newisa.setClass(cls, this);
#endif
        newisa.extra_rc = 1;
    }

    // This write must be performed in a single store in some cases
    // (for example when realizing a class because other threads
    // may simultaneously try to use the class).
    // fixme use atomics here to guarantee single-store and to
    // guarantee memory order w.r.t. the class index table
    // ...but not too atomic because we don't want to hurt instantiation
    isa = newisa;
}

3.1 class绑定流程图

3.2 中间有个判断 Nonpointer isa

下面我们具体研究下

四、Nonpointer isa

在上面我们有多次看到Nonpointer isa出现。现在我们深入的研究一下

4.1 isa_t

在上面我们知道isa是一个联合体，而联合体成员是互斥的。

这个就是Nonpointer isa区别于纯isa的核心！

4.2 isa_t::setClass

这里是设置Class的核心实现

// Set the class field in an isa. Takes both the class to set and
// a pointer to the object where the isa will ultimately be used.
// This is necessary to get the pointer signing right.
//
// Note: this method does not support setting an indexed isa. When
// indexed isas are in use, it can only be used to set the class of a
// raw isa.
inline void
isa_t::setClass(Class newCls, UNUSED_WITHOUT_PTRAUTH objc_object *obj)
{
    // Match the conditional in isa.h.
#if __has_feature(ptrauth_calls) || TARGET_OS_SIMULATOR
#   if ISA_SIGNING_SIGN_MODE == ISA_SIGNING_SIGN_NONE
    // No signing, just use the raw pointer.
    uintptr_t signedCls = (uintptr_t)newCls;

#   elif ISA_SIGNING_SIGN_MODE == ISA_SIGNING_SIGN_ONLY_SWIFT
    // We're only signing Swift classes. Non-Swift classes just use
    // the raw pointer
    uintptr_t signedCls = (uintptr_t)newCls;
    if (newCls->isSwiftStable())
        signedCls = (uintptr_t)ptrauth_sign_unauthenticated((void *)newCls, ISA_SIGNING_KEY, ptrauth_blend_discriminator(obj, ISA_SIGNING_DISCRIMINATOR));

#   elif ISA_SIGNING_SIGN_MODE == ISA_SIGNING_SIGN_ALL
    // We're signing everything
    uintptr_t signedCls = (uintptr_t)ptrauth_sign_unauthenticated((void *)newCls, ISA_SIGNING_KEY, ptrauth_blend_discriminator(obj, ISA_SIGNING_DISCRIMINATOR));

#   else
#       error Unknown isa signing mode.
#   endif

    shiftcls_and_sig = signedCls >> 3;

#elif SUPPORT_INDEXED_ISA
    // Indexed isa only uses this method to set a raw pointer class.
    // Setting an indexed class is handled separately.
    cls = newCls;

#else // Nonpointer isa, no ptrauth
    shiftcls = (uintptr_t)newCls >> 3;
#endif
}

4.3 Nonpointer isa 和纯isa的区别

Nonpointer isa
- 类对象会被赋值到isa_t的BITFIELD中的shiftcls
纯isa
- 会被直接赋值到isa_t的cls
两者互斥
默认创建的对象都是Nonpointer isa
- 可通过修改Xcode环境变量改成使用纯isa

基于iCloud构建用户体系

Fri, 11 Jun 2021 00:00:00 GMT

一、前言

这个md文档一月份就创建了，一直没填坑。

虽然应用本身不是什么成功的应用，但是自己感觉在做的过程中还是有挺多收获的。

注意： 本文不会非常详细的说明具体类的使用方法，代码具体怎么写，这些官方文档比任何人都说的清楚。

目的在于对于个人开发者提供一个思路。

大多个人开发者，比如我自己，资源时间精力有限，但是想法很多。

而iCloud是我遇到最合适用来构建起用户体系，以及拓展功能需求的工具了。

自己已经独立做了两款应用，都是基于iCloud建立起来的，欢迎体验反馈，要是再来个五星好评是对我最大的鼓励~

-	扫雷Elic 无尽天梯	梦见账本
下载	AppStore	AppStore

哎，没有设计师自己整UI终究还是不太好看啊~TAT~

下面会以扫雷项目中的例子来做一些说明

二、独立项目用户体系技术方案选型

2.1 自己开发

也不是没考虑过，但不是自己所擅长的。而且需要考虑的问题太多，技术、运维、安全都是需要考虑的。

当然如果有大佬这些都能搞定的话，这是最好的方案了。

2.2 LeanCloud

早期有用这家的服务写过Demo，所以选型的时候也有考虑他家的服务，毕竟后期拓展到不同的平台没有障碍。

但是收费限制多，具体可以自行去查看。Pass

2.3 GameCenter

很早以前有研究过一下，就如其名苹果系统内部的一套游戏用户体系。

包含了用户、排行榜、成就点之类的比较基础的功能。

虽然很多游戏都有接入，但是存在感实在不高。

就我对GameCenter浅薄的了解来说，要拓展功能业务的话，只依靠CameCenter的话是很难支撑起来的，依旧需要另一套东西来承载。

所以Pass掉了。

2.4 iCloud

大家初步对iCloud的认识可能停留在可以备份同步照片文件的基础上。

这里建立用户体系依靠的是CloudKit，建议直接阅读官方文档，想知道的都有。

官方文档：CloudKit

三、什么是CloudKit

Store structured app and user data in iCloud containers that all users of your app can share.

The CloudKit framework provides interfaces for moving data between your app and your iCloud containers. You use CloudKit to store your app’s existing data in the cloud so that the user can access it on multiple devices. You can also store data in a public area where all users can access it.

上面是官方文档中对CloudKit的说明，比较重要的一句 You can also store data in a public area where all users can access it.。

数据可共享是建立起用户体系的核心。

推荐苹果的官方文章，根据自身场景，选择合适的接入方案「Determining If CloudKit Is Right for Your App」

四、CloudKit存储数据的方式

CloudKit控制面板

进入DataBase，对核心的几块内容做一下说明：

4.1 基础数据单元：CKRecord

所有数据都是由CKRecord承载，存储在容器中的。

值得注意的是，只要用户开启啦iCloud及iCloudDrive服务。

支持的数据类型如下，这是官方注释里面的：

/// Acceptable value object classes are:
/// - `String`
/// - `Date`
/// - `Data`
/// - `Bool`
/// - `Int`
/// - `UInt`
/// - `Float`
/// - `Double`
/// - `[U]Int8 et al`
/// - `CKReference / CKRecord.Reference`
/// - `CKAsset`
/// - `CLLocation`
/// - `NSData`
/// - `NSDate`
/// - `NSNumber`
/// - `NSString`
/// - `Array` and/or `NSArray` containing objects of any of the types above
///
/// Any other classes will result in an exception with name `NSInvalidArgumentException`.
///
/// Field keys starting with `_` are reserved. Attempting to set a key prefixed with a `_` will result in an error.
///
/// Key names roughly match C variable name restrictions. They must begin with an ASCII letter and can contain ASCII letters and numbers and the underscore character.
/// The maximum key length is 255 characters.

CKRecord本身包含了一些基础字段比如创建者id、创建时间、修改时间、记录id等。

当然我们也可以自定义字段，读写起来就和使用字典类似。具体可以点进CKRecord文件查看，这里就不再多说了。

4.2 数据存储空间：Zone

这里就是三个不同访问权限的数据库，通过CKContainer访问。

a.Public

默认所有用户可读，所有者可修改
可设置权限，只能在后台进行调整，不可通过API修改
开发者可以通过后台查看
不占用所有者的iCloud储存空间
占用App的iCloud存储空间

扫雷用的是这个数据库，因为包含了排行榜，需要所有用户都可以访问。

下面是相关的两段官方说明：

 *  Records in a public database
 *  - By default are world readable, owner writable.
 *  - Can be locked down by Roles, a process done in the Developer Portal, a web interface.  Roles are not present in the client API.
 *  - Are visible to the application developer via the Developer Portal.
 *  - Do not contribute to the owner's iCloud account storage quota.

This database is available regardless of whether the user’s device has an iCloud account. The contents of the public database are readable by all users of the app, and users have write access to the records, and other objects, they create. The public database’s contents are visible in the developer portal, where you can assign roles to users and restrict access as necessary. Data in the public database counts toward your app’s iCloud storage quota.

b.Private

默认只有所有者可读写
开发者在后台也无法访问
占用所有者的iCloud存储空间

这个适合做一些私密性较强的应用，比如密码管理应用。

 *  Records in a private database
 *  - By default are only owner readable and owner writable.
 *  - Are not visible to the application developer via the Developer Portal.
 *  - Are counted towards the owner's iCloud account storage quota.

c.Shared

只对通过CKShare授权的合作者可见
开发者在后台也无法访问
占用组织者的iCloud储存空间

这个没具体用过，先不深入探讨。

 *  Records in a shared database
 *  - Are available to share participants based on the permissions of the enclosing CKShare
 *  - Are not visible to the application developer via the Developer Portal.
 *  - Are counted towards the originating owner's iCloud account storage quota.

4.3 数据表结构：RecordTypes

User是默认就存在的一张表，无须自己创建。如果用户安装了你的应用，你去获取用户对象的时候CloudKit后台会自动生成一条记录。是不是很方便？

根据扫雷Elic的需求场景，我创建了这些表

User(default)：用户
AvatarSpace：头像
EndLessRank：无尽模式排行榜
GameHistory：游戏记录
AppConfig：应用配置
ZenRank：“禅”模式排行榜

添加自定义字段

点进对应Type后就可以看到表结构了，上面一半是默认的数据结构。在下方点+可以添加自定义的字段，并选择数据类型。

需要注意的是：在测试环境下，新增的字段可以删除掉。一旦发布线上后，就不能删除了。只能新增。

4.4 数据索引：Indexs

QUERYABLE
- 可查询
SORTABLE
- 可排序
SEARCHABLE
- 可搜索

根据需求进行设置，不设置的话会读不到数据的。

比如无尽模式排行榜，需要根据时间和等级进行的排序，就把level & duration 设置了SORTABLE

效果：

五、QA

5.1 存在iCloud安全么？

虽然没有绝对的安全，但对比市面上的云存储服务。苹果的还是相对让我放心的。

关键是便宜啊！

5.2 要是用户抓包改数据呢？

我试过抓包，直接连不上容器了。感兴趣的可以尝试一下。

5.3 破解？

写到这里了我掏出了我的越狱机。。。说干就干，砸一个出来重签。

想了解砸壳请移步：应用砸壳

好家伙，直接崩了，挺安全的了吧？

当然我并没有深究能不能跳过系统这一步的验证，等萨尔有下了再来研究下。

我也还没做防Hook，有兴趣破解一下的也可以找我交流哈，十分欢迎。

5.4 访问速度

说不上非常快，但是够用。主要还是要合理设计表结构，要是在列表的数据结构里直接包含资源文件的话，那请求速度和用户体验就惨不忍睹了。

5.5 运维成本

几乎谈不上运维，咱也做不了什么。作为开发者能做的就是把应用逻辑和数据结构设计得合理一些。

一些基础的运维数据在后台也是可以看到的。

5.6 跨平台

只做iOS平台还好，要是以后想拓展到不同平台的话，是不是就用不成了？难道还要单独搞一套，甚至迁移用户？

放心，苹果贴心的提供了APICloudKit JS

具体没研究，看起来是可以做跨平台的。

5.7 容量

1PB够用不？

抱歉，我刚看到这个单位的第一时间没反应过来。

就是1024TB，真没想到。

不是一下子就有1P，随着你用户的量级来的。

开发者需要关心的只有Public database所占用的大小。

Build Apps Using CloudKit

5.8 资源存储 CKAsset

CloudKit提供了CKAsset这个数据类型用来保存一些资源文件，可以放在CKRecord中进行保存。

看起来挺方便。

问题

如扫雷的排行榜功能，是需要显示头像的。

这里如果将头像直接添加为User表中，那么实际拉取用户的时候会很慢，因为这里会把图片资源一起带下来。而不是我们平时的Url的形式。

如果将图片传到图床上然后添加图片Url的字段也是ok的，但近年来感觉图床限制越来越多了，不方便使用。

这里我后面单独键了张表用来存头像资源，然后封装了一个加载、缓存CKAsset图片资源的工具，方便在排行版中使用。

七、总结

iCloud对于个人开发者来说是个好东西，可以低成本的构建用户体系。

只要发挥想象力，很多功能都是可以可以做的。

这里我用到的只是CloudKit的一部分，还有很多没用过。也许还存在很多的发掘空间。

八、参考

结构体内存对齐

Wed, 09 Jun 2021 00:00:00 GMT

一、各类型所占内存对照表

二、结构体内存大小

2.1 创建调试用结构体

struct Girl {
    double height;
    char firstChar;
    int age;
    short hairCount;
}Misa;

struct Boy {
    double height;
    int age;
    char firstChar;
    short hairCount;
}Light;

struct Kira {
    double height;
    int age;
    char firstChar;
    short hairCount;
    struct Girl misa;
    struct Boy light;
}Together;

2.2 调试输出结构体大小

(lldb) po sizeof(Misa)
24

(lldb) po sizeof(Light)
16

(lldb) po sizeof(Together)
56

2.3 思考

奇怪了，Misa和Light，明明内存成员相同，怎么一个16，一个24呢？下面我们先了解一个东西：内存对齐

三、内存对齐规则

3.1 数据成员对齐规则

第一个数据成员从偏移量为0的地方开始，占用该成员大小的字节。
- 如Misa，以double开始，那么就是0-7
以后每个成员的存储起始位置都要从该成员大小或者成员的子成员大小的整数倍开始
- 子成员，如：
  - 数组、结构体等

3.2 结构体作为成员对齐规则

如果一个结构体A内，有结构体B作为成员。则该成员要从其内部最大元素大小的整数倍地址开始存储.

3.3 总大小对齐

结构体总大小，必须是其内部最大成员的整数倍，不足要补齐。

四、还原内存结构

4.1 Misa的结构

-	double	char	int	short
大小（字节）	8	1	4	2
使用空间	0.1.2.3.4.5.6.7	8	12.13.14.15	16.17

double
- 8字节
- 从0开始，占用0-7
char
- 1字节
- 从1的整数倍开始，8满足条件，占用8
int
- 4字节
- 从4的整数倍开始，上一个末位为8，那么先后找，就找从12开始，占用12-15
short
- 2字节
- 从2的整数倍开始，上一个末位为15，那就从16开始，暂用16-17
总大小
- 这些成员暂用了0-16共17个字节
- 按照第三条对齐规则，向上取最大成员8的倍数，结果就是0-23，即24字节。和实际输出相同

4.2 Light的结构

-	double	int	char	short
大小（字节）	8	4	1	2
使用空间	0.1.2.3.4.5.6.7	8.9.10.11	12	14.15

double
- 8字节
- 从0开始，占用0-7
int
- 4字节
- 从4的倍数开始，合适的是8，暂用8-11
char
- 1字节
- 从1的倍数开始，合适的是12，占用12
short
- 2字节
- 从2的倍数开始，合适的是14，占用14-15
总大小
- 成员占用了0-15
- 按照原则3，需要是最大成员8的倍数，即16字节。和实际输出相同

4.3 对比Light和Misa

如此我们可以发现，对于结构体来说，内部成员的顺序直接影响了结构体占用的空间。

五、嵌套结构体Together的内存结构

5.1 Together的外层结构

-	double	int	char	short	Girl	Boy
大小（字节）	8	4	1	2	成员最大8	成员最大8
使用空间	0.1.2.3.4.5.6.7	8.9.10.11	12	14.15	...	...

由于比较长，Girl和Boy我们拿出来做

5.2 Girl

从8的整数倍开始，即16

-	double	char	int	short
大小（字节）	8	1	4	2
使用空间	16.17.18.19.20.21.22.23	24	28.29.30.31	32.33

5.3 Boy

从8的整数倍开始，即40

-	double	int	char	short
大小（字节）	8	4	1	2
使用空间	40.41.42.43.44.45.46.47	48.49.50.51	52	54.55

5.4 总size

占用0-55
最大成员8，则Together总大小为56。与输出一致。

六、思考

6.1 顺序影响大小，我们知道OC对象的本质就是结构体,那么是不是我们在开发的时候要算出最优解，再来排列成员呢？

并不用，这里内部做了优化了的。后面我们会单独对这里进行研究。

6.2 做内存对齐的意义何在呢？

a.平台因素

不是所有硬件平台都能访问任意地址上的任意数据的
某些硬件平台只能在某些地址处理某些特定的数据类型，否则会抛出硬件异常

b.性能因素

数据结构，尤其是栈，应该尽可能的在自然边界上对齐
因为未来访问未对齐的内存，处理器需要做两次内存访问；而对其的内存访问只需要一次

c.总结

内存对齐是一个以空间换时间的过程，为了使CPU更高效的读写数据，提升性能

七、联合体

结构体
- 优点：所有成员可共存，全面
- 缺点：内存分配存在浪费，不管用不用，全部分配
联合体
- 优点：内存使用更加精细灵活，节省空间
- 缺点：成员互斥
- 同时只有一个成员可以得到这块内存的使用权(对该内存的读写)，各变量共用一个内存首地址
- 一个union变量的总长度至少能容纳最大的成员变量，而且要满足是所有成员变量类型大小的整数倍

举个例子：游戏中的控制角色移动

union Dirction {
  bool up;
  bool down;
  bool left;
  bool right;
} move;

alloc与字节对齐

Sun, 06 Jun 2021 00:00:00 GMT

一、探索alloc

看下面的例子，输出会是什么样的呢？

Ryukie *obj1 = [Ryukie alloc];
Ryukie *obj2 = [obj1 init];
Ryukie *obj3 = [obj1 init];

NSLog(@"Objc1：%p，他的指针：%p", obj1, &obj1);
NSLog(@"Objc2：%p，他的指针：%p", obj2, &obj2);
NSLog(@"Objc3：%p，他的指针：%p", obj3, &obj3);

输出如下：

2021-06-06 19:56:22.045515+0800 OCObject[10944:3914848] Objc1：0x28220bc60，他的指针：0x16d421bf8
2021-06-06 19:56:22.045611+0800 OCObject[10944:3914848] Objc2：0x28220bc60，他的指针：0x16d421bf0
2021-06-06 19:56:22.045659+0800 OCObject[10944:3914848] Objc3：0x28220bc60，他的指针：0x16d421be8

不同的指针，指向了同样的内存空间

二、通过源码了解alloc实现

Source Browser

Apple Open Source

NSObject.mm这里就是NSobject的核心实现代码

2.1 可运行调试的源码

GitHub

将项目Clone下来，即可运行调试。更加直观的学习底层实现。

2.2 调用流程探究

a. 实验代码

我们在main中写下如下代码，分别在<-处添加断点

int main(int argc, const char * argv[]) {
    @autoreleasepool {
        // insert code here...
        NSLog(@"Hello, World!");
        RYModel *father = [RYModel alloc];<-
        
        RYModel *objc = [RYModel alloc];<-    
    }
    return 0;
}

b. alloc

现在是RYModel第一次调用alloc。字面实现如下：

+ (id)alloc {
    return _objc_rootAlloc(self);
}

按照代码下一步应该会调用_objc_rootAlloc，真的吗？

c. objc_alloc

我们发现断点走到了这里，正如注释里面所说：Calls [cls alloc].

// Calls [cls alloc].
id
objc_alloc(Class cls)
{
    return callAlloc(cls, true/*checkNil*/, false/*allocWithZone*/);
}

我们推断，这里应该是alloc的实现IMP被修改了。继续下一步

d. callAlloc

断点直接来到了 objc_msgSend 处，又继续调用了 alloc

// Call [cls alloc] or [cls allocWithZone:nil], with appropriate
// shortcutting optimizations.
static ALWAYS_INLINE id
callAlloc(Class cls, bool checkNil, bool allocWithZone=false)
{
#if __OBJC2__
    if (slowpath(checkNil && !cls)) return nil;
    if (fastpath(!cls->ISA()->hasCustomAWZ())) {
        return _objc_rootAllocWithZone(cls, nil);
    }
#endif

    // No shortcuts available.
    if (allocWithZone) {
        return ((id(*)(id, SEL, struct _NSZone *))objc_msgSend)(cls, @selector(allocWithZone:), nil);
    }
    return ((id(*)(id, SEL))objc_msgSend)(cls, @selector(alloc));
}

e. _objc_rootAlloc

这次断点才来到了，_objc_rootAlloc

id
_objc_rootAlloc(Class cls)
{
    return callAlloc(cls, false/*checkNil*/, true/*allocWithZone*/); <-
}

f. _objc_rootAllocWithZone

又来到了callAlloc方法中，这次断点来到了_objc_rootAllocWithZone

static ALWAYS_INLINE id
callAlloc(Class cls, bool checkNil, bool allocWithZone=false) {
#if __OBJC2__
    ...
    if (fastpath(!cls->ISA()->hasCustomAWZ())) { // 这里会判断类对象的isa指针是否有自定义的AllocWithZone的实现
        return _objc_rootAllocWithZone(cls, nil); <-
    }
#endif
    ...
}

_objc_rootAllocWithZone的实现：

NEVER_INLINE
id
_objc_rootAllocWithZone(Class cls, malloc_zone_t *zone __unused)
{
    // allocWithZone under __OBJC2__ ignores the zone parameter
    return _class_createInstanceFromZone(cls, 0, nil,
                                         OBJECT_CONSTRUCT_CALL_BADALLOC);
}

我们继续下一步

g. _class_createInstanceFromZone 创建实例

/***********************************************************************
* class_createInstance
* fixme
* Locking: none
*
* Note: this function has been carefully written so that the fastpath
* takes no branch.
**********************************************************************/
static ALWAYS_INLINE id
_class_createInstanceFromZone(Class cls, size_t extraBytes, void *zone,
                              int construct_flags = OBJECT_CONSTRUCT_NONE,
                              bool cxxConstruct = true,
                              size_t *outAllocatedSize = nil)
{
    ASSERT(cls->isRealized());

    // Read class's info bits all at once for performance
    bool hasCxxCtor = cxxConstruct && cls->hasCxxCtor();
    bool hasCxxDtor = cls->hasCxxDtor();
    bool fast = cls->canAllocNonpointer();
    size_t size;

    size = cls->instanceSize(extraBytes);// 1. 计算所需大小
    if (outAllocatedSize) *outAllocatedSize = size;

    id obj;
    if (zone) {
        obj = (id)malloc_zone_calloc((malloc_zone_t *)zone, 1, size);
    } else {
        obj = (id)calloc(1, size); // 2. 开辟空间
    }
    if (slowpath(!obj)) {
        if (construct_flags & OBJECT_CONSTRUCT_CALL_BADALLOC) {
            return _objc_callBadAllocHandler(cls);
        }
        return nil;
    }

    if (!zone && fast) {
        obj->initInstanceIsa(cls, hasCxxDtor); // 3. 实例化isa
    } else {
        // Use raw pointer isa on the assumption that they might be
        // doing something weird with the zone or RR.
        obj->initIsa(cls);
    }

    if (fastpath(!hasCxxCtor)) {
        return obj;
    }

    construct_flags |= OBJECT_CONSTRUCT_FREE_ONFAILURE;
    return object_cxxConstructFromClass(obj, cls, construct_flags);
}

g.1 instanceSize 大小

这里会去缓存中查找
CoreFoundation规定最小16个字节
- 有isa指针的8字节
- 还有8字节预留
// Class's ivar size rounded up to a pointer-size boundary.
- 成员变量的大小向上取整（一个指针的大小8字节）
- 即：成员变量的字节对齐
- 即：不足8字节就按8字节
// May be unaligned depending on class's ivars.
- 大小取决于成员变量的大小

inline size_t instanceSize(size_t extraBytes) const {
    if (fastpath(cache.hasFastInstanceSize(extraBytes))) {
        return cache.fastInstanceSize(extraBytes);
    }

    size_t size = alignedInstanceSize() + extraBytes;
    // CF requires all objects be at least 16 bytes.
    if (size < 16) size = 16;
    return size;
}

// Class's ivar size rounded up to a pointer-size boundary.
uint32_t alignedInstanceSize() const {
    return word_align(unalignedInstanceSize());
}

// May be unaligned depending on class's ivars.
uint32_t unalignedInstanceSize() const {
    ASSERT(isRealized());
    return data()->ro()->instanceSize;
}

g.2 calloc 开空间

这里分配的还空间内还有数据，因为内存只覆写，不删除。

if (zone) {
    obj = (id)malloc_zone_calloc((malloc_zone_t *)zone, 1, size);// OBJC2 zone已经不用了，不走这里
} else {
    obj = (id)calloc(1, size);
}

g.3 initInstanceIsa 初始化实例isa

这里会将刚创建的obj和isa进行绑定，完成这一步后，可以发现，obj就会先变成RYModel了。

inline void 
objc_object::initInstanceIsa(Class cls, bool hasCxxDtor)
{
    ASSERT(!cls->instancesRequireRawIsa());
    ASSERT(hasCxxDtor == cls->hasCxxDtor());

    initIsa(cls, true, hasCxxDtor);
}

h. 非第一次alloc

发现在d. callAlloc这一步中有所不同：
没有走return ((id(*)(id, SEL))objc_msgSend)(cls, @selector(alloc));
而是直接走了_objc_rootAllocWithZone

这里是LLVM做了处理，对alloc的IMP做了调整，在类第一次调用alloc时进行了一些处理，然后再调用原有的alloc实现。

i. 流程图

图片较大较长，建议下载到本地

三、字节对齐

3.1 算法

// Class's ivar size rounded up to a pointer-size boundary.
uint32_t alignedInstanceSize() const {
    return word_align(unalignedInstanceSize());
}

static inline uint32_t word_align(uint32_t x) {
    return (x + WORD_MASK) & ~WORD_MASK;
}
static inline size_t word_align(size_t x) {
    return (x + WORD_MASK) & ~WORD_MASK;
}
static inline size_t align16(size_t x) {
    return (x + size_t(15)) & ~size_t(15);
}

#ifdef __LP64__
#   define WORD_SHIFT 3UL
#   define WORD_MASK 7UL
#   define WORD_BITS 64
#else
#   define WORD_SHIFT 2UL
#   define WORD_MASK 3UL
#   define WORD_BITS 32
#endif

3.2 先思考一个问题：

显然第二种效率更高，但是牺牲了一定的空间。
- 这就是典型的以空间，换时间，对于CPU来说处理速度非常重要

3.3 内存调试

我们在第一个demo中下个断点

(lldb) x obj1
0x282d86140: 0d 57 41 04 a1 61 00 00 28 00 41 04 01 00 00 00  .WA..a..(.A.....
0x282d86150: 42 00 00 00 00 00 00 00 40 61 d8 82 02 00 00 00  B.......@a......
(lldb) p 0x000061a10441570d // 小端、反着看
(long) $3 = 107344189019917

(long) $1 = 80361110149439809这里其实是isa指针，但是打印出来确实long类型？

3.4 isa 与 MASK

a.获取isa指针

// Get the class pointer out of an isa. When ptrauth is supported,
// this operation is optionally authenticated. Many code paths don't
// need the authentication, so it can be skipped in those cases for
// better performance.
//
// Note: this method does not support retrieving indexed isas. When
// indexed isas are in use, it can only be used to retrieve the class
// of a raw isa.
#if SUPPORT_INDEXED_ISA || (ISA_SIGNING_AUTH_MODE != ISA_SIGNING_AUTH)
#define MAYBE_UNUSED_AUTHENTICATED_PARAM __attribute__((unused))
#else
#define MAYBE_UNUSED_AUTHENTICATED_PARAM UNUSED_WITHOUT_PTRAUTH
#endif

inline Class
isa_t::getClass(MAYBE_UNUSED_AUTHENTICATED_PARAM bool authenticated) {
#if SUPPORT_INDEXED_ISA
    return cls;
#else

    uintptr_t clsbits = bits;

#   if __has_feature(ptrauth_calls)
#       if ISA_SIGNING_AUTH_MODE == ISA_SIGNING_AUTH
    // Most callers aren't security critical, so skip the
    // authentication unless they ask for it. Message sending and
    // cache filling are protected by the auth code in msgSend.
    if (authenticated) {
        // Mask off all bits besides the class pointer and signature.
        clsbits &= ISA_MASK;
        if (clsbits == 0)
            return Nil;
        clsbits = (uintptr_t)ptrauth_auth_data((void *)clsbits, ISA_SIGNING_KEY, ptrauth_blend_discriminator(this, ISA_SIGNING_DISCRIMINATOR));
    } else {
        // If not authenticating, strip using the precomputed class mask.
        clsbits &= objc_debug_isa_class_mask;
    }
#       else
    // If not authenticating, strip using the precomputed class mask.
    clsbits &= objc_debug_isa_class_mask;
#       endif

#   else
    clsbits &= ISA_MASK;
#   endif

    return (Class)clsbits;
#endif
}

这里要拿到isa需要&一个mask，在isa.h中可以找到对应架构的定义

b.获取MASk

下面是ARM64的，其他架构的可以自行在头文件中查找，很简单的

#     define ISA_MASK        0x0000000ffffffff8ULL

c.复原出isa

再次输出

(lldb) po 0x000061a10441570d & 0x0000000ffffffff8
Ryukie

成功输出了Class: Ryukie

3.5 查看真实的内存排列方式

@interface Ryukie : NSObject
@property (nonatomic, copy) NSString *name;
@property (nonatomic, assign) int age;
@property (nonatomic, assign) BOOL isboy;
@property (nonatomic, copy) NSString *desc;
@end

a.一个内存对齐的场景

首先我们格式化打印分析 x/4gx
这种方式更加直观，不用我们自己去按小端的方式反着看了。
- 4代表打印4个单位的，可以按需要调整。

(lldb) x/4gx obj1
0x28150e2e0: 0x000041a100c0577d 0x0000001200000001
0x28150e2f0: 0x0000000100c00008 0x0000000100c00028

这里发现 po 0x0000001200000001 结果很怪异 77309411329
这里我们还剩 age & isboy 两个成员变量没有输出
将这里的16位分开看下
- po 0x00000012
  - 18
- po 0x00000001
  - 1
  - 这里Bool只占一个字节但是拉伸为了8个字节
这里就是比较明显的内存对齐的一个场景

b.思考

如果我们将上面的@property (nonatomic, assign) int age;改为@property (nonatomic, assign) NSInteger age; 会是怎样呢？

实战人人视频破解

Sun, 23 May 2021 00:00:00 GMT

一、class-dump

提前准备好砸壳🔗的应用（人人视频5.5.1）

使用class-dump导出头文件，便于我们定位目标。

class-dump -H MachO文件名 -o 输出的文件夹/

二、确定逆向目标

这里我想要实现非VIP用户可以查看VIP视频。

一般情况下我们会通过类似isVIP这样的字眼去进行相关的判断。

Cycript链接手机进行分析

三、登录态

通过在Headers中搜索isLogin看到一个很可能是用来判断登录态的东西：

3.1 hook登录态

@interface UserInfoConfig

+ (bool)isLogined;

- (bool)isLogined;

@end

%hook UserInfoConfig

+ (bool)isLogined {
    return YES;
}

- (bool)isLogined {
    return YES;
}

%end

3.2 检验登录态

原版

Hook版

通过！这里的立即登录已经变成立即开通了

这里因为是直接改写了登录状态的返回值，所以这里有了大量的错误提示：

2021-05-23 14:52:09.592113+0800 PUClient[6981:2390642] You should call login api before calling any im related api

3.3 找到VIP态

从UI层开始分析

a.找到容器: `RRVipUserInfoView`

看看它内部有没有做数据逻辑

看起来resetStatus&reloadUIData是有做些请求的，我们先记录一下。继续分析。

b.父视图：`RRVipBannerTopCell`

这里看到一个@property(retain, nonatomic) RRTopBannerModel *bannerModel;

但是没有和用户相关的模型属性，推测VIP的判断是在RRVipUserInfoView内部！

c.VIP相关类

通过Headers查找VIP关键字，逐个查看，发现RRIMManager疑似。而且还是个单例。我们Hook看下有什么效果。

下面又找到几个，可能的文件

f.RrmjUser

其中有这样一个属性：@property(retain, nonatomic) RRMedalModel *vipMedal;

g.RRMedalModel

@interface RRMedalModel : NSObject <NSCoding>
{
    _Bool _isExpired;
    long long _medalId;
    NSString *_imgUrl;
    NSString *_name;
    NSString *_endTime;
}

+ (id)modelCustomPropertyMapper;
+ (id)replacedKeyFromPropertyName;
- (void).cxx_destruct;
@property(nonatomic) _Bool isExpired; // @synthesize isExpired=_isExpired;
@property(copy, nonatomic) NSString *endTime; // @synthesize endTime=_endTime;
@property(copy, nonatomic) NSString *name; // @synthesize name=_name;
@property(copy, nonatomic) NSString *imgUrl; // @synthesize imgUrl=_imgUrl;
@property(nonatomic) long long medalId; // @synthesize medalId=_medalId;
- (id)endTimeTextString;
- (id)endTimeString;
- (_Bool)isPermanent;
- (id)initWithCoder:(id)arg1;
- (void)encodeWithCoder:(id)arg1;

@end

查看Header后发现疑似VIP相关字段

在第二步的UserInfoConfig中发现有RrmjUser属性存在，这里准备在运行时set一个我们自己创建的对象，重写会员是否过期的方法。

Logos代码：

#pragma mark - RRMedalModel

@interface RRMedalModel: NSObject

- (bool)isPermanent;
- (bool)isExpired;

@end

%hook RRMedalModel

- (bool)isPermanent {
    return YES;
}

- (bool)isExpired {
    return NO;
}

%end

#pragma mark - RrmjUser

@interface RrmjUser: NSObject

@end

%hook RrmjUser

- (id)vipMedal {
    id vip = [[%c(RRMedalModel) alloc] init];
    return vip;
}

%end

#pragma mark - UserInfoConfig-这里Hook了登录态

@interface UserInfoConfig

+ (bool)isLogined;

- (bool)isLogined;

- (id)userInfo;

@end

%hook UserInfoConfig

+ (bool)isLogined {
    return YES;
}

- (bool)isLogined {
    return YES;
}

- (id)userInfo {
    id tempUser = [[%c(RrmjUser) alloc] init];
    return tempUser;
}

%end

结果

之前开通会员的入口都变成了续费了。哈哈哈哈

但是观看会员视频还是只能试看5分钟

下面的目标就是解除5分钟的限制了！

四：无限制调广告

试着直接把广告加载的方法Return了，但是直接不能加载视频了。于是改成不用等就能点跳过。

#pragma mark - RRPlayerControlAdPlay
@interface RRPlayerControlAdPlay: NSObject

- (bool)canJump;

@end

%hook RRPlayerControlAdPlay

- (bool)canJump {
    return YES;
}

%end

五：改变视频权限

5.1结合正常显示的剧集数据对比非会员和会员的视频区别

5.2 调试找出关键字段的区别

5.3 Hook

#pragma mark - MovieEpisode
@interface MovieEpisode: NSObject
/// 2 VIP nil free
- (long long)feeModeType;
- (NSString *)feeMode;

@end

%hook MovieEpisode

- (NSString *)feeMode {
    return @"free";
}

- (long long)feeModeType {
    return 0;
}

%end

5.4 结果

列表页显示成功，没有了VIp标签

但是点击对应集数观看的时候就报错了

六：视频流

试了很多数据模型进行改写都不行

免费的视频流，在浏览器即可访问

(lldb) po ((M3u8Model *)0x2828f1300).dibblingTotalDuration
0

(lldb) po ((M3u8Model *)0x2828f1300).url
https://tx-cdn-local.rr.tv/2a66f13043434abb9114720c3cc4f19c/d6372e9485f84ba38a4b82ab0f31bad2-0e37a229c0ddec2ae7b75fbcac9f6f55-ld.mp4?auth_key=1622396264-900b321e0b42e34f95ab888009a63e84-0-39b17c20f3adcd88504a446cd2496c25&clientType=ios_rrsp_jzsp&clientVersion=5.5.1&parseUsage=PLAY&uid=0

VIP视频免费5min看的视频流，调整参数也不能访问完整视频。从域名看的话免费的放在腾讯云收费的放在阿里云。

(lldb) po ((M3u8Model *)0x2828d9280).url
https://ali-preview.rr.tv/da81107fbb414227bad8faafa68ba9e6/eb37b38567b44e34817a36d9a8b09c3f-74a18a8c38dc4be51298ea5519a1815c-ld.mp4?auth_key=1622396977-56748ddc75ea4acf87fe91146aecae62-0-fb83047d57857ce0deded4705ee8a6be&end=300

(lldb) po ((M3u8Model *)0x2828d9280).dibblingTotalDuration
0

(lldb)

6.1 暂时的结论

基本可以确定，VIP视频的逻辑是有在视频流做处理的，不能简单通过客户端调整进行破解操作。

人人视频破解暂时告一段落。

不过也算挺有收货的

LLDB

Sat, 22 May 2021 00:00:00 GMT

一：前言

平时我们进行开发的时候可以通过Xcode进行断点设置。
但我们在进行逆向研究的时候，并没有源码不能直接进行断点调试。
这时候我们就需要使用LLDB进行断点设置

二、符号断点相关指令

2.1 单个符号断点

breakpoint set -n funcname

2.2 一组符号断点

breakpoint set -n funcname -n funcname -n funcname -n funcname

这种方便对一个流程进行断点，同时开启和禁用一组断点

(lldb) breakpoint set -n "[ViewController saceAction:]" -n "[ViewController stopAction:]" -n "[ViewController goonAction:]"
Breakpoint 3: 3 locations.

---

3: names = {'[ViewController saceAction:]', '[ViewController saceAction:]', '[ViewController saceAction:]', '[ViewController stopAction:]', '[ViewController stopAction:]', '[ViewController stopAction:]', '[ViewController goonAction:]', '[ViewController goonAction:]', '[ViewController goonAction:]'}, locations = 3, resolved = 3, hit count = 0
  3.1: where = LLDB调试`-[ViewController saceAction:] + 60 at ViewController.m:32:5, address = 0x0000000100c99ecc, resolved, hit count = 0 
  3.2: where = LLDB调试`-[ViewController stopAction:] + 60 at ViewController.m:36:5, address = 0x0000000100c99f24, resolved, hit count = 0 
  3.3: where = LLDB调试`-[ViewController goonAction:] + 60 at ViewController.m:40:5, address = 0x0000000100c99f7c, resolved, hit count = 0

2.3 c

Continue

2.4 查看断点

breakpoint list
- 查看断点列表
  - 第一个数字为断点id

2.5 删除

delete
- 删除全部
delete id
- 删除指定id的断点

2.6 禁用

breakpoint disable 加id 禁用一组或一个

breakpoint disable 禁用全部

2.7 激活

breakpoint enable 启用全部加id启用单个

2.8 包含指令

breakpoint set -r touchesBegan:withEvent: 会对所有方法名包含这个的

可简写：b -r xxx

2.9 selector

breakpoint set --selector touchesBegan:withEvent: 整个项目中的同名selector

2.10 指定文件selector

breakpoint set --file ViewController.m --selector stopAction: 一般逆向不知道用不上。

2.11 下一步

n

2.- 产看更多指令

help breakpoint

三、执行代码

expression
- 就是常用的p，可以用来执行代码

四、堆栈

4.1 bt

查看堆栈信息

4.2 查看当前作用域内的变量信息

frame variable

4.3 直接返回不执行后面的代码，提前返回

thread return

可以在调试阶段，绕过检测。在逆向调试时很有用。

五、内存断点

5.1 对象set方法断点

watchpoint set varible 对象->属性

5.2 地址断点

watchpoint set expression 0x... 当该地址被访问的时候就会触发

其他用法和符号断点类似

六、target stop-hook

6.1 target stop-hook add

在断点内添加一段指令，每当断点触发就会调用这段指令

(lldb) target stop-hook add -o "frame variable"
Stop hook #1 added.
(lldb) n
2021-05-22 11:31:12.733658+0800 LLDB调试[5728:2271351] 1
(ViewController *) self = 0x000000012dd0f590
(SEL) _cmd = "touchesBegan:withEvent:"
(__NSSetM *) touches = 0x00000002816feae0 1 element
(UITouchesEvent *) event = 0x00000002823caf40

(lldb) n
2021-05-22 11:31:15.528090+0800 LLDB调试[5728:2271351] funcA
(ViewController *) self = 0x000000012dd0f590
(SEL) _cmd = "touchesBegan:withEvent:"
(__NSSetM *) touches = 0x00000002816feae0 1 element
(UITouchesEvent *) event = 0x00000002823caf40

6.2 target stop-hook list

(lldb) target stop-hook list
Hook: 1
  State: enabled
  Commands: 
      frame variable
(lldb)

6.3 target stop-hook delete

(lldb) target stop-hook list
Hook: 1
  State: enabled
  Commands: 
      frame variable
(lldb) target stop-hook delete 1
(lldb) target stop-hook list
No stop hooks.

6.4 undisplay

和delete类似

(lldb) target stop-hook add -o "frame variable"
Stop hook #2 added.
(lldb) target stop-hook list
Hook: 2
  State: enabled
  Commands: 
      frame variable
(lldb) undisplay 2
(lldb) target stop-hook list
No stop hooks.
(lldb)

七、LLDB初始化配置

cd到根目录下
- cd ~
修改.lldbinit文件
- 没有就创建
- 添加指令
  - 如：target stop-hook add -o "frame variable"
- 保存
就不用每次都自己去加了
不要的话去文件中删掉即可

虚拟内存

Sat, 22 May 2021 00:00:00 GMT

一、物理内存

早期计算机系统的内存地址都是物理地址。

1.1 内存不够用

应用程序会被完整加载到内存中，大量浪费空间。

1.2 物理地址不安全

可以直接访问内存地址实现跨进程，访问其他应用程序的进程。

物理内存中的数据不会清除，只覆写：这个过程是系统控制的，新的需要存进物理内存的数据，会被写入最不活跃的区域中。应用在后台可能被kill掉的原因之一就是被覆写了。

二、虚拟内存

2.1 虚拟页表

应用程序进程内拿到的地址并不是真实的地址，会通过虚拟页表映射到物理内存。

iOS 一页数据 16kb

Mac 4K ，可以在终端中使用 PAGESIZE，命令获取

2.2 内存优化

应用程序不会完整的加载，当用到某一页数据的时候，才会被加载到物理内存中。

流程：

系统和CPU配合进行地址翻译
- 硬件中MMU（内存管理单元）进行地址翻译
  - 非常快
  - 高速缓存
    - 映射过的会被缓存不会重复翻译
- 找到物理地址
将数据加载进物理内存或读取

2.3 ASLR

ASLR 每次启动为 虚拟页表 添加随机的偏移值，已获得更高的安全性。

三、缺页中断

由于 虚拟页表 的存在，在我们代码访问的数据 page 没有被加载进内存的时候，就会出现 PageFault 缺页中断。而大量的缺页中断会影响应用的启动速度。

而我们可以通过 二进制重排 对数据在 MachO 中的分页布局进行优化，使启动时相关的数据尽量在连续的 page 中，来减少 Page Fault 的次数。

这里我有进行一次相关的实战：二进制重排实践

Chisel工具

Sat, 22 May 2021 00:00:00 GMT

chisel

Chisel is a collection of LLDB commands to assist in the debugging of iOS apps.

说明

alamborder

Put a border around views with an ambiguous layout. Expects 'raw' input (see 'help raw-input'.)

Syntax: alamborder Put a border around views with an ambiguous layout

Options: --color/-c <color>; Type: string; A color name such as 'red', 'green', 'magenta', etc. --width/-w <width>; Type: CGFloat; Desired width of border.

Syntax: alamborder [--color=color] [--width=width]

This command is implemented as FBAutolayoutBorderAmbiguous in /usr/local/Cellar/chisel/1.5.0/libexec/commands/FBAutoLayoutCommands.py.

alamunborder

Removes the border around views with an ambiguous layout. Expects 'raw' input (see 'help raw-input'.)

Syntax: alamunborder Removes the border around views with an ambiguous layout

Syntax: alamunborder

This command is implemented as FBAutolayoutUnborderAmbiguous in /usr/local/Cellar/chisel/1.5.0/libexec/commands/FBAutoLayoutCommands.py.

binside

Set a breakpoint for a relative address within the framework/library that's currently running. This does the work of finding the offset for the framework/library and sliding your address accordingly. Expects 'raw' input (see 'help raw-input'.)

Syntax: binside Set a breakpoint for a relative address within the framework/library that's currently running. This does the work of finding the offset for the framework/library and sliding your address accordingly.

Arguments: <address>; Type: string; Address within the currently running framework to set a breakpoint on.

Syntax: binside <address>

This command is implemented as FBFrameworkAddressBreakpointCommand in /usr/local/Cellar/chisel/1.5.0/libexec/commands/FBDebugCommands.py.

bmessage

Set a breakpoint for a selector on a class, even if the class itself doesn't override that selector. It walks the hierarchy until it finds a class that does implement the selector and sets a conditional breakpoint there. Expects 'raw' input (see 'help raw-input'.)

Syntax: bmessage Set a breakpoint for a selector on a class, even if the class itself doesn't override that selector. It walks the hierarchy until it finds a class that does implement the selector and sets a conditional breakpoint there.

Arguments: <expression>; Type: string; Expression to set a breakpoint on, e.g. "-[MyView setFrame:]", "+[MyView awesomeClassMethod]" or "-[0xabcd1234 setFrame:]"

Syntax: bmessage <expression>

This command is implemented as FBMethodBreakpointCommand in /usr/local/Cellar/chisel/1.5.0/libexec/commands/FBDebugCommands.py.

border

Draws a border around <viewOrLayer>. Color and width can be optionally provided. Additionally depth can be provided in order to recursively border subviews. Expects 'raw' input (see 'help raw-input'.)

Syntax: border Draws a border around <viewOrLayer>. Color and width can be optionally provided. Additionally depth can be provided in order to recursively border subviews.

Arguments: <viewOrLayer>; Type: UIView/NSView/CALayer *; The view/layer to border. NSViews must be layer-backed.

Options: --color/-c <color>; Type: string; A color name such as 'red', 'green', 'magenta', etc. --width/-w <width>; Type: CGFloat; Desired width of border. --depth/-d <depth>; Type: int; Number of levels of subviews to border. Each level gets a different color beginning with the provided or default color

Syntax: border [--color=color] [--width=width] [--depth=depth] <viewOrLayer>

This command is implemented as FBDrawBorderCommand in /usr/local/Cellar/chisel/1.5.0/libexec/commands/FBDisplayCommands.py.

caflush

Force Core Animation to flush. This will 'repaint' the UI but also may mess with ongoing animations. Expects 'raw' input (see 'help raw-input'.)

Syntax: caflush Force Core Animation to flush. This will 'repaint' the UI but also may mess with ongoing animations.

Syntax: caflush

This command is implemented as FBCoreAnimationFlushCommand in /usr/local/Cellar/chisel/1.5.0/libexec/commands/FBDisplayCommands.py.

dcomponents

Set debugging options for components. Expects 'raw' input (see 'help raw-input'.)

Syntax: dcomponents Set debugging options for components.

Options: --set/-s ; Set debug mode for components --unset/-u ; Unset debug mode for components

Syntax: dcomponents [--set] [--unset]

This command is implemented as FBComponentsDebugCommand in /usr/local/Cellar/chisel/1.5.0/libexec/commands/FBComponentCommands.py.

dismiss

Dismiss a presented view controller. Expects 'raw' input (see 'help raw-input'.)

Syntax: dismiss Dismiss a presented view controller.

Arguments: <viewController>; Type: UIViewController *; The view controller to dismiss.

Syntax: dismiss <viewController>

This command is implemented as FBDismissViewControllerCommand in /usr/local/Cellar/chisel/1.5.0/libexec/commands/FBDisplayCommands.py.

fa11y

Find the views whose accessibility labels match labelRegex and puts the address of the first result on the clipboard. Expects 'raw' input (see 'help raw-input'.)

Syntax: fa11y Find the views whose accessibility labels match labelRegex and puts the address of the first result on the clipboard.

Arguments: <labelRegex>; Type: string; The accessibility label regex to search the view hierarchy for.

Syntax: fa11y <labelRegex>

This command is implemented as FBFindViewByAccessibilityLabelCommand in /usr/local/Cellar/chisel/1.5.0/libexec/commands/FBAccessibilityCommands.py.

flicker

Quickly show and hide a view to quickly help visualize where it is. Expects 'raw' input (see 'help raw-input'.)

Syntax: flicker Quickly show and hide a view to quickly help visualize where it is.

Arguments: <viewOrLayer>; Type: UIView/NSView*; The view to flicker.

Syntax: flicker <viewOrLayer>

This command is implemented as FBFlickerViewCommand in /usr/local/Cellar/chisel/1.5.0/libexec/commands/FBFlickerCommands.py.

fv

Find the views whose class names match classNameRegex and puts the address of first on the clipboard. Expects 'raw' input (see 'help raw-input'.)

Syntax: fv Find the views whose class names match classNameRegex and puts the address of first on the clipboard.

Arguments: <classNameRegex>; Type: string; The view-class regex to search the view hierarchy for.

Syntax: fv <classNameRegex>

This command is implemented as FBFindViewCommand in /usr/local/Cellar/chisel/1.5.0/libexec/commands/FBFindCommands.py.

fvc

Find the view controllers whose class names match classNameRegex and puts the address of first on the clipboard. Expects 'raw' input (see 'help raw-input'.)

Syntax: fvc Find the view controllers whose class names match classNameRegex and puts the address of first on the clipboard.

Options: --name/-n <classNameRegex>; Type: string; The view-controller-class regex to search the view controller hierarchy for. --view/-v <view>; Type: UIView; This function will print the View Controller that owns this view.

Syntax: fvc [--name=classNameRegex] [--view=view]

This command is implemented as FBFindViewControllerCommand in /usr/local/Cellar/chisel/1.5.0/libexec/commands/FBFindCommands.py.

hide

Hide a view or layer. Expects 'raw' input (see 'help raw-input'.)

Syntax: hide Hide a view or layer.

Arguments: <viewOrLayer>; Type: UIView/NSView/CALayer *; The view/layer to hide.

Syntax: hide <viewOrLayer>

This command is implemented as FBHideViewCommand in /usr/local/Cellar/chisel/1.5.0/libexec/commands/FBDisplayCommands.py.

mask

Add a transparent rectangle to the window to reveal a possibly obscured or hidden view or layer's bounds Expects 'raw' input (see 'help raw-input'.)

Syntax: mask Add a transparent rectangle to the window to reveal a possibly obscured or hidden view or layer's bounds

Arguments: <viewOrLayer>; Type: UIView/NSView/CALayer *; The view/layer to mask.

Options: --color/-c <color>; Type: string; A color name such as 'red', 'green', 'magenta', etc. --alpha/-a <alpha>; Type: CGFloat; Desired alpha of mask.

Syntax: mask [--color=color] [--alpha=alpha] <viewOrLayer>

This command is implemented as FBMaskViewCommand in /usr/local/Cellar/chisel/1.5.0/libexec/commands/FBDisplayCommands.py.

mwarning

simulate a memory warning Expects 'raw' input (see 'help raw-input'.)

Syntax: mwarning simulate a memory warning

Syntax: mwarning

This command is implemented as FBMemoryWarningCommand in /usr/local/Cellar/chisel/1.5.0/libexec/commands/FBDebugCommands.py.

pa11y

Print accessibility labels of all views in hierarchy of <aView>. Expects 'raw' input (see 'help raw-input'.)

Syntax: pa11y Print accessibility labels of all views in hierarchy of <aView>

Arguments: <aView>; Type: UIView*; The view to print the hierarchy of.

Syntax: pa11y <aView>

This command is implemented as FBPrintAccessibilityLabels in /usr/local/Cellar/chisel/1.5.0/libexec/commands/FBAccessibilityCommands.py.

pa11yi

Print accessibility identifiers of all views in hierarchy of <aView>. Expects 'raw' input (see 'help raw-input'.)

Syntax: pa11yi Print accessibility identifiers of all views in hierarchy of <aView>

Arguments: <aView>; Type: UIView*; The view to print the hierarchy of.

Syntax: pa11yi <aView>

This command is implemented as FBPrintAccessibilityIdentifiers in /usr/local/Cellar/chisel/1.5.0/libexec/commands/FBAccessibilityCommands.py.

pactions

Print the actions and targets of a control. Expects 'raw' input (see 'help raw-input'.)

Syntax: pactions Print the actions and targets of a control.

Arguments: <control>; Type: UIControl *; The control to inspect the actions of.

Syntax: pactions <control>

This command is implemented as FBPrintTargetActions in /usr/local/Cellar/chisel/1.5.0/libexec/commands/FBPrintCommands.py.

paltrace

Print the Auto Layout trace for the given view. Defaults to the key window. Expects 'raw' input (see 'help raw-input'.)

Syntax: paltrace Print the Auto Layout trace for the given view. Defaults to the key window.

Arguments: <view>; Type: UIView *; The view to print the Auto Layout trace for.

Syntax: paltrace <view>

This command is implemented as FBPrintAutolayoutTrace in /usr/local/Cellar/chisel/1.5.0/libexec/commands/FBAutoLayoutCommands.py.

panim

Prints if the code is currently execution with a UIView animation block. Expects 'raw' input (see 'help raw-input'.)

Syntax: panim Prints if the code is currently execution with a UIView animation block.

Syntax: panim

This command is implemented as FBPrintIsExecutingInAnimationBlockCommand in /usr/local/Cellar/chisel/1.5.0/libexec/commands/FBPrintCommands.py.

pbcopy

Print object and copy output to clipboard Expects 'raw' input (see 'help raw-input'.)

Syntax: pbcopy Print object and copy output to clipboard

Arguments: <object>; Type: id; The object to print

Syntax: pbcopy <object>

This command is implemented as FBPrintToClipboard in /usr/local/Cellar/chisel/1.5.0/libexec/commands/FBPrintCommands.py.

pblock

Print the block`s implementation address and signature. Expects 'raw' input (see 'help raw-input'.)

Syntax: pblock Print the block`s implementation address and signature

Arguments: <block>; Type: ; The block object you want to print

Syntax: pblock <block>

This command is implemented as FBPrintBlock in /usr/local/Cellar/chisel/1.5.0/libexec/commands/FBClassDump.py.

pbundlepath

Print application's bundle directory path. Expects 'raw' input (see 'help raw-input'.)

Syntax: pbundlepath Print application's bundle directory path.

Options: --open/-o ; open in Finder

Syntax: pbundlepath [--open]

This command is implemented as FBPrintApplicationBundlePath in /usr/local/Cellar/chisel/1.5.0/libexec/commands/FBPrintCommands.py.

pca

Print layer tree from the perspective of the render server. Expects 'raw' input (see 'help raw-input'.)

Syntax: pca Print layer tree from the perspective of the render server.

Syntax: pca

This command is implemented as FBPrintCoreAnimationTree in /usr/local/Cellar/chisel/1.5.0/libexec/commands/FBPrintCommands.py.

pcells

Print the visible cells of the highest table view in the hierarchy. Expects 'raw' input (see 'help raw-input'.)

Syntax: pcells Print the visible cells of the highest table view in the hierarchy.

Syntax: pcells

This command is implemented as FBPrintOnscreenTableViewCells in /usr/local/Cellar/chisel/1.5.0/libexec/commands/FBPrintCommands.py.

pclass

Print the inheritance starting from an instance of any class. Expects 'raw' input (see 'help raw-input'.)

Syntax: pclass Print the inheritance starting from an instance of any class.

Arguments: <object>; Type: id; The instance to examine.

Syntax: pclass <object>

This command is implemented as FBPrintInheritanceHierarchy in /usr/local/Cellar/chisel/1.5.0/libexec/commands/FBPrintCommands.py.

pcomponents

Print a recursive description of components found starting from <aView>. Expects 'raw' input (see 'help raw-input'.)

Syntax: pcomponents Print a recursive description of components found starting from <aView>.

Arguments: <aView>; Type: UIView*; The view to from which the search for components begins.

Options: --up/-u ; Print only the component hierarchy found on the first superview that has them, carrying the search up to its window. --show-views/-v <showViews>; Type: BOOL; Prints the component hierarchy and does not print the views if the supplied argument is 'NO'. Supply either a 'YES' or a 'NO'. The default is to show views.

Syntax: pcomponents [--up] [--show-views=showViews] <aView>

This command is implemented as FBComponentsPrintCommand in /usr/local/Cellar/chisel/1.5.0/libexec/commands/FBComponentCommands.py.

pcurl

Print the NSURLRequest (HTTP) as curl command. Expects 'raw' input (see 'help raw-input'.)

Syntax: pcurl Print the NSURLRequest (HTTP) as curl command.

Arguments: <request>; Type: NSURLRequest*/NSMutableURLRequest*; The request to convert to the curl command.

Options: --embed-data/-e ; Embed request data as base64.

Syntax: pcurl [--embed-data] <request>

This command is implemented as FBPrintAsCurl in /usr/local/Cellar/chisel/1.5.0/libexec/commands/FBPrintCommands.py.

pdata

Print the contents of NSData object as string. Expects 'raw' input (see 'help raw-input'.)

Syntax: pdata Print the contents of NSData object as string. Supported encodings:

ascii,
utf8,
utf16, unicode,
utf16l (Little endian),
utf16b (Big endian),
utf32,
utf32l (Little endian),
utf32b (Big endian),
latin1, iso88591 (88591),
latin2, iso88592 (88592),
cp1251 (1251),
cp1252 (1252),
cp1253 (1253),
cp1254 (1254),
cp1250 (1250),

Arguments: <data>; Type: NSData *; NSData object.

Options: --encoding/-e <encoding>; Type: string; Used encoding (default utf-8).

Syntax: pdata [--encoding=encoding] <data>

This command is implemented as FBPrintData in /usr/local/Cellar/chisel/1.5.0/libexec/commands/FBPrintCommands.py.

pdocspath

Print application's 'Documents' directory path. Expects 'raw' input (see 'help raw-input'.)

Syntax: pdocspath Print application's 'Documents' directory path.

Options: --open/-o ; open in Finder

Syntax: pdocspath [--open]

This command is implemented as FBPrintApplicationDocumentsPath in /usr/local/Cellar/chisel/1.5.0/libexec/commands/FBPrintCommands.py.

pinternals

Show the internals of an object by dereferencing it as a pointer. Expects 'raw' input (see 'help raw-input'.)

Syntax: pinternals Show the internals of an object by dereferencing it as a pointer.

Arguments: <object>; Type: id; Object expression to be evaluated.

Syntax: pinternals <object>

This command is implemented as FBPrintInternals in /usr/local/Cellar/chisel/1.5.0/libexec/commands/FBPrintCommands.py.

pinvocation

Print the stack frame, receiver, and arguments of the current invocation. It will fail to print all arguments if any arguments are variadic (varargs). Expects 'raw' input (see 'help raw-input'.)

Syntax: pinvocation Print the stack frame, receiver, and arguments of the current invocation. It will fail to print all arguments if any arguments are variadic (varargs).

NOTE: Sadly this is currently only implemented on x86.

Options: --all/-a ; Specify to print the entire stack instead of just the current frame.

Syntax: pinvocation [--all]

This command is implemented as FBPrintInvocation in /usr/local/Cellar/chisel/1.5.0/libexec/commands/FBInvocationCommands.py.

pivar

Print the value of an object's named instance variable. Expects 'raw' input (see 'help raw-input'.)

Syntax: pivar Print the value of an object's named instance variable.

Arguments: <object>; Type: id; Object expression to be evaluated. <ivarName>; Type: ; Name of instance variable to print.

Syntax: pivar <object> <ivarName>

This command is implemented as FBPrintInstanceVariable in /usr/local/Cellar/chisel/1.5.0/libexec/commands/FBPrintCommands.py.

pjson

Print JSON representation of NSDictionary or NSArray object Expects 'raw' input (see 'help raw-input'.)

Syntax: pjson Print JSON representation of NSDictionary or NSArray object

Arguments: <object>; Type: id; The NSDictionary or NSArray object to print

Options: --plain/-p ; Plain JSON

Syntax: pjson [--plain] <object>

This command is implemented as FBPrintJSON in /usr/local/Cellar/chisel/1.5.0/libexec/commands/FBPrintCommands.py.

pkp

Print out the value of the key path expression using -valueForKeyPath:. Expects 'raw' input (see 'help raw-input'.)

Syntax: pkp Print out the value of the key path expression using -valueForKeyPath:

Arguments: <keypath>; Type: NSString *; The keypath to print

Syntax: pkp <keypath>

This command is implemented as FBPrintKeyPath in /usr/local/Cellar/chisel/1.5.0/libexec/commands/FBPrintCommands.py.

pmethods

Print the class and instance methods of a class. Expects 'raw' input (see 'help raw-input'.)

Syntax: pmethods Print the class and instance methods of a class.

Arguments: <instance or class>; Type: instance or Class; an Objective-C Class.

Options: --address/-a ; Print the implementation address of the method --instance/-i ; Print the instance methods --class/-c ; Print the class methods --name/-n ; Take the argument as class name

Syntax: pmethods [--address] [--instance] [--class] [--name] <instance or class>

This command is implemented as FBPrintMethods in /usr/local/Cellar/chisel/1.5.0/libexec/commands/FBClassDump.py.

poobjc

Print the expression result, with the expression run in an ObjC++ context. (Shortcut for "expression -O -l ObjC++ -- " ) Expects 'raw' input (see 'help raw-input'.)

Syntax: poobjc Print the expression result, with the expression run in an ObjC++ context. (Shortcut for "expression -O -l ObjC++ -- " )

Arguments: <expression>; Type: ; ObjC expression to evaluate and print.

Syntax: poobjc <expression>

This command is implemented as FBPrintObjectInObjc in /usr/local/Cellar/chisel/1.5.0/libexec/commands/FBPrintCommands.py.

pproperties

Print the properties of an instance or Class Expects 'raw' input (see 'help raw-input'.)

Syntax: pproperties Print the properties of an instance or Class

Arguments: <instance or class>; Type: instance or Class; an Objective-C Class.

Options: --name/-n ; Take the argument as class name

Syntax: pproperties [--name] <instance or class>

This command is implemented as FBPrintProperties in /usr/local/Cellar/chisel/1.5.0/libexec/commands/FBClassDump.py.

present

Present a view controller. Expects 'raw' input (see 'help raw-input'.)

Syntax: present Present a view controller.

Arguments: <viewController>; Type: UIViewController *; The view controller to present.

Syntax: present <viewController>

This command is implemented as FBPresentViewControllerCommand in /usr/local/Cellar/chisel/1.5.0/libexec/commands/FBDisplayCommands.py.

presponder

Print the responder chain starting from a specific responder. Expects 'raw' input (see 'help raw-input'.)

Syntax: presponder Print the responder chain starting from a specific responder.

Arguments: <startResponder>; Type: UIResponder *; The responder to use to start walking the chain.

Syntax: presponder <startResponder>

This command is implemented as FBPrintUpwardResponderChain in /usr/local/Cellar/chisel/1.5.0/libexec/commands/FBPrintCommands.py.

ptv

Print the highest table view in the hierarchy. Expects 'raw' input (see 'help raw-input'.)

Syntax: ptv Print the highest table view in the hierarchy.

Syntax: ptv

This command is implemented as FBPrintOnscreenTableView in /usr/local/Cellar/chisel/1.5.0/libexec/commands/FBPrintCommands.py.

pvc

Print the recursion description of <aViewController>. Expects 'raw' input (see 'help raw-input'.)

Syntax: pvc Print the recursion description of <aViewController>.

Arguments: <aViewController>; Type: UIViewController*; The view controller to print the description of.

Syntax: pvc <aViewController>

This command is implemented as FBPrintViewControllerHierarchyCommand in /usr/local/Cellar/chisel/1.5.0/libexec/commands/FBPrintCommands.py.

pviews

Print the recursion description of <aView>. Expects 'raw' input (see 'help raw-input'.)

Syntax: pviews Print the recursion description of <aView>.

Arguments: <aView>; Type: UIView*/NSView*; The view to print the description of.

Options: --up/-u ; Print only the hierarchy directly above the view, up to its window. --depth/-d <depth>; Type: int; Print only to a given depth. 0 indicates infinite depth.

Syntax: pviews [--up] [--depth=depth] <aView>

This command is implemented as FBPrintViewHierarchyCommand in /usr/local/Cellar/chisel/1.5.0/libexec/commands/FBPrintCommands.py.

rcomponents

Synchronously reflow and update root components found starting from <aView>. Expects 'raw' input (see 'help raw-input'.)

Syntax: rcomponents Synchronously reflow and update root components found starting from <aView>.

Arguments: <aView>; Type: UIView*; The view to from which the search for the root components begins.

Options: --up/-u ; Reflow only the root components found on the first superview that has them, carrying the search up to its window.

Syntax: rcomponents [--up] <aView>

This command is implemented as FBComponentsReflowCommand in /usr/local/Cellar/chisel/1.5.0/libexec/commands/FBComponentCommands.py.

setinput

Input text into text field or text view that is first responder. Expects 'raw' input (see 'help raw-input'.)

Syntax: setinput Input text into text field or text view that is first responder.

Arguments: <inputText>; Type: string; The text to input.

Syntax: setinput <inputText>

This command is implemented as FBInputTexToFirstResponderCommand in /usr/local/Cellar/chisel/1.5.0/libexec/commands/FBTextInputCommands.py.

settext

Set text on text on a view by accessibility id. Expects 'raw' input (see 'help raw-input'.)

Syntax: settext Set text on text on a view by accessibility id.

Arguments: <accessibilityId>; Type: string; The accessibility ID of the input view. <replacementText>; Type: string; The text to set.

Syntax: settext <accessibilityId> <replacementText>

This command is implemented as FBInputTexByAccessibilityIdCommand in /usr/local/Cellar/chisel/1.5.0/libexec/commands/FBTextInputCommands.py.

show

Show a view or layer. Expects 'raw' input (see 'help raw-input'.)

Syntax: show Show a view or layer.

Arguments: <viewOrLayer>; Type: UIView/NSView/CALayer *; The view/layer to show.

Syntax: show <viewOrLayer>

This command is implemented as FBShowViewCommand in /usr/local/Cellar/chisel/1.5.0/libexec/commands/FBDisplayCommands.py.

slowanim

Slows down animations. Works on the iOS Simulator and a device. Expects 'raw' input (see 'help raw-input'.)

Syntax: slowanim Slows down animations. Works on the iOS Simulator and a device.

Arguments: <speed>; Type: float; Animation speed (default 0.1).

Syntax: slowanim <speed>

This command is implemented as FBSlowAnimationCommand in /usr/local/Cellar/chisel/1.5.0/libexec/commands/FBDisplayCommands.py.

taplog

Log tapped view to the console. Expects 'raw' input (see 'help raw-input'.)

Syntax: taplog Log tapped view to the console.

Syntax: taplog

This command is implemented as FBTapLoggerCommand in /usr/local/Cellar/chisel/1.5.0/libexec/commands/FBFindCommands.py.

unborder

Removes border around <viewOrLayer>. Expects 'raw' input (see 'help raw-input'.)

Syntax: unborder Removes border around <viewOrLayer>.

Arguments: <viewOrLayer>; Type: UIView/NSView/CALayer *; The view/layer to unborder.

Options: --depth/-d <depth>; Type: int; Number of levels of subviews to unborder.

Syntax: unborder [--depth=depth] <viewOrLayer>

This command is implemented as FBRemoveBorderCommand in /usr/local/Cellar/chisel/1.5.0/libexec/commands/FBDisplayCommands.py.

unmask

Remove mask from a view or layer Expects 'raw' input (see 'help raw-input'.)

Syntax: unmask Remove mask from a view or layer

Arguments: <viewOrLayer>; Type: UIView/CALayer *; The view/layer to mask.

Syntax: unmask <viewOrLayer>

This command is implemented as FBUnmaskViewCommand in /usr/local/Cellar/chisel/1.5.0/libexec/commands/FBDisplayCommands.py.

unslowanim

Turn off slow animations. Expects 'raw' input (see 'help raw-input'.)

Syntax: unslowanim Turn off slow animations.

Syntax: unslowanim

This command is implemented as FBUnslowAnimationCommand in /usr/local/Cellar/chisel/1.5.0/libexec/commands/FBDisplayCommands.py.

visualize

Open a UIImage, CGImageRef, UIView, or CALayer in Preview.app on your Mac. Expects 'raw' input (see 'help raw-input'.)

Syntax: visualize Open a UIImage, CGImageRef, UIView, or CALayer in Preview.app on your Mac.

Arguments: <target>; Type: (id); The object to visualize.

Syntax: visualize <target>

This command is implemented as FBVisualizeCommand in /usr/local/Cellar/chisel/1.5.0/libexec/commands/FBVisualizationCommands.py.

vs

Interactively search for a view by walking the hierarchy. Expects 'raw' input (see 'help raw-input'.)

Syntax: vs Interactively search for a view by walking the hierarchy.

Arguments: <view>; Type: UIView*; The view to border.

Syntax: vs <view>

This command is implemented as FBViewSearchCommand in /usr/local/Cellar/chisel/1.5.0/libexec/commands/FBFlickerCommands.py.

wivar

Set a watchpoint for an object's instance variable. Expects 'raw' input (see 'help raw-input'.)

Syntax: wivar Set a watchpoint for an object's instance variable.

Arguments: <object>; Type: id; Object expression to be evaluated. <ivarName>; Type: ; Name of the instance variable to watch.

Syntax: wivar <object> <ivarName>

This command is implemented as FBWatchInstanceVariableCommand in /usr/local/Cellar/chisel/1.5.0/libexec/commands/FBDebugCommands.py.

DS.LLDB工具

Sat, 22 May 2021 00:00:00 GMT

DerekSelander/LLDB

可以用来找对象，拿到地址来进行逆向分析。

Cycript工具

Sat, 22 May 2021 00:00:00 GMT

cycript

一、执行可执行文件报错

dyld: Library not loaded: /System/Library/Frameworks/Ruby.framework/Versions/2.0/usr/lib/libruby.2.0.0.dylib

找到当前的ruby的如：libruby.3.0.dylib文件，赋值一份到Cycript.lib下，改名为libruby.2.0.0.dylib。

control + d 退出

二、环境配置

如果配置了MonkeyDev的环境变量的话，因为自带了cycript，所以在任意路径下cycript都是有效的。

三、玩法

可以通过端口进入当前进程，访问内存环境。

运行App

方便起见使用Monkey项目运行

获取设备ip

通过命令行链接

cycript -r 192.168.0.102:6666
cy#

进入了cycript状态，就可以直接输入代码进行调试了

Cycrupt用法

Sat, 22 May 2021 00:00:00 GMT

一、动态调试

这里我通过Cycript修改了微信语言选择按钮的文案。

1.1 choose

cy# choose(UILabel)
[#"<UIButtonLabel: 0x111f48ca0; frame = (70 12.6667; 37 22); text = '\xe7\x99\xbb\xe5\xbd\x95'; opaque = NO; userInteractionEnabled = NO; layer = <_UILabelLayer: 0x280c9b700>>",#"<UIButtonLabel: 0x111f674f0; frame = (70 12.6667; 37 22); text = '\xe6\xb3\xa8\xe5\x86\x8c'; opaque = NO; userInteractionEnabled = NO; layer = <_UILabelLayer: 0x280c8a530>>",#"<UIButtonLabel: 0x111f78250; frame = (15 16; 58 17); text = '\xe7\xae\x80\xe4\xbd\x93\xe4\xb8\xad\xe6\x96\x87'; opaque = NO; userInteractionEnabled = NO; layer = <_UILabelLayer: 0x280c8aa30>>",#"<MMUILabel: 0x111f89350; baseClass = UILabel; frame = (0 0; 0 36); userInteractionEnabled = NO; layer = <_UILabelLayer: 0x280cf1ef0>>",#"<MMUILabel: 0x111f8c750; baseClass = UILabel; frame = (0 0; 0 36); userInteractionEnabled = NO; layer = <_UILabelLayer: 0x280cf2ad0>>",#"<UILabel: 0x111f8e430; frame = (0 0; 0 0); userInteractionEnabled = NO; layer = <_UILabelLayer: 0x280cf3890>>",#"<UILabel: 0x111c36770; frame = (0 0; 0 0); userInteractionEnabled = NO; layer = <_UILabelLayer: 0x280cc9720>>"]

1.2 设置值

cy# #0x111f78250.text = @"Ryukie"
@"Ryukie"

二、高级用法

2.1 cy封装

APPID

cy# APPID
@"cn.Ryukie.Sama.Hanoi"

pvcs

cy# pvcs()
"<MMUINavigationController 0x1120d5a00>, state: appeared, view: <UILayoutContainerView 0x111c0e060>\n   | <WCAccountLoginFirstViewController 0x11292d400>, state: appeared, view: <UIView 0x111c1c680>"

这些其实都是封装好的一些.cy文件。再拷贝进包中。

2.2 自定义cy

➜  Cy touch Ryukie.cy
➜  Cy vim Ryukie.cy
➜  Cy cat Ryukie.cy
sum = function(a,b) {
	return a + b;
}

a. 添加到工程中

b. 添加Copy

c. 运行工程，链接cy

➜  Cy sh cyWifiLogin.sh // 这里是封装了链接的脚本
cy# @import Ryukie
{}
cy# sum(1,3)
4

Logos

Sat, 22 May 2021 00:00:00 GMT

应用砸壳

Sat, 22 May 2021 00:00:00 GMT

一、frida-ios-dump 🔗

1.1 电脑上安装frida

Clone到本地先
cd进目录
执行sudo pip install -r requirements.txt --upgrade

1.2 手机上安装frida

添加源build.frida.re
搜索并安装frida
- 两端版本要一致

1.3 手机连上电脑进行端口映射

这里为了方便起见提供了几个好用的脚本：

sh iPhoneUSBProxy.sh
- 🔗
- 进行端口映射（22-2222）
- 2222是frida默认的
- 22是系统默认的
sh iPhoneLocalLogin.sh(另开一个终端页)
- 🔗
- USB链接
ptython-client

注意电脑上只能插一个手机。血的教训啊。有一天本地登录一直报错，搞了一个小时各种搜索，头要炸了，拔掉手机去上个厕所。拔下数据线的一瞬间感觉世界都亮了，我才意识到插了两个手机。

1.4 查看可砸壳应用

进入Clone下来的frida-ios-dump目录下

./dump.py -l

➜  frida-ios-dump git:(master) ./dump.py -l
 PID  Name           Identifier
----  -------------  -----------------------------
5853  Cydia          com.saurik.Cydia
6661  人人视频           com.rrds.rrdianshi
6609  设置             com.apple.Preferences
   -  App Store      com.apple.AppStore
   -  Azizi          com.inke.yaamar
   -  DobbyDemo      cn.Ryukie.Sama.Loviary
   -  Elic           com.ryukie.sama.minesweeper
   -  FaceTime通话     com.apple.facetime
   -  Facebook       com.facebook.Facebook
   -  Google Maps    com.google.Maps
   -  LogiDemo       cn.Ryukie.Sama.LogiDemo
   -  Safari浏览器      com.apple.mobilesafari
   -  Shadowrocket   com.liguangming.Shadowrocket
   -  Substitute     com.ex.substitute.settings
   -  Twitter        com.atebits.Tweetie2
   -  Watch          com.apple.Bridge
   -  iTunes Store   com.apple.MobileStore
   -  unc0verSobani  com.ryukie.sama.Sobani
   -  信息             com.apple.MobileSMS
   -  健康             com.apple.Health
   -  图书             com.apple.iBooks
   -  地图             com.apple.Maps
   -  备忘录            com.apple.mobilenotes
   -  天气             com.apple.weather
   -  家庭             com.apple.Home
   -  微信             cn.Ryukie.Sama.Hanoi
   -  快捷指令           com.apple.shortcuts
   -  指南针            com.apple.compass
   -  提示             com.apple.tips
   -  提醒事项           com.apple.reminders
   -  播客             com.apple.podcasts
   -  文件             com.apple.DocumentsApp
   -  日历             com.apple.mobilecal
   -  时钟             com.apple.mobiletimer
   -  查找             com.apple.findmy
   -  梦见账本           com.ryukie.sama.ledger.Ledger
   -  测距仪            com.apple.measure
   -  照片             com.apple.mobileslideshow
   -  电话             com.apple.mobilephone
   -  百度地图           com.baidu.map
   -  相机             com.apple.camera
   -  股市             com.apple.stocks
   -  腾讯地图           com.tencent.sosomap
   -  视频             com.apple.tv
   -  计算器            com.apple.calculator
   -  语音备忘录          com.apple.VoiceMemos
   -  通讯录            com.apple.MobileAddressBook
   -  邮件             com.apple.mobilemail
   -  钉钉             com.laiwang.DingTalk
   -  钱包             com.apple.Passbook
   -  音乐             com.apple.Music
   -  高德地图           com.autonavi.amap

1.4 执行砸壳脚本

Run ./dump.py Display name or Bundle identifier

成功后就可以在frida-ios-dump中找到砸壳的包了！

二、Python版本问题

升级系统为MacOS11.4后就一直dump不出来了

➜  frida-ios-dump git:(master) ./dump.py -l
/Library/Python/2.7/site-packages/paramiko/transport.py:33: CryptographyDeprecationWarning: Python 2 is no longer supported by the Python core team. Support for it is now deprecated in cryptography, and will be removed in the next release.
  from cryptography.hazmat.backends import default_backend
Traceback (most recent call last):
  File "./dump.py", line 20, in <module>
    import paramiko
  File "/Library/Python/2.7/site-packages/paramiko/__init__.py", line 22, in <module>
    from paramiko.transport import SecurityOptions, Transport
  File "/Library/Python/2.7/site-packages/paramiko/transport.py", line 129, in <module>
    class Transport(threading.Thread, ClosingContextManager):
  File "/Library/Python/2.7/site-packages/paramiko/transport.py", line 190, in Transport
    if KexCurve25519.is_available():
  File "/Library/Python/2.7/site-packages/paramiko/kex_curve25519.py", line 30, in is_available
    X25519PrivateKey.generate()
  File "/System/Library/Frameworks/Python.framework/Versions/2.7/Extras/lib/python/cryptography/hazmat/primitives/asymmetric/x25519.py", line 39, in generate
    from cryptography.hazmat.backends.openssl.backend import backend
  File "/System/Library/Frameworks/Python.framework/Versions/2.7/Extras/lib/python/cryptography/hazmat/backends/openssl/__init__.py", line 7, in <module>
    from cryptography.hazmat.backends.openssl.backend import backend
  File "/System/Library/Frameworks/Python.framework/Versions/2.7/Extras/lib/python/cryptography/hazmat/backends/openssl/backend.py", line 117, in <module>
    from cryptography.hazmat.bindings.openssl import binding
  File "/System/Library/Frameworks/Python.framework/Versions/2.7/Extras/lib/python/cryptography/hazmat/bindings/openssl/binding.py", line 14, in <module>
    from cryptography.hazmat.bindings._openssl import ffi, lib
ImportError: dlopen(/System/Library/Frameworks/Python.framework/Versions/2.7/Extras/lib/python/cryptography/hazmat/bindings/_openssl.so, 2): Symbol not found: _DTLS_client_method
  Referenced from: /System/Library/Frameworks/Python.framework/Versions/2.7/Extras/lib/python/cryptography/hazmat/bindings/_openssl.so
  Expected in: flat namespace
 in /System/Library/Frameworks/Python.framework/Versions/2.7/Extras/lib/python/cryptography/hazmat/bindings/_openssl.so
Error in atexit._run_exitfuncs:
Traceback (most recent call last):
  File "/System/Library/Frameworks/Python.framework/Versions/2.7/lib/python2.7/atexit.py", line 24, in _run_exitfuncs
    func(*targs, **kargs)
  File "/Library/Python/2.7/site-packages/paramiko/transport.py", line 120, in _join_lingering_threads
    for thr in _active_threads:
TypeError: 'NoneType' object is not iterable
Error in sys.exitfunc:
Traceback (most recent call last):
  File "/System/Library/Frameworks/Python.framework/Versions/2.7/lib/python2.7/atexit.py", line 24, in _run_exitfuncs
    func(*targs, **kargs)
  File "/Library/Python/2.7/site-packages/paramiko/transport.py", line 120, in _join_lingering_threads
    for thr in _active_threads:
TypeError: 'NoneType' object is not iterable

解决

前提是安装了Python3

切换用Python3环境

➜ frida-ios-dump git:(master) sudo pip3 install -r requirements.txt --upgrade

Inlinehook:Dobby

Fri, 21 May 2021 00:00:00 GMT

一、Dobby

GitHub:Dobby

按文档生成一个Xcode工程。获取DobbyX.framework。一个跨平台的用于Hook静态语言的框架。

cd Dobby && mkdir build_for_ios_arm64 && cd build_for_ios_arm64
cmake .. -G Xcode \
-DCMAKE_TOOLCHAIN_FILE=cmake/ios.toolchain.cmake \
-DPLATFORM=OS64 -DARCHS="arm64" -DCMAKE_SYSTEM_PROCESSOR=arm64 \
-DENABLE_BITCODE=0 -DENABLE_ARC=0 -DENABLE_VISIBILITY=1 -DDEPLOYMENT_TARGET=9.3 \
-DDynamicBinaryInstrument=ON -DNearBranch=ON -DPlugin.SymbolResolver=ON -DPlugin.Darwin.HideLibrary=ON -DPlugin.Darwin.ObjectiveC=ON

二、将framework集成进工程

将上面获取到的DobbyX.framework，拖进项目。
Build Phases 中添加 Copy file，添加DobbyX.framework，类型为framework

三、使用

3.1 int DobbyHook(void address, void replace_call, void **origin_call);

address
- 需要hook的函数地址
replace_call
- 新函数地址
origin_call
- 原始函数指针的地址

由于静态语言没有符号，直接通过地址来进行hook

3.2 试验一下

下面就是简单的使用方式

#import "ViewController.h"
#import "DobbyX.framework/Headers/dobby.h"

@interface ViewController ()

@end

@implementation ViewController

int test_sum(int a, int b) {
    return a + b;
}

- (void)viewDidLoad {
    [super viewDidLoad];
    self.view.backgroundColor = [UIColor redColor];
    
    DobbyHook(test_sum, new_sum, (void *)&old_sum_p);
}

/// 原始函数指针
static int (*old_sum_p)(int a, int b);
// 新函数地址
int new_sum(int a, int b) {
    int right = old_sum_p(a, b);
    NSLog(@"Hook了！正确的结果是：%d",right);
    return right + 1;
}

- (void)touchesBegan:(NSSet<UITouch *> *)touches withEvent:(UIEvent *)event {
    NSLog(@"结果：%d",test_sum(1, 1));
}

@end

控制台输出：

[*] ================================
[*] Dobby
[*] ================================
[*] dobby in debug log mode, disable with cmake flag "-DDOBBY_DEBUG=OFF"


[*] [DobbyHook] Initialize at 0x104d31d90
[*] [trampoline] Generate trampoline buffer 0x104d31d90 -> 0x104d31e74
[*] [insn relocate] origin 0x104d31d90 - 12
[*] [insn relocate] relocated 0x10d2c0000 - 32
[*] [intercept routing] Active patch 0x104d31d90
2021-05-19 08:33:00.081796+0800 DobbyDemo[4207:1785806] Hook了！正确的结果是：2
2021-05-19 08:33:00.081972+0800 DobbyDemo[4207:1785806] 结果：3

四、流程分析

4.1 汇编分析 test_sum

a. 原始函数的汇编

DobbyDemo`test_sum:
    0x104a71dc4 <+0>:  sub    sp, sp, #0x10             ; =0x10 
    0x104a71dc8 <+4>:  str    w0, [sp, #0xc]
    0x104a71dcc <+8>:  str    w1, [sp, #0x8]
->  0x104a71dd0 <+12>: ldr    w8, [sp, #0xc]
    0x104a71dd4 <+16>: ldr    w9, [sp, #0x8]
    0x104a71dd8 <+20>: add    w0, w8, w9
    0x104a71ddc <+24>: add    sp, sp, #0x10             ; =0x10 
    0x104a71de0 <+28>: ret

b. Hook后的汇编

DobbyDemo`test_sum:
    0x104c7dd90 <+0>:  adrp   x17, 0
    0x104c7dd94 <+4>:  add    x17, x17, #0xe74          ; =0xe74 
    0x104c7dd98 <+8>:  br     x17
->  0x104c7dd9c <+12>: ldr    w8, [sp, #0xc]
    0x104c7dda0 <+16>: ldr    w9, [sp, #0x8]
    0x104c7dda4 <+20>: add    w0, w8, w9
    0x104c7dda8 <+24>: add    sp, sp, #0x10             ; =0x10 
    0x104c7ddac <+28>: ret

c. 分析

我们可以发现，前面三行指令不一样了。下面我们从调用方法断点开始调试

touchbegin

...
    0x102b7df1c <+76>:  bl     0x102b7e554               ; symbol stub for: objc_storeStrong
    0x102b7df20 <+80>:  mov    w10, #0x1
    0x102b7df24 <+84>:  mov    x0, x10
    0x102b7df28 <+88>:  mov    x1, x10
->  0x102b7df2c <+92>:  bl     0x102b7dd90               ; test_sum at ViewController.m:17
...

test_sum

DobbyDemo`test_sum:
    0x102b7dd90 <+0>:  adrp   x17, 0
    0x102b7dd94 <+4>:  add    x17, x17, #0xe74          ; =0xe74 
->  0x102b7dd98 <+8>:  br     x17
    0x102b7dd9c <+12>: ldr    w8, [sp, #0xc]
    0x102b7dda0 <+16>: ldr    w9, [sp, #0x8]
    0x102b7dda4 <+20>: add    w0, w8, w9
    0x102b7dda8 <+24>: add    sp, sp, #0x10             ; =0x10 
    0x102b7ddac <+28>: ret

(lldb) register read x17
     x17 = 0x0000000102b7de74  DobbyDemo`new_sum at ViewController.m:31

这里发现x17已经编程了new_sum了！跳到new_sum中了。

在调用原函数指针的时候才会继续执行->下面的指令

d. 原理

实际上是对一段Text进行了替换（内存中的）！
Text段无法修改！
原始MachO无变化！

五、将符号替换成地址

在实战的时候，更多情况下我们并不能像上面的Demo中一样简单的拿到方法进行替换。

所以我们需要将符号替换城地址！

5.1 定位函数地址

->  0x1025f1f3c <+84>:  mov    x0, x10
    0x1025f1f40 <+88>:  mov    x1, x10
    0x1025f1f44 <+92>:  bl     0x1025f1dc4               ; test_sum at ViewController.m:17

a.函数地址

通过汇编断点我们看到真实的函数地址为：0x1025f1dc4

b.MachO中的偏移量

我们可以通过函数地址定位到它在MachO中的偏移量

ASLR

(lldb) image list
[  0] 6B1471FE-409A-37F0-93ED-86FDFDEE421E 0x00000001025ec000 /Users/RyukieW/Library/Developer/Xcode/DerivedData/DobbyDemo-fyyzoosecpnxmcakyfrtrxocpawl/Build/Products/Debug-iphoneos/DobbyDemo.app/DobbyDemo

offset 0x1025f1dc4 - 0x00000001025ec000 = 0x5DC4

通过MachOView验证我们的计算没有问题。

5.2 代码实现上面的逆向流程

a.通过代码获取ASLR

uintptr_t aslr = _dyld_get_image_vmaddr_slide(0);

你可能会遇到下面的问题

Implicit declaration of function '_dyld_get_image_vmaddr_slide' is invalid in C99

#import <mach-o/dyld.h> 即可

b.获得函数在MachO中的Offset

通过断点调试计算出偏移量，记录下来

static uintptr_t addrSum = 0x100005D40;

c. 通过地址进行hook

完整HOOK代码：

static uintptr_t addrSum = 0x100005D40;
uintptr_t aslr = _dyld_get_image_vmaddr_slide(0);
addrSum += aslr;
DobbyHook((void *)addrSum, new_sum, (void *)&old_sum_p);

d. 结果

2021-05-21 11:30:34.318180+0800 DobbyDemo[5521:2140764] Hook了！正确的结果是：2
2021-05-21 11:30:34.318525+0800 DobbyDemo[5521:2140764] 结果：3

5.3 注意点

对于自己的工程，每次修改代码，都会导致MachO内的偏移量改变，所以调试的时候需要注意
- 调整变量内容不会变
对于IPA包，同一个IPA包是不会变的，但是不同版本的会不一样
- 所以插件的话只能针对某个特定版本

5.4 参考

利用纯地址进行HOOK

fishhook原理

Mon, 17 May 2021 00:00:00 GMT

参考：

GitHub-Fishhook

为源码添加注释

源码代码量不大，建议直接对照源码查看。

// Copyright (c) 2013, Facebook, Inc.
// All rights reserved.
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are met:
//   * Redistributions of source code must retain the above copyright notice,
//     this list of conditions and the following disclaimer.
//   * Redistributions in binary form must reproduce the above copyright notice,
//     this list of conditions and the following disclaimer in the documentation
//     and/or other materials provided with the distribution.
//   * Neither the name Facebook nor the names of its contributors may be used to
//     endorse or promote products derived from this software without specific
//     prior written permission.
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
// DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
// FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
// DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
// SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
// CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
// OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

#include "fishhook.h"

#include <dlfcn.h>
#include <stdbool.h>
#include <stdlib.h>
#include <string.h>
#include <sys/mman.h>
#include <sys/types.h>
#include <mach/mach.h>
#include <mach/vm_map.h>
#include <mach/vm_region.h>
#include <mach-o/dyld.h>
#include <mach-o/loader.h>
#include <mach-o/nlist.h>

#ifdef __LP64__
typedef struct mach_header_64 mach_header_t;
typedef struct segment_command_64 segment_command_t;
typedef struct section_64 section_t;
typedef struct nlist_64 nlist_t;
#define LC_SEGMENT_ARCH_DEPENDENT LC_SEGMENT_64
#else
typedef struct mach_header mach_header_t;
typedef struct segment_command segment_command_t;
typedef struct section section_t;
typedef struct nlist nlist_t;
#define LC_SEGMENT_ARCH_DEPENDENT LC_SEGMENT
#endif

#ifndef SEG_DATA_CONST
#define SEG_DATA_CONST  "__DATA_CONST"
#endif

struct rebindings_entry {
  struct rebinding *rebindings;
  size_t rebindings_nel;
  struct rebindings_entry *next;
};

static struct rebindings_entry *_rebindings_head;

static int prepend_rebindings(struct rebindings_entry **rebindings_head,
                              struct rebinding rebindings[],
                              size_t nel) {
  struct rebindings_entry *new_entry = (struct rebindings_entry *) malloc(sizeof(struct rebindings_entry));
  if (!new_entry) {
    return -1;
  }
  new_entry->rebindings = (struct rebinding *) malloc(sizeof(struct rebinding) * nel);
  if (!new_entry->rebindings) {
    free(new_entry);
    return -1;
  }
  memcpy(new_entry->rebindings, rebindings, sizeof(struct rebinding) * nel);
  new_entry->rebindings_nel = nel;
  new_entry->next = *rebindings_head;
  *rebindings_head = new_entry;
  return 0;
}

static vm_prot_t get_protection(void *sectionStart) {
  mach_port_t task = mach_task_self();
  vm_size_t size = 0;
  vm_address_t address = (vm_address_t)sectionStart;
  memory_object_name_t object;
#if __LP64__
  mach_msg_type_number_t count = VM_REGION_BASIC_INFO_COUNT_64;
  vm_region_basic_info_data_64_t info;
  kern_return_t info_ret = vm_region_64(
      task, &address, &size, VM_REGION_BASIC_INFO_64, (vm_region_info_64_t)&info, &count, &object);
#else
  mach_msg_type_number_t count = VM_REGION_BASIC_INFO_COUNT;
  vm_region_basic_info_data_t info;
  kern_return_t info_ret = vm_region(task, &address, &size, VM_REGION_BASIC_INFO, (vm_region_info_t)&info, &count, &object);
#endif
  if (info_ret == KERN_SUCCESS) {
    return info.protection;
  } else {
    return VM_PROT_READ;
  }
}


/// 终点：执行重绑定
/// @param rebindings 链表头
/// @param section -
/// @param slide aslr
/// @param symtab 符号表
/// @param strtab String表
/// @param indirect_symtab 间接符号表
static void perform_rebinding_with_section(struct rebindings_entry *rebindings,
                                           section_t *section,
                                           intptr_t slide,
                                           nlist_t *symtab,
                                           char *strtab,
                                           uint32_t *indirect_symtab) {
  const bool isDataConst = strcmp(section->segname, SEG_DATA_CONST) == 0;
    
    /**
     nl_symbol_ptr 和 la_symbol_ptresction 中的 reserved1 字段指明对应的 indirect symbol table 起始的 index
     */
  uint32_t *indirect_symbol_indices = indirect_symtab + section->reserved1;
    
    /**
     slide + section->addr 就是符号对应的存放函数的数组，相应的 __nl_symbol_ptr 和 __la_symbol_ptr 相应的函数指针都在这里面了，所以可以去寻找到函数的地址
     */
  void **indirect_symbol_bindings = (void **)((uintptr_t)slide + section->addr);
  vm_prot_t oldProtection = VM_PROT_READ;
  if (isDataConst) {
    oldProtection = get_protection(rebindings);
    mprotect(indirect_symbol_bindings, section->size, PROT_READ | PROT_WRITE);
  }
    // 遍历section里面的每一个符号
  for (uint i = 0; i < section->size / sizeof(void *); i++) {
      // 找到符号在Indirect symbol table 表中的值
      // 读取 indirect table 中的数据
    uint32_t symtab_index = indirect_symbol_indices[i];
    if (symtab_index == INDIRECT_SYMBOL_ABS || symtab_index == INDIRECT_SYMBOL_LOCAL ||
        symtab_index == (INDIRECT_SYMBOL_LOCAL   | INDIRECT_SYMBOL_ABS)) {
      continue;
    }
      // 以 symtab_index 作为下标，访问 symbol table
    uint32_t strtab_offset = symtab[symtab_index].n_un.n_strx;
      // 获取到 symbol_name
    char *symbol_name = strtab + strtab_offset;
      // 判断是否函数的名称是否有两个字符，因为函数前面有个"_"，所以方法名至少两个
    bool symbol_name_longer_than_1 = symbol_name[0] && symbol_name[1];
      // 遍历最初的链表，来进行hook
    struct rebindings_entry *cur = rebindings;
    while (cur) {
      for (uint j = 0; j < cur->rebindings_nel; j++) {
          
          // 判断 symbol_name[1]开始，两个函数的名字是否一致
        if (symbol_name_longer_than_1 &&
            strcmp(&symbol_name[1], cur->rebindings[j].name) == 0) {
            
            // 判断replaced的地址不为null以及我方法的实现和rebindings[j].replacement 的方法不一致
          if (cur->rebindings[j].replaced != NULL &&
              indirect_symbol_bindings[i] != cur->rebindings[j].replacement) {
              // 让 rebindings[j].replaced 保存 indirect_symbol_bindings[i] 的函数地址
            *(cur->rebindings[j].replaced) = indirect_symbol_bindings[i];
          }
            // 将替换后的方法给原先的方法，也就是替换内容为自定义函数地址
          indirect_symbol_bindings[i] = cur->rebindings[j].replacement;
          goto symbol_loop;
        }
      }
      cur = cur->next;
    }
  symbol_loop:;
  }
  if (isDataConst) {
    int protection = 0;
    if (oldProtection & VM_PROT_READ) {
      protection |= PROT_READ;
    }
    if (oldProtection & VM_PROT_WRITE) {
      protection |= PROT_WRITE;
    }
    if (oldProtection & VM_PROT_EXECUTE) {
      protection |= PROT_EXEC;
    }
    mprotect(indirect_symbol_bindings, section->size, protection);
  }
}


/// 绑定的核心函数
/// @param rebindings 链表头
/// @param header image的头
/// @param slide ASLR
static void rebind_symbols_for_image(struct rebindings_entry *rebindings,
                                     const struct mach_header *header,
                                     intptr_t slide) {
    /**
     dladdr() 这个函数就是在程序里面找header
     
     可确定指定的address，是否位于构成进程的地址空间的其中一个加载模块（可执行文件或共享库）内。
     
     如果某个地址，位于在其上面映射加载模块的基址，和为该加载模块映射的最高虚拟地址之间（包括两端），则认为改地址在加载模块的范围内。
     
     如果某个加载模块复合这个条件，则会搜索其动态符号表，以查找指定的address最接近的符号。
     最接近符号是指其值等于，或最为接近但小于指定address的符号
     
     如果指定的address不再其中一个模块的加载范围内的话，返回0，且不修改Dl_info结构的内容。否则将返回一个非零值，同时设置Dl_info结构的字段。
     
     如果在包含address的加载模块内，找不到其值小于或等于address的符号，则dlisname、dli_saddr和dli_size字段将设置为0，dli_bind字段设置为STB_LOCAL，dli_typs字段设置为STT_NOTYPE。
     
     */
  Dl_info info;
  if (dladdr(header, &info) == 0) {
    return;
  }
// 准备从macho里面去找
  segment_command_t *cur_seg_cmd;
  segment_command_t *linkedit_segment = NULL;
  struct symtab_command* symtab_cmd = NULL;
  struct dysymtab_command* dysymtab_cmd = NULL;
// 跳过header的大小，找到loadCommand
  uintptr_t cur = (uintptr_t)header + sizeof(mach_header_t);
  for (uint i = 0; i < header->ncmds; i++, cur += cur_seg_cmd->cmdsize) {
    cur_seg_cmd = (segment_command_t *)cur;
    if (cur_seg_cmd->cmd == LC_SEGMENT_ARCH_DEPENDENT) {
      if (strcmp(cur_seg_cmd->segname, SEG_LINKEDIT) == 0) {
        linkedit_segment = cur_seg_cmd;
      }
    } else if (cur_seg_cmd->cmd == LC_SYMTAB) {
      symtab_cmd = (struct symtab_command*)cur_seg_cmd;
    } else if (cur_seg_cmd->cmd == LC_DYSYMTAB) {
      dysymtab_cmd = (struct dysymtab_command*)cur_seg_cmd;
    }
  }
// 如果刚才获取的，有一项为空就直接返回
  if (!symtab_cmd || !dysymtab_cmd || !linkedit_segment ||
      !dysymtab_cmd->nindirectsyms) {
    return;
  }

    // 链接时程序的基址 = __LINKEDEDIT.VM_Address - __LINKEDIT.File_Offset + silde
  // Find base symbol/string table addresses
  uintptr_t linkedit_base = (uintptr_t)slide + linkedit_segment->vmaddr - linkedit_segment->fileoff;
  nlist_t *symtab = (nlist_t *)(linkedit_base + symtab_cmd->symoff);
  char *strtab = (char *)(linkedit_base + symtab_cmd->stroff);

    // 间接（动态）符号表的地址 = 基址 + 符号表偏移量
  // Get indirect symbol table (array of uint32_t indices into symbol table)
  uint32_t *indirect_symtab = (uint32_t *)(linkedit_base + dysymtab_cmd->indirectsymoff);

  cur = (uintptr_t)header + sizeof(mach_header_t);
  for (uint i = 0; i < header->ncmds; i++, cur += cur_seg_cmd->cmdsize) {
    cur_seg_cmd = (segment_command_t *)cur;
    if (cur_seg_cmd->cmd == LC_SEGMENT_ARCH_DEPENDENT) {
        // 找到Data段
      if (strcmp(cur_seg_cmd->segname, SEG_DATA) != 0 &&
          strcmp(cur_seg_cmd->segname, SEG_DATA_CONST) != 0) {
        continue;
      }
      for (uint j = 0; j < cur_seg_cmd->nsects; j++) {
        section_t *sect =
          (section_t *)(cur + sizeof(segment_command_t)) + j;
          // 找懒加载表
        if ((sect->flags & SECTION_TYPE) == S_LAZY_SYMBOL_POINTERS) {
          perform_rebinding_with_section(rebindings, sect, slide, symtab, strtab, indirect_symtab);
        }
          // 非懒加载表
        if ((sect->flags & SECTION_TYPE) == S_NON_LAZY_SYMBOL_POINTERS) {
          perform_rebinding_with_section(rebindings, sect, slide, symtab, strtab, indirect_symtab);
        }
      }
    }
  }
}

static void _rebind_symbols_for_image(const struct mach_header *header,
                                      intptr_t slide) {
    rebind_symbols_for_image(_rebindings_head, header, slide);
}

// 指定image进行hook
int rebind_symbols_image(void *header,
                         intptr_t slide,
                         struct rebinding rebindings[],
                         size_t rebindings_nel) {
    struct rebindings_entry *rebindings_head = NULL;
    int retval = prepend_rebindings(&rebindings_head, rebindings, rebindings_nel);
    // 这里就少了遍历所有image的操作了
    rebind_symbols_for_image(rebindings_head, (const struct mach_header *) header, slide);
    if (rebindings_head) {
      free(rebindings_head->rebindings);
    }
    free(rebindings_head);
    return retval;
}

/// 未指定image进行hook
int rebind_symbols(struct rebinding rebindings[], size_t rebindings_nel) {
    // prepend_rebindings 的函数会将整个 rebings 数组添加到 _rebindings_head 这个链表的头部
    // fishhook 采用链表的方式来存储每一次调用 rebind_sysbols传入的参数，每次调用，就会在链表的头部插入一个节点，链表的头部是：_rebindings_head
  int retval = prepend_rebindings(&_rebindings_head, rebindings, rebindings_nel);
    // 根据上面的 prepend_rebindings 来做判断，如果小于0的话，直接返回一个错误码回去
  if (retval < 0) {
    return retval;
  }
  // If this was the first call, register callback for image additions (which is also invoked for
  // existing images, otherwise, just run on existing images
    // 判断 _rebindings_head -> next是否为空，来判断是不是第一次调用
  if (!_rebindings_head->next) {
      // 第一次调用的话调用 _dyld_register_func_for_add_image 注册监听方法
      // 已经被 dyld加载的image会立即加入这个回调
      // 之后的image会在dyld装在的时候触发回调
    _dyld_register_func_for_add_image(_rebind_symbols_for_image);
  } else {
      // 遍历已经加载的image，进行hook
    uint32_t c = _dyld_image_count();
    for (uint32_t i = 0; i < c; i++) {
      _rebind_symbols_for_image(_dyld_get_image_header(i), _dyld_get_image_vmaddr_slide(i));
    }
  }
  return retval;
}

总结

rebind_symbols
- rebindings数组添加到链表
- 根据链表判断是否第一次调用，这么做的目的是保证注册方法只会调用一次。两种情况都是为了回调_rebind_symbols_for_image
  - 第一次
    - 利用_dyld_register_func_for_add_image注册监听方法：_rebind_symbols_for_image
  - 不是第一次
    - 循环遍历已经加载的iamge，进行 _rebind_symbols_for_image 回调
_rebind_symbols_for_image
- 第一步
  - 拿到三张表在内存中的地址
    - 符号表地址：symtab
    - 字符串表地址：strtab
    - 动态（间接）符号表地址：indirect_symtab
- 第二步
  - 找懒加载和非懒加载表
- 第三部
  - 调用perform_rebinding_with_section
perform_rebinding_with_section
- 1.得到indirect_symn=bol_bindings
- 2.遍历间接符号表，找到符号
- 3.判断是否是需要hook的
- 4.保存函数指针，然后替换懒加载符号表中的函数地址
完成Hook。

反HOOK防护（一）：基于Fishhook

Mon, 17 May 2021 00:00:00 GMT

一、用Fishhook进行防护

我们需要防护别人的Hook，但是保留自己的Hook。

1.1 在哪里防护

a.Framework里

工程中的Load在Framework里的Load之后调用
别人注入的Hook代码的Load在Framework之后，工程之前
- 有点疑问，这里的Framework是动态库么？

1.2 操作一下

a. 创建一个Framework

b. 引入fishhook、objc/message.h

c. 在Framework中创建一个类，防护 `method_exchangeImplementations`

+ (void)load {
    struct rebinding exchange;
    
    exchange.name = "method_exchangeImplementations";
    exchange.replacement = my_axchange;
    exchange.replaced = (void *)&sysExchangePoint;
    
    struct rebinding bds[] = { exchange };
    
    rebind_symbols(bds, 1);
}

// 保存原函数的指针，这个可以暴露给自己使用
void (*sysExchangePoint)(Method _Nonnull methA, Method _Nonnull methB);

void my_axchange(Method _Nonnull methA, Method _Nonnull methB) {
    NSLog(@"⚠️检测到了Hook！");
}

d. 注入

04.利用Xcode进行重签名与调试

05.dylib注入

效果：

1.3 缺点

a. 字符串

因为我们用到了method_exchangeImplementations这样一个字符串，一旦被逆向工程师找到，很容易定位到防护代码。

b. 时间

这个防护方案是基于调用时间来进行防护的，如果找到fishhook的相关调用，进行相关操作，会被破解掉。

c. get set IMP 没处理

反HOOK防护（二）：Monkey

Mon, 17 May 2021 00:00:00 GMT

一、安装：MonkeyDev

GitHub-MonkeyDev

安装完成后，重启Xcode，就可以看到有个MonkeyDev

二、重签名

创建一个MonkeyApp，我们看到目录下有个TargetApp，将需要重签名的ipa包或者app文件放进去。并将Demo给为自己的一个可用的BundleID，运行即可！

三、Hook：Logos语法

Logos

我们可以看到这个文件，没有高亮。

在这里改一下类型为ObjectiveC++Source，切换一下文件就可以了。

3.1 试着Hook上一篇中我们做了防护的项目

这里我们准备HookViewController的actionA

a. 将编译出的app文件放进TargetApp目录下

b. 用Logos语法写Hook代码

#import <UIKit/UIKit.h>

%hook ViewController

- (void)actionA:(id)sender {
    NSLog(@"action-A-(Hooked!)");
}

%end

就这么简单！

c. 运行查看Log

2021-05-16 23:10:24.635341+0800 AntiHook[3859:1526960] ⚠️检测到了Hook！
2021-05-16 23:10:24.635477+0800 AntiHook[3859:1526960] ⚠️检测到了Hook！
2021-05-16 23:10:24.635519+0800 AntiHook[3859:1526960] [AntiAntiDebug Init]
               🎉!!！congratulations!!！🎉
👍----------------insert dylib success----------------👍
[MethodTrace] 
📚--------------------OCMethodTrace(Usage)-------------------📚
https://github.com/omxcodec/OCMethodTrace/blob/master/README.md
📚--------------------OCMethodTrace(Usage)-------------------📚
[MethodTrace] logLevel: 0: logWhen: 0 traceFlag: 2 traceObject: 0(未指定类)
[MethodTrace] Method Trace is disabled

Download cycript(https://cydia.saurik.com/api/latest/3) then run: ./cycript -r 192.168.0.102:6666

2021-05-16 23:10:24.915464+0800 AntiHook[3859:1526960] result: <UIApplication: 0x1017100d0>
2021-05-16 23:10:24.996174+0800 AntiHook[3859:1526960]  INFO: Reveal Server started (Protocol Version 43).
2021-05-16 23:10:33.341774+0800 AntiHook[3859:1526960] action-A-(Hooked!)

虽然我们的防护代码检测到了Hook，但是依然成功了。

d. 思考

这里我们使用反HOOK防护（一）中的技术去进行防护，并没有成功防护到Monkey的Hook。我们大概可以推测出：它使用的是Set和Get进行的Hook！

下面我们针对Set Get进行一下防护验证我们的想法！

四、Set/Get Hook防护

这里我们简单修改下防护代码。

+ (void)load {
    struct rebinding exchange;
    exchange.name = "method_exchangeImplementations";
    exchange.replacement = my_exchange;
    exchange.replaced = (void *)&sysExchangePoint;
    
    struct rebinding get;
    get.name = "method_getImplementation";
    get.replacement = my_get;
    get.replaced = (void *)&sysExchangePoint;

    struct rebinding set;
    set.name = "method_setImplementation";
    set.replacement = my_set;
    set.replaced = (void *)&sysExchangePoint;
    
    struct rebinding bds[] = { exchange, get, set };
    
    rebind_symbols(bds, 3);
}

// 保存原函数的指针，这个可以暴露给自己使用
void (*sysExchangePoint)(Method _Nonnull methA, Method _Nonnull methB);

void my_exchange(Method _Nonnull methA, Method _Nonnull methB) {
    NSLog(@"⚠️检测到了Hook！-method_exchangeImplementations");
}

void my_get(Method _Nonnull methA, Method _Nonnull methB) {
    NSLog(@"⚠️检测到了Hook！-method_getImplementation");
}

void my_set(Method _Nonnull methA, Method _Nonnull methB) {
    NSLog(@"⚠️检测到了Hook！-method_setImplementation");
}

4.1 防护成果

2021-05-17 23:25:17.892661+0800 AntiHook[3999:1630972] ⚠️检测到了Hook！-method_getImplementation
2021-05-17 23:25:17.892798+0800 AntiHook[3999:1630972] ⚠️检测到了Hook！-method_exchangeImplementations
2021-05-17 23:25:17.892840+0800 AntiHook[3999:1630972] ⚠️检测到了Hook！-method_getImplementation
2021-05-17 23:25:17.892874+0800 AntiHook[3999:1630972] ⚠️检测到了Hook！-method_exchangeImplementations
2021-05-17 23:25:17.892912+0800 AntiHook[3999:1630972] [AntiAntiDebug Init]
               🎉!!！congratulations!!！🎉
👍----------------insert dylib success----------------👍
2021-05-17 23:25:17.914757+0800 AntiHook[3999:1630972] ⚠️检测到了Hook！-method_getImplementation
2021-05-17 23:25:17.914913+0800 AntiHook[3999:1630972] ⚠️检测到了Hook！-method_setImplementation
[MethodTrace] 
...
2021-05-17 23:25:26.987849+0800 AntiHook[3999:1630972] action-A
2021-05-17 23:25:27.952512+0800 AntiHook[3999:1630972] action-A
2021-05-17 23:25:28.803100+0800 AntiHook[3999:1630972] action-B
2021-05-17 23:25:29.170666+0800 AntiHook[3999:1630972] action-B

可以看到我们的set/get防护代码被触发了，并且输出了点击按钮输出了正确的Log！防护成功！也验证了我们的想法：Monkey的Hook是基于Get/Set的

去符号与恢复符号

Sun, 16 May 2021 00:00:00 GMT

一、去符号

我们在做逆向的时候，App的符号都被去掉了，所以我们需要对符号进行符号恢复。去符号会使应用包更小。

动态库：保留全局符号

1.1 设置去符号的类型

Deployment Postprocessing
- YES: 编译也去符号
- NO: 只在打包时去符号
Strip Style
- All Symbols
  - 所有符号
- Non-Global Symbols
  - 除了全局符号
- Debugging Symbols
  - 调试符号

1.2 去符号前后的MachO

a.去符号之前

b.去符号之后

只剩下间接符号和一个全局、一个本地

1.3 函数的实现地址

这里是函数的实现地址
- 间接符号的地址这里全是0，调用的时候会先去找桩
- 详情参考
去符号之前可以看到全局符和本地符号的地址

二、符号类型

3.1 全局符号

我们定义的基本都是全集符号

3.2 本地符号

static 是本地符号

3.3 命令查看类型

objdump --macho -t 你的macho文件名

SymbolBind:
SYMBOL TABLE:
0000000100005f18 l     F __TEXT,__text -[ViewController viewDidLoad]
0000000100005f88 l     F __TEXT,__text -[ViewController test]
0000000100005fd0 l     F __TEXT,__text -[AppDelegate application:didFinishLaunchingWithOptions:]
000000010000604c l     F __TEXT,__text -[AppDelegate application:configurationForConnectingSceneSession:options:]
000000010000614c l     F __TEXT,__text -[AppDelegate application:didDiscardSceneSessions:]
000000010000625c l     F __TEXT,__text -[SceneDelegate scene:willConnectToSession:options:]
00000001000062f8 l     F __TEXT,__text -[SceneDelegate sceneDidDisconnect:]
0000000100006344 l     F __TEXT,__text -[SceneDelegate sceneDidBecomeActive:]
0000000100006390 l     F __TEXT,__text -[SceneDelegate sceneWillResignActive:]
00000001000063dc l     F __TEXT,__text -[SceneDelegate sceneWillEnterForeground:]
0000000100006428 l     F __TEXT,__text -[SceneDelegate sceneDidEnterBackground:]
0000000100006474 l     F __TEXT,__text -[SceneDelegate window]
0000000100006498 l     F __TEXT,__text -[SceneDelegate setWindow:]
00000001000064d4 l     F __TEXT,__text -[SceneDelegate .cxx_destruct]
00000001000080c0  w    O __DATA_CONST,__objc_protolist __OBJC_LABEL_PROTOCOL_$_NSObject
00000001000080c8  w    O __DATA_CONST,__objc_protolist __OBJC_LABEL_PROTOCOL_$_UIApplicationDelegate
00000001000080d0  w    O __DATA_CONST,__objc_protolist __OBJC_LABEL_PROTOCOL_$_UISceneDelegate
00000001000080d8  w    O __DATA_CONST,__objc_protolist __OBJC_LABEL_PROTOCOL_$_UIWindowSceneDelegate
000000010000c068 l     O __DATA,__objc_const __OBJC_METACLASS_RO_$_ViewController
000000010000c0b0 l     O __DATA,__objc_const __OBJC_$_INSTANCE_METHODS_ViewController
000000010000c0e8 l     O __DATA,__objc_const __OBJC_CLASS_RO_$_ViewController
000000010000c130 l     O __DATA,__objc_const __OBJC_$_PROTOCOL_INSTANCE_METHODS_NSObject
000000010000c300 l     O __DATA,__objc_const __OBJC_$_PROTOCOL_INSTANCE_METHODS_OPT_NSObject
000000010000c320 l     O __DATA,__objc_const __OBJC_$_PROP_LIST_NSObject
000000010000c368 l     O __DATA,__objc_const __OBJC_$_PROTOCOL_METHOD_TYPES_NSObject
000000010000c408 l     O __DATA,__objc_const __OBJC_$_PROTOCOL_REFS_UIApplicationDelegate
000000010000c420 l     O __DATA,__objc_const __OBJC_$_PROTOCOL_INSTANCE_METHODS_OPT_UIApplicationDelegate
000000010000c938 l     O __DATA,__objc_const __OBJC_$_PROP_LIST_UIApplicationDelegate
000000010000c950 l     O __DATA,__objc_const __OBJC_$_PROTOCOL_METHOD_TYPES_UIApplicationDelegate
000000010000cb00 l     O __DATA,__objc_const __OBJC_CLASS_PROTOCOLS_$_AppDelegate
000000010000cb18 l     O __DATA,__objc_const __OBJC_METACLASS_RO_$_AppDelegate
000000010000cb60 l     O __DATA,__objc_const __OBJC_$_INSTANCE_METHODS_AppDelegate
000000010000cbb0 l     O __DATA,__objc_const __OBJC_$_PROP_LIST_AppDelegate
000000010000cc08 l     O __DATA,__objc_const __OBJC_CLASS_RO_$_AppDelegate
000000010000cc50 l     O __DATA,__objc_const __OBJC_$_PROTOCOL_INSTANCE_METHODS_NSObject
000000010000ce20 l     O __DATA,__objc_const __OBJC_$_PROTOCOL_INSTANCE_METHODS_OPT_NSObject
000000010000ce40 l     O __DATA,__objc_const __OBJC_$_PROP_LIST_NSObject
000000010000ce88 l     O __DATA,__objc_const __OBJC_$_PROTOCOL_METHOD_TYPES_NSObject
000000010000cf28 l     O __DATA,__objc_const __OBJC_$_PROTOCOL_REFS_UISceneDelegate
000000010000cf40 l     O __DATA,__objc_const __OBJC_$_PROTOCOL_INSTANCE_METHODS_OPT_UISceneDelegate
000000010000d068 l     O __DATA,__objc_const __OBJC_$_PROTOCOL_METHOD_TYPES_UISceneDelegate
000000010000d0c8 l     O __DATA,__objc_const __OBJC_$_PROTOCOL_REFS_UIWindowSceneDelegate
000000010000d0e0 l     O __DATA,__objc_const __OBJC_$_PROTOCOL_INSTANCE_METHODS_OPT_UIWindowSceneDelegate
000000010000d160 l     O __DATA,__objc_const __OBJC_$_PROP_LIST_UIWindowSceneDelegate
000000010000d178 l     O __DATA,__objc_const __OBJC_$_PROTOCOL_METHOD_TYPES_UIWindowSceneDelegate
000000010000d1a0 l     O __DATA,__objc_const __OBJC_CLASS_PROTOCOLS_$_SceneDelegate
000000010000d1b8 l     O __DATA,__objc_const __OBJC_METACLASS_RO_$_SceneDelegate
000000010000d200 l     O __DATA,__objc_const __OBJC_$_INSTANCE_METHODS_SceneDelegate
000000010000d2e0 l     O __DATA,__objc_const __OBJC_$_INSTANCE_VARIABLES_SceneDelegate
000000010000d308 l     O __DATA,__objc_const __OBJC_$_PROP_LIST_SceneDelegate
000000010000d360 l     O __DATA,__objc_const __OBJC_CLASS_RO_$_SceneDelegate
000000010000d3e0 l     O __DATA,__objc_ivar _OBJC_IVAR_$_SceneDelegate._window
000000010000d4d8 l     O __DATA,__data __dyld_private
000000010000d4e0  w    O __DATA,__data __OBJC_PROTOCOL_$_NSObject
000000010000d540  w    O __DATA,__data __OBJC_PROTOCOL_$_UIApplicationDelegate
000000010000d5a0  w    O __DATA,__data __OBJC_PROTOCOL_$_UISceneDelegate
000000010000d600  w    O __DATA,__data __OBJC_PROTOCOL_$_UIWindowSceneDelegate
0000000000000000      d  *UND* /Users/RyukieW/RyukieSamaProject/Study/逆向/Code/SymbolBind/SymbolBind/
0000000000000000      d  *UND* ViewController.m
0000000060a0b161      d  *UND* /Users/RyukieW/Library/Developer/Xcode/DerivedData/SymbolBind-bhluvjpsukewfxgsouyiwqlmcntk/Build/Intermediates.noindex/SymbolBind.build/Debug-iphoneos/SymbolBind.build/Objects-normal/arm64/ViewController.o
0000000100005f18      d  *UND*
0000000100005f18      d  *UND* -[ViewController viewDidLoad]
0000000000000070      d  *UND*
0000000000000070      d  *UND*
0000000100005f88      d  *UND*
0000000100005f88      d  *UND* -[ViewController test]
000000000000002c      d  *UND*
000000000000002c      d  *UND*
0000000100005fb4      d  *UND*
0000000100005fb4      d  *UND* _testLocalFunction
000000000000001c      d  *UND*
000000000000001c      d  *UND*
000000010000c068      d  *UND* __OBJC_METACLASS_RO_$_ViewController
000000010000c0b0      d  *UND* __OBJC_$_INSTANCE_METHODS_ViewController
000000010000c0e8      d  *UND* __OBJC_CLASS_RO_$_ViewController
0000000000000000      d  *UND* _OBJC_CLASS_$_ViewController
0000000000000000      d  *UND* _OBJC_METACLASS_$_ViewController
0000000000000000      d  *UND*
0000000000000000      d  *UND* /Users/RyukieW/RyukieSamaProject/Study/逆向/Code/SymbolBind/SymbolBind/
0000000000000000      d  *UND* AppDelegate.m
0000000060a0b161      d  *UND* /Users/RyukieW/Library/Developer/Xcode/DerivedData/SymbolBind-bhluvjpsukewfxgsouyiwqlmcntk/Build/Intermediates.noindex/SymbolBind.build/Debug-iphoneos/SymbolBind.build/Objects-normal/arm64/AppDelegate.o
0000000100005fd0      d  *UND*
0000000100005fd0      d  *UND* -[AppDelegate application:didFinishLaunchingWithOptions:]
000000000000007c      d  *UND*
000000000000007c      d  *UND*
000000010000604c      d  *UND*
000000010000604c      d  *UND* -[AppDelegate application:configurationForConnectingSceneSession:options:]
0000000000000100      d  *UND*
0000000000000100      d  *UND*
000000010000614c      d  *UND*
000000010000614c      d  *UND* -[AppDelegate application:didDiscardSceneSessions:]
0000000000000074      d  *UND*
0000000000000074      d  *UND*
0000000000000000      d  *UND* __OBJC_LABEL_PROTOCOL_$_NSObject
0000000000000000      d  *UND* __OBJC_LABEL_PROTOCOL_$_UIApplicationDelegate
000000010000c130      d  *UND* __OBJC_$_PROTOCOL_INSTANCE_METHODS_NSObject
000000010000c300      d  *UND* __OBJC_$_PROTOCOL_INSTANCE_METHODS_OPT_NSObject
000000010000c320      d  *UND* __OBJC_$_PROP_LIST_NSObject
000000010000c368      d  *UND* __OBJC_$_PROTOCOL_METHOD_TYPES_NSObject
000000010000c408      d  *UND* __OBJC_$_PROTOCOL_REFS_UIApplicationDelegate
000000010000c420      d  *UND* __OBJC_$_PROTOCOL_INSTANCE_METHODS_OPT_UIApplicationDelegate
000000010000c938      d  *UND* __OBJC_$_PROP_LIST_UIApplicationDelegate
000000010000c950      d  *UND* __OBJC_$_PROTOCOL_METHOD_TYPES_UIApplicationDelegate
000000010000cb00      d  *UND* __OBJC_CLASS_PROTOCOLS_$_AppDelegate
000000010000cb18      d  *UND* __OBJC_METACLASS_RO_$_AppDelegate
000000010000cb60      d  *UND* __OBJC_$_INSTANCE_METHODS_AppDelegate
000000010000cbb0      d  *UND* __OBJC_$_PROP_LIST_AppDelegate
000000010000cc08      d  *UND* __OBJC_CLASS_RO_$_AppDelegate
0000000000000000      d  *UND* _OBJC_METACLASS_$_AppDelegate
0000000000000000      d  *UND* _OBJC_CLASS_$_AppDelegate
0000000000000000      d  *UND* __OBJC_PROTOCOL_$_NSObject
0000000000000000      d  *UND* __OBJC_PROTOCOL_$_UIApplicationDelegate
0000000000000000      d  *UND*
0000000000000000      d  *UND* /Users/RyukieW/RyukieSamaProject/Study/逆向/Code/SymbolBind/SymbolBind/
0000000000000000      d  *UND* main.m
0000000060a0b161      d  *UND* /Users/RyukieW/Library/Developer/Xcode/DerivedData/SymbolBind-bhluvjpsukewfxgsouyiwqlmcntk/Build/Intermediates.noindex/SymbolBind.build/Debug-iphoneos/SymbolBind.build/Objects-normal/arm64/main.o
00000001000061c0      d  *UND*
00000001000061c0      d  *UND* _main
000000000000009c      d  *UND*
000000000000009c      d  *UND*
0000000000000000      d  *UND*
0000000000000000      d  *UND* /Users/RyukieW/RyukieSamaProject/Study/逆向/Code/SymbolBind/SymbolBind/
0000000000000000      d  *UND* SceneDelegate.m
0000000060a0b161      d  *UND* /Users/RyukieW/Library/Developer/Xcode/DerivedData/SymbolBind-bhluvjpsukewfxgsouyiwqlmcntk/Build/Intermediates.noindex/SymbolBind.build/Debug-iphoneos/SymbolBind.build/Objects-normal/arm64/SceneDelegate.o
000000010000625c      d  *UND*
000000010000625c      d  *UND* -[SceneDelegate scene:willConnectToSession:options:]
000000000000009c      d  *UND*
000000000000009c      d  *UND*
00000001000062f8      d  *UND*
00000001000062f8      d  *UND* -[SceneDelegate sceneDidDisconnect:]
000000000000004c      d  *UND*
000000000000004c      d  *UND*
0000000100006344      d  *UND*
0000000100006344      d  *UND* -[SceneDelegate sceneDidBecomeActive:]
000000000000004c      d  *UND*
000000000000004c      d  *UND*
0000000100006390      d  *UND*
0000000100006390      d  *UND* -[SceneDelegate sceneWillResignActive:]
000000000000004c      d  *UND*
000000000000004c      d  *UND*
00000001000063dc      d  *UND*
00000001000063dc      d  *UND* -[SceneDelegate sceneWillEnterForeground:]
000000000000004c      d  *UND*
000000000000004c      d  *UND*
0000000100006428      d  *UND*
0000000100006428      d  *UND* -[SceneDelegate sceneDidEnterBackground:]
000000000000004c      d  *UND*
000000000000004c      d  *UND*
0000000100006474      d  *UND*
0000000100006474      d  *UND* -[SceneDelegate window]
0000000000000024      d  *UND*
0000000000000024      d  *UND*
0000000100006498      d  *UND*
0000000100006498      d  *UND* -[SceneDelegate setWindow:]
000000000000003c      d  *UND*
000000000000003c      d  *UND*
00000001000064d4      d  *UND*
00000001000064d4      d  *UND* -[SceneDelegate .cxx_destruct]
000000000000003c      d  *UND*
000000000000003c      d  *UND*
0000000000000000      d  *UND* __OBJC_LABEL_PROTOCOL_$_UISceneDelegate
0000000000000000      d  *UND* __OBJC_LABEL_PROTOCOL_$_UIWindowSceneDelegate
000000010000cc50      d  *UND* __OBJC_$_PROTOCOL_INSTANCE_METHODS_NSObject
000000010000ce20      d  *UND* __OBJC_$_PROTOCOL_INSTANCE_METHODS_OPT_NSObject
000000010000ce40      d  *UND* __OBJC_$_PROP_LIST_NSObject
000000010000ce88      d  *UND* __OBJC_$_PROTOCOL_METHOD_TYPES_NSObject
000000010000cf28      d  *UND* __OBJC_$_PROTOCOL_REFS_UISceneDelegate
000000010000cf40      d  *UND* __OBJC_$_PROTOCOL_INSTANCE_METHODS_OPT_UISceneDelegate
000000010000d068      d  *UND* __OBJC_$_PROTOCOL_METHOD_TYPES_UISceneDelegate
000000010000d0c8      d  *UND* __OBJC_$_PROTOCOL_REFS_UIWindowSceneDelegate
000000010000d0e0      d  *UND* __OBJC_$_PROTOCOL_INSTANCE_METHODS_OPT_UIWindowSceneDelegate
000000010000d160      d  *UND* __OBJC_$_PROP_LIST_UIWindowSceneDelegate
000000010000d178      d  *UND* __OBJC_$_PROTOCOL_METHOD_TYPES_UIWindowSceneDelegate
000000010000d1a0      d  *UND* __OBJC_CLASS_PROTOCOLS_$_SceneDelegate
000000010000d1b8      d  *UND* __OBJC_METACLASS_RO_$_SceneDelegate
000000010000d200      d  *UND* __OBJC_$_INSTANCE_METHODS_SceneDelegate
000000010000d2e0      d  *UND* __OBJC_$_INSTANCE_VARIABLES_SceneDelegate
000000010000d308      d  *UND* __OBJC_$_PROP_LIST_SceneDelegate
000000010000d360      d  *UND* __OBJC_CLASS_RO_$_SceneDelegate
0000000000000000      d  *UND* _OBJC_IVAR_$_SceneDelegate._window
0000000000000000      d  *UND* _OBJC_METACLASS_$_SceneDelegate
0000000000000000      d  *UND* _OBJC_CLASS_$_SceneDelegate
0000000000000000      d  *UND* __OBJC_PROTOCOL_$_UISceneDelegate
0000000000000000      d  *UND* __OBJC_PROTOCOL_$_UIWindowSceneDelegate
0000000000000000      d  *UND*
000000010000d460 g     O __DATA,__objc_data _OBJC_CLASS_$_AppDelegate
000000010000d4b0 g     O __DATA,__objc_data _OBJC_CLASS_$_SceneDelegate
000000010000d3e8 g     O __DATA,__objc_data _OBJC_CLASS_$_ViewController
000000010000d438 g     O __DATA,__objc_data _OBJC_METACLASS_$_AppDelegate
000000010000d488 g     O __DATA,__objc_data _OBJC_METACLASS_$_SceneDelegate
000000010000d410 g     O __DATA,__objc_data _OBJC_METACLASS_$_ViewController
0000000100000000 g     F __TEXT,__text __mh_execute_header
00000001000061c0 g     F __TEXT,__text _main
0000000100005fb4 g     F __TEXT,__text _testLocalFunction
0000000000000000         *UND* _NSLog
0000000000000000         *UND* _NSStringFromClass
0000000000000000         *UND* _OBJC_CLASS_$_UIResponder
0000000000000000         *UND* _OBJC_CLASS_$_UISceneConfiguration
0000000000000000         *UND* _OBJC_CLASS_$_UIViewController
0000000000000000         *UND* _OBJC_METACLASS_$_NSObject
0000000000000000         *UND* _OBJC_METACLASS_$_UIResponder
0000000000000000         *UND* _OBJC_METACLASS_$_UIViewController
0000000000000000         *UND* _UIApplicationMain
0000000000000000         *UND* ___CFConstantStringClassReference
0000000000000000         *UND* __objc_empty_cache
0000000000000000         *UND* _objc_alloc
0000000000000000         *UND* _objc_autoreleasePoolPop
0000000000000000         *UND* _objc_autoreleasePoolPush
0000000000000000         *UND* _objc_autoreleaseReturnValue
0000000000000000         *UND* _objc_msgSend
0000000000000000         *UND* _objc_msgSendSuper2
0000000000000000         *UND* _objc_opt_class
0000000000000000         *UND* _objc_release
0000000000000000         *UND* _objc_retainAutoreleasedReturnValue
0000000000000000         *UND* _objc_storeStrong
0000000000000000         *UND* dyld_stub_binder
➜  11 clear
➜  11 objdump --macho -t SymbolBind
SymbolBind:
SYMBOL TABLE:
0000000100005f10 l     F __TEXT,__text -[ViewController viewDidLoad]
0000000100005f80 l     F __TEXT,__text -[ViewController test]
0000000100005fc8 l     F __TEXT,__text -[AppDelegate application:didFinishLaunchingWithOptions:]
0000000100006044 l     F __TEXT,__text -[AppDelegate application:configurationForConnectingSceneSession:options:]
0000000100006144 l     F __TEXT,__text -[AppDelegate application:didDiscardSceneSessions:]
0000000100006254 l     F __TEXT,__text -[SceneDelegate scene:willConnectToSession:options:]
00000001000062f0 l     F __TEXT,__text -[SceneDelegate sceneDidDisconnect:]
000000010000633c l     F __TEXT,__text -[SceneDelegate sceneDidBecomeActive:]
0000000100006388 l     F __TEXT,__text -[SceneDelegate sceneWillResignActive:]
00000001000063d4 l     F __TEXT,__text -[SceneDelegate sceneWillEnterForeground:]
0000000100006420 l     F __TEXT,__text -[SceneDelegate sceneDidEnterBackground:]
000000010000646c l     F __TEXT,__text -[SceneDelegate window]
0000000100006490 l     F __TEXT,__text -[SceneDelegate setWindow:]
00000001000064cc l     F __TEXT,__text -[SceneDelegate .cxx_destruct]
00000001000080c0  w    O __DATA_CONST,__objc_protolist __OBJC_LABEL_PROTOCOL_$_NSObject
00000001000080c8  w    O __DATA_CONST,__objc_protolist __OBJC_LABEL_PROTOCOL_$_UIApplicationDelegate
00000001000080d0  w    O __DATA_CONST,__objc_protolist __OBJC_LABEL_PROTOCOL_$_UISceneDelegate
00000001000080d8  w    O __DATA_CONST,__objc_protolist __OBJC_LABEL_PROTOCOL_$_UIWindowSceneDelegate
000000010000c068 l     O __DATA,__objc_const __OBJC_METACLASS_RO_$_ViewController
000000010000c0b0 l     O __DATA,__objc_const __OBJC_$_INSTANCE_METHODS_ViewController
000000010000c0e8 l     O __DATA,__objc_const __OBJC_CLASS_RO_$_ViewController
000000010000c130 l     O __DATA,__objc_const __OBJC_$_PROTOCOL_INSTANCE_METHODS_NSObject
000000010000c300 l     O __DATA,__objc_const __OBJC_$_PROTOCOL_INSTANCE_METHODS_OPT_NSObject
000000010000c320 l     O __DATA,__objc_const __OBJC_$_PROP_LIST_NSObject
000000010000c368 l     O __DATA,__objc_const __OBJC_$_PROTOCOL_METHOD_TYPES_NSObject
000000010000c408 l     O __DATA,__objc_const __OBJC_$_PROTOCOL_REFS_UIApplicationDelegate
000000010000c420 l     O __DATA,__objc_const __OBJC_$_PROTOCOL_INSTANCE_METHODS_OPT_UIApplicationDelegate
000000010000c938 l     O __DATA,__objc_const __OBJC_$_PROP_LIST_UIApplicationDelegate
000000010000c950 l     O __DATA,__objc_const __OBJC_$_PROTOCOL_METHOD_TYPES_UIApplicationDelegate
000000010000cb00 l     O __DATA,__objc_const __OBJC_CLASS_PROTOCOLS_$_AppDelegate
000000010000cb18 l     O __DATA,__objc_const __OBJC_METACLASS_RO_$_AppDelegate
000000010000cb60 l     O __DATA,__objc_const __OBJC_$_INSTANCE_METHODS_AppDelegate
000000010000cbb0 l     O __DATA,__objc_const __OBJC_$_PROP_LIST_AppDelegate
000000010000cc08 l     O __DATA,__objc_const __OBJC_CLASS_RO_$_AppDelegate
000000010000cc50 l     O __DATA,__objc_const __OBJC_$_PROTOCOL_INSTANCE_METHODS_NSObject
000000010000ce20 l     O __DATA,__objc_const __OBJC_$_PROTOCOL_INSTANCE_METHODS_OPT_NSObject
000000010000ce40 l     O __DATA,__objc_const __OBJC_$_PROP_LIST_NSObject
000000010000ce88 l     O __DATA,__objc_const __OBJC_$_PROTOCOL_METHOD_TYPES_NSObject
000000010000cf28 l     O __DATA,__objc_const __OBJC_$_PROTOCOL_REFS_UISceneDelegate
000000010000cf40 l     O __DATA,__objc_const __OBJC_$_PROTOCOL_INSTANCE_METHODS_OPT_UISceneDelegate
000000010000d068 l     O __DATA,__objc_const __OBJC_$_PROTOCOL_METHOD_TYPES_UISceneDelegate
000000010000d0c8 l     O __DATA,__objc_const __OBJC_$_PROTOCOL_REFS_UIWindowSceneDelegate
000000010000d0e0 l     O __DATA,__objc_const __OBJC_$_PROTOCOL_INSTANCE_METHODS_OPT_UIWindowSceneDelegate
000000010000d160 l     O __DATA,__objc_const __OBJC_$_PROP_LIST_UIWindowSceneDelegate
000000010000d178 l     O __DATA,__objc_const __OBJC_$_PROTOCOL_METHOD_TYPES_UIWindowSceneDelegate
000000010000d1a0 l     O __DATA,__objc_const __OBJC_CLASS_PROTOCOLS_$_SceneDelegate
000000010000d1b8 l     O __DATA,__objc_const __OBJC_METACLASS_RO_$_SceneDelegate
000000010000d200 l     O __DATA,__objc_const __OBJC_$_INSTANCE_METHODS_SceneDelegate
000000010000d2e0 l     O __DATA,__objc_const __OBJC_$_INSTANCE_VARIABLES_SceneDelegate
000000010000d308 l     O __DATA,__objc_const __OBJC_$_PROP_LIST_SceneDelegate
000000010000d360 l     O __DATA,__objc_const __OBJC_CLASS_RO_$_SceneDelegate
000000010000d3e0 l     O __DATA,__objc_ivar _OBJC_IVAR_$_SceneDelegate._window
000000010000d4d8 l     O __DATA,__data __dyld_private
000000010000d4e0  w    O __DATA,__data __OBJC_PROTOCOL_$_NSObject
000000010000d540  w    O __DATA,__data __OBJC_PROTOCOL_$_UIApplicationDelegate
000000010000d5a0  w    O __DATA,__data __OBJC_PROTOCOL_$_UISceneDelegate
000000010000d600  w    O __DATA,__data __OBJC_PROTOCOL_$_UIWindowSceneDelegate
0000000000000000      d  *UND* /Users/RyukieW/RyukieSamaProject/Study/逆向/Code/SymbolBind/SymbolBind/
0000000000000000      d  *UND* ViewController.m
0000000060a0b259      d  *UND* /Users/RyukieW/Library/Developer/Xcode/DerivedData/SymbolBind-bhluvjpsukewfxgsouyiwqlmcntk/Build/Intermediates.noindex/SymbolBind.build/Debug-iphoneos/SymbolBind.build/Objects-normal/arm64/ViewController.o
0000000100005f10      d  *UND*
0000000100005f10      d  *UND* -[ViewController viewDidLoad]
0000000000000070      d  *UND*
0000000000000070      d  *UND*
0000000100005f80      d  *UND*
0000000100005f80      d  *UND* -[ViewController test]
000000000000002c      d  *UND*
000000000000002c      d  *UND*
0000000100005fac      d  *UND*
0000000100005fac      d  *UND* _testGlobalFunction
000000000000001c      d  *UND*
000000000000001c      d  *UND*
000000010000c068      d  *UND* __OBJC_METACLASS_RO_$_ViewController
000000010000c0b0      d  *UND* __OBJC_$_INSTANCE_METHODS_ViewController
000000010000c0e8      d  *UND* __OBJC_CLASS_RO_$_ViewController
0000000000000000      d  *UND* _OBJC_CLASS_$_ViewController
0000000000000000      d  *UND* _OBJC_METACLASS_$_ViewController
0000000000000000      d  *UND*
0000000000000000      d  *UND* /Users/RyukieW/RyukieSamaProject/Study/逆向/Code/SymbolBind/SymbolBind/
0000000000000000      d  *UND* AppDelegate.m
0000000060a0b259      d  *UND* /Users/RyukieW/Library/Developer/Xcode/DerivedData/SymbolBind-bhluvjpsukewfxgsouyiwqlmcntk/Build/Intermediates.noindex/SymbolBind.build/Debug-iphoneos/SymbolBind.build/Objects-normal/arm64/AppDelegate.o
0000000100005fc8      d  *UND*
0000000100005fc8      d  *UND* -[AppDelegate application:didFinishLaunchingWithOptions:]
000000000000007c      d  *UND*
000000000000007c      d  *UND*
0000000100006044      d  *UND*
0000000100006044      d  *UND* -[AppDelegate application:configurationForConnectingSceneSession:options:]
0000000000000100      d  *UND*
0000000000000100      d  *UND*
0000000100006144      d  *UND*
0000000100006144      d  *UND* -[AppDelegate application:didDiscardSceneSessions:]
0000000000000074      d  *UND*
0000000000000074      d  *UND*
0000000000000000      d  *UND* __OBJC_LABEL_PROTOCOL_$_NSObject
0000000000000000      d  *UND* __OBJC_LABEL_PROTOCOL_$_UIApplicationDelegate
000000010000c130      d  *UND* __OBJC_$_PROTOCOL_INSTANCE_METHODS_NSObject
000000010000c300      d  *UND* __OBJC_$_PROTOCOL_INSTANCE_METHODS_OPT_NSObject
000000010000c320      d  *UND* __OBJC_$_PROP_LIST_NSObject
000000010000c368      d  *UND* __OBJC_$_PROTOCOL_METHOD_TYPES_NSObject
000000010000c408      d  *UND* __OBJC_$_PROTOCOL_REFS_UIApplicationDelegate
000000010000c420      d  *UND* __OBJC_$_PROTOCOL_INSTANCE_METHODS_OPT_UIApplicationDelegate
000000010000c938      d  *UND* __OBJC_$_PROP_LIST_UIApplicationDelegate
000000010000c950      d  *UND* __OBJC_$_PROTOCOL_METHOD_TYPES_UIApplicationDelegate
000000010000cb00      d  *UND* __OBJC_CLASS_PROTOCOLS_$_AppDelegate
000000010000cb18      d  *UND* __OBJC_METACLASS_RO_$_AppDelegate
000000010000cb60      d  *UND* __OBJC_$_INSTANCE_METHODS_AppDelegate
000000010000cbb0      d  *UND* __OBJC_$_PROP_LIST_AppDelegate
000000010000cc08      d  *UND* __OBJC_CLASS_RO_$_AppDelegate
0000000000000000      d  *UND* _OBJC_METACLASS_$_AppDelegate
0000000000000000      d  *UND* _OBJC_CLASS_$_AppDelegate
0000000000000000      d  *UND* __OBJC_PROTOCOL_$_NSObject
0000000000000000      d  *UND* __OBJC_PROTOCOL_$_UIApplicationDelegate
0000000000000000      d  *UND*
0000000000000000      d  *UND* /Users/RyukieW/RyukieSamaProject/Study/逆向/Code/SymbolBind/SymbolBind/
0000000000000000      d  *UND* main.m
0000000060a0b259      d  *UND* /Users/RyukieW/Library/Developer/Xcode/DerivedData/SymbolBind-bhluvjpsukewfxgsouyiwqlmcntk/Build/Intermediates.noindex/SymbolBind.build/Debug-iphoneos/SymbolBind.build/Objects-normal/arm64/main.o
00000001000061b8      d  *UND*
00000001000061b8      d  *UND* _main
000000000000009c      d  *UND*
000000000000009c      d  *UND*
0000000000000000      d  *UND*
0000000000000000      d  *UND* /Users/RyukieW/RyukieSamaProject/Study/逆向/Code/SymbolBind/SymbolBind/
0000000000000000      d  *UND* SceneDelegate.m
0000000060a0b259      d  *UND* /Users/RyukieW/Library/Developer/Xcode/DerivedData/SymbolBind-bhluvjpsukewfxgsouyiwqlmcntk/Build/Intermediates.noindex/SymbolBind.build/Debug-iphoneos/SymbolBind.build/Objects-normal/arm64/SceneDelegate.o
0000000100006254      d  *UND*
0000000100006254      d  *UND* -[SceneDelegate scene:willConnectToSession:options:]
000000000000009c      d  *UND*
000000000000009c      d  *UND*
00000001000062f0      d  *UND*
00000001000062f0      d  *UND* -[SceneDelegate sceneDidDisconnect:]
000000000000004c      d  *UND*
000000000000004c      d  *UND*
000000010000633c      d  *UND*
000000010000633c      d  *UND* -[SceneDelegate sceneDidBecomeActive:]
000000000000004c      d  *UND*
000000000000004c      d  *UND*
0000000100006388      d  *UND*
0000000100006388      d  *UND* -[SceneDelegate sceneWillResignActive:]
000000000000004c      d  *UND*
000000000000004c      d  *UND*
00000001000063d4      d  *UND*
00000001000063d4      d  *UND* -[SceneDelegate sceneWillEnterForeground:]
000000000000004c      d  *UND*
000000000000004c      d  *UND*
0000000100006420      d  *UND*
0000000100006420      d  *UND* -[SceneDelegate sceneDidEnterBackground:]
000000000000004c      d  *UND*
000000000000004c      d  *UND*
000000010000646c      d  *UND*
000000010000646c      d  *UND* -[SceneDelegate window]
0000000000000024      d  *UND*
0000000000000024      d  *UND*
0000000100006490      d  *UND*
0000000100006490      d  *UND* -[SceneDelegate setWindow:]
000000000000003c      d  *UND*
000000000000003c      d  *UND*
00000001000064cc      d  *UND*
00000001000064cc      d  *UND* -[SceneDelegate .cxx_destruct]
000000000000003c      d  *UND*
000000000000003c      d  *UND*
0000000000000000      d  *UND* __OBJC_LABEL_PROTOCOL_$_UISceneDelegate
0000000000000000      d  *UND* __OBJC_LABEL_PROTOCOL_$_UIWindowSceneDelegate
000000010000cc50      d  *UND* __OBJC_$_PROTOCOL_INSTANCE_METHODS_NSObject
000000010000ce20      d  *UND* __OBJC_$_PROTOCOL_INSTANCE_METHODS_OPT_NSObject
000000010000ce40      d  *UND* __OBJC_$_PROP_LIST_NSObject
000000010000ce88      d  *UND* __OBJC_$_PROTOCOL_METHOD_TYPES_NSObject
000000010000cf28      d  *UND* __OBJC_$_PROTOCOL_REFS_UISceneDelegate
000000010000cf40      d  *UND* __OBJC_$_PROTOCOL_INSTANCE_METHODS_OPT_UISceneDelegate
000000010000d068      d  *UND* __OBJC_$_PROTOCOL_METHOD_TYPES_UISceneDelegate
000000010000d0c8      d  *UND* __OBJC_$_PROTOCOL_REFS_UIWindowSceneDelegate
000000010000d0e0      d  *UND* __OBJC_$_PROTOCOL_INSTANCE_METHODS_OPT_UIWindowSceneDelegate
000000010000d160      d  *UND* __OBJC_$_PROP_LIST_UIWindowSceneDelegate
000000010000d178      d  *UND* __OBJC_$_PROTOCOL_METHOD_TYPES_UIWindowSceneDelegate
000000010000d1a0      d  *UND* __OBJC_CLASS_PROTOCOLS_$_SceneDelegate
000000010000d1b8      d  *UND* __OBJC_METACLASS_RO_$_SceneDelegate
000000010000d200      d  *UND* __OBJC_$_INSTANCE_METHODS_SceneDelegate
000000010000d2e0      d  *UND* __OBJC_$_INSTANCE_VARIABLES_SceneDelegate
000000010000d308      d  *UND* __OBJC_$_PROP_LIST_SceneDelegate
000000010000d360      d  *UND* __OBJC_CLASS_RO_$_SceneDelegate
0000000000000000      d  *UND* _OBJC_IVAR_$_SceneDelegate._window
0000000000000000      d  *UND* _OBJC_METACLASS_$_SceneDelegate
0000000000000000      d  *UND* _OBJC_CLASS_$_SceneDelegate
0000000000000000      d  *UND* __OBJC_PROTOCOL_$_UISceneDelegate
0000000000000000      d  *UND* __OBJC_PROTOCOL_$_UIWindowSceneDelegate
0000000000000000      d  *UND*
000000010000d460 g     O __DATA,__objc_data _OBJC_CLASS_$_AppDelegate
000000010000d4b0 g     O __DATA,__objc_data _OBJC_CLASS_$_SceneDelegate
000000010000d3e8 g     O __DATA,__objc_data _OBJC_CLASS_$_ViewController
000000010000d438 g     O __DATA,__objc_data _OBJC_METACLASS_$_AppDelegate
000000010000d488 g     O __DATA,__objc_data _OBJC_METACLASS_$_SceneDelegate
000000010000d410 g     O __DATA,__objc_data _OBJC_METACLASS_$_ViewController
0000000100000000 g     F __TEXT,__text __mh_execute_header
00000001000061b8 g     F __TEXT,__text _main
0000000100005fac g     F __TEXT,__text _testGlobalFunction
0000000000000000         *UND* _NSLog
0000000000000000         *UND* _NSStringFromClass
0000000000000000         *UND* _OBJC_CLASS_$_UIResponder
0000000000000000         *UND* _OBJC_CLASS_$_UISceneConfiguration
0000000000000000         *UND* _OBJC_CLASS_$_UIViewController
0000000000000000         *UND* _OBJC_METACLASS_$_NSObject
0000000000000000         *UND* _OBJC_METACLASS_$_UIResponder
0000000000000000         *UND* _OBJC_METACLASS_$_UIViewController
0000000000000000         *UND* _UIApplicationMain
0000000000000000         *UND* ___CFConstantStringClassReference
0000000000000000         *UND* __objc_empty_cache
0000000000000000         *UND* _objc_alloc
0000000000000000         *UND* _objc_autoreleasePoolPop
0000000000000000         *UND* _objc_autoreleasePoolPush
0000000000000000         *UND* _objc_autoreleaseReturnValue
0000000000000000         *UND* _objc_msgSend
0000000000000000         *UND* _objc_msgSendSuper2
0000000000000000         *UND* _objc_opt_class
0000000000000000         *UND* _objc_release
0000000000000000         *UND* _objc_retainAutoreleasedReturnValue
0000000000000000         *UND* _objc_storeStrong
0000000000000000         *UND* dyld_stub_binder

l
- 本地符号
g
- 全局符号

三、恢复符号表的线索

虽然符号表中没有了符号，但是在MachO中的类的方法列表中还是有的！

3.1 类名

在TEXT段__objc_classname中：

3.2 方法名

在TEXT段__objc_methname中：

四、符号表恢复

4.1 脚本

GitHub: restore-symbol

将MachO文件放入目录中
执行脚本./restore-symbol MachO文件名 -o MachO输出文件名

=========== Start =============
2021-05-16 15:11:40.712 restore-symbol[97858:6671327] Unknown load command: 0x00000032
Scan OC method in mach-o-file.
Scan OC method finish.
=========== Finish ============

在用MachOView查看符号表，发现在后面已经恢复了！
- 严谨的说是添加了符号
- 由于是基于Runtime的，动态派发的可以恢复。
对比发现文件大小也增大了

深入理解动态库与静态库

Sun, 09 May 2021 00:00:00 GMT

一、简单的区别

静态和动态是相对编译时和运行时进行区分的

1.1 静态库

静态库在编译时会被链接进MachO中

后缀一般为.a/.framework

1.2 动态库

在程序编译时不会被链接到MachO中，而是在程序启动的时候加载动态库到内存中。其中动态库分动态链接库和动态加载库两种

动态库文件一般为.tbd(以前是.dylib)/.framework

动态链接库

在编译阶段确定了依赖关系的动态库。当运行可执行文件时，如果尚未加载，则会将加载这些动态库。

常见的动态库都是这种

动态加载库

编译阶段不需要指定app需要依赖哪些动态库。当运行过程中需要加载某个动态库时，就会用dlopen函数动态的把库加载到内存中使用。

这种玩玩可以，上架就别想了。比通过网络如下载一个动态库，然后加载调用。

1.3 体积

一般来说，静态库直接拷贝进可执行文件，相较动态库对包体积的影响会大一些。

静态库被多个可执行文件依赖就会被拷贝多次。

1.4 启动速度

因为动态库在应用启动的时候需要加载，所以对应用的启动速度是有一定的影响的。

严谨的说，对于已经加载过的动态库已经存在于共享缓存中，那么对启动速度的影响就很小了。

1.5 各自优缺点

静态库
- 模块化，分工合作，提高了代码的复用及核心技术的保密程度
- 避免少量改动经常导致大量的重复编译连接
- 也可以重用，注意不是共享使用
动态库
- 可以将最终可执行文件体积缩小，将整个应用程序分模块，团队合作，进行分工，影响比较小
- 多个应用程序共享内存中得同一份库文件，节省资源
- 可以不重新编译连接可执行程序的前提下，更新动态库文件达到更新应用程序的目的
- 应用插件化
- 软件版本实时模块升级
- 在其它大部分平台上，动态库都可以用于不同应用间共享，共享可执行文件，这就大大节省了内存

在 iOS8 之前，苹果不允许第三方框架使用动态方式加载，从 iOS8 开始允许开发者有条件地创建和使用动态框架，这种框架叫做 Cocoa Touch Framework。

虽然同样是动态框架，但是和系统 framework 不同，苹果系统专属的 framework 是共享的（如 UIKit），使用 Cocoa Touch Framework 制作的动态库在打包和提交 app 时会被放到 app main bundle 的根目录中，运行在沙盒里，而不是系统中。

也就是说，不同的 app 就算使用了同样的 framework，但还是会有多份的框架被分别签名、打包和加载。

不过 iOS8 上开放了 App Extension 功能，可以为一个应用创建插件，这样主 app 和插件之间共享动态库还是可行的。

二、什么是framework

Framework 是 Cocoa/Cocoa Touch 程序中使用的一种资源打包方式，可以将代码文件、头文件、资源文件、说明文档等集中在一起，方便开发者使用。一般如果是静态 Framework 的话，资源打包进 Framework 是读取不了的。静态 Framework 和 .a 文件都是编译进可执行文件里面的。只有动态 Framework 能在 .app 下面的 Framework 文件夹下看到，并读取 .framework 里的资源文件。

Cocoa/Cocoa Touch 开发框架本身提供了大量的 Framework，比如 Foundation.framework/UIKit.framework 等。需要注意的是，这些 Framework 无一例外都是动态库。

平时用的第三方 SDK 的 Framework 都是静态库，真正的动态库是上不了 AppStore（iOS8 之后能上 AppStore，因为 App Extension，需要动态库支持)。

2.1 结构

Headers

表示暴露的头文件，一般都会有一个和 Framework 同名的 .h 文件，在创建 Framework 的时候文件夹里也会默认生成这样一个文件。有这个和 Framework 同名的 .h 文件 @import 导入库的时候编译器才能找到这个库。

info.plist

主要就是这个 Framework 的一些配置信息。

Modules

这个文件夹里有个 module.modulemap 文件

framework module DynamicFramework {
  umbrella header "DynamicFramework.h"

  export *

  module * { export * }

}

这里面有这样一句 umbrella header "DynamicFramework.h"，umbrella 有保护伞、庇护的意思。

也就是说 Headers 中暴露的 DynamicFramework.h 文件被放在 umbrella 雨伞下保护起来了，所以我们需要将其他的所有需要暴露的 .h 文件放到 DynamicFramework.h 文件中保护起来，不然会出现警告。

@import 的时候也只能找到 umbrella 雨伞下保护起来的 .h 文件。

二进制文件（Unix 可执行文件）

这个就是你源码编译而成的二进制文件，主要的执行代码就在这个里面。

.bundle 文件

如果我们在 Build Phases -> Copy Bundle Resources 里加入 .bundle 文件，那么创建出来的 .Framework 里就会有这个 .bundle 的资源文件夹。

2.2 资源文件

CocoaPods 如何生成 Framework 的资源文件？

我们能看到用 cocoapods 创建 Framework 的时候，Framework 里面有一个 .bundle 文件，跟 Framework 同级目录里也有一个 .bundle文件。这两个文件其实是一样的。

那这两个 .bundle 是怎么来的呢？我们能看到用 use_frameworks! 生成的 pod 里面，pods 这个 PROJECT 下面会为每一个 pod 生成一个 target。

那么如果这个 pod 有资源文件的话，就会有一个叫 xxx-bundleName 的 target，最后这个 target 生成的就是 bundleName.bundle。

在 xxx 的 target 的Build Phases -> Copy Bundle Resources里加入这个 .bundle，在 Framework 里面就会生成这样一个 bundle。

在 xxx 的 target 的Build Phases -> Target Dependencies里加入这个 target：xxx-bundleName，就会在 Framework 的同级目录里生成这样一个 bundle。

静态 Framework 里不需要加入资源文件。一般资源打包进静态 Framework 是读取不了的。

静态 Framework 和 .a 文件都是编译进可执行文件里面的。只有动态 Framework 能在 .app 的 Framework 文件夹下看到，并读取 .framework 里的资源文件。

你可以用 NSBundle * bundle = [[NSBundle mainBundle] bundlePath]; 得到 .app 目录，如果是动态库你能在 Framework 目录下看到这个动态库以及动态库里面资源文件。

然后你只要用 NSBundle * bundle = [NSBundle bundleForClass:<#ClassFromFramework#>]; 得到这个动态库的路径就能读取到里面的资源了。但是如果是静态库的话，因为编译进了可执行文件里面，你也就没办法读到这个静态库了，你能看到 .app 下的 Framework 目录为空。

2.3 Embedded Framework

报错 Reason: image not found

如果直接在工程里使用创建的动态库时候会出现此错误，需要在工程的 General 里的 Embedded Binaries 添加这个动态库才能使用。

因为创建的这个动态库其实也不能给其他程序使用的，而你的 App Extension 和 APP 之间是需要使用这个动态库的。这个动态库可以 App Extension 和 APP 之间共用一份（App 和 Extension 的 Bundle 是共享的），因此苹果又把这种 Framework 称为 Embedded Framework。

三、CocoaPods

在使用 CocoaPods 的时候在 Podfile 里加入 use_frameworks!，那么你在编译的时候就会默认帮你生成动态库，我们能看到每个源码 Pod 都会在 Pods 工程下面生成一个对应的动态库 Framework 的 target，我们能在这个 target 的 Build Settings -> Mach-O Type 看到默认设置是 Dynamic Library，也就是会生成一个动态 Framework，我们能在 Products 下面看到每一个 Pod 对应生成的动态库。

这些生成的动态库将链接到主项目给主工程使用，但是我们上面说过动态库需要在主工程 target 的 General -> Embedded Binaries 中添加才能使用，而我们并没有在 Embedded Binaries 中看到这些动态库。那这是怎么回事呢，其实是 cocoapods 已经执行了脚本把这些动态库嵌入到了 .app 的 Framework 目录下，相当于在 Embedded Binaries 加入了这些动态库。我们能在主工程 target 的 Build Phase -> Embed Pods Frameworks 里看到执行的脚本。

参考

iOS 静态库和动态库初识iOS中的动态库和静态库

dyld

Wed, 05 May 2021 00:00:00 GMT

DYLD源码

一、验证

1.1 在main函数处下断点

我们新建一个项目，在main函数起始处下个断点。

查看堆栈信息bt

(lldb) bt
* thread #1, queue = 'com.apple.main-thread', stop reason = breakpoint 1.1
  * frame #0: 0x0000000100d9a190 DyleDemo`main(argc=1, argv=0x000000016f06b8e0) at main.m:12:16
    frame #1: 0x00000001afbb48f0 libdyld.dylib`start + 4
(lldb)

很明显，这里的堆栈信息不足以供我们进行分析。我们需要在更早的地方下断点。

1.2 在+load下断点

(lldb) bt
* thread #1, queue = 'com.apple.main-thread', stop reason = breakpoint 2.1
  * frame #0: 0x0000000100911e78 DyleDemo`+[ViewController load](self=ViewController, _cmd="load") at ViewController.m:18:1
    frame #1: 0x00000001afadf35c libobjc.A.dylib`load_images + 984
    frame #2: 0x0000000100aca190 dyld`dyld::notifySingle(dyld_image_states, ImageLoader const*, ImageLoader::InitializerTimingList*) + 448
    frame #3: 0x0000000100ada0d8 dyld`ImageLoader::recursiveInitialization(ImageLoader::LinkContext const&, unsigned int, char const*, ImageLoader::InitializerTimingList&, ImageLoader::UninitedUpwards&) + 512
    frame #4: 0x0000000100ad8520 dyld`ImageLoader::processInitializers(ImageLoader::LinkContext const&, unsigned int, ImageLoader::InitializerTimingList&, ImageLoader::UninitedUpwards&) + 184
    frame #5: 0x0000000100ad85e8 dyld`ImageLoader::runInitializers(ImageLoader::LinkContext const&, ImageLoader::InitializerTimingList&) + 92
    frame #6: 0x0000000100aca658 dyld`dyld::initializeMainExecutable() + 216
    frame #7: 0x0000000100aceeb0 dyld`dyld::_main(macho_header const*, unsigned long, int, char const**, char const**, char const**, unsigned long*) + 4400
    frame #8: 0x0000000100ac9208 dyld`dyldbootstrap::start(dyld3::MachOLoaded const*, int, char const**, dyld3::MachOLoaded const*, unsigned long*) + 396
    frame #9: 0x0000000100ac9038 dyld`_dyld_start + 56

因为load方法在main之前就已经执行了，在这里我们可以看到更丰富的堆栈信息。

1.3 一些关键流程

跟具体的可以结合dyld源码进行了解

1.3.1 dyld start

rebaseDyld 重定位调用 main dyld的核心逻辑

1.3.2 dyld main

Return address of main() in target program which __dyld_start jumps to

a. 加载动态库共享缓存

何为共享缓存？UIKit、ARKit等系统库就是在共享缓存中的。

三种情况的加载

仅加载到当前进程（设置不放入共享缓存）
已经加载了共享缓存
第一次加载共享缓存

b. dyld3 ClosureMode(闭包模式)

iOS11 之后引入了dyld3和闭包模式闭包模式加载速度更快效率更高。 iOS13 之后Framework和三方库也会通过闭包模式加载

先去缓存中找mainClosure 没找到就创建一个

launchWithClosure
- 使用上面的mainClosure启动main
- 并返回main函数地址

二、流程总结

程序执行从_dyld_start开始
进入dyld_main函数
配置环境变量以及rebase_dyld
加载共享缓存
- 系统的动态库都在这里了
dyld2/dyld(ClosureMode)决定以哪种模式继续进行
实例化主程序ImageLoaderMachO，加入到allImages中
到此共享缓存加载完毕，设置版本化的dylib覆盖
- Now that shared cache is loaded, setup an versioned dylib overrides
加载插入的动态库
- 越狱插件在这里加入
记录插入的库的数量，以便统一搜索将先查看插入的库，然后是main，然后是其他。
- record count of inserted libraries so that a flat search will look at inserted libraries, then main, then others.
链接主程序
- 绑定符号（非懒加载、弱符号）等
链接所有插入的库
- 链接主可执行文件后执行此操作，以使插入的dylib（例如libSystem）不在程序使用的dylib的前面
- 只有插入的库可以插入。绑定所有插入的库后，注册插入信息，以便链接工作
绑定并通知主程序可执行文件，现在插入的已被注册
绑定并通知现在已插入的库已插入的Image已被注册
执行所有初始化方法：ImageLoader
- 初始化所有插入的库、运行主要可执行文件的初始化程序及其依赖
- ImageLoader:
  - runInitializers:
    - processInitializers:
      - ecursiveInitialization:
        
        notifySingle:
        
        此函数执行一个回调，此回调是_objc_init初始化时服饰的一个函数load_images
        
        load_images里执行class_load_metgods函数
        
        class_load_metgods里调用call_class_loads函数：循环调用各个类的load函数
        
        doModInitFunction
        
        内部会调用全局C++对象的构造函数__attribute__((constructor))的C函数
通知任何监视过程此过程即将进入main()
查找主要可执行文件的指针并return

三、主程序中的Load先执行还是framework中的先执行？分类呢？子类呢？

3.1 创建一个Demo，创建两个Framework。

Main函数内添加Log

int main(int argc, char * argv[]) {
    printf("Main函数");
    NSString * appDelegateClassName;
    @autoreleasepool {
        // Setup code that might create autoreleased objects goes here.
        appDelegateClassName = NSStringFromClass([AppDelegate class]);
    }
    return UIApplicationMain(argc, argv, nil, appDelegateClassName);
}

添加C++构造函数

__attribute__((constructor)) void funcA() {
    printf(__FUNCTION__);
    printf("\n");
}

__attribute__((constructor)) void funcB() {
    printf(__FUNCTION__);
    printf("\n");
}

Frameworks中添加Log

运行看Log

2021-05-09 19:59:09.301905+0800 DyleDemo[34074:1711187] TestSecond-TestClassSecond-Load
2021-05-09 19:59:09.302965+0800 DyleDemo[34074:1711187] TestF-TestClass-Load
2021-05-09 19:59:09.303008+0800 DyleDemo[34074:1711187] ViewController-Load
2021-05-09 19:59:09.303027+0800 DyleDemo[34074:1711187] SomeClass-Load
funcA
funcB
2021-05-09 19:59:09.303178+0800 DyleDemo[34074:1711187] Main函数

调整一下Framework的链接顺序

再看下下log

2021-05-09 20:02:42.713300+0800 DyleDemo[34120:1713030] TestSecond-TestClassSecond-Load
2021-05-09 20:02:42.713925+0800 DyleDemo[34120:1713030] TestF-TestClass-Load
2021-05-09 20:02:42.713961+0800 DyleDemo[34120:1713030] ViewController-Load
2021-05-09 20:02:42.713983+0800 DyleDemo[34120:1713030] SomeClass-Load
funcA
funcB
2021-05-09 20:02:42.714103+0800 DyleDemo[34120:1713030] Main函数

小结

Frameworks(有多个的话按照链接顺序来) -> 主程序内的Load -> C++构造函数 -> Main

3.2 我们再加两个分类玩玩吧！

Log如下

2021-05-09 20:14:38.455892+0800 DyleDemo[34267:1718526] TestSecond-TestClassSecond-Load
2021-05-09 20:14:38.456556+0800 DyleDemo[34267:1718526] TestF-TestClass-Load
2021-05-09 20:14:38.456594+0800 DyleDemo[34267:1718526] ViewController-Load
2021-05-09 20:14:38.456615+0800 DyleDemo[34267:1718526] SomeClass-Load
2021-05-09 20:14:38.456633+0800 DyleDemo[34267:1718526] UIViewController+Test Load
2021-05-09 20:14:38.456651+0800 DyleDemo[34267:1718526] UIView+Test Load
funcA
funcB
2021-05-09 20:14:38.456782+0800 DyleDemo[34267:1718526] Main函数

当前的顺序是这样的

调整一下顺序能让分类提前加载Load么？我们试一下！

2021-05-09 20:20:04.294895+0800 DyleDemo[34337:1721873] TestSecond-TestClassSecond-Load
2021-05-09 20:20:04.295441+0800 DyleDemo[34337:1721873] TestF-TestClass-Load
2021-05-09 20:20:04.295476+0800 DyleDemo[34337:1721873] ViewController-Load
2021-05-09 20:20:04.295495+0800 DyleDemo[34337:1721873] SomeClass-Load
2021-05-09 20:20:04.295511+0800 DyleDemo[34337:1721873] UIView+Test Load
2021-05-09 20:20:04.295526+0800 DyleDemo[34337:1721873] UIViewController+Test Load
funcA
funcB
2021-05-09 20:20:04.295640+0800 DyleDemo[34337:1721873] Main函数

小结

项目内的分类在最后调用Load，在C++构造函数之前

3.3 Framework中的分类呢？

我们在两个Framework中分别添加一个分类

Log如下

2021-05-09 20:22:41.298458+0800 DyleDemo[34371:1723177] TestSecond-TestClassSecond-Load
2021-05-09 20:22:41.299001+0800 DyleDemo[34371:1723177] TestSecond-TestClassSecond+Cate-Load
2021-05-09 20:22:41.299032+0800 DyleDemo[34371:1723177] TestF-TestClass-Load
2021-05-09 20:22:41.299048+0800 DyleDemo[34371:1723177] TestF-TestClass+Cate-Load
2021-05-09 20:22:41.299076+0800 DyleDemo[34371:1723177] ViewController-Load
2021-05-09 20:22:41.299093+0800 DyleDemo[34371:1723177] SomeClass-Load
2021-05-09 20:22:41.299109+0800 DyleDemo[34371:1723177] UIView+Test Load
2021-05-09 20:22:41.299145+0800 DyleDemo[34371:1723177] UIViewController+Test Load
funcA
funcB
2021-05-09 20:22:41.299451+0800 DyleDemo[34371:1723177] Main函数

小结

和在主工程中类似，每个Framework内部的分类在Framework最后调用Load。

3.4 再来个子类看下

这次我们在Framework中建一个子类看看

2021-05-09 20:31:31.124655+0800 DyleDemo[34472:1726758] TestSecond-TestClassSecond-Load
2021-05-09 20:31:31.125259+0800 DyleDemo[34472:1726758] TestSecond-TestClassSecond+Cate-Load
2021-05-09 20:31:31.125288+0800 DyleDemo[34472:1726758] TestF-TestClass-Load
2021-05-09 20:31:31.125306+0800 DyleDemo[34472:1726758] TestF-TestSubClass-Load
2021-05-09 20:31:31.125323+0800 DyleDemo[34472:1726758] TestF-TestClass+Cate-Load
2021-05-09 20:31:31.125350+0800 DyleDemo[34472:1726758] ViewController-Load
2021-05-09 20:31:31.125367+0800 DyleDemo[34472:1726758] SomeClass-Load
2021-05-09 20:31:31.125427+0800 DyleDemo[34472:1726758] UIView+Test Load
2021-05-09 20:31:31.125575+0800 DyleDemo[34472:1726758] UIViewController+Test Load
funcA
funcB
2021-05-09 20:31:31.125796+0800 DyleDemo[34472:1726758] Main函数

小结

子类的Load先于分类

Hook

Wed, 05 May 2021 00:00:00 GMT

一、常见的Hook技术

Method Swizzle
- 利用OC的Runtime特性，动态改变SEL和IMP的对应关系，达到OC方法调用流程的改变。主要用于OC方法。
fishhook
- Facebook提供的一个动态修改链接mach-O文件的工具。利用MachO文件加载原理，通过懒加载和非懒加载两个表的指针达到C函数Hook的目的。
Cydia Substrate
- 主要针对OC方法、C函数以及对函数地址进行Hook操作。不经针对iOS，安卓也可以用。

二、fishhook

fishhook-Github

首先回顾一下OC的动态特性
- 并不是直接调用方法的实现地址，而是通过一张selector和imp的映射表去找
- 静态语言如C，是直接通过地址访问
  - 但外部C函数调用是通过符号绑定来的

2.1 rebind_symbols

/*
 * For each rebinding in rebindings, rebinds references to external, indirect
 * symbols with the specified name to instead point at replacement for each
 * image in the calling process as well as for all future images that are loaded
 * by the process. If rebind_functions is called more than once, the symbols to
 * rebind are added to the existing list of rebindings, and if a given symbol
 * is rebound more than once, the later rebinding will take precedence.
 */
FISHHOOK_VISIBILITY
int rebind_symbols(struct rebinding rebindings[], size_t rebindings_nel);

参数列表：

需要Hook的rebinding数组
长度

2.2 rebinding

/*
 * A structure representing a particular intended rebinding from a symbol
 * name to its replacement
 */
struct rebinding {
  const char *name;
  void *replacement;
  void **replaced;
};

name 需要Hook的函数名称，C字符串 replacement 新函数的地址 replaced 原始函数的指针

2.3 使用 rebind_symbols hook NSLog

通过查看接口我们需要创建一些数据。

- (void)viewDidLoad {
    [super viewDidLoad];
    self.view.backgroundColor = [UIColor blackColor];
    // 目标去Hook系统的NSLog函数
    
    struct rebinding nslog;
    nslog.name = "NSLog";
    nslog.replacement = hook_NSLog;
    // 保存NSLog函数的指针
    nslog.replaced = (void *)&sys_NSLog;
    
    struct rebinding bds[] = {nslog};
    
    rebind_symbols(bds, 1);
}

/// 旧函数的指针
static void (*sys_NSLog)(NSString *format, ...);

// 新函数
void hook_NSLog(NSString *format, ...) {
    format = [format stringByAppendingString:@"\n🌈"];
    // 再调用系统的
    sys_NSLog(format);
}

- (void)touchesBegan:(NSSet<UITouch *> *)touches withEvent:(UIEvent *)event {
    NSLog(@"RyukieLog");
}

输出结果：

2021-05-05 15:51:44.230666+0800 Hook[1650:239418] RyukieLog
🌈
2021-05-05 15:51:44.430579+0800 Hook[1650:239418] RyukieLog
🌈
2021-05-05 15:51:44.679392+0800 Hook[1650:239418] RyukieLog
🌈

Hook成功！

2.4 试一试hook C函数？

定义一个这样的函数

void logFun(const char * str) {
    NSLog(@"%s", str);
}

修改rebinding信息

struct rebinding nslog;
nslog.name = "logFun";
nslog.replacement = new_logfun;
nslog.replaced = (void *)&old_logfun;

static void(*old_logfun)(const char * str);

void new_logfun(const char * str) {
    str = "🌈";
    // 再调用旧的
    old_logfun(str);
}

发现并没有成功！应为这个是通过地址直接访问的。

三、重绑定符号

一个问题：编译的时候，NSLog的真实地址知道么？不知道。

在MachO加载进内存时，dyld会先加载依赖的系统库进共享缓存。

NSLog在Foundation框架中，加载后dyld会将NSLog的真实地址告诉MachO。

验证一下fishhook的实现：

在hook前后分别下断点，打开汇编断点。

第一个断点：

-> 0x10233d234 <+188>: bl 0x10233e320 ; symbol stub for: NSLog

下一步：

->  0x104cae320 <+0>: nop    
    0x104cae324 <+4>: ldr    x16, #0x5cdc              ; (void *)0x0000000104cae464
    0x104cae328 <+8>: br     x16

第二个断点：

-> 0x10233d254 <+220>: bl 0x10233e320 ; symbol stub for: NSLog

下一步：

->  0x104cae320 <+0>: nop    
    0x104cae324 <+4>: ldr    x16, #0x5cdc              ; (void *)0x0000000104cad44c: hook_NSLog at /Users/RyukieW/RyukieSamaProject/Study/逆向/Code/Hook/Hook/Hook/ViewController.m:75
    0x104cae328 <+8>: br     x16

分析：

bl 0x10233e320 ; symbol stub for: NSLog

这一段是到0x10233e320中去寻找符号绑定的地址

第一次的第二步找到了系统原本函数的地址

第二次走到第二步后发现已经是hookNSLog了

四、符号绑定的过程

间接符号表
- MachO文件以外的，所有调用系统的都是外部的。
本地符号
- 上架去符号，去的是本地符号
全局符号
- 可以暴露给外界

4.1 桩

一块代码！

上面一段中看到的一段汇编指令

bl 0x10233e320 ; symbol stub for: NSLog

0x10233e320就是NSLog的桩

bl -> 桩 -> 通过符号表去执行代码

懒加载符号表全部都是通过桩去进行绑定的

五、总结

符号绑定过程
- 外部函数调用是执行桩里的代码
  - 通过懒加载符号表里的地址去执行
- 懒加载符号表里面默认保存的是binder的代码
  - bingder函数在非懒加载符号的表里面（程序运行就绑定好了）

MachO文件

Tue, 04 May 2021 00:00:00 GMT

一、基础概念

Mach-O文件其实是MachObject文件格式的缩写。是Mac以及iOS上客户性文件的格式。
属于MachO格式的常见文件：
- 目标文件.o
- 库文件
  - .a
  - .dylib
  - Framework
- 可执行文件
- dyld
- .dsym
file指令可以产看文件类型

二、我们通过一个简单的例子来看下MachO是怎么生成的

Test.c

# include <stdio.h>

int main() {
    printf("Hello world");
    return 1;
}

Test2.c

# include <stdio.h>

int main2() {
    printf("Hello money");
    return 1;
}

2.1 源文件编译为.o文件（中间对象文件）

执行命令clang -c Test.c Test2.c

看到编译出了两个对应的.o文件

可以直接 -o 一步到位

2.2 将.o文件生成可执行文件

执行命名clang -o TestEx Test.o Test2.o

生成TestEx的可执行文件，通过file指令确认一下，这里可以发现生成的就是MachO文件了

file TestEx
TestEx: Mach-O 64-bit executable x86_64

2.3 链接顺序对MachO文件的影响

我们看下当前生成TestEx文件的MD5

md5 TestEx
MD5 (TestEx) = 3db04e90a4e078438a03f7cb9d8bf8c8

再执行命名clang -o TestEx2 Test2.o Test.o，调整.o文件顺序。

➜  Create md5 TestEx2
MD5 (TestEx2) = b32bbfd76c8784f8a517249f5f7c4bec

通过objdump查看MachO文件数据

➜  Create objdump --macho -d TestEx
TestEx:
(__TEXT,__text) section
_main:
100003f20:	55	pushq	%rbp
100003f21:	48 89 e5	movq	%rsp, %rbp
100003f24:	48 83 ec 10	subq	$16, %rsp
100003f28:	c7 45 fc 00 00 00 00	movl	$0, -4(%rbp)
100003f2f:	48 8d 3d 60 00 00 00	leaq	96(%rip), %rdi ## literal pool for: "Hello world"
100003f36:	b0 00	movb	$0, %al
100003f38:	e8 39 00 00 00	callq	0x100003f76 ## symbol stub for: _printf
100003f3d:	b9 01 00 00 00	movl	$1, %ecx
100003f42:	89 45 f8	movl	%eax, -8(%rbp)
100003f45:	89 c8	movl	%ecx, %eax
100003f47:	48 83 c4 10	addq	$16, %rsp
100003f4b:	5d	popq	%rbp
100003f4c:	c3	retq
100003f4d:	90	nop
100003f4e:	90	nop
100003f4f:	90	nop
_main2:
100003f50:	55	pushq	%rbp
100003f51:	48 89 e5	movq	%rsp, %rbp
100003f54:	48 83 ec 10	subq	$16, %rsp
100003f58:	48 8d 3d 43 00 00 00	leaq	67(%rip), %rdi ## literal pool for: "Hello money"
100003f5f:	b0 00	movb	$0, %al
100003f61:	e8 10 00 00 00	callq	0x100003f76 ## symbol stub for: _printf
100003f66:	b9 01 00 00 00	movl	$1, %ecx
100003f6b:	89 45 fc	movl	%eax, -4(%rbp)
100003f6e:	89 c8	movl	%ecx, %eax
100003f70:	48 83 c4 10	addq	$16, %rsp
100003f74:	5d	popq	%rbp
100003f75:	c3	retq

➜  Create objdump --macho -d TestEx2
TestEx2:
(__TEXT,__text) section
_main2:
100003f20:	55	pushq	%rbp
100003f21:	48 89 e5	movq	%rsp, %rbp
100003f24:	48 83 ec 10	subq	$16, %rsp
100003f28:	48 8d 3d 6f 00 00 00	leaq	111(%rip), %rdi ## literal pool for: "Hello money"
100003f2f:	b0 00	movb	$0, %al
100003f31:	e8 48 00 00 00	callq	0x100003f7e ## symbol stub for: _printf
100003f36:	b9 01 00 00 00	movl	$1, %ecx
100003f3b:	89 45 fc	movl	%eax, -4(%rbp)
100003f3e:	89 c8	movl	%ecx, %eax
100003f40:	48 83 c4 10	addq	$16, %rsp
100003f44:	5d	popq	%rbp
100003f45:	c3	retq
100003f46:	90	nop
100003f47:	90	nop
100003f48:	90	nop
100003f49:	90	nop
100003f4a:	90	nop
100003f4b:	90	nop
100003f4c:	90	nop
100003f4d:	90	nop
100003f4e:	90	nop
100003f4f:	90	nop
_main:
100003f50:	55	pushq	%rbp
100003f51:	48 89 e5	movq	%rsp, %rbp
100003f54:	48 83 ec 10	subq	$16, %rsp
100003f58:	c7 45 fc 00 00 00 00	movl	$0, -4(%rbp)
100003f5f:	48 8d 3d 44 00 00 00	leaq	68(%rip), %rdi ## literal pool for: "Hello world"
100003f66:	b0 00	movb	$0, %al
100003f68:	e8 11 00 00 00	callq	0x100003f7e ## symbol stub for: _printf
100003f6d:	b9 01 00 00 00	movl	$1, %ecx
100003f72:	89 45 f8	movl	%eax, -8(%rbp)
100003f75:	89 c8	movl	%ecx, %eax
100003f77:	48 83 c4 10	addq	$16, %rsp
100003f7b:	5d	popq	%rbp
100003f7c:	c3	retq

可以确定生成的MachO文件不同了。

MachO是一系列.o文件的集合

三：MachO文件结构

3.1 Header

包含了二进制文件的一般信息
- 字节顺序、架构类型、加载指令的数量等
- 使得一些信息可以快速确认
  - 比如当前文件是用于32位还是64位，对应的处理器是什么、文件类型是什么

Header数据结构

可以再Xcode中快速打开文件 Loader.h查看，这个文件时学习MachO非常好的一个入口！

/*
 * The 64-bit mach header appears at the very beginning of object files for
 * 64-bit architectures.
 */
struct mach_header_64 {
	uint32_t	magic;		/* mach magic number identifier */
	cpu_type_t	cputype;	/* cpu specifier */
	cpu_subtype_t	cpusubtype;	/* machine specifier */
	uint32_t	filetype;	/* type of file */
	uint32_t	ncmds;		/* number of load commands */
	uint32_t	sizeofcmds;	/* the size of all the load commands */
	uint32_t	flags;		/* flags */
	uint32_t	reserved;	/* reserved */
};

magic 快速定位是64位还是32位 cputype CPU类型，比如ARM cpusubtype CPU具体类型，比如：arm64/armv7 filetype 文件类型，比如：可执行文件 ncmds LoadCommands条数 sizeofcmds LoadCommands大小 flags 标志位，标识二进制文件支持的功能。主要是和系统加载、链接有关。

使用`otool`查看`Header`内容

➜  Create otool -v -h TestEx2
TestEx2:
Mach header
      magic  cputype cpusubtype  caps    filetype ncmds sizeofcmds      flags
MH_MAGIC_64   X86_64        ALL  0x00     EXECUTE    16       1368   NOUNDEFS DYLDLINK TWOLEVEL PIE

3.2 Load commands

内容包括区域的位置、符号表、动态符号表等

Rebase info offset

MachO文件在加载到内存中后（虚拟内存），会被分配一个随机的偏移值ASLR。我们使用静态分析工具看到的并不是真实的内存地址。

查看当前ASLR

命令image list -o -f | grep 当前MachO文件名

(lldb) image list -o -f | grep WeChat
[  0] 0x0000000000118000 /Users/RyukieW/Library/Developer/Xcode/DerivedData/WeChat-ajurlvyhlazpsbhatmdivvridyee/Build/Products/Debug-iphoneos/WeChat.app/WeChat

ASLR 0x0000000000118000 （随机的每次都不一样）真实地址 0x10011e640

用工具查看地址

0x0000000100006640

计算真实地址

ASLR + 工具显示的地址
使用编程计算器验证成功！

使用`otool`查看`Load commands`内容

➜  Create otool -v -l TestEx2
...

3.3 Data

通常是文件中最大的部分
包含Segement的具体数据

戴铭-Apple 操作系统可执行文件 Mach-O iOS逆向工程（九）：ASLR

利用Xcode进行重签名与调试

Mon, 03 May 2021 00:00:00 GMT

一、使用方式：

Xcode - Build Phases - Run Script - 添加脚本即可

二、脚本

# ${SRCROOT} 它是工程文件所在的目录
TEMP_PATH="${SRCROOT}/Temp"
#资源文件夹，我们提前在工程目录下新建一个APP文件夹，里面放ipa包
ASSETS_PATH="${SRCROOT}/APP"
#目标ipa包路径
TARGET_IPA_PATH="${ASSETS_PATH}/*.ipa"
#清空Temp文件夹
rm -rf "${SRCROOT}/Temp"
mkdir -p "${SRCROOT}/Temp"

#----------------------------------------
# 1. 解压IPA到Temp下
unzip -oqq "$TARGET_IPA_PATH" -d "$TEMP_PATH"
# 拿到解压的临时的APP的路径
TEMP_APP_PATH=$(set -- "$TEMP_PATH/Payload/"*.app;echo "$1")
# echo "路径是:$TEMP_APP_PATH"


#----------------------------------------
# 2. 将解压出来的.app拷贝进入工程下
# BUILT_PRODUCTS_DIR 工程生成的APP包的路径
# TARGET_NAME target名称
TARGET_APP_PATH="$BUILT_PRODUCTS_DIR/$TARGET_NAME.app"
echo "app路径:$TARGET_APP_PATH"

rm -rf "$TARGET_APP_PATH"
mkdir -p "$TARGET_APP_PATH"
cp -rf "$TEMP_APP_PATH/" "$TARGET_APP_PATH"



#----------------------------------------
# 3. 删除extension和WatchAPP.个人证书没法签名Extention
rm -rf "$TARGET_APP_PATH/PlugIns"
rm -rf "$TARGET_APP_PATH/Watch"



#----------------------------------------
# 4. 更新info.plist文件 CFBundleIdentifier
#  设置:"Set : KEY Value" "目标文件路径"
/usr/libexec/PlistBuddy -c "Set :CFBundleIdentifier $PRODUCT_BUNDLE_IDENTIFIER" "$TARGET_APP_PATH/Info.plist"


#----------------------------------------
# 5. 给MachO文件上执行权限
# 拿到MachO文件的路径
APP_BINARY=`plutil -convert xml1 -o - $TARGET_APP_PATH/Info.plist|grep -A1 Exec|tail -n1|cut -f2 -d\>|cut -f1 -d\<`
#上可执行权限
chmod +x "$TARGET_APP_PATH/$APP_BINARY"



#----------------------------------------
# 6. 重签名第三方 FrameWorks
TARGET_APP_FRAMEWORKS_PATH="$TARGET_APP_PATH/Frameworks"
if [ -d "$TARGET_APP_FRAMEWORKS_PATH" ];
then
for FRAMEWORK in "$TARGET_APP_FRAMEWORKS_PATH/"*
do

#签名
/usr/bin/codesign --force --sign "$EXPANDED_CODE_SIGN_IDENTITY" "$FRAMEWORK"
done
fi

三、如何安装重签名的包进行调试

3.1 安装

使用Xcode成功运行后会直接安装到手机上，也可以在Products中选择.app文件拷贝出来保存一下，通过下面的方式进行安装

3.2 调试

成功！愉快的学习吧~

四：生成重签名后的IPA

在项目的Products下找到.app文件，拷贝出来。
创建Payload文件夹，将上面获得的.app文件放入其中。
压缩Payload文件夹，修改后缀为.ipa即可。

dylib注入

Mon, 03 May 2021 00:00:00 GMT

一、分析MachO

可以发现系统动态库的路径是在系统下的

非系统库是在工程的相对路径中

因为我们并没有源码，所以想要注入代码就要通过直接修改MachO文件来实现。

二、工具yololib

在利用Xcode进行重签名与调试中有提到如何使用脚本进行重签名，这里我们也可以通过修改脚本快速的使用工具进行MachO文件的修改。

结尾加上这一句：

./yololib "$TARGET_APP_PATH/$APP_BINARY" "Frameworks/你要注入的.dylib"

可能会遇到 ./yololib: Permission denied 错误，为文件添加权限即可 chmod +x yololib

三、准备自己的dylib

3.1 建一个`MacOS`的`Library`。

@implementation RyukieHook
+ (void)load {
    NSLog(@"\n\n\n\n\n\n\n\n\n\n\n RyukieHookSuccess \n\n\n\n\n\n\n\n\n\n\n");
}
@end

3.2 修改`BaseSDK`为`iOS`

3.3 设置编译时拷贝文件

运行注入成功！

iOS应用签名原理

Sat, 01 May 2021 00:00:00 GMT

一：代码签名

代码签名是对可执行文件或脚本进行数字签名，用来确认软件在签名后未被修改或者损坏的措施。和数字签名原理一样，只不过签名的数据是代码而已。

1.1 简单的代码签名

在iOS系统出来之前，以前主流的操作系统软件随便从哪里下载都能运行。存在安全隐患。苹果为了保证每一个安装到iOS设备上的App都是经过苹果允许的，设计了代码签名。

最简单的方式就是通过：

苹果官方生成非对称加密的一堆公私钥。
在iOS系统中内置一个公钥，私钥由苹果后台保存。
我们将App传到AppStore后
苹果后台用私钥对App进行签名
iOS系统下载这个App后，用公钥验证这个签名。

1.2 问题

如果只能从AppStore安装App的话问题就简单了，但是实际上还是有很多渠道的。比如开发者调试安装，企业安装。这些就无法通过简单的代码签名来办到了。

1.3 苹果的需求

安装包不用上传AppStore，可以直接安装到手机上
苹果为了保证系统的安全性，必须对安装的App拥有绝对的控制权
- 经过苹果允许才能安装
- 不能被滥用导致开发者App也能被安装

为了达到上述目的苹果的方案是双层签名

二：双层代码签名

上面的只是简单的一部分，结合描述文件达到更严格的限制

三：描述文件

四：流程

Mac电脑有一对密钥公钥A+私钥A
苹果服务器有一个私钥B
iPhone有一个公钥B
电脑生成CSR文件（公钥A及一些组织信息），向苹果请求描述文件
- 描述文件
  - 可安装的设备IDs
  - AppID
  - 应用权限
  - 证书
    - 被私钥B加密
    - 公钥A
    - 公钥A的hash值
电脑打包出App
- MachO文件
- App的签名（用公钥A签名）
- 证书
安装到iPhone上
- 公钥B解出证书中的公钥A
- 用解出的公钥A验证App签名
- 验证成功就可以安装了

Swift位移枚举

Mon, 29 Mar 2021 00:00:00 GMT

一：以系统中的一个位移枚举为例

a. OC版本

typedef NS_OPTIONS(NSUInteger, UIRectCorner) {
    UIRectCornerTopLeft     = 1 << 0,
    UIRectCornerTopRight    = 1 << 1,
    UIRectCornerBottomLeft  = 1 << 2,
    UIRectCornerBottomRight = 1 << 3,
    UIRectCornerAllCorners  = ~0UL
};

[view addRoundedCorners:(UIRectCornerTopLeft | UIRectCornerTopRight) withRadii:CGSizeMake(12.f, 12.f)];

b.Swift版本

public struct UIRectCorner : OptionSet {
    public init(rawValue: UInt)
    
    public static var topLeft: UIRectCorner { get }

    public static var topRight: UIRectCorner { get }

    public static var bottomLeft: UIRectCorner { get }

    public static var bottomRight: UIRectCorner { get }

    public static var allCorners: UIRectCorner { get }
}

$0.addRoundedCorners([.topLeft, .topRight], withRadii: CGSize(width: 15, height: 15))

c.分析

发现在Swift中它并不是枚举，而是装换为了结构体，使用的API出则是转换为了对应元素类型的数组。我们需要自定义位移枚举的时候可以参考系统的这种实现方式。

如：

struct Sports: OptionSet {
    let rawValue: Int

    static let running = Sports(rawValue: 1)
    static let cycling = Sports(rawValue: 2)
    static let swimming = Sports(rawValue: 4)
    static let fencing = Sports(rawValue: 8)
    static let shooting = Sports(rawValue: 32)
    static let horseJumping = Sports(rawValue: 512)
}

二：Swift:union

当然部分API并没有经过上面的这种转化，如：下面就是我在异步处理图片的时候遇到的一个场景

let bitmapInfo: CGBitmapInfo = CGBitmapInfo(rawValue: hasAlpha ? CGImageAlphaInfo.premultipliedFirst.rawValue : CGImageAlphaInfo.noneSkipFirst.rawValue).union(.byteOrder32Little)

正如注释中所说：A new option set made up of the elements contained in this set, in other, or in both.

知识点梳理：算法数据结构

Thu, 25 Mar 2021 00:00:00 GMT

01 时间复杂度与空间复杂度

我们衡量算法的优劣主要通过两个维度时间``空间,而这两个维度对应的就是时间复杂度``空间复杂度. 但鱼和熊掌不可兼得,我们只能在这两者间取得一个合适的平衡点

1.时间复杂度

算法所需要的时间工作量

标记公式
- T(n) = O(n)

常见的时间复杂度量级

a.常数阶O(1)

int i = 1;
int j = 2;
++i;
j++;
int m = i + j;

b.线性阶O(n)

for(i=1; i<=n; ++i)
{
   j = i;
   j++;
}

c.对数阶O(logN)

以2为底

int i = 1;
while(i<n)
{
    i = i * 2;
}

d.线性对数阶(nlogN)

for(m=1; m<n; m++)
{
    i = 1;
    while(i<n)
    {
        i = i * 2;
    }
}

e.平方阶(n²)

for(x=1; i<=n; x++)
{
   for(i=1; i<=n; i++)
    {
       j = i;
       j++;
    }
}

如果把一层循环的n改成m,时间复杂度就成了 O(m*n)

for(x=1; i<=m; x++)
{
   for(i=1; i<=n; i++)
    {
       j = i;
       j++;
    }
}

f.立方阶O(n³)、K次方阶O(n^k)

参考的O(n²),O(n³)相当于三层n循环

2.空间复杂度

算法在运算中临时占用的控件的大小

标记公式
- S(n) = O(n)

常见的空间复杂度量级

a. O(1)

如果算法执行所需要的临时空间不随着某个变量n的大小而变化，即此算法空间复杂度为一个常量，可表示为 O(1)

int i = 1;
int j = 2;
++i;
j++;
int m = i + j;

b. O(n)

int[] m = new int[n]
for(i=1; i<=n; ++i)
{
   j = i;
   j++;
}

这段代码中，第一行new了一个数组出来，这个数据占用的大小为n，这段代码的2-6行，虽然有循环，但没有再分配新的空间，因此，这段代码的空间复杂度主要看第一行即可，即 S(n) = O(n)

02 排序题

这里简单的说下几种快速排序的不同之处，随机快排，是为了解决在近似有序的情况下，时间复杂度会退化为O(n^2),双路快排是为了解决快速排序在大量数据重复的情况下，时间复杂度会退化为O(n^2)，三路快排是在大量数据重复的情况下，对双路快排的一种优化。

冒泡排序

extension Array where Element : Comparable{
    public mutating func bubbleSort() {
        let count = self.count
        for i in 0..<count {
            for j in 0..<(count - 1 - i) {
                if self[j] > self[j + 1] {
                    (self[j], self[j + 1]) = (self[j + 1], self[j])
                }
            }
        }
    }
}

选择排序

extension Array where Element : Comparable{
    public mutating func selectionSort() {
        let count = self.count
        for i in 0..<count {
            var minIndex = i
            for j in (i+1)..<count {
                if self[j] < self[minIndex] {
                    minIndex = j
                }
            }
            (self[i], self[minIndex]) = (self[minIndex], self[i])
        }
    }
}

插入排序

extension Array where Element : Comparable{
    public mutating func insertionSort() {
        let count = self.count
        guard count > 1 else { return }
        for i in 1..<count {
            var preIndex = i - 1
            let currentValue = self[i]
            while preIndex >= 0 && currentValue < self[preIndex] {
                self[preIndex + 1] = self[preIndex]
                preIndex -= 1
            }
            self[preIndex + 1] = currentValue
        }
    }
}

快速排序

extension Array where Element : Comparable{
    public mutating func quickSort() {
        func quickSort(left:Int, right:Int) {
            guard left < right else { return }
            var i = left + 1,j = left
            let key = self[left]
            while i <= right {
                if self[i] < key {
                    j += 1
                    (self[i], self[j]) = (self[j], self[i])
                }
                i += 1
            }
            (self[left], self[j]) = (self[j], self[left])
            quickSort(left: j + 1, right: right)
            quickSort(left: left, right: j - 1)
        }
        quickSort(left: 0, right: self.count - 1)
    }
}

随机快排

extension Array where Element : Comparable{
    public mutating func quickSort1() {
        func quickSort(left:Int, right:Int) {
            guard left < right else { return }
            let randomIndex = Int.random(in: left...right)
            (self[left], self[randomIndex]) = (self[randomIndex], self[left])
            var i = left + 1,j = left
            let key = self[left]
            while i <= right {
                if self[i] < key {
                    j += 1
                    (self[i], self[j]) = (self[j], self[i])
                }
                i += 1
            }
            (self[left], self[j]) = (self[j], self[left])
            quickSort(left: j + 1, right: right)
            quickSort(left: left, right: j - 1)
        }
        quickSort(left: 0, right: self.count - 1)
    }
}

双路快排

extension Array where Element : Comparable{
    public mutating func quickSort2() {
        func quickSort(left:Int, right:Int) {
            guard left < right else { return }
            let randomIndex = Int.random(in: left...right)
            (self[left], self[randomIndex]) = (self[randomIndex], self[left])
            var l = left + 1, r = right
            let key = self[left]
            while true {
                while l <= r && self[l] < key {
                    l += 1
                }
                while l < r && key < self[r]{
                    r -= 1
                }
                if l > r { break }
                (self[l], self[r]) = (self[r], self[l])
                l += 1
                r -= 1
            }
            (self[r], self[left]) = (self[left], self[r])
            quickSort(left: r + 1, right: right)
            quickSort(left: left, right: r - 1)
        }
        quickSort(left: 0, right: self.count - 1)
    }
}

三路快排

// 三路快排
extension Array where Element : Comparable{
    public mutating func quickSort3() {
        func quickSort(left:Int, right:Int) {
            guard left < right else { return }
            let randomIndex = Int.random(in: left...right)
            (self[left], self[randomIndex]) = (self[randomIndex], self[left])
            var lt = left, gt = right
            var i = left + 1
            let key = self[left]
            while i <= gt {
                if self[i] == key {
                    i += 1
                }else if self[i] < key{
                    (self[i], self[lt + 1]) = (self[lt + 1], self[i])
                    lt += 1
                    i += 1
                }else {
                    (self[i], self[gt]) = (self[gt], self[i])
                    gt -= 1
                }
                
            }
            (self[left], self[lt]) = (self[lt], self[left])
            quickSort(left: gt + 1, right: right)
            quickSort(left: left, right: lt - 1)
        }
        quickSort(left: 0, right: self.count - 1)
    }
}

知识点梳理：多线程

Thu, 25 Mar 2021 00:00:00 GMT

1. GCD实现多读单写

比如在内存中维护一份数据，有多处地方可能会同时操作这块数据，怎么能保证数据安全？这道题目总结得到要满足以下三点：

读写互斥
写写互斥
读读并发

@implementation KCPerson
- (instancetype)init
{
    if (self = [super init]) {
       _concurrentQueue = dispatch_queue_create("com.kc_person.syncQueue", DISPATCH_QUEUE_CONCURRENT);
       _dic = [NSMutableDictionary dictionary];
    }
    return self;
}
- (void)kc_setSafeObject:(id)object forKey:(NSString *)key{
    key = [key copy];
    dispatch_barrier_async(_concurrentQueue, ^{
       [_dic setObject:object key:key];
    });
}

- (id)kc_safeObjectForKey：:(NSString *)key{
    __block NSString *temp;
    dispatch_sync(_concurrentQueue, ^{
        temp =[_dic objectForKey：key];
    });
    return temp;
}
@end

首先我们要维系一个GCD 队列，最好不用全局队列，毕竟大家都知道全局队列遇到栅栏函数是有坑点的，这里就不分析了！
因为考虑性能死锁堵塞的因素不考虑串行队列，用的是自定义的并发队列！_concurrentQueue = dispatch_queue_create("com.kc_person.syncQueue", DISPATCH_QUEUE_CONCURRENT);
首先我们来看看读操作:kc_safeObjectForKey 我们考虑到多线程影响是不能用异步函数的！说明：
- 线程2 获取：name 线程3 获取 age
- 如果因为异步并发，导致混乱本来读的是name 结果读到了age
- 我们允许多个任务同时进去! 但是读操作需要同步返回，所以我们选择:同步函数 （读读并发）
我们再来看看写操作，在写操作的时候对key进行了copy, 关于此处的解释，插入一段来自参考文献的引用:

函数调用者可以自由传递一个NSMutableString的key，并且能够在函数返回后修改它。因此我们必须对传入的字符串使用copy操作以确保函数能够正确地工作。如果传入的字符串不是可变的（也就是正常的NSString类型），调用copy基本上是个空操作。

这里我们选择 dispatch_barrier_async, 为什么是栅栏函数而不是异步函数或者同步函数，下面分析：
- 栅栏函数任务：
  - 之前所有的任务执行完毕，并且在它后面的任务开始之前，期间不会有其他的任务执行，这样比较好的促使写操作一个接一个写（写写互斥），不会乱！
- 为什么不是异步函数？
  - 应该很容易分析，毕竟会产生混乱！
- 为什么不用同步函数？
  - 如果读写都操作了，那么用同步函数，就有可能存在：我写需要等待读操作回来才能执行，显然这里是不合理！

2 多线程和锁

**进程：**是资源分配的基本单位，它是程序执行时的一个实例，在程序运行时创建。

**线程：**是程序执行的最小单位，是进程的一个执行流，一个进程由多个线程组成。

多线程：

一个进程中并发执行多个线程，叫做多线程。在一个时间片内，CPU只能处理一个线程中的一个任务，对于一个单核CPU来说，在不同的时间片来执行不同线程中的任务，就形成了多个任务在同时执行的“假象”。

多线程的几种方式

pthread：
- 即POSIX Thread，缩写称为pthread，是线程的POSIX标准，是一套通用的多线程API，可以在Unix/Linux/Windows等平台跨平台使用。iOS中基本不使用。
NSThread：
- 苹果封装的面向对象的线程类，可以直接操作线程，比起GCD，NSThread效率更高，由程序员自行创建，当线程中的任务执行完毕后，线程会自动退出，程序员也可手动管理线程的生命周期。使用频率较低。
GCD：
- 全称Grand Central Dispatch，由C语言实现，是苹果为多核并行运算提出的解决方案，CGD会自动利用更多的CPU内核，自动管理线程的生命周期，程序员只需要告诉GCD需要执行的任务，无需编写任何管理线程的代码。GCD也是iOS使用频率最高的多线程技术。
NSOperation：
- 基于GCD封装的面向对象的多线程技术，常配合NSOperationQueue使用，使用频率较高。

GCD 和 NSOperation 区别

GCD仅仅支持先进先出FIFO队列，不支持异步操作之间的依赖关系设置。而NSOperation中的队列可以被重新设置优先级，从而实现不同操作的执行顺序调整。
NSOperation支持KVO，可以观察任务的执行状态。
GCD更接近底层，GCD在追求性能的底层操作来说，是速度最快的。
从异步操作之间的事务性，顺序行，依赖关系。GCD需要自己写更多的代码来实现，而NSOperation已经内建了这些支持。
如果异步操作的过程需要更多的被交互和UI呈现出来，NSOperation更好。底层代码中，任务之间不太互相依赖，而需要更高的并发能力，GCD则更有优势。

线程池原理

使用线程执行任务的时候，需要到线程池中去取线程进行任务分配。
首先判断线程池大小是否小于核心线程池大小，如果小于的话，创建新的线程执行任务；
如果当前线程池大小大于了核心线程池大小，然后开始判断工作队列是否已满，如果没满，将任务提交到工作队列。
如果工作队列已满，判断线程池的线程是否都在工作，如果有空闲线程没有在工作，就交给它去执行任务。
如果线程池中的线程都在工作，那么就交给饱和策略去执行。

饱和策略分为下面四种：

AbortPolicy 直接抛出RejectedExecutionExeception 异常来阻止系统正常运行；
CallerRunsPolicy 将任务回退到调用者；
DisOldestPolicy 丢掉等待最久的任务‘；
DisCardPolicy 直接丢弃任务。

线程间通讯

直接同步或者异步向任务队列添加任务。

通过NSPort端口的形式进行发送消息，实现不同的线程间的通信。使用的时候注意需要将NSPort加入的线程的RunLoop中去。

**直接消息传递：**通过performSelector的一系列方法，可以实现由某一线程指定在另外的线程上执行任务。因为任务的执行上下文是目标线程，这种方式发送的消息将会自动的被序列化。
**全局变量、共享内存块和对象：**在两个线程之间传递信息的另一种简单方法是使用全局变量，共享对象或共享内存块。尽管共享变量既快速又简单，但是它们比直接消息传递更脆弱。必须使用锁或其他同步机制仔细保护共享变量，以确保代码的正确性。否则可能会导致竞争状况，数据损坏或崩溃。
**条件执行：**条件是一种同步工具，可用于控制线程何时执行代码的特定部分。您可以将条件视为关守，让线程仅在满足指定条件时运行。
Runloop sources：一个自定义的Runloop source配置可以让一个线程上收到特定的应用程序消息。由于Runloop source是事件驱动的，因此在无事可做时，线程会自动进入睡眠状态，从而提高了线程的效率。
**Ports and sockets：**基于端口的通信是在两个线程之间进行通信的一种更为复杂的方法，但它也是一种非常可靠的技术。更重要的是，端口和套接字可用于与外部实体（例如其他进程和服务）进行通信。为了提高效率，使用Runloop source来实现端口，因此当端口上没有数据等待时，线程将进入睡眠状态。
**消息队列：**传统的多处理服务定义了先进先出（FIFO）队列抽象，用于管理传入和传出数据。尽管消息队列既简单又方便，但是它们不如其他一些通信技术高效。
**Cocoa 分布式对象：**分布式对象是一种 Cocoa 技术，可提供基于端口的通信的高级实现。尽管可以将这种技术用于线程间通信，但是强烈建议不要这样做，因为它会产生大量开销。分布式对象更适合与其他进程进行通信，尽管在这些进程之间进行事务的开销也很高。

锁

线程安全就是在同一时刻，对同一个数据操作的线程只有一个。这时就用到了锁。

**锁：**是保证线程安全的同步工具。每一个线程在访问数据资源之前，要先获取(acquire)锁，然后在访问结束之后释放(release)锁。如果锁已经被占用，其它要获取锁的线程会等待，直到锁重新可用。
iOS中的锁分为互斥锁、自旋锁、信号量这三种。

互斥锁

就是在多线程编程中，防止两条线程同时对同一公共资源(比如全局变量)进行读写。

@synchronized：是递归锁

调用synchronzied的每个对象，runtime都会为其分配一个递归锁并存储在哈希表中。
如果在synchronzied内部对象被释放或为nil，会执行类似objc_sync_nil的空方法。
注意不要像synchronzied传入nil , 这将会从代码中移走线程安全。

NSLock：遵循 NSLocking 协议，lock方法是加锁，unlock是解锁，tryLock是尝试加锁，如果失败的话返回 NO，lockBeforeDate: 是在指定Date之前尝试加锁，如果在指定时间之前都不能加锁，则返回NO。注意不能多次调用lock方法，会造成死锁。

自旋锁

线程会反复检查锁变量是否可用，线程在这一过程中保持执行，是一种忙等待，一旦获取了自旋锁，线程会一直保持该锁，直至显式释放自旋锁，自旋锁避免了进程上下文的调度开销，因此对于线程只会阻塞很短时间的场合是有效的。atomic就是通过个set和get方法添加一个自旋锁。

信号量

dispatch_semaphore

使用：

1). 通过dispatch_semaphore_create(value)创建一个信号量，初始为1。
2). 等待信号量dispatch_semaphore_wait，可以理解为lock加锁，会使信号量-1。
3). 发送信号量dispatch_semaphore_signal，可以理解为 unlock解锁，会使 signal 信号量+1。

互斥锁是 dispatch_semaphore在取值0/1时的特例。信号量可以有更多的取值空间，用来实现更加复杂的同步，而不仅仅是线程间互斥。

3 通知，能不能跨线程

不能跨线程，在哪个线程发送的通知，就会在哪个线程接收。所以需要手动切换到主线程更新UI。

测试过程发出通知的线程决定接收通知处理代码线程
- 主线程发通知 — 子线程监听通知：接收通知代码在主线程处理
- 子线程发通知 — 主线程监听通知：接收通知代码在子线程处理

4 面试题记录-C语言

Thu, 25 Mar 2021 00:00:00 GMT

001_int ptr=(int )(&a+1)

下面的输出结果是什么?

int main()
{
	int a[5]={1,2,3,4,5};
	int *ptr=(int *)(&a+1);
	printf("%d,%d\n",*(a+1),*(ptr-1));
}

*(a+1)
- 这里吧a当成一个指针
- a+1 = a + sizeof(int)
- a+1指向a的下一个整形地址即 &a[1]
(&a+1)
- 先获取a的地址
- +1再获取下一个与a同类型(int[5])的相邻地址
- &a+1 = &a + sizeof(a)
- 即&a[5],a最后一个元素的下一个地址
*(ptr-1)
- 同*(a+1)原理
- 指向了&a[5]前一个元素地址
- 即&a[4]
结果
- 2,5

知识点梳理：网络

Thu, 25 Mar 2021 00:00:00 GMT

一、 HTTPS 和 HTTP

1.1 HTTPS协议 = HTTP协议 + SSL/TLS协议

SSL的全称是Secure Sockets Layer，即安全套接层协议，是为网络通信提供安全及数据完整性的一种安全协议。
TLS的全称是Transport Layer Security，即安全传输层协议。

1.2 即HTTPS是安全的HTTP

https, 全称Hyper Text Transfer Protocol Secure，相比http，多了一个secure，这一个secure是怎么来的呢？
这是由TLS（SSL）提供的！大概就是一个叫openSSL的library提供的。
https和http都属于application layer，基于TCP（以及UDP）协议，但是又完全不一样。
TCP用的port是80， https用的是443（值得一提的是，google发明了一个新的协议，叫QUIC，并不基于TCP，用的port也是443，同样是用来给https的。谷歌好牛逼啊。）总体来说，https和http类似，但是比http安全。

1.3 HTTPS的握手流程

1：客户端发起HTTPS请求，将SSL协议版本的信息发送给服务端。
2：服务器收到之后，会以Server Hello 报文作为应答。和客户端一样，报文中包含客户端支持的SSL的版本，加密组件列表。服务器的加密组件内容是从接收到的客户端加密组件内筛选出来的
3：服务器发送Certificate报文。报文中包含公开密钥证书。
4：然后服务器发送Server Hello Done报文通知客户端，最初阶段的SSL握手协商部分结束
5：SSL第一次握手结束之后，客户端以Client Key Exchange报文作为会议。报文中包含通信加密中使用的一种被称为Pre-master secret的随机密码串
6：接着客户端发送Change Cipher Space报文。该报文会提示服务器，在次报文之后的通信会采用Pre-master secret密钥加密
7：客户端发送Finished 报文。该报文包含链接至今全部报文的整体校验值。这次握手协商是否能够成功，要以服务器是否能够正确揭秘该报文作为判定标准
8：服务器同样发送Change Cipher Space报文。
9：服务器同样发送Finished报文。
10：服务器和客户端的Finished报文交换完毕之后，SSL连接建立完成，从此开始HTTP通信，通信的内容都使用Pre-master secret加密。然后开始发送HTTP请求
11：应用层收到HTTP请求之后，发送HTTP响应
12：最后有客户端断开连接

1.4 为什么密钥的传递需要使用非对称加密？

使用非对称加密是为了后面客户端生成的Pre-master secret密钥的安全，通过上面的步骤能得知，服务器向客户端发送公钥证书这一步是有可能被别人拦截的，如果使用对称加密的话，在客户端向服务端发送Pre-master secret密钥的时候，被黑客拦截的话，就能够使用公钥进行解码，就无法保证Pre-master secret密钥的安全了

1.5 对称加密和非对称加密的区别？分别有哪些算法的实现？

对称加密，加密的加密和解密使用同一密钥。

非对称加密，使用一对密钥用于加密和解密，分别为公开密钥和私有密钥。公开密钥所有人都可以获得，通信发送方获得接收方的公开密钥之后，就可以使用公开密钥进行加密，接收方收到通信内容后使用私有密钥解密。
对称加密常用的算法实现有AES,ChaCha20,DES,不过DES被认为是不安全的;非对称加密用的算法实现有RSA，ECC

1.6 双向认证了解么？

上面的HTTPS的通信流程只验证了服务端的身份，而服务端没有验证客户端的身份，双向认证是服务端也要确保客户端的身份，大概流程是客户端在校验完服务器的证书之后，会向服务器发送自己的公钥，然后服务端用公钥加密产生一个新的密钥，传给客户端，客户端再用私钥解密，以后就用此密钥进行对称加密的通信

1.7 HTTP2.0 的特性

内容安全
- 应为 http2.0 是基于 https 的，天然具有安全特性，通过 http2.0 的特性可以避免单纯使用 https 的性能下降
二进制格式
- http1.X 的解析是基于文本的，http2.0 将所有的传输信息分割为更小的消息和帧，并对他们采用二进制格式编码，基于二进制可以让协议有更多的扩展性，比如引入了帧来传输数据和指令
多路复用
- 这个功能相当于是长连接的增强，每个 request 请求可以随机的混杂在一起，接收方可以根据 request 的 id 将 request 再归属到各自不同的服务端请求里面
- 另外多路复用中也支持了流的优先级，允许客户端告诉服务器那些内容是更优先级的资源，可以优先传输。

二、 TCP

2.1 三次握手

TCP是面向连接的协议，建立连接需要经过三次握手

客户端向服务端发起请求链接，首先发送SYN报文，SYN=1，seq=x,并且客户端进入SYN_SENT状态
服务端收到请求链接，服务端向客户端进行回复，并发送响应报文，SYN=1，seq=y,ACK=1,ack=x+1,并且服务端进入到SYN_RCVD状态
客户端收到确认报文后，向服务端发送确认报文，ACK=1，ack=y+1，此时客户端进入到ESTABLISHED，服务端收到用户端发送过来的确认报文后，也进入到ESTABLISHED状态，此时链接创建成功

2.2 四次挥手

TCP断开连接需要经过 四次挥手

客户端向服务端发起关闭链接，并停止发送数据
服务端收到关闭链接的请求时，向客户端发送回应，我知道了，然后停止接收数据
当服务端发送数据结束之后，向客户端发起关闭链接，并停止发送数据
客户端收到关闭链接的请求时，向服务端发送回应，我知道了，然后停止接收数据

2.3 为什么需要三次握手

为了防止已失效的连接请求报文段突然又传送到了服务端，因而产生错误，假设这是一个早已失效的报文段。但server收到此失效的连接请求报文段后，就误认为是client再次发出的一个新的连接请求。于是就向client发出确认报文段，同意建立连接。假设不采用“三次握手”，那么只要server发出确认，新的连接就建立了。由于现在client并没有发出建立连接的请求，因此不会理睬server的确认，也不会向server发送数据。但server却以为新的运输连接已经建立，并一直等待client发来数据。这样，server的很多资源就白白浪费掉了。

2.4 为什么需要四次挥手

因为TCP是全双工通信的，在接收到客户端的关闭请求时，还可能在向客户端发送着数据，因此不能再回应关闭链接的请求时，同时发送关闭链接的请求

2.3 TCP/UDP

TCP是传输控制协议，具有面向连接、可靠传输、点到点通信、全双工服务等特点，TCP侧重可靠传输。
UDP是用户数据报协议，具有非连接的、不可靠的、点到多点的通信等特点，UDP侧重快速传输。

2.4 TCP/IP协议

TCP/IP不是一个协议，而是一个协议簇的统称。
通常使用的网络是在TCP/IP协议簇的基础上运行的。
- 应用层的HTTP、DNS、FTP，传输层的TCP(传输控制协议)、UDP(用户数据报协议)，网络层的IP等等都属于它内部的一个子集。

2.5 TCP报文重点字段

序号：Seq序号，占32位，用来标识从TCP源端向目的端发送的字节流，发起方发送数据时对此进行标记。 确认序号：Ack序号，占32位，只有ACK标志位为1时，确认序号字段才有效，Ack=Seq+1。 标志位：共6个，即URG、ACK、PSH、RST、SYN、FIN等，具体含义如下：

（A）URG：紧急指针（urgent pointer）有效。
（B）ACK：确认序号有效。
（C）PSH：接收方应该尽快将这个报文交给应用层。
（D）RST：重置连接。
（E）SYN：发起一个新连接。
（F）FIN：释放一个连接。

2.6 为什么不能用两次握手进行连接？

因为三次握手是为了双方都知道彼此已做好准备，如果改成两次握手，会发生。
假设客户端给服务端发送连接请求，服务端收到后发送确认连接给客户端，如果两次握手的话此时服务端会认为已经建立了连接，可以发送数据了
但是如果确认连接数据丢失，客户端还不知道已经建立了连接
- 会一直等待确认连接序号，导致数据传输超时
- 服务端重复发送同样的数据，造成死锁。

2.7 客户端进入`TIME_WAIT`状态而不是直接进入`CLOSED`状态是因为

我们必须要假想网络是不可靠的，你无法保证你最后发送的ACK报文一定会被对方收到

因此对方处于LAST_ACK状态下的SOCKET可能会因为超时未收到ACK报文，而重发FIN报文

所以这个TIME_WAIT状态的作用就是用来重发可能丢失的ACK报文。

五、如何用Charles抓HTTPS的包？其中原理和流程是什么？

5.1 流程

首先在手机上安装Charles证书
在代理设置中开启Enable SSL Proxying
之后添加需要抓取服务端的地址

5.2 原理

Charles作为中间人，对客户端伪装成服务端，对服务端伪装成客户端。简单来说：

截获客户端的HTTPS请求，伪装成中间人客户端去向服务端发送HTTPS请求
接受服务端返回，用自己的证书伪装成中间人服务端向客户端发送数据内容。

具体流程如下图:扯一扯HTTPS单向认证、双向认证、抓包原理、反抓包策略

六、什么是中间人攻击？

中间人攻击就是截获到客户端的请求以及服务器的响应，比如Charles抓取HTTPS的包就属于中间人攻击。

如何避免？

避免的方式：客户端可以预埋证书在本地，然后进行证书的比较是否是匹配的

八、 Socket

1. WebSocket 与 TCP Socket的区别

Socket

Socket是抽象层，并不是一个协议
- 是为了方便使用TCP或UDP而抽象出来的一层，是位于应用层和传输层(TCP/UDP)之间的一组接口。

WebSocket

WebSocket和HTTP一样，都是应用层协议
- 是基于TCP 连接实现的双向通信协议，替代HTTP轮询的一种技术方案。
- 是全双工通信协议，HTTP是单向的
- 注意WebSocket和Socket是完全不同的两个概念。
WebSocket建立连接时通过HTTP传输，
- 但是建立之后，在真正传输时候是不需要HTTP协议的。
相对于传统 HTTP 每次请求-应答都需要客户端与服务端建立连接的模式，WebSocket 是类似 Socket 的 TCP 长连接的通讯模式，
一旦 WebSocket 连接建立后，后续数据都以帧序列的形式传输。
在客户端断开 WebSocket 连接或 Server 端断掉连接前，不需要客户端和服务端重新发起连接请求。
在海量并发及客户端与服务器交互负载流量大的情况下，极大的节省了网络带宽资源的消耗，有明显的性能优势，且客户端发送和接受消息是在同一个持久连接上发起，实时性优势明显。

2. WebSocket 连接过程 —— 握手过程

1.浏览器、服务器建立TCP连接，三次握手。这是通信的基础，传输控制层，若失败后续都不执行。
2.TCP连接成功后，浏览器通过HTTP协议向服务器传送WebSocket支持的版本号等信息。（开始前的HTTP握手）
3.服务器收到客户端的握手请求后，同样采用HTTP协议回馈数据。
4.当收到了连接成功的消息后，通过TCP通道进行传输通信。

3. Socket.IO

Socket.IO 是一个为浏览器（客户端）和服务器之间提供实时，双向和基于事件的通信软件库。

Socket.IO 是把数据传输抽离成 Engine.IO，内部对轮询（Polling）和 WebSocket 等进行了封装，抹平一些细节和平台兼容的问题，提供统一的 API。

注意 Socket.IO 不是 WebSocket 的实现，只是在必要时使用 WebSocket 传输数据，并在此基础上会加一些 MetaData。这就是为什么 WebSocket 的客户端/服务器无法和 Socket.IO 的服务器/客户端进行通信。

九、 POST和GET

9.1 POST安全?

其实也只是一点点罢了..

get请求的URL会被缓存在浏览器及Web服务器日志里,可能泄露
POST没有记录,只要数据服务器不被黑就安全
抓包的话GG(非HTTPS)

9.2 GET相对POST最大的优势

可以手输URL

9.3 何时使用GET

请求中的URL可以被手动输入
请求中的URL可以被存在书签里，或者历史里，或者快速拨号里面，或者分享给别人
请求中的URL是可以被搜索引擎收录的
带云压缩的浏览器，比如Opera mini/Turbo 2, 只有GET才能在服务器端被预取的
请求中的URL可以被缓存
可重复的交互例如: 取个数据,跳个页面用Get
- 不可重复的操作如创建,修改就用POST

参考

https://www.zhihu.com/question/31640769?rf=37401322

十、网络分层

1. 网络层级结构

TCP/IP四层结构

应用层
传输层
网络层
数据链路层
物理层

OSI七层网络结构

应用层
表示层
会话层
传输层
网络层
数据链路层
物理层

2. 优点

面试被问到了,记录下

各层之间是独立的
- 某一层并不需要知道它的下一层是怎么实现的,而仅仅需要知道该层通过层间接口所提供的接口服务
- 由于每一层间只实现相对独立的功能,因而可以将一个难以处理的复杂问题分解为若干个较容易处理的更小的问题,这样问题的复杂度就降低了
灵活性好
- 当某一层发生变化的时候只要层间关系保持不变,则这层的上下层均不受影响,此外,对某一层提供的服务还可以进行修改.当某一层提供的服务不再需要时,甚至可以将这层取消
结构上可分割开
- 各层都可以采用最合适的技术来实现
易于实现和维护
- 这种结构使得实现和调试一个庞大复杂的系统变得容易处理,因为整个系统已经被分解为若干个相对独立的子系统
能够促进标准化工作
- 因为每一层的功能机器提供的服务都已经有了明确的说明
注意
- 分层是应该注意每一层的功能非常明确,若层数太少,会使得每一层协议太复杂
- 层数太多又会在描述和综述各功能的系统工程任务时遇到较多困难

知识点梳理：计算机基础

Thu, 25 Mar 2021 00:00:00 GMT

1 了解编译的过程么？分为哪几个步骤？

1:预编译：主要处理以“#”开始的预编译指令。

2:编译：

词法分析：将字符序列分割成一系列的记号。
语法分析：根据产生的记号进行语法分析生成语法树。
语义分析：分析语法树的语义，进行类型的匹配、转换、标识等。
中间代码生成：源码级优化器将语法树转换成中间代码，然后进行源码级优化，比如把 1+2 优化为 3。中间代码使得编译器被分为前端和后端，不同的平台可以利用不同的编译器后端将中间代码转换为机器代码，实现跨平台。
目标代码生成：此后的过程属于编译器后端，代码生成器将中间代码转换成目标代码（汇编代码），其后目标代码优化器对目标代码进行优化，比如调整寻址方式、使用位移代替乘法、删除多余指令、调整指令顺序等。

3:汇编：汇编器将汇编代码转变成机器指令。

静态链接：链接器将各个已经编译成机器指令的目标文件链接起来，经过重定位过后输出一个可执行文件。
装载：装载可执行文件、装载其依赖的共享对象。
动态链接：动态链接器将可执行文件和共享对象中需要重定位的位置进行修正。
最后，进程的控制权转交给程序入口，程序终于运行起来了。

知识点梳理：iOS底层

Thu, 25 Mar 2021 00:00:00 GMT

1 KVC原理

KVC可以通过Key直接访问对象的属性，可以方便的在运行时对对象的属性进行访问和修改。

需要注意的是: 有时我们通过KVC去修改系统控件未暴露出的属性的时候，会出现部分内部API进行了调整导致崩溃。

1.1 API

- (void)setValue:(id)value forKeyPath:(NSString *)keyPath;
- (void)setValue:(id)value forKey:(NSString *)key;
- (id)valueForKeyPath:(NSString *)keyPath;
- (id)valueForKey:(NSString *)key;

forKeyPath 用于访问对象内对象属性的属性，如：user.name

1.2 写过程

查看setKey:方法是否存在, 如果存在直接调用, 如果不存在进入下一步
查看_setKey:方法是否存在, 如果存在直接调用, 如果不存在进入下一步
查看+ (BOOL)accessInstanceVariablesDirectly方法的返回值, 默认返回YES
- YES: 可以访问成员变量, 进入下一步
- NO: 不可以访问成员变量, 同时调用- (void)setValue:(id)value forUndefinedKey:(NSString *)key方法, 如果方法不存在会抛出异常
调用成员变量:_key, _isKey, key, isKey
- 调用顺序, 从左到右, 只有发现存在成员变量, 就不会在调用后续变量
- 如果没有成员变量, 会调用- (void)setValue:(id)value forUndefinedKey:(NSString *)key方法, 如果方法不存在会抛出异常

1.3 读过程

判断是否有这几个方法: getKey, key, isKey, _key
- 从左到右, 如果有方法, 直接调用, 取值结束
- 如果没有进入下一步
调用+ (BOOL)accessInstanceVariablesDirectly查看是否可以访问成员变量. 默认YES
- YES: 可以访问成员变量, 进入下一步
- NO: 不可以访问成员变量, 判断是否实现- (id)valueForUndefinedKey:(NSString *)key方法, 实现时调用, 未实现报错
判断是否有这几个成员变量: _key, _isKey, key, isKey
- 从左到右, 如果有成员变量, 直接访问, 取值结束
- 如果没有这几个成员变量, 直接进入下一步
判断是否实现- (id)valueForUndefinedKey:(NSString *)key方法, 实现时调用, 未实现报错

1.4 如何禁用KVC

如果重写了类方法 + (BOOL)accessInstanceVariablesDirectly 返回 NO 的话，那么会直接调用 valueForUndefinedKey: 方法，默认是抛出异常

2 讲一下atomic的实现机制；为什么不能保证绝对的线程安全（最好可以结合场景来说）？

A: atomic的实现机制与保证范围

atomic 是 Objective-C 属性的修饰符，也是默认选项。对于编译器自动生成的 getter/setter，它保证单次读取或单次赋值的原子性，读取或写入的属性值是完整的。不能理解成“写安全，读不安全”。
底层实现会根据属性类型、内存管理语义、编译器和 Runtime 版本选择相应的访问方式。以 atomic strong/copy 对象属性为例，自动生成的访问器可以走 objc_getProperty、objc_setProperty 或 objc_setProperty_atomic 等 Runtime 函数。下面的锁机制说明针对这些对象属性访问路径，不能直接套用到所有属性；例如 int、NSInteger 等简单类型可能通过原子读写实现，不一定调用这些函数或使用这些锁。

内部使用什么锁？

在 Apple 当前公开的 objc4 源码中，属性锁存放在 PropertyLocks 中，类型为 StripedMap<spinlock_t>。虽然名字叫 spinlock_t，它实际上是 objc_lock_t 的别名，在 Darwin 平台底层封装的是 os_unfair_lock。因此不能只看名字就把它理解成传统的自旋锁，也不能把具体锁类型当作跨版本不变的 API 保证。
Runtime 使用“对象地址 + 成员变量偏移量”计算属性的存储地址 slot，再根据该地址从 PropertyLocks 中选择锁。同一个属性的 getter 和 setter 会选中同一把锁，但每次访问分别加锁、解锁，不能共同保护整个 self.count++。
PropertyLocks 使用有限数量的锁，而不是给每个对象或每个属性单独创建一把锁。不同对象、不同属性的存储地址可能映射到同一把锁，因此可能产生额外的锁竞争。
关于原文的“iOS 8 个、Mac 64 个”：在本次核对的 objc4/main 源码中，StripedMap 的条件是 TARGET_OS_IPHONE && !TARGET_OS_SIMULATOR 时使用 8 个槽，其余情况使用 64 个槽。因此还需要区分真机与模拟器；这些数量属于该源码版本的实现细节。

getter 与 setter 的加锁范围

对象属性的 atomic getter 在锁内读取并 retain 对象，解锁后再处理返回值的自动释放，避免读取期间对象被并发替换并释放。
对象属性的 atomic setter 通常先在锁外对新值执行 retain/copy，在锁内读取旧值并替换属性值，再解锁并释放旧值。锁保护的是属性值的读取或替换，不保护返回对象后对其内容的操作。

以下是 getter 路径的源码片段：

// 根据对象地址与成员变量偏移量，找到属性的存储位置。
id *slot = (id *)((char *)self + offset);
spinlock_t& slotlock = PropertyLocks.get()[slot];
slotlock.lock();
id value = objc_retain(*slot);
slotlock.unlock();
return objc_autoreleaseReturnValue(value);

源码参考（本次核对日期：2026-10-11，main 分支内容可能更新）：objc-accessors.mm：属性访问与锁范围、objc-os.h：spinlock_t 别名、Threading/darwin.h：底层锁实现、objc-private.h：StripedMap 与槽数量。

这个保证针对自动生成的访问方法。直接访问成员变量会绕过这些方法；自行实现 getter/setter 时，也需要自己实现相应的同步逻辑。

B: 为什么 atomic 不能保证完整的线程安全？

场景一：复合操作 self.count++

@property (atomic, assign) NSInteger count;

self.count++ 包含“读取 → 加一 → 写回”三个步骤。atomic 保护单次读取和单次写入，但不会把整个自增过程作为一个原子操作。

假设初始值为 0，两个线程可能按下面的顺序执行：

步骤	线程 A	线程 B
1	读取到 0
2		读取到 0
3	加一并写入 1
4		加一并写入 1

最终结果为 1，而预期为 2，发生了更新丢失。

解决方式：保护整个“读—改—写”过程。 可以使用同一把互斥锁，也可以把相关访问统一安排到同一个串行队列中。

以下示例假设 countLock 是提前初始化、供所有相关线程共用且不会被替换的 NSLock 实例：

[self.countLock lock];

// 锁必须覆盖整个自增过程，不能只保护最后的写入。
self.count++;

[self.countLock unlock];

其他修改 count 的地方也必须遵守同一套同步规则。若其他读取需要与这段业务操作保持一致，也应使用同一把锁；采用串行队列时，则应统一通过该队列访问。

场景二：可变容器的内容修改

@property (atomic, strong) NSMutableArray *array;

[self.array addObject:obj];

这段代码先通过 getter 获取数组对象，再调用数组的 addObject:。atomic 保护的是属性所保存的对象引用的读取和赋值，不保护数组内部的修改。两个线程同时调用 addObject: 仍不安全，并发读写数组内容也需要额外同步。

面试回答示例：

atomic 保证自动生成的 getter 和 setter 的单次访问具有原子性，但不保证复合操作或属性所指向对象的线程安全。例如 self.count++ 的读取和写回之间可能被其他线程插入，导致更新丢失；atomic 的可变数组属性也不能保证并发添加元素安全。需要根据业务操作的范围，用同一把锁或同一个串行队列统一同步。

参考：Apple：Encapsulating Data、Apple：Declared Properties。

3 Autoreleasepool所使用的数据结构是什么？AutoreleasePoolPage结构体了解么？

Autoreleasepool是由多个AutoreleasePoolPage以双向链表的形式连接起来的.
Autoreleasepool的基本原理：在每个自动释放池创建的时候，会在当前的AutoreleasePoolPage中设置一个标记位，在此期间，当有对象调用autorelsease时，会把对象添加 AutoreleasePoolPage中
若当前页添加满了，会初始化一个新页，然后用双向量表链接起来，并把新初始化的这一页设置为hotPage,当自动释放池pop时，从最下面依次往上pop，调用每个对象的release方法，直到遇到标志位。

AutoreleasePoolPage结构如下

class AutoreleasePoolPage {
    magic_t const magic;
    id *next;//下一个存放autorelease对象的地址
    pthread_t const thread; //AutoreleasePoolPage 所在的线程
    AutoreleasePoolPage * const parent;//父节点
    AutoreleasePoolPage *child;//子节点
    uint32_t const depth;//深度,也可以理解为当前page在链表中的位置
    uint32_t hiwat;
}

4 iOS中内省的几个方法？class方法和objc_getClass方法有什么区别?

4.1 什么是内省？

在计算机科学中，内省是指计算机程序在运行时（Run time）检查对象（Object）类型的一种能力，通常也可以称作运行时类型检查。不应该将内省和反射混淆。相对于内省，反射更进一步，是指计算机程序在运行时（Run time）可以访问、检测和修改它本身状态或行为的一种能力。

4.2 iOS中内省的几个方法？

isMemberOfClass //对象是否是某个类型的对象
isKindOfClass //对象是否是某个类型或某个类型子类的对象
isSubclassOfClass //某个类对象是否是另一个类型的子类
isAncestorOfObject //某个类对象是否是另一个类型的父类
respondsToSelector //是否能响应某个方法
conformsToProtocol //是否遵循某个协议*

4.3 class方法和object_getClass方法有什么区别?

实例class方法就直接返回object_getClass(self)
类class方法直接返回self，而object_getClass(类对象)，则返回的是元类

5 分类和扩展有什么区别？可以分别用来做什么？分类有哪些局限性？分类的结构体里面有哪些成员？

分类
- 主要用来为某个类添加方法，属性，协议（我一般用来为系统的类扩展方法或者把某个复杂的类的按照功能拆到不同的文件里）
扩展
- 主要用来为某个类原来没有的成员变量、属性、方法。注：方法只是声明（我一般用扩展来声明私有属性，或者把.h的只读属性重写成可读写的）

分类和扩展的区别：

分类是在运行时把分类信息合并到类信息中，而扩展是在编译时，就把信息合并到类中的
分类声明的属性，只会生成getter/setter方法的声明，不会自动生成成员变量和getter/setter方法的实现，而扩展会
分类不可用为类添加实例变量，而扩展可以
分类可以为类添加方法的实现，而扩展只能声明方法，而不能实现

分类的局限性：

无法为类添加实例变量，但可通过关联对象进行实现，注：关联对象中内存管理没有weak，用时需要注意野指针的问题，可通过其他办法来实现，具体可参考iOS weak 关键字漫谈
分类的方法若和类中原本的实现重名，会覆盖原本方法的实现，注：并不是真正的覆盖
多个分类的方法重名，会调用最后编译的那个分类的实现

分类的结构体里有哪些成员

struct category_t {
    const char *name; //名字
    classref_t cls; //类的引用
    struct method_list_t *instanceMethods;//实例方法列表
    struct method_list_t *classMethods;//类方法列表
    struct protocol_list_t *protocols;//协议列表
    struct property_list_t *instanceProperties;//实例属性列表
    // 此属性不一定真正的存在
    struct property_list_t *_classProperties;//类属性列表
};

6 能不能简述一下 Dealloc 的实现机制

Dealloc 的实现机制是内容管理部分的重点，把这个知识点弄明白，对于全方位的理解内存管理的只是很有必要。

1.Dealloc 调用流程

1.首先调用 _objc_rootDealloc()
2.接下来调用 rootDealloc()
3.这时候会判断是否可以被释放，判断的依据主要有 5 个，判断是否有以上五种情况
- NONPointer_ISA
- weakly_reference
- has_assoc
- has_cxx_dtor
- has_sidetable_rc
4-1.如果有以上五中任意一种，将会调用 object_dispose()方法，做下一步的处理。
4-2.如果没有之前五种情况的任意一种，则可以执行释放操作，C 函数的 free()。
5.执行完毕。

2.object_dispose() 调用流程。

1.直接调用 objc_destructInstance()。
2.之后调用 C 函数的 free()。

3.objc_destructInstance() 调用流程

1.先判断 hasCxxDtor，如果有 C++ 的相关内容，要调用 object_cxxDestruct() ，销毁 C++ 相关的内容。
2.再判断 hasAssocitatedObjects，如果有的话，要调用 object_remove_associations()，销毁关联对象的一系列操作。
3.然后调用 clearDeallocating()。
4.执行完毕。

4.clearDeallocating() 调用流程。

1.先执行 sideTable_clearDellocating()。
2.再执行 weak_clear_no_lock，在这一步骤中，会将指向该对象的弱引用指针置为 nil。
3.接下来执行 table.refcnts.eraser()，从引用计数表中擦除该对象的引用计数。
4.至此为止，Dealloc 的执行流程结束。

7 静态链接了解么？静态库和动态库的区别？

静态链接是指将多个目标文件合并为一个可执行文件，直观感觉就是将所有目标文件的段合并。需要注意的是可执行文件与目标文件的结构基本一致，不同的是是否“可执行”。
静态库：链接时完整地拷贝至可执行文件中，被多次使用就有多份冗余拷贝。
动态库：链接时不复制，程序运行时由系统动态加载到内存，供程序调用，系统只加载一次，多个程序共用，节省内存。

8 App网络层有哪些优化策略？

优化DNS解析和缓存
对传输的数据进行压缩，减少传输的数据
使用缓存手段减少请求的发起次数
使用策略来减少请求的发起次数，比如在上一个请求未着地之前，不进行新的请求
避免网络抖动，提供重发机制

9 [self class] 与 [super class]

@implementation Son : Father
- (id)init
{
    self = [super init];
    if (self)
    {
        NSLog(@"%@", NSStringFromClass([self class]));
        NSLog(@"%@", NSStringFromClass([super class]));
    }
return self;
}
@end

self和super的区别：

self 是类的一个隐藏参数，每个方法的实现的第一个参数即为self。
super并不是隐藏参数，它实际上只是一个**”编译器标示符”**，它负责告诉编译器，当调用方法时，去调用父类的方法，而不是本类中的方法。

在调用[super class]的时候，runtime会去调用objc_msgSendSuper方法，而不是objc_msgSend

OBJC_EXPORT void objc_msgSendSuper(void /* struct objc_super *super, SEL op, ... */ )
 
 
/// Specifies the superclass of an instance. 
struct objc_super {
    /// Specifies an instance of a class.
    __unsafe_unretained id receiver;
 
    /// Specifies the particular superclass of the instance to message. 
#if !defined(__cplusplus)  &&  !__OBJC2__
    /* For compatibility with old objc-runtime.h header */
    __unsafe_unretained Class class;
#else
    __unsafe_unretained Class super_class;
#endif
    /* super_class is the first class to search */
}

在objc_msgSendSuper方法中，第一个参数是一个objc_super的结构体，这个结构体里面有两个变量，一个是接收消息的receiver，一个是当前类的父类super_class。

入院考试第一题错误的原因就在这里，误认为[super class]是调用的[super_class class]。

objc_msgSendSuper的工作原理应该是这样的:

从objc_super结构体指向的superClass父类的方法列表开始查找selector，
找到后以objc->receiver去调用父类的这个selector。注意，最后的调用者是objc->receiver，而不是super_class！

那么objc_msgSendSuper最后就转变成

objc_msgSend(objc_super->receiver, @selector(class))
 
+ (Class)class {
    return self;
}

10 isKindOfClass 与 isMemberOfClass

下面代码输出什么？

@interface Sark : NSObject
 @end
 
 @implementation Sark
 @end
 
 int main(int argc, const char * argv[]) {
@autoreleasepool {
    BOOL res1 = [(id)[NSObject class] isKindOfClass:[NSObject class]];
    BOOL res2 = [(id)[NSObject class] isMemberOfClass:[NSObject class]];
    BOOL res3 = [(id)[Sark class] isKindOfClass:[Sark class]];
    BOOL res4 = [(id)[Sark class] isMemberOfClass:[Sark class]];
 
   NSLog(@"%d %d %d %d", res1, res2, res3, res4);
}
return 0;
}

先来分析一下源码这两个函数的对象实现

+ (Class)class {
    return self;
}
 
- (Class)class {
    return object_getClass(self);
}
 
Class object_getClass(id obj)
{
    if (obj) return obj->getIsa();
    else return Nil;
}
 
inline Class 
objc_object::getIsa() 
{
    if (isTaggedPointer()) {
        uintptr_t slot = ((uintptr_t)this >> TAG_SLOT_SHIFT) & TAG_SLOT_MASK;
        return objc_tag_classes[slot];
    }
    return ISA();
}
 
inline Class 
objc_object::ISA() 
{
    assert(!isTaggedPointer()); 
    return (Class)(isa.bits & ISA_MASK);
}
 
+ (BOOL)isKindOfClass:(Class)cls {
    for (Class tcls = object_getClass((id)self); tcls; tcls = tcls->superclass) {
        if (tcls == cls) return YES;
    }
    return NO;
}
 
- (BOOL)isKindOfClass:(Class)cls {
    for (Class tcls = [self class]; tcls; tcls = tcls->superclass) {
        if (tcls == cls) return YES;
    }
    return NO;
}
 
+ (BOOL)isMemberOfClass:(Class)cls {
    return object_getClass((id)self) == cls;
}
 
- (BOOL)isMemberOfClass:(Class)cls {
    return [self class] == cls;
}

首先题目中NSObject 和 Sark分别调用了class方法。

+ (BOOL)isKindOfClass:(Class)cls方法内部，会先去获得object_getClass的类，而object_getClass的源码实现是去调用当前类的obj->getIsa()，最后在ISA()方法中获得meta class的指针。
接着在isKindOfClass中有一个循环，先判断class是否等于meta class，不等就继续循环判断是否等于super class，不等再继续取super class，如此循环下去。

[NSObject class]执行完之后调用isKindOfClass，第一次判断先判断NSObject 和 NSObject的meta class是否相等，之前讲到meta class的时候放了一张很详细的图，从图上我们也可以看出，NSObject的meta class与本身不等。
接着第二次循环判断NSObject与meta class的superclass是否相等。还是从那张图上面我们可以看到：Root class(meta) 的superclass 就是 Root class(class)，也就是NSObject本身。所以第二次循环相等，于是第一行res1输出应该为YES。
同理，[Sark class]执行完之后调用isKindOfClass，第一次for循环，Sark的Meta Class与[Sark class]不等，第二次for循环，Sark Meta Class的super class 指向的是 NSObject Meta Class，和 Sark Class不相等。
第三次for循环，NSObject Meta Class的super class指向的是NSObject Class，和 Sark Class 不相等。第四次循环，NSObject Class的 super class 指向 nil，和 Sark Class不相等。第四次循环之后，退出循环，所以第三行的res3输出为NO。
如果把这里的Sark改成它的实例对象，[sark isKindOfClass:[Sark class]，那么此时就应该输出YES了。因为在isKindOfClass函数中，判断sark的meta class是自己的元类Sark，第一次for循环就能输出YES了。
isMemberOfClass的源码实现是拿到自己的isa指针和自己比较，是否相等。
第二行isa 指向 NSObject 的 Meta Class，所以和 NSObject Class不相等。第四行，isa指向Sark的Meta Class，和Sark Class也不等，所以第二行res2和第四行res4都输出NO。

11 Class与内存地址

下面的代码会？Compile Error / Runtime Crash / NSLog…?

@interface Sark : NSObject
@property (nonatomic, copy) NSString *name;
- (void)speak;
@end
@implementation Sark
- (void)speak {
    NSLog(@"my name's %@", self.name);
}
@end
@implementation ViewController
- (void)viewDidLoad {
    [super viewDidLoad];
    id cls = [Sark class];
    void *obj = &cls;
    [(__bridge id)obj speak];
}
@end

这道题有两个难点。

难点一:obj调用speak方法，到底会不会崩溃。
难点二:如果speak方法不崩溃，应该输出什么？

首先需要谈谈隐藏参数self和_cmd的问题。 当[receiver message]调用方法时，系统会在运行时偷偷地动态传入两个隐藏参数self和_cmd，之所以称它们为隐藏参数，是因为在源代码中没有声明和定义这两个参数。self在已经明白了，接下来就来说说_cmd。_cmd表示当前调用方法，其实它就是一个方法选择器SEL。

难点一，能不能调用speak方法？

id cls = [Sark class]; 
void *obj = &cls;

答案是可以的。obj被转换成了一个指向Sark Class的指针，然后使用id转换成了objc_object类型。obj现在已经是一个Sark类型的实例对象了。当然接下来可以调用speak的方法。

难点二，如果能调用speak，会输出什么呢？

很多人可能会认为会输出sark相关的信息。这样答案就错误了。

正确的答案会输出

my name is <ViewController: 0x7ff6d9f31c50>

内存地址每次运行都不同，但是前面一定是ViewController。why？

我们把代码改变一下，打印更多的信息出来。

- (void)viewDidLoad {
    [super viewDidLoad];
 
    NSLog(@"ViewController = %@ , 地址 = %p", self, &self);
 
    id cls = [Sark class];
    NSLog(@"Sark class = %@ 地址 = %p", cls, &cls);
 
    void *obj = &cls;
    NSLog(@"Void *obj = %@ 地址 = %p", obj,&obj);
 
    [(__bridge id)obj speak];
 
    Sark *sark = [[Sark alloc]init];
    NSLog(@"Sark instance = %@ 地址 = %p",sark,&sark);
 
    [sark speak];
 
}

我们把对象的指针地址都打印出来。输出结果：

ViewController = <ViewController: 0x7fb570e2ad00> , 地址 = 0x7fff543f5aa8
Sark class = Sark 地址 = 0x7fff543f5a88
Void *obj = <Sark: 0x7fff543f5a88> 地址 = 0x7fff543f5a80
 
my name is <ViewController: 0x7fb570e2ad00>
 
Sark instance = <Sark: 0x7fb570d20b10> 地址 = 0x7fff543f5a78
my name is (null)

objc_msgSendSuper2 解读

// objc_msgSendSuper2() takes the current search class, not its superclass.
OBJC_EXPORT id objc_msgSendSuper2(struct objc_super *super, SEL op, ...)
    __OSX_AVAILABLE_STARTING(__MAC_10_6, __IPHONE_2_0);

objc_msgSendSuper2方法入参是一个objc_super *super。

/// Specifies the superclass of an instance. 
struct objc_super {
    /// Specifies an instance of a class.
    __unsafe_unretained id receiver;
 
    /// Specifies the particular superclass of the instance to message. 
#if !defined(__cplusplus)  &&  !__OBJC2__
    /* For compatibility with old objc-runtime.h header */
    __unsafe_unretained Class class;
#else
    __unsafe_unretained Class super_class;
#endif
    /* super_class is the first class to search */
};
#endif

所以按viewDidLoad执行时各个变量入栈顺序从高到底为self, _cmd, self.class, self, obj。

第一个self和第二个_cmd是隐藏参数。
第三个self.class和第四个self是[super viewDidLoad]方法执行时候的参数。
在调用self.name的时候，本质上是self指针在内存向高位地址偏移一个指针。在32位下面，一个指针是4字节=4*8bit=32bit。（64位不一样但是思路是一样的）
从打印结果我们可以看到，obj就是cls的地址。在obj向上偏移32bit就到了0x7fff543f5aa8，这正好是ViewController的地址。

所以输出为my name is <ViewController: 0x7fb570e2ad00>。

至此，Objc中的对象到底是什么呢？

实质：Objc中的对象是一个指向ClassObject地址的变量，即 id obj = &ClassObject ，而对象的实例变量 void *ivar = &obj + offset(N)

加深一下对上面这句话的理解，下面这段代码会输出什么？

- (void)viewDidLoad {
    [super viewDidLoad];
 
    NSLog(@"ViewController = %@ , 地址 = %p", self, &self);
 
    NSString *myName = @"halfrost";
 
    id cls = [Sark class];
    NSLog(@"Sark class = %@ 地址 = %p", cls, &cls);
 
    void *obj = &cls;
    NSLog(@"Void *obj = %@ 地址 = %p", obj,&obj);
 
    [(__bridge id)obj speak];
 
    Sark *sark = [[Sark alloc]init];
    NSLog(@"Sark instance = %@ 地址 = %p",sark,&sark);
 
    [sark speak];
 
}
ViewController = <ViewController: 0x7fff44404ab0> ,  地址  = 0x7fff56a48a78
Sark class = Sark  地址  = 0x7fff56a48a50
Void *obj = <Sark: 0x7fff56a48a50>  地址 = 0x7fff56a48a48
 
my name is halfrost
 
Sark instance = <Sark: 0x6080000233e0>  地址 = 0x7fff56a48a40
my name is (null)

由于加了一个字符串，结果输出就完全变了，[(__bridge id)obj speak];这句话会输出“my name is halfrost”

原因还是和上面的类似。按viewDidLoad执行时各个变量入栈顺序从高到底为self，_cmd，self.class，self，myName，obj。obj往上偏移32位，就是myName字符串，所以输出变成了输出myName了。

12 iOS开发中的加密方式

iOS加密相关算法框架：CommonCrypto。

1:对称加密： DES、3DES、AES

加密和解密使用同一个密钥。
加密解密过程：
- 明文->密钥加密->密文，
- 密文->密钥解密->明文。
优点：算法公开、计算量少、加密速度快、加密效率高、适合大批量数据加密；
缺点：双方使用相同的密钥，密钥传输的过程不安全，易被破解，因此为了保密其密钥需要经常更换。

AES：AES又称高级加密标准，是下一代的加密算法标准，支持128、192、256位密钥的加密，加密和解密的密钥都是同一个。iOS一般使用ECB模式，16字节128位密钥。

AES算法主要包括三个方面：轮变化、圈数和密钥扩展。

优点：高性能、高效率、灵活易用、安全级别高。
缺点：加密与解密的密钥相同，所以前后端利用AES进行加密的话，如何安全保存密钥就成了一个问题。

DES：数据加密标准，DES算法的入口参数有三个：Key、Data、Mode。

其中Key为7个字节共56位，是DES算法的工作密钥；Data为8个字节64位，是要被加密或被解密的数据；Mode为DES的工作方式，有两种：加密、解密。
缺点：与AES相比，安全性较低。

3DES：3DES是DES加密算法的一种模式，它使用3条64位的密钥对数据进行三次加密。是DES向AES过渡的加密算法，是DES的一个更安全的变形。它以DES为基本模块，通过组合分组方法设计出分组加密算法。

2.非对称加密:RSA加密

非对称加密算法需要成对出现的两个密钥，公开密钥(publickey) 和私有密钥(privatekey) 。
**加密解密过程：**对于一个私钥，有且只有一个与之对应的公钥。生成者负责生成私钥和公钥，并保存私钥，公开公钥。

公钥加密，私钥解密；或者私钥数字签名，公钥验证。公钥和私钥是成对的，它们互相解密。

特点：
- 1). **对信息保密，防止中间人攻击：**将明文通过接收人的公钥加密，传输给接收人，因为只有接收人拥有对应的私钥，别人不可能拥有或者不可能通过公钥推算出私钥，所以传输过程中无法被中间人截获。只有拥有私钥的接收人才能阅读。此方法通常用于交换对称密钥。
- 2). **身份验证和防止篡改：**权限狗用自己的私钥加密一段授权明文，并将授权明文和加密后的密文，以及公钥一并发送出来，接收方只需要通过公钥将密文解密后与授权明文对比是否一致，就可以判断明文在中途是否被篡改过。此方法用于数字签名。
**优点：**加密强度小，加密时间长，常用于数字签名和加密密钥、安全性非常高、解决了对称加密保存密钥的安全问题。
**缺点：**加密解密速度远慢于对称加密，不适合大批量数据加密。

3. 哈希算法加密：MD5加密、.SHA加密、HMAC加密

哈希算法加密是通过哈希算法对数据加密，加密后的结果不可逆，即加密后不能再解密。
**特点：**不可逆、算法公开、相同数据加密结果一致。
**作用：**信息摘要，信息“指纹”，用来做数据识别的。如：用户密码加密、文件校验、数字签名、鉴权协议。

MD5加密：**对不同的数据加密的结果都是定长的32位字符。

**.SHA加密：**安全哈希算法，主要适用于数字签名标准(DSS)里面定义的数字签名算法(DSA)。对于长度小于2^64位的消息，SHA1会产生一个160位的消息摘要。当接收到消息的时候，这个消息摘要可以用来验证数据的完整性。在传输的过程中，数据很可能会发生变化，那么这时候就会产生不同的消息摘要。当然除了SHA1还有SHA256以及SHA512等。

**HMAC加密：**给定一个密钥，对明文加密，做两次“散列”，得到的结果还是32位字符串。

4. Base64加密

一种编码方式，严格意义上来说不算加密算法。其作用就是将二进制数据编码成文本，方便网络传输。
用 base64 编码之后，数据长度会变大，增加了大约 1/3，但是好处是编码后的数据可以直接在邮件和网页中显示；
虽然 base64 可以作为加密，但是 base64 能够逆运算，非常不安全！
base64 编码有个非常显著的特点，末尾有个 ‘=’ 号。
原理：
- 1). 将所有字符转化为ASCII码；
- 2). 将ASCII码转化为8位二进制；
- 3). 将二进制三位一组不足补0，共24位，再拆分成6位一组共四组；
- 4). 统一在6位二进制前补两个0到八位；
- 5). 将补0后的二进制转为十进制；
- 6). 最后从Base64编码表获取十进制对应的Base64编码。

13 App安全，数字签名，App签名，重签名

因为应用实际上是一个加壳的ipa文件，但是有可能被砸壳甚至越狱手机下载的ipa包直接就是脱壳的，可以直接反编译，所以不要在plist文件、项目中的静态文件中存储关键的信息。所以敏感信息对称加密存储或者就存储到keychain里。而且加密密钥也要定期更换。

数字签名是通过HASH算法和RSA加密来实现的。 我们将明文数据加上**通过RSA加密的数据HASH值**一起传输给对方，对方可以解密拿出HASH值来进行验证。这个通过RSA加密HASH值数据，我们称之为数字签名。

App签名

1.在Mac开发机器上生成一对公钥和私钥，这里称为公钥L，私钥L(L：Local)。
2.苹果自己有固定的一对公钥和私钥，私钥在苹果后台，公钥在每个iOS设备上。这里称为公钥A，私钥A(A：Apple)。
3.把开发机器上的公钥L传到苹果后台，用苹果后台的私钥A去签名公钥L。得到一个包含公钥L以及其签名数据证书。
4.在苹果后台申请AppID，配置好设备ID列表和APP可使用的权限，再加上第③步的证书，组成的数据用私钥A签名，把数据和签名一起组成一个Provisioning Profile描述文件，下载到本地Mac开发机器。
5.在开发时，编译完一个APP后，用本地的私钥L对这个APP进行签名，同时把第④步得到的Provisioning Profile描述文件打包进APP里，文件名为embedded.mobileprovision，把 APP安装到手机上。
6.在安装时，iOS系统取得证书，通过系统内置的公钥A，去验证embedded.mobileprovision的数字签名是否正确，里面的证书签名也会再验一遍。
7.确保了embedded.mobileprovision里的数据都是苹果授权的以后，就可以取出里面的数据，做各种验证，包括用公钥 L 验证APP签名，验证设备 ID 是否在 ID 列表上，AppID 是否对应得上，权限开关是否跟 APP 里的 Entitlements 对应等。

14 OC数据类型

① 基本数据类型

C语言基本数据类型（如short、int、float等）在OC中都不是对象，只是一定字节的内存空间用于存储数值，他们都不具备对象的特性，没有属性方法可以被调用。
OC中的基本数据类型：
- NSInteger(相当于long型整数)、
- NSUInteger(相当于unsigned long型整数)、
- CGFloat(在64位系统相当于double，32位系统相当于float)等。
- 他们并不是类，只是用typedef对基本数据类型进行了重定义，他们依然只是基本数据类型。
- **枚举类型：**其本质是无符号整数。
- **BOOL类型：**是宏定义，OC底层是使用signed char来代表BOOL。

② 指针数据类型

指针数据类型包括： 类class、id。

类class：NSString、NSSet、NSArray、NSMutableArray、NSDictionary、NSMutableDictionary、NSValue、NSNumber(继承NSValue)等，都是class，创建后便是对象，继承NSObject。

OC中提供了NSValue、NSNumber来封装C语言的基本类型，这样我们就可以让他们具有面向对象的特征了。

id：id是指向Objective-C对象的指针，等价于C语言中的void*，可以映射任何对象指针指向他，或者映射它指向其他的对象。常见的id类型就是类的delegate属性。

集合NSSet和数组NSArray区别：

都是存储不同的对象的地址；
但是NSArray是有序的集合，NSSet是无序的集合，它们俩可以互相转换。
NSSet会自动删除重复元素。
集合是一种哈希表，运用散列算法，查找集合中的元素比数组速度更快，但是它没有顺序。

③ 构造类型

**构造类型包括：**结构体、联合体

结构体：struct，将多个基本数据类型的变量组合成一个整体。结构体中访问内部成员用点运算符访问。
联合体(共用体)：union，有些类似结构体struct的一种数据结构，联合体(union)和结构体(struct)同样可以包含很多种数据类型和变量。

结构体和联合体的区别：

结构体(struct)中所有变量是“共存”的，同一时刻每个成员都有值，其sizeof为所以成员的和。

**优点：**是“有容乃大”，全面；

**缺点：**是struct内存空间的分配是粗放的，不管用不用，全分配，会造成内存浪费。
联合体(union)中各变量是“互斥”的，同一时刻只有一个成员有值，其sizeof为最长成员的sizeof。

**优点：**是内存使用更为精细灵活，也节省了内存空间。

**缺点：**就是不够“包容”，修改其中一个成员时会覆盖原来的成员值；

15 property和属性修饰符

@property的本质是 ivar(实例变量) + setter + getter.

我们每次增加一个属性时内部都做了什么：

1.系统都会在 ivar_list 中添加一个成员变量的描述；
2.在 method_list 中增加 setter 与 getter 方法的描述；
3.在属性列表中增加一个属性的描述；
4.然后计算该属性在对象中的偏移量；
5.给出 setter 与 getter 方法对应的实现，在 setter 方法中从偏移量的位置开始赋值，在 getter 方法中从偏移量开始取值，为了能够读取正确字节数，系统对象偏移量的指针类型进行了类型强转。

修饰符：

MRC下： assign、retain、copy、readwrite、readonly、nonatomic、atomic等。
ARC下：assign、strong、weak、copy、readwrite、readonly、nonatomic、atomic、nonnull、nullable、null_resettable、_Null_unspecified等。

下面分别解释

assign：用于基本数据类型，不更改引用计数。如果修饰对象(对象在堆需手动释放内存，基本数据类型在栈系统自动释放内存)，会导致对象释放后指针不置为nil 出现野指针。
retain：和strong一样，释放旧对象，传入的新对象引用计数+1；在MRC中和release成对出现。
strong：在ARC中使用，告诉系统把这个对象保留在堆上，直到没有指针指向，并且ARC下不需要担心引用计数问题，系统会自动释放。
weak：在被强引用之前，尽可能的保留，不改变引用计数；weak引用是弱引用，你并没有持有它；它本质上是分配一个不被持有的属性，当引用者被销毁(dealloc)时，weak引用的指针会自动被置为nil。可以避免循环引用。
copy：一般用来修饰不可变类型属性字段，如：NSString、NSArray、NSDictionary等。用copy修饰可以防止本对象属性受外界影响，在NSMutableString赋值给NSString时，修改前者会导致后者的值跟着变化。还有block也经常使用 copy 修饰符，但是其实在ARC中编译器会自动对block进行copy操作，和strong的效果是一样的。但是在MRC中方法内部的block是在栈区，使用copy可以把它放到堆区。
readwrite：可以读、写；编译器会自动生成setter/getter方法。
readonly：只读；会告诉编译器不用自动生成setter方法。属性不能被赋值。
nonatomic：非原子性访问。用nonatomic意味着可以多线程访问变量，会导致读写线程不安全。但是会提高执行性能。
atomic：原子性访问。编译器会自动生成互斥锁，对 setter 和 getter 方法进行加锁来保证属性的赋值和取值原子性操作是线程安全的，但不包括可变属性的操作和访问。比如我们对数组进行操作，给数组添加对象或者移除对象，是不在atomic的负责范围之内的，所以给被atomic修饰的数组添加对象或者移除对象是没办法保证线程安全的。原子性访问的缺点是会消耗性能导致执行效率慢。
nonnull：设置属性或方法参数不能为空，专门用来修饰指针的，不能用于基本数据类型。
nullable：设置属性或方法参数可以为空。
null_resettable：设置属性，get方法不能返回为空，set方法可以赋值为空。
_Null_unspecified：设置属性或方法参数不确定是否为空。

后四个属性应该主要就是为了提高开发规范，提示使用的人应该传什么样的值，如果违反了对规范值的要求，就会有警告。

weak修饰的对象释放则自动被置为nil的实现原理：

Runtime维护了一个weak表，存储指向某个对象的所有weak指针。weak表其实是一个hash（哈希）表，Key是所指对象的地址，Value是weak指针的地址数组（这个地址的值是所指对象的地址）。

weak 的实现原理可以概括一下三步：

1、初始化时：runtime会调用objc_initWeak函数，初始化一个新的weak指针指向对象的地址。
2、添加引用时：objc_initWeak函数会调用 objc_storeWeak()函数， objc_storeWeak() 的作用是更新指针指向，创建对应的弱引用表。
3、释放时，调用clearDeallocating函数。clearDeallocating函数首先根据对象地址获取所有weak指针地址的数组，然后遍历这个数组把其中的数据设为nil，最后把这个entry从weak表中删除，最后清理对象的记录。

16 成员变量`ivar`和属性`property`的区别，以及不同关键字的作用

**成员变量：**成员变量的默认修饰符是@protected、不会自动生成set和get方法，需要手动实现、不能使用点语法调用，因为没有set和get方法，只能使用->。

**属性：**属性会默认生成带下划线的成员变量和setter/getter方法、可以用点语法调用，实际调用的是set和get方法。

注意：分类中添加的属性是不会自动生成 setter/getter方法的，必须要手动添加。

**实例变量：**class类进行实例化出来的对象为实例对象

关键字作用：

访问范围关键字

@public：声明公共实例变量，在任何地方都能直接访问对象的成员变量。
@private：声明私有实例变量，只能在当前类的对象方法中直接访问，子类要访问需要调用父类的get/set方法。
@protected：可以在当前类及其子类对象方法中直接访问(系统默认)。
@package：在同一个包下就可以直接访问，比如说在同一个框架。

关键字

@property：声明属性，自动生成一个以下划线开头的成员变量_propertyName(默认用@private修饰)、属性setter、getter方法的声明、属性setter、getter方法的实现。**注意：**在协议@protocol中只会生成getter和setter方法的声明，所以不仅需要手动实现getter和setter方法还需要手动定义变量。
@sythesize：修改@property自动生成的_propertyName成员变量名，@synthesize propertyName = newName；。
@dynamic：告诉编译器：属性的 setter 与 getter 方法由用户自己实现，不自动生成。**谨慎使用：**如果对属性赋值取值可以编译成功，但运行会造成程序崩溃，这就是常说的动态绑定。
@interface：声明类
@implementation：类的实现
@selecter：创建一个SEL，类成员指针
@protocol：声明协议
@autoreleasepool：ARC中的自动释放池
@end：类结束

17 类簇

类簇是Foundation框架中广泛使用的设计模式。类簇在公共抽象超类下对多个私有的具体子类进行分组。以这种方式对类进行分组简化了面向对象框架的公共可见体系结构，而不会降低其功能丰富度。类簇是基于抽象工厂设计模式的。

常见的类簇有 NSString、NSArray、NSDictionary等。**以数组为例：**不管创建的是可变还是不可变的数组，在alloc之后得到的类都是 __NSPlaceholderArray。而当我们 init 一个不可变的空数组之后，得到的是 __NSArray0；如果有且只有一个元素，那就是 __NSSingleObjectArrayI；有多个元素的，叫做 __NSArrayI；init 出来一个可变数组的话，都是 __NSArrayM。

优点：

可以将抽象基类背后的复杂细节隐藏起来。
程序员不会需要记住各种创建对象的具体类实现，简化了开发成本，提高了开发效率。
便于进行封装和组件化。
减少了 if-else 这样缺乏扩展性的代码。
增加新功能支持不影响其他代码。

缺点：

已有的类簇非常不好扩展。

我们运用类簇的场景：

出现 bug 时，可以通过崩溃报告中的类簇关键字，快速定位 bug 位置。
在实现一些固定且并不需要经常修改的事物时，可以高效的选择类簇去实现。例：
- 针对不同版本，不同机型往往需要不同的设置，这时可以选择使用类簇。
- app 的设置页面这种并不需要经常修改的页面，可以使用类簇去创建大量重复的布局代码。

18 设计模式

创建型模式：

单例模式：
- 在整个应用程序中，共享一份资源。保证在程序运行过程中，一个类只有一个实例，而且该实例只提供一个全局访问点供外界访问，从而方便控制实例个数，节约系统资源。
  - 优点是：提供了对唯一实例的受控访问、可扩展、避免频繁创建销毁对象影响性能。
  - 缺点是：延长了声明周期，一直存在占用内存。如果两个单例循环依赖会造成死锁，所以尽量不去产生单例间的依赖关系。
工厂方法模式：
- 通过类继承创建抽象产品，创建一种产品，子类化创建者并重载工厂方法以创建新产品。
抽象工厂模式：
- 通过对象组合创建抽象产品，可以创建多系列产品，必须修改父类的接口才能支持新的产品。

结构型模式：

代理模式
- 代理用来处理事件的监听和参数传递。@required修饰必须实现这个协议方法方法，@optional修饰是可选实现。使用方法时最好先判断方法是否实现respondsToSelector: ，避免找不到方法而崩溃。

delegate和block、Notification对比优缺点：delegate和block是一对一通信、block比delegate更加简洁清晰，但是如果通信事件较多时delegate运行成本较低且不易造成循环引用；通知适合一对多通信，代码清晰简单，但问题查找溯源会比较困难，并且注册通知要注意在合适的时间移除，避免对野指针发送消息引起崩溃（**注意：**iOS9之后已经做了弱引用处理不需要移除了，之前版本使用不安全引用__unsafe_unretained是为了兼容旧版本）。

类簇：
- 见上边 5. 类簇
装饰模式
- 在不必改变原类文件和使用继承的情况下，动态地扩展一个对象的功能。如：分类。
享元模式：
- 使用共享物件，减少同一类对象的大量创建。如：UITableviewCell复用。

行为型模式：

观察者模式：
- 其本质上是一种发布-订阅模型，用来消除具有不同行为的对象之间的耦合，通过这一模式，不同对象可以协同工作。如：KVO。
命令模式：
- 是一种将方法调用封装为对象的设计模式，在iOS中具体实现为NSInvocation。下边为NSInvocation的实现代码。

- (void)viewDidLoad {
    NSMethodSignature *signature = [ViewController instanceMethodSignatureForSelector:@selector(sendMessageWithPhone:WithName:)]; // 方法签名：用来获得方法的返回类型和参数类型
    NSInvocation *invocation = [NSInvocation invocationWithMethodSignature:signature];
    invocation.target = self; // 目标：接收消息的对象
    invocation.selector = @selector(sendMessageWithPhone:WithName:); // 选择器：被发送的消息, 方法必须和签名中的方法一致。
    
    NSString *phone = @"13512345678";
    // 注意：设置参数的索引时不能从0开始，因为0已经被self占用，1已经被_cmd占用
    [invocation setArgument:&phone atIndex:2]; // 参数：可以添加任意数量的参数。
    NSString *name = @"Dezi";
    [invocation setArgument:&name atIndex:3];
    /*
     注：调用invocation的invoke方法，就代表需要执行NSInvocation对象中指定对象的指定方法，并且传递指定的参数
     */
    [invocation invoke];
}
- (void)sendMessageWithPhone:(NSString*)phone WithName:(NSString*)name {
    NSLog(@"电话号=%@, 姓名=%@",phone, name);
}
// 电话号=13512345678, 姓名Dezi

MVC和MVVM算是架构。

19 架构设计

MVC：

M 是数据模型Model，负责处理数据，以及数据改变时发出通知(Notification、KVO)，Model和View不能直接进行通信，这样会违背MVC设计模式；
V 是视图View，用来展示界面，和用户进行交互，为了解耦合一般不会直接持有或者操作数据层中的数据模型(可以通过action-target、delegate、block等方式解耦)；
C 是控制器Controller用来调节Model和View之间的交互，可以直接与Model还有View进行通信，操作Model进行数据更新，刷新View。

优点：View、Model低耦合、高复用、容易维护。

缺点：Controller的代码过于臃肿，如果View与Model直接交互会导致View和Model之间的耦合性比较大、网络逻辑会加重Controller的臃肿。

MVVM：Model - View - ViewModel

MVVM衍生于MVC，是MVC的一种演进，促进了UI代码和业务逻辑的分离，抽取Controller中的展示逻辑放到ViewModel里边。
M：数据模型Model。
V：就是View和Controller联系到一起，视为是一个组件View。View和Controller都不能直接引用模型Model，可以引用视图模型ViewModel。ViewController 尽量不涉及业务逻辑，让 ViewModel 去做这些事情。ViewController 只是一个中间人，负责接收 View 的事件、调用 ViewModel 的方法、响应 ViewModel 的变化。
VM：ViewModel负责封装业务逻辑、网络处理和数据缓存。使用ViewModel会轻微的增加代码量，但是总体上减少了代码的复杂性。ViewModel之间可以有依赖。

注意事项：

View引用ViewModel，但反过来不行，因为如果VM跟V产生了耦合，不方便复用。即不要在viewModel中引入#import UIKit.h，任何视图本身的引用都不应该放在viewModel中 (注意：基本要求，必须满足)。
ViewModel可以引用Model，但反过来不行。

优点：

低耦合、可复用、数据流向清晰、而且兼容MVC，便于代码的移植、并且ViewModel可以拆出来独立开发、方便测试。

缺点： 类会增多、ViewModel会越来越庞大、调用复杂度增加、双向绑定数据会导致问题调试变得困难。

总结：

MVVM其实是MVC的变种。MVVM只是帮MVC中的Controller瘦身，把一些逻辑代码和网络请求分离出去。不让Controller处理更多的东西，不会变得臃肿，MVVM和MVC可以根据实际需求进行灵活选择。
MVVM 在使用当中，通常还会利用双向绑定技术，使得Model 变化时，ViewModel会自动更新，而ViewModel变化时，View 也会自动变化。OC中可以用**RAC(ReactiveCocoa)**函数响应式框架来实现响应式编程。

20 ReactiveCocoa的使用及优缺点

ReactiveCocoa简称RAC，是函数响应式编程框架，因为它具有函数式编程和响应式编程的特性。

由于该框架的编程思想，使得它具有相当魅惑人心的功能，它能实现传统设计模式和事件监听所能实现的功能，比如KVO、通知、block回调、action、协议等等，它的全面性并不是它最为优越的特色，RAC最值得炫耀的是它提供了统一的消息传递机制，这种机制使得它的代码更加的简洁，同一功能代码块更少，这正是符合了我们编程的思想：高聚合、低耦合，它非常适合MVVM设计模式的开发。
不过它也并不能完全取代传统的编码方式，在多人开发和代码维护方面，RAC还是有着一些让人头痛的问题。

优点：
- 使用灵活方便、代码简洁、逻辑清晰
缺点：
- 维护成本较高、问题溯源困难

使用：

RAC的统一消息传递机制，其所以动作都离不开信号(sigal)。

1). 信号的创建、发送、接收

// 创建  此时为冷信号，并不会被触发
RACSignal *signal = [RACSignal createSignal:^RACDisposable *(id<RACSubscribersubscriber) {  
    // 发送信号  
    [subscriber sendNext:@"oh my god"];  
    // 回收资源。注意：手动创建一个signal一定要记得回收资源，不然程序会崩溃
    return [RACDisposable disposableWithBlock:^{  
        NSLog(@"信号发送完成");  
    }];  
}];  
// 订阅信号后才会变为热信号，可以被触发
[signal subscribeNext:^(id x) {  
    NSLog(@"singalContent:%@", x);  
}];

2). RAC的ControlEvents 这个方法可以简单的实现监听操作，并且逻辑在其后的block中处理，而且也能添加手势并进行监听。

[[self.textField rac_signalForControlEvents:UIControlEventEditingDidBegin] subscribeNext:^(id x) {  
    NSLog(@"%@", x);  
}];  

UITapGestureRecognizer *tap = [UITapGestureRecognizer new];  
[[tap rac_gestureSignal] subscribeNext:^(id x) {  
    NSLog(@"three:%@", x);  
}];  
[self.view addGestureRecognizer:tap];

3). RAC的KVO

[[self.textField rac_valuesAndChangesForKeyPath:@"text" options:NSKeyValueObservingOptionNew observer:self] subscribeNext:^(id x) {  
    NSLog(@"%@", x);  
}];

4). RAC的通知

[[[NSNotificationCenter defaultCenter] rac_addObserverForName:UIKeyboardDidShowNotification object:nil] subscribeNext:^(id x) {  
    NSLog(@"键盘弹起");  
}];

5). RAC的协议

- (void)viewDidLoad {  
    [super viewDidLoad];  
    // 代理  
    self.textField.delegate = self;  
    [[self rac_signalForSelector:@selector(textFieldDidBeginEditing:) fromProtocol:@protocol(UITextFieldDelegate)] subscribeNext:^(id x) {  
        NSLog(@"打印点击信息:%@", x);  
    }];  
}  
- (void)textFieldDidBeginEditing:(UITextField *)textField {  
    NSLog(@"开始编辑了");  
}

6). RAC遍历数组和字典

相当于枚举遍历，但是效率相比更高

NSArray *arr = @[@"1", @"2", @"3", @"4", @"5"];  
[arr.rac_sequence.signal subscribeNext:^(id x) {  
    NSLog(@"arr : %@", x);  
}];  
NSDictionary *dic = @{@"name":@"yangBo", @"age":@"19"};  
[dic.rac_sequence.signal subscribeNext:^(id x) {  
    NSLog(@"dic : %@", x);  
}];

7). RAC信号处理（map、filter、combine）

① 对信号不做处理

[[self.textField rac_textSignal] subscribeNext:^(id x) {  
    NSLog(@"doNothing:%@", x);  
}];

② 对信号进行过滤（filter）可以对信号进行条件判断是否处理。

[[[self.textField rac_textSignal] filter:^BOOL(NSString* value) {
    if (value.length 3) {
        return YES;
    }
    return NO;
}] subscribeNext:^(id x) {
    NSLog(@"filter:%@", x);
}];

③ 对信号进行映射（map）映射也可以理解为转换，第一个block返回的是id类型，如果返回"map now"，就相当于信号转换，第二个block打印的值就是你return的值"map now"。

[[[self.textField rac_textSignal] map:^id(NSString* value) {
    if (value.length 3) {
        return @"map now";
    }
    return value;
}] subscribeNext:^(id x) {
    NSLog(@"map:%@", x);
}];

④ 信号的联合（combine）

// 创建需要联合的信号
RACSignal *firstCombineSignal = [self.textField rac_textSignal];
RACSignal *secondeCombineSignal = [tap rac_gestureSignal];
// 信号联合处理返回self.label的背景色
RAC(self.label, backgroundColor) = [RACSignal combineLatest:@[firstCombineSignal, secondeCombineSignal] reduce:^id(NSString *text, UITapGestureRecognizer * tap){
    // 这里进行信号逻辑判断和处理
    if (text.length == 3 && tap.state == UIGestureRecognizerStateEnded) {
        return [UIColor redColor];
    }
    return [UIColor cyanColor];
}];

⑤ 信号关联

RAC(self.label, text) = [self.textField rac_textSignal];

21 类的继承，类能否多继承，协议能不能做继承

OC的类不支持多继承只支持单继承。
协议可以实现多继承，遵循多个协议即可。
消息的转发也可以实现多继承，但并不建议，维护成本高。

继承和类别在实现中有何区别？

category 可以在不获悉、不改变原来代码的情况下往里面添加并且只能添加方法不能删除修改。如果类别和原来类中的方法产生名称冲突，则类别将覆盖原来的方法，因为类别具有更高的优先级。类别不会影响到其他类与原有类的关系。
类别主要有3个作用：
- (1)将类的实现分散到多个不同文件或多个不同框架中。
- (2)创建对私有方法的前向引用。
- (3)向对象添加非正式协议。
继承可以增加，修改或者删除方法，并且可以增加属性。

22 分类(category)和类扩展(extension)的区别

1). 分类实现原理

Category编译之后的底层结构是struct category_t，里面存储着分类的对象方法、类方法、属性、协议信息。在程序运行的时候，runtime会将Category的数据，合并到类信息中（类对象、元类对象中）。

2). Category和Extension的区别是什么？
- 类扩展可以为类添加私有变量和私有方法，在类的源文件中书写，不能被子类继承，类扩展在编译的时候，它的数据就已经包含在类信息中。
- 分类可以为类添加方法并且可以被子类继承，因为分类是运行时才会将数据合并到类信息中。但是分类不能直接添加属性，需要借助运行时关联对象。
3). 分类为啥不能添加成员变量?

struct _category_t {
	const char *name;
	struct _class_t *cls;
	const struct _method_list_t *instance_methods;
	const struct _method_list_t *class_methods;
	const struct _protocol_list_t *protocols;
	const struct _prop_list_t *properties;
};

从结构体可以知道，有属性列表，所以分类可以声明属性，但是分类只会生成该属性对应的get和set的声明，没有去实现该方法。
结构体没有成员变量列表，所以不能声明成员变量。

23 如何实现week

weak 该属性定义了一种非拥有关系。为属性设置新值时，设置方法既不持有新值，也不释放旧值。

weak实现原理：

当一个对象被weak指针指向时，这个weak指针会以对象为key，存储到sideTable类的weak_table散列表上对应的一个weak指针数组里面。
当一个对象的dealloc方法被调用时，Runtime会以obj为key，从sideTable的weak_table散列表中，找出对应的weak指针列表，然后将里面的weak指针逐个置为nil。

key是weak指向的对象内存地址，value是所有指向该对象的weak指针表。

24 字典注意事项：setvalue和setobject的区别

setObject:ForKey：是NSMutableDictionary特有的。
setValue:ForKey：是KVC的主要方法。
setobject中的key和value可以为nil以外的任何对象。
setValue中的key只能为字符串，value可以为nil也可以为空对象[NSNull null]以及全部对象

25 事件传递和响应机制

在iOS中只有继承了UIResponder的对象才能接受并处理事件。

事件传递：事件的传递是从上到下（父控件到子控件）

产生触摸事件A后，触摸事件会被添加到由UIApplication管理的事件队列中(首先接收到事件的是UIApplication)。
UIApplication会从事件队列中取出最前面的事件(此处假设为触摸事件A)，将事件对象由上往下传递(UIApplication-keyWindow-父控件-子控件)，查找最合适的控件处理事件
只要事件传递给控件，就会调用自身的hitTest:withEvent:方法，寻找能够响应事件最合适的view(其内部会调用pointInside:withEvent:判断触摸点是否在自己身上)。

响应机制：从下到上（顺着响应者链条向上传递：子控件到父控件) 当事件传递到某个控件，但是最终hitTest:withEvent:没有找到第一响应者，那么该事件会沿着响应者链向上回溯，如果UIWindow实例和UIApplication实例都不能处理该事件，则该事件会被丢弃。

**响应者链条：**在iOS程序中视图的摆放是有前后关系的，一个控件可以放到另一个控件上面或下面，那么用户点击某个控件时是触发上面的控件还是下面的控件呢，这种先后关系构成一个链条就叫响应者链。也可以说，响应者链是由多个响应者对象连接起来的链条。

如果父控件不能接受触摸事件，那么子控件就不可能接收到触摸事件
UIView有三种情况不能接收事件：
- 不接收用户交互：userInteractionEnabled = NO
- 隐藏：hidden = YES
- 透明：alpha<0.01

子视图在父视图之外区域点击是否有效？

无效**(父视图的clipsToBounds=NO，这样超过父视图bound区域的子视图内容也会显示)，因为父视图的pointInside:withEvent:方法会返回NO，就不会向下遍历子视图了。
但是可以通过重写pointInside:withEvent:来处理。

26 runloop

runloop：通过系统内部维护的循环进行事件/消息管理的一个对象。runloop实际上就是一个do...while循环，有任务时开始，无任务时休眠。

其本质是通过mach_msg()函数接收、发送消息。

RunLoop 与线程的关系：

RunLoop的作用就是来管理线程的，当线程的RunLoop开启后，线程就会在执行完任务后，处于休眠状态，随时等待接受新的任务，不会退出。
只有主线程的RunLoop是默认开启的，其他线程的RunLoop需要手动开启。所以当程序开启后，主线程会一直运行，不会退出。

runloop 事件循环机制内部流程

RunLoop主要涉及五个类：

CFRunLoop：RunLoop对象、

CFRunLoopMode：五种RunLoop运行模式、

CFRunLoopSource：输入源/事件源，包括Source0 和 Source1

CFRunLoopTimer：定时源，就是NSTimer、

CFRunLoopObserver：观察者，用来监听RunLoop。

CFRunLoop：RunLoop对象
CFRunLoopMode：RunLoop运行模式，有五种：
- kCFRunLoopDefaultMode：默认的运行模式，通常主线程是在这个 Mode 下运行的。
- UITrackingRunLoopMode：界面跟踪 Mode，用于 ScrollView 追踪触摸滑动，保证界面滑动时不受其他 Mode 影响。
- UIInitializationRunLoopMode：在刚启动 App 时第进入的第一个 Mode，启动完成后就不再使用。
- GSEventReceiveRunLoopMode：接受系统事件的内部 Mode，通常用不到。
- kCFRunLoopCommonModes：是一个伪模式，可以在标记为CommonModes的模式下运行，RunLoop会自动将_commonModeItems里的 Source、Observer、Timer 同步到具有此标记的Mode里。

CFRunLoopSource：输入源/事件源，包括Source0 和 Source1两种：
- Source1：基于mach_Port，处理来自系统内核或其它进程的事件，比如点击手机屏幕。
- Source0 ：非基于Port的处理事件，也就是应用层事件，需要手动标记为待处理和手动唤醒RunLoop。
- 简单举例：一个APP在前台静止，用户点击APP界面，屏幕表面的事件会先包装成Event告诉source1(mach_port)，source1唤醒RunLoop将事件Event分发给source0，由source0来处理。
CFRunLoopTimer：定时源，就是NSTimer。在预设的时间点唤醒RunLoop执行回调。因为它是基于RunLoop的，因此它不是实时的（就是NSTimer 是不准确的。因为RunLoop只负责分发源的消息。如果线程当前正在处理繁重的任务，就有可能导致Timer本次延时，或者少执行一次）。
CFRunLoopObserver：观察者，用来监听以下时间点：CFRunLoopActivity
- kCFRunLoopEntry：RunLoop准备启动
- kCFRunLoopBeforeTimers：RunLoop将要处理一些Timer相关事件
- kCFRunLoopBeforeSources：RunLoop将要处理一些Source事件
- kCFRunLoopBeforeWaiting：RunLoop将要进行休眠状态,即将由用户态切换到内核态
- kCFRunLoopAfterWaiting：RunLoop被唤醒，即从内核态切换到用户态后
- kCFRunLoopExit：RunLoop退出
- kCFRunLoopAllActivities：监听所有状态

各数据结构之间的联系：

1：Runloop和线程是一对一的关系
2：Runloop和RunloopMode是一对多的关系
3：RunloopMode和RunloopSource是一对多的关系
4：RunloopMode和RunloopTimer是一对多的关系
5：RunloopMode和RunloopObserver是一对多的关系

为什么 main 函数能够保持一直存在且不退出？

在 main 函数内部会调用 UIApplicationMain 这样一个函数，而在UIApplicationMain内部会启动主线程的 runloop，可以做到有消息处理时，能够迅速从内核态到用户态的切换，立刻唤醒处理，而没有消息处理时通过用户态到内核态的切换进入等待状态，避免资源占用。因此 main 函数能够一直存在且不退出。

27 runtime

什么是runtime？

runtime 一套c、c++、汇编编写的API，为OC提供运行时功能。能够将数据类型的确定由编译期推迟到运行时。

问1：方法的本质，问2：runtime的消息机制

方法的本质其实就是发送消息。

发送消息主要流程：

快速查找：objc_msgSend查找cache_t缓存消息
慢速查找：递归自己和父类查找方法lookUpImpOrForward
查找不到消息，进行动态方法解析：resolveInstanceMethod
消息快速转发：forwardingTargetForSelector
消息慢速转发：消息签名methodSignatureForSelector和分发forwardInvocation
最终仍未找到消息：程序crash，报经典错误信息unrecognized selector sent to instance xxx

SEL是什么？IMP是什么？两者有什么联系？

SEL是方法编号，即方法名称，在dyld加载镜像时，通过read_image方法加载到内存的表中了。
IMP是函数实现指针，找IMP就是找函数的过程
两者的关系：sel相当于书本的目录标题，imp就是书本的页码。查找具体的函数就是想看这本书里面具体篇章的内容：
- 1). 我们首先知道想看什么，也就是title -sel
- 2). 然后根据目录对应的页码 -imp
- 3). 打开具体的内容 -方法的具体实现

runtime应用：

1.方法的交换：具体应用拦截系统自带的方法调用（Method Swizzling黑魔法）
2.实现给分类增加属性
3.实现字典的模型和自动转换
4.JSPatch替换已有的OC方法实行等
5.aspect 切面编程

能否向编译后得到的类中增加实例变量？能否向运行时创建的类中添加实例变量？为什么？

1.不能向编译后得到的类中增加实例变量。
2.可以向运行时创建的类中添加实例变量。
3.因为编译后的类已经注册在 runtime 中，类结构体中的 objc_ivar_list实例变量的链表和 instance_size 实例变量的内存大小已经确定，同时runtime会调用 class_setIvarLayout或class_setWeakIvarLayout来处理 strong、weak引用，所以不能向存在的类中添加实例变量。

运行时创建的类是可以添加实例变量，调用class_addIvar函数。但是得在调用objc_allocateClassPair之后，objc_registerClassPair之前，原因同上。

Category中添加属性和成员变量的区别

Category它的主要作用是在不改变原有类的前提下，动态地给这个类添加一些方法。
分类的结构体指针中，没有属性列表，只有方法列表。原则上它只能添加方法，不能添加属性(成员变量)，但是可以借助运行时关联对象objc_setAssociatedObject(self, @selector(name), name, OBJC_ASSOCIATION_COPY_NONATOMIC);、objc_getAssociatedObject(self,@selector(name));。
分类中的可以写@property，但不会生成setter/getter方法声明和实现，也不会生成私有的成员变量，会编译通过，但是引用变量会报错。
如果分类中有和原有类同名的方法，会优先调用分类中的方法，就是说会忽略原有类的方法，同名方法调用的优先级为分类本类父类，因为方法是放在方法栈中，遵循先进后出原则；

28 isa指针

isa是一个Class类型的指针，其源码结构为isa_t联合体，在类中以Class对象存在，指向类的地址，大小为8字节(64位)。
每个实例对象都有isa的指针指向对象的类。Class里也有个isa的指针指向meteClass(元类)。元类保存了类方法的列表。当类方法被调用时，先会从本身查找类方法的实现，如果没有，元类会向他父类查找该方法。元类（meteClass）也是类，它也是对象，也有isa指针。

isa的指向：对象的isa指向类，类的isa指向元类(meta class)，元类isa指向根元类，根元类的isa指向本身，形成了一个封闭的内循环。isa可以帮助一个对象找到它的方法。

isa指向图中类的继承关系：Teacher -> Person -> NSObject -> nil。这里需要注意的是根元类的父类是 NSObject，NSObject的父类是nil。

29 block

什么是Block Block是将函数及其执行上下文封装起来的对象。

什么是Block调用 Block调用即是函数的调用。

Block的几种形式(类型)

Block有三种形式，包括：

全局Block(_NSConcreteGlobalBlock)：当我们声明一个block时，如果这个block没有捕获外部的变量，那么这个block就位于全局区(已初始化数据(.data)区)。
栈Block(_NSConcreteStackBlock)：
- 1). ARC环境下，当我们声明并且定义了一个block，系统默认使用__strong修饰符，如果该Block捕获了外部变量，实质上是从__NSStackBlock__转变到__NSMallocBlock__的过程，只不过是系统帮我们完成了copy操作，将栈区的block迁移到堆区，延长了Block的生命周期。对于栈block而言，变量作用域结束，空间被回收。
- 2). ARC的环境下，如果我们在声明一个block的时候，使用了__weak或者__unsafe__unretained的修饰符，那么系统就不会做copy的操作，也就不会将其迁移到堆区。
堆Block(_NSConcreteMallocBlock)：
- 1). 在MRC环境下，我们需要手动调用copy方法才可以将block迁移到堆区
- 2). 而在ARC环境下，__strong修饰的（默认）block捕获了外部变量就会位于堆区，NSMallocBlock支持retain、release，会对其引用计数＋1或 -1。
- 只有局部变量 - 和定义的属性才会拷贝到堆区

1). 存储在程序的数据区域，在 block 内部没有引用任何外部变量。

2). 使用外部变量并且未进行copy操作的block是栈block。

3). 对栈block进行copy操作，就是堆block。对堆Block进行copy，将会增加引用计数。对全局block进行copy，仍是全局block。

在什么场景下使用__block修饰符呢？

1). 对截获变量进行赋值操作需要添加__block修饰符（赋值 != 使用）。
2). 对局部变量（基本数据类型和对象类型）进行赋值需要__block修饰符。其内部其实是对该__block对象进行拷贝，所以通过__block可以修改被截获变量的值且不会和外部变量互相影响。
3). 对静态局部变量、全局变量、静态全局变量不需要__block修饰符。

block 的截获变量特性？

基本数据类型的局部变量 Block 可以截获其值。

对于对象类型的局部变量连同所有权修饰符一起截获。

局部静态变量以指针的形式进行截获。

全局变量和静态全局变量，block 是不截获的。

weak打破Block循环引用原理

block内部操作的是weakSelf的指针地址，它和self是两个不同的指针地址，即没有直接持有self，所以可以weakSelf可以打破self的循环引用关系 self -block - weakSelf。

Protocol与静态派发、动态派发

Thu, 25 Mar 2021 00:00:00 GMT

一、场景一

我们定义这样一个Protocol

protocol DescriptionProtocol {
    var name: String { get }
}

添加拓展方法 printDescription

extension DescriptionProtocol {
    func printDescription() {
        print("我是：\(name)")
    }
}

新建类 Apple 遵循协议 DescriptionProtocol

class Apple: DescriptionProtocol {
    var name: String {
        return "苹果"
    }
    
    func printDescription() {
        print("\(name)好好吃啊！")
    }
}

新建类 People 遵循协议 DescriptionProtocol

class People: DescriptionProtocol {
    var name: String {
        return "人类"
    }
    
    func printDescription() {
        print("\(name)真有意思！")
    }
}

分别创建实例对象

let aApple = Apple()
let aPeople = People()

aApple.printDescription()
aPeople.printDescription()

1.1 思考

🤔思考一下会输出什么呢？














// 这里是调用了Class内实现的方法，而没有调用protocol的拓展实现
aApple.printDescription() // 苹果好好吃啊！
aPeople.printDescription() // 人类真有意思！

1.2 再通过这样的方法来调用：

func showDescription(of: DescriptionProtocol) {
    of.printDescription()
}

showDescription(of: aApple)
showDescription(of: aPeople)

🤔思考一下会输出什么呢？
















showDescription(of: aApple) // 我是：苹果
showDescription(of: aPeople) // 我是：人类

是不是感觉很奇怪？

aApple.printDescription()
- 这种方式直接调用了类定义的实例方法，而不是协议中实现的方法，是动态派发的
showDescription
- 中调用的是Protocol中实现的函数，是静态派发
printDescription在协议中和类中虽然同名，但却是毫不相干的函数，存储的区域也各不相同

二、场景二

我们将函数在协议中声明一下下，又会有什么结果呢？

protocol DescriptionProtocol {
    var name: String { get }
    func printDescription()
}

结果：

苹果好好吃啊！
人类真有意思！
苹果好好吃啊！
人类真有意思！

aApple.printDescription()
- 和场景一是一样的，是动态派发
showDescription
- 调用了协议中声明的函数，是动态派发

三、总结

由继承而得到的多态表现，本质上是把所有的方法的实现都放在一张表里，每次调用都必须先在表中查询，可以称之为动态调用。因此才有了覆写的概念：方法被覆写，即当子类调用该方法时，会使用子类的实现而非父类的。

而协议与类有所不同。协议所定义的方法，也和类一样，是动态调用的；但那些未出现在定义中，而仅出现于 Extension 中的方法是静态调用的，即这个方法属于协议，不属于协议的遵从者。

性能上也是静态优于动态。像是一些高频调用的函数我们可以通过静态的方式来做提高效率。动态调用虽然步骤会多一些，比如OC的消息转发机制，但是充满灵活性，在业务开发中会经常用到。

参考

static-vs-dynamic-dispatch-in-swift

寄存器

Tue, 23 Mar 2021 00:00:00 GMT

寄存器是什么

CPU除了有控制器、运算器还有寄存器。其中寄存器的作用是进行数据的临时存储

CPU的运算速度非常快，为了性能CPU在内部开辟一小块零食存储区域，并在进行运算时先将数据从内存复制到这一小块临时区域中，运算时就在这一小块临时存储区域内进行。

高速缓存

CPU每执行一条指令前都要从内存中将指令读取到CPU内执行。而寄存器的运行速度相比内存读写要快很多，为了性能，CPU还集成了一个高速缓存存储区域当程序在运行时，先将需要执行的指令代码以及数据复制到高速缓存中去（由操作系统完成），CPU直接从高速缓存中依次读取指令来执行。

ARM64一个寄存器64位，8个字节

一：几种寄存器

浮点寄存器
- 因为浮点数的存储以及运算的特殊性，CPU中专门提供浮点寄存器来处理浮点数
  - 浮点寄存器64位：D0-D31 32位：S0-S31
向量寄存器
- 先在很多CPU支持向量运算（图形处理用的很多），为了支持向量计算而提供
  - 向量寄存器：128位 V0-V31
异常状态寄存器
通用寄存器(数据地址寄存器)
- ARM64拥有32个64位的通用寄存器X0-X30以及XZR（零寄存器）
- 为了兼容32位，所以ARM64拥有W0-W30和WZR30个32位寄存器
- 32位寄存器并不是独立存在的。如：W0是X0的低32位
PC寄存器：指令指针寄存器
- PC寄存器里面的值就是保存的CPU接下来需要执行的指令地址
- 改变PC寄存器的值可以改变程序执行的流程

1.1 通用寄存器

x0-x7: 用于子程序调用时的参数传递，X0还用于返回值传递
x0 - x30是31个通用整形寄存器。每个寄存器可以存取一个64位大小的数。当使用 r0 - r30访问时，它就是一个64位的数。当使用 w0 - w30访问时，访问的是这些寄存器的低32位，如图：

1.2 CPSR 状态寄存器

Current Program State Register

状态寄存器是32位的

CPSR的低8位（包括I、F、T和M[4：0]）称为控制位，程序无法修改，除非CPU运行于特权模式下，程序才能修改控制位
N、Z、C、V均为条件码标志位。它们的内容可被算术或逻辑运算的结果所改变，并且可以决定某条指令是否被执行，意义重大
NZCV是状态寄存器的条件标志位，分别代表运算过程中产生的状态，其中：
- N, negative condition flag，一般代表运算结果是负数
  - 1 代表结果为负数
  - 0 代表结果为非负数
- Z, zero condition flag, 指令结果为0时Z=1，否则Z=0
- C, carry condition flag, 一般情况下进行无符号数的运算
  - 加法运算
    - 当运算结果产生了进位（无符号溢出）C=1否则C=0
  - 减法运算（包括CMP）
    - 当运算是产生了借位时（无符号溢出）则C=0，否则C=1
    - 对于位数为N的无符号数来说其对应的二进制的最高位，即第N-1位就是他的最高有效位，而假想存在的第N位就是相对于最高有效位的更高位。
  - 进位
    - 我们知道，当两个数相加的时候，有可能从最高有效位向更高位进位。比如两个32位数据：0xaaaaaaaa + 0xaaaaaaaa，将会产生进位。但由于进位值在32位中无法保存，我们就只是简单的说这个进位值丢失了。其实CPU在运算的时候并不会丢弃这个进位值，而是记录在一个特殊的寄存器的某一位上。ARM上就用C为来记录这个进位值。
  - 借位
    - 当两个数据做减法的时候，有可能向更高位。比如：0x00000000 - 0x000000ff，将产生借位，借位后相当于计算0x100000000 - 0x000000ff = 0xffffff01，由于借了一位，所以C位用来标记借位。

V, oVerflow condition flag 有符号运算有溢出时，V=1
- 正数 + 正数 = 负数则溢出
- 负数 + 负数 = 正数则溢出
- 正数 + 负数不可能溢出

二：栈

后进先出 ARM64栈开口向底地址，即开辟的地址是朝底地址方向的

2.01 SP 和 FP寄存器

SP寄存器在任意时刻会保存栈顶的地址
FP寄存器也称为X29寄存器属于通用寄存器，但是在某些时候我们利用它保存栈底的地址

注意：ARM64开始，取消了32位的LDM、STM、PUSH、POP指令，取而代之的是：ldr、ldp、str、stp。在ARM64中对栈的操作是16字节对齐的

2.02 编译器会根据编译情况开辟固定的栈空间

2.03 函数调用栈

常见函数调用开辟和恢复栈空间

sub sp, sp, #0x40
- 拉伸0x40（64字节）空间
- 即sp寄存器地址减0x40
- 开辟了64字节空间
stp x29, x30, [sp, #0x30]
- x29、x30寄存器入栈保护
add x29, sp, #0x30
- x29指向栈帧的底部
ldp x29, x30, [sp, #0x30]
- 恢复x29、x30寄存器的值
add sp, sp, #0x40
- 栈平衡，用完了要归位
ret

2.03 内存读写指令

读写：数据都是往高地址读写的即：一段数据一个字节无法完整保存的话，连续的多个地址进行保存，地址递增

str 指令 store register
- 将数据从寄存器中读出来，存到内存中
ldr 指令 load register
- 将数据冲内存中读出来，存到寄存器中
ldp stp 可以一次性操作两个寄存器

2.04 bl 和 ret 指令

bl
- 将下一条指令的地址放入lr(x30)寄存器
- 转到标号处执行指令
ret
- 默认使用lr(x30)寄存器的值，通过底层指令提示CPU此处作为下条指令地址
lr(x30)寄存器
- 存放的是函数的返回地址，当ret指令执行时，回去寻找lr(x30)寄存器保存的地址
- 在嵌套调用函数的时候需要将 x30 入栈

2.05 函数的参数和返回值

ARM64下，函数的参数是放在x0 ~ x7（w0 ~ w7）这8个寄存器中。如果超过八个参数就会入栈。
函数的返回值会放在X0寄存器中的。
函数的局部变量是放在栈里面的

顶点着色器与片元着色器

Mon, 15 Mar 2021 00:00:00 GMT

管道渲染流程

一：顶点着色器

1.1 输入

着色器程序
- 描述顶点上执行操作的顶点着色器程序源代码/可执行文件
顶点着⾊器输入(属性)
- 用顶点数组提供每个顶点的数据
统一变量(uniform)
- 顶点/片元着⾊器使用的不变数据
采样器
- 代表顶点着色器使用纹理的特殊统一变量类型，一般是ID类型，GLSL会根据ID标签查找到纹理

1.2 输出

1.2.1 图元装配

图元(Primitive)：
- 点、线、三角形等
图元装配
- 将顶点数据计算成一个个图元，在这个阶段会执行裁剪、透视分割和Viewport变换操作。即确定顶点形成的图形，点或线或三角形等。
- 对于每个图元，必须确定图元是否位于视锥体(屏幕上可见的3D空间区域)内：
  - 图元没有完全在视锥体内，可能需要进行裁剪。
  - 图元完全处于该区域之外，它就会被抛弃

1.2.2 光栅化

绘制对应的图片(点、线、三角形)，将图元转化成一组二维片段的过程，就是将顶点数据计算成的图片转化成片元，然后这些片元由片元着色器处理。

1.3 顶点着色器业务

矩阵变换位置
计算光照公式生成出顶点颜色
生成/变换纹理坐标

二：片元着色器

2.1 输入

着色器程序
- 描述片段上执行操作的片元着色器程序源代码/可执行文件。
输入变量
- 光栅化单元用插值为每个片段生成的顶点着色器输出
统一变量(uniform)
- 顶点或片元着色器使用的不变数据
采样器
- 代表片元着色器使用纹理的特殊统一变量

2.2 插值(Interpolation)：

光栅器在三角形的三个顶点之间进行插值（或者通过另外一种技术一行一行的插值）并执行片元着色器遍历三角形的每一个像素。片元着色器会返回光栅器存在颜色缓存中用于显示的像素颜色值（在其他一些额外的检测之后，比如：深度测试depth test等）

2.3 片元着色器业务

计算颜色
获取纹理值
往像素点中填充颜色值、纹理值

它可以⽤于图⽚/视频/图形中每个像素的颜色填充(比如给视频添加滤镜,实际上就是将视频中每个图片的像素点颜色填充进行修改.)

2.4 逐片段操作

像素归属测试:
- 确定帧缓存区中位置(Xw,Yw)的像素目前是不是归属于OpenGL ES所有. 例如，如果⼀个显示OpenGL ES帧缓存区View被另外⼀个View所遮蔽.则窗口系统可以确定被遮蔽的像素不属于OpenGL ES上下⽂。从而不全显示这些像素。而像素归属测试是OpenGL ES的一部分，它不由开发者开人为控制，而是由OpenGL ES内部进行.
裁剪测试:
- 裁剪测试确定(Xw,Yw)是否位于作为OpenGL ES状态的一部分裁剪矩形范围内。如果该⽚段位于裁剪区域之外，则被抛弃。
深度测试:
- 输⼊片段的深度值进步比较，确定片段是否拒绝测试
混合:
- 混合将新生成的⽚段颜色与保存在帧缓存的位置的颜色值组合起来
抖动:
- 抖动可用于最小化因为使用有限精度在帧缓存区中保存颜色值⽽产生的伪像.

三：EGL (Embedded Graphics Library )

OpenGL ES命令需要渲染上下文和绘制表面才能完成图形图像的绘制.
- 渲染上下文:
  - 存储相关OpenGL ES状态.
- 绘制表面:
  - 是用于绘制图元的表面，它指定渲染所需要的缓存区类型，例如颜色缓冲区，深度缓冲区和模板缓冲区.
OpenGL ES API并没有提供如何创建渲染上下⽂或者上下⽂如何连接到原生窗口系统。 EGL是Khronos渲染API(如OpenGL ES)和原⽣窗口系统之间的接口。唯一⽀持OpenGL ES却不⽀持EGL的平台是iOS。Apple提供⾃己的EGL API的iOS实现,称为EAGL。
因为每个窗口系统都有不同的定义，所以EGL提供基本的不透明类型EGLDisplay，这个类型封装了所有系统相关性，用于和原生窗口系统接口.

由于OpenGL ES是基于C的API，因此它⾮常便携且受到广泛支持。作为C的API，它与Objective-C Cocoa Touch应⽤程序⽆缝集成。OpenGL ES规范没有定义窗口层; 相反，托管操作系统必须提供函数来创建一个接受命令的OpenGL ES``渲染上下文和一个帧缓冲区，其中写入任何绘图命令的结果。在iOS上使用OpenGL ES需要使⽤iOS类来设置和呈现绘图表面，并使用平台中立的API来呈现其内容。

Anaconda

Thu, 04 Mar 2021 00:00:00 GMT

可视化界面

同时可以对常用的工具进行管理。

环境管理

可以进行不同Python环境的配置，以适应不同项目不同开发环境。

JupyterNotebook

Thu, 04 Mar 2021 00:00:00 GMT

JupyterNootbook

设置默认目录

Anaconda -> Enviroments -> Terminal

初次使用会创建一个配置文件

(base) gebiwangshushudeMacBook:~ RyukieW$ jupyter notebook --generate-config
Writing default config to: /Users/RyukieW/.jupyter/jupyter_notebook_config.py
(base) gebiwangshushudeMacBook:~ RyukieW$

打开配置脚本修改路径

c.NotebookApp.notebook_dir = '指定路径'

安装TensorFlow

Thu, 04 Mar 2021 00:00:00 GMT

一：进入项目环境进行安装

通过Anaconda进入环境

Open Terminal

官方指引

二：验证安装成功

进入Python交互模式，引入TensorFlow头文件，没有报错就成功了

(TensorFlow2) gebiwangshushudeMacBook:~ RyukieW$ python
Python 3.8.8 (default, Feb 24 2021, 13:46:16) 
[Clang 10.0.0 ] :: Anaconda, Inc. on darwin
Type "help", "copyright", "credits" or "license" for more information.
>>> import tensorflow
>>> 
>>> exit()
(TensorFlow2) gebiwangshushudeMacBook:~ RyukieW$

线性可分

Thu, 04 Mar 2021 00:00:00 GMT

样本可以用一条直线划分或者平面来划分

感知机与神经网络

Thu, 04 Mar 2021 00:00:00 GMT

深度学习发展史

感知机

单层感知机模型用于解决线性可分二分的问题，非线性问题无能为力

多层感知机模型（多层神经网络）

解决线性不可分问题

深度学习

非常多的多层神经网络

循环的标签控制

Wed, 14 Oct 2020 00:00:00 GMT

滑梯游戏

游戏的规则如下：

游戏盘面包括 25 个方格，游戏目标是达到或者超过第 25 个方格；
每一轮，你通过掷一个六面体骰子来确定你移动方块的步数，移动的路线由上图中横向的虚线所示；
如果在某轮结束，你移动到了梯子的底部，可以顺着梯子爬上去；
如果在某轮结束，你移动到了蛇的头部，你会顺着蛇的身体滑下去。

let finalSquare = 25
var board = [Int](repeating: 0, count: finalSquare + 1)

// 一些转折点
board[03] = +08; 
board[06] = +11; 
board[09] = +09; 
board[10] = +02
board[14] = -10; 
board[19] = -11; 
board[22] = -02; 
board[24] = -08


var square = 0
var diceRoll = 0
while square < finalSquare {
    // 掷骰子
    diceRoll += 1
    if diceRoll == 7 { diceRoll = 1 }
    // 根据点数移动
    square += diceRoll
    if square < board.count {
        // 如果玩家还在棋盘上，顺着梯子爬上去或者顺着蛇滑下去
        square += board[square]
    }
}
print("Game over!")

滑梯变种-循环标签

增加一条规则：为了获胜，你必须刚好落在第 25 个方块中。

gameLoop: while square != finalSquare {
    diceRoll += 1
    if diceRoll == 7 { diceRoll = 1 }
    switch square + diceRoll {
    case finalSquare:
        // 骰子数刚好使玩家移动到最终的方格里，游戏结束。
        break gameLoop
    case let newSquare where newSquare > finalSquare:
        // 骰子数将会使玩家的移动超出最后的方格，那么这种移动是不合法的，玩家需要重新掷骰子
        continue gameLoop
    default:
        // 合法移动，做正常的处理
        square += diceRoll
        square += board[square]
    }
}
print("Game over!")

这种循环条件嵌套的场景下通过标签可以方便精确的进行控制

如果不使用标签的话，上面的break continue 只能控制switch

参考

SwiftGG

Array,Set,Dictionary

Wed, 14 Oct 2020 00:00:00 GMT

三种集合类型：

Array
- 有序数据集合
Set
- 无序无重复数据集合
Dictionary
- 无序键值对集合

Swift 中的数组、集合和字典必须明确其中保存的键和值类型，这样就可以避免插入一个错误数据类型的值。同理，对于获取到的值你也可以放心，其数据类型是确定的。

Set

注意 Swift 的 Set 类型被桥接到 Foundation 中的 NSSet 类。

集合类型的Hash

一个类型想要存储在Set中必须是可Hash的。该类型必须提供一个方法来计算它的Hash值。(Hashable协议)

Swift 的所有基本类型（比如 String、Int、Double 和 Bool）默认都是可哈希化的，可以作为集合值的类型或者字典键的类型。没有关联值的枚举成员值默认也是可哈希化的。

语法

// 声明
var favoriteGenres: Set<String> = ["Rock", "Classical", "Hip hop"]

// 推断
var favoriteGenres: Set = ["Rock", "Classical", "Hip hop"]

集合操作

let oddDigits: Set = [1, 3, 5, 7, 9]
let evenDigits: Set = [0, 2, 4, 6, 8]
let singleDigitPrimeNumbers: Set = [2, 3, 5, 7]

oddDigits.union(evenDigits).sorted()
// [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
oddDigits.intersection(evenDigits).sorted()
// []
oddDigits.subtracting(singleDigitPrimeNumbers).sorted()
// [1, 9]
oddDigits.symmetricDifference(singleDigitPrimeNumbers).sorted()
// [1, 2, 9]

let houseAnimals: Set = ["🐶", "🐱"]
let farmAnimals: Set = ["🐮", "🐔", "🐑", "🐶", "🐱"]
let cityAnimals: Set = ["🐦", "🐭"]

houseAnimals.isSubset(of: farmAnimals)
// true
farmAnimals.isSuperset(of: houseAnimals)
// true
farmAnimals.isDisjoint(with: cityAnimals)
// true

For-in跳跃遍历

Wed, 14 Oct 2020 00:00:00 GMT

let hours = 12
let hourInterval = 3
for tickMark in stride(from: 3, through: hours, by: hourInterval) {
    // 每3小时渲染一个刻度线（3, 6, 9, 12）
}

String与Substring

Wed, 14 Oct 2020 00:00:00 GMT

当你从字符串中获取一个子字符串 —— 例如，使用下标或者 prefix(_:) 之类的方法 —— 就可以得到一个 Substring 的实例，而非另外一个 String。Swift 里的 Substring 绝大部分函数都跟 String 一样，意味着你可以使用同样的方式去操作 Substring 和 String。然而，跟 String 不同的是，你只有在短时间内需要操作字符串时，才会使用 Substring。当你需要长时间保存结果时，就把 Substring 转化为 String 的实例：

let greeting = "Hello, world!"
let index = greeting.firstIndex(of: ",") ?? greeting.endIndex
let beginning = greeting[..<index]
// beginning 的值为 "Hello"

// 把结果转化为 String 以便长期存储。
let newString = String(beginning)

就像 String，每一个 Substring 都会在内存里保存字符集。而 String 和 Substring 的区别在于性能优化上，Substring 可以重用原 String 的内存空间，或者另一个 Substring 的内存空间（String 也有同样的优化，但如果两个 String 共享内存的话，它们就会相等）。这一优化意味着你在修改 String 和 Substring 之前都不需要消耗性能去复制内存。就像前面说的那样，Substring 不适合长期存储 —— 因为它重用了原 String 的内存空间，原 String 的内存空间必须保留直到它的 Substring 不再被使用为止。

上面的例子，greeting 是一个 String，意味着它在内存里有一片空间保存字符集。而由于 beginning 是 greeting 的 Substring，它重用了 greeting 的内存空间。相反，newString 是一个 String —— 它是使用 Substring 创建的，拥有一片自己的内存空间。下面的图展示了他们之间的关系：

参考： SwiftGG

Switch元祖

Wed, 14 Oct 2020 00:00:00 GMT

let somePoint = (1, 1)
switch somePoint {
case (0, 0):
    print("\(somePoint) is at the origin")
case (_, 0):
    print("\(somePoint) is on the x-axis")
case (0, _):
    print("\(somePoint) is on the y-axis")
case (-2...2, -2...2):
    print("\(somePoint) is inside the box")
default:
    print("\(somePoint) is outside of the box")
}
// 输出“(1, 1) is inside the box”

CodeReading-01-YYModel

Tue, 13 Oct 2020 00:00:00 GMT

感觉值对于优秀源码的学习阅读不是很够,开个坑,希望自己坚持下去 YY作者写的相关文章必看: https://blog.ibireme.com/2015/10/23/ios_model_framework_benchmark/

结构

加上.h只有5个文件相当轻量级的一个转模型框架,十分适合作为源码阅读计划的第一弹

YYModel.h NSObject+YYModel.h NSObject+YYModel.m YYClassInfo.h YYClassInfo.m

YYModel.h

头文件

NSObject+YYModel

负责转模型的操作

类型

YYEncodingNSType

对应Foundation框架中基本类型的枚举

内联函数

YYClassGetNSType(Class cls)

类型映射
返回: YYEncodingNSType

YYEncodingTypeIsCNumber(YYEncodingType type)

判断是否是C的number类型
返回: BOOL

NSNumber *YYNSNumberCreateFromID(__unsafe_unretained id value)

从id类型返回NSNumber
其中对空的判断还有小数整数的处理值得一看

NSDate *YYNSDateFromString(__unsafe_unretained NSString *string)

从字符串获得NSDate对象
作用域的控制值得学习 {}

Class YYNSBlockClass()

获取NSBlock类
在判断value类型的时候有用到

id YYValueForKeyPath(__unsafe_unretained NSDictionary *dic, __unsafe_unretained NSArray *keyPaths)

通过一个 keyPaths 来从字典中获取对应 value
例如 [@"id",@"ID",@"myId"] 来从dic中获取一个ID

id YYValueForMultiKeys(__unsafe_unretained NSDictionary *dic, __unsafe_unretained NSArray *multiKeys)

Get the value with multi key (or key path) from dictionary
The dic should be NSDictionary
和上一个方法类似但这里的遍历时如果key不是NSString会调用上面的方法

NSNumber *ModelCreateNumberFromProperty(__unsafe_unretained id model,__unsafe_unretained _YYModelPropertyMeta *meta)

Get number from property.
这里位移枚举的使用值得一看

void ModelSetNumberToProperty(__unsafe_unretained id model,__unsafe_unretained NSNumber *num,__unsafe_unretained _YYModelPropertyMeta *meta)

Set number to property.
与上面的方法一对

void ModelSetValueForProperty(__unsafe_unretained id model,__unsafe_unretained id value,__unsafe_unretained _YYModelPropertyMeta *meta)

Set value to model with a property meta.
核心函数之一

void ModelSetWithDictionaryFunction(const void *_key, const void *_value, void *_context)

Apply function for dictionary, to set the key-value pair to model.
在void CFDictionaryApplyFunction(CFDictionaryRef theDict, CFDictionaryApplierFunction applier, void *context);方法中调用
对字典中所有键值对执行applier函数

void ModelSetWithPropertyMetaArrayFunction(const void *_propertyMeta, void *_context)

Apply function for model property meta, to set dictionary to model.
和上面的类似,是数组的

Class

结构体 ModelSetContext

typedef struct {
    void *modelMeta;  ///< _YYModelMeta
    void *model;      ///< id (self)
    void *dictionary; ///< NSDictionary (json)
} ModelSetContext;

_YYModelPropertyMeta : NSObject

A property info in object model.
表示模型对象中的属性信息
对应YYClassPropertyInfo
可理解为属性中间件

_YYModelMeta : NSObject

A class info in object model.
表示模型的类信息
对应YYClassInfo
可理解为类中间件

/// Returns the cached model class meta
+ (instancetype)metaWithClass:(Class)cls {
    if (!cls) return nil;
    static CFMutableDictionaryRef cache;
    static dispatch_once_t onceToken;
    static dispatch_semaphore_t lock;
    dispatch_once(&onceToken, ^{
        cache = CFDictionaryCreateMutable(CFAllocatorGetDefault(), 0, &kCFTypeDictionaryKeyCallBacks, &kCFTypeDictionaryValueCallBacks);
        lock = dispatch_semaphore_create(1);
    });
    dispatch_semaphore_wait(lock, DISPATCH_TIME_FOREVER);
    _YYModelMeta *meta = CFDictionaryGetValue(cache, (__bridge const void *)(cls));
    dispatch_semaphore_signal(lock);
    if (!meta || meta->_classInfo.needUpdate) {
        meta = [[_YYModelMeta alloc] initWithClass:cls];
        if (meta) {
            dispatch_semaphore_wait(lock, DISPATCH_TIME_FOREVER);
            CFDictionarySetValue(cache, (__bridge const void *)(cls), (__bridge const void *)(meta));
            dispatch_semaphore_signal(lock);
        }
    }
    return meta;
}

其中使用了 dispatch_semaphore信号量保证线程安全
建立了一个静态缓存,缓存了每个class对应的_YYModelMeta对象,提高了性能

YYClassInfo

将Runtime中C的一些东西,通过面向对象的方式进行了封装,便于理解使用转模型的基础

类型

YYEncodingType

Type encoding's type.

列举了各类编码信息，包括值类型、方法限定类型、属性修饰类型。YYEncodingType使用掩码的方式对三类不同的枚举信息进行分类，各占据1个字节

///值类型
YYEncodingTypeMask                = 0xFF       
///方法限定类型
YYEncodingTypeQualifierMask      = 0xFF00       
///属性修饰类型
YYEncodingTypePropertyMask      = 0xFF0000

Class

YYClassIvarInfo

成员变量 objc_ivar

YYClassMethodInfo

方法 objc_method

YYClassPropertyInfo

成员属性 property_t

YYClassInfo

类 objc_class

/.../

/// 成员变量列表
@property (nullable, nonatomic, strong, readonly) NSDictionary<NSString *, YYClassIvarInfo *> *ivarInfos; ///< ivars
/// 方法列表
@property (nullable, nonatomic, strong, readonly) NSDictionary<NSString *, YYClassMethodInfo *> *methodInfos; ///< methods
/// 成员属性
@property (nullable, nonatomic, strong, readonly) NSDictionary<NSString *, YYClassPropertyInfo *> *propertyInfos; ///<

/.../

Tips:

kCFNull

+ (NSDictionary *)_yy_dictionaryWithJSON:(id)json {
    if (!json || json == (id)kCFNull) return nil;
    ...
}

点进去

/* Null representant */

typedef const struct CF_BRIDGED_TYPE(NSNull) __CFNull * CFNullRef;

CF_EXPORT
CFTypeID CFNullGetTypeID(void);

CF_EXPORT
const CFNullRef kCFNull;	// the singleton null instance

打印

id null1 = (id)kCFNull;
id null2 = [NSNull null];

打印地址

null1=(NSNull *)0x10426eaf0
null2=(NSNull *)0x10426eaf0

拓展

标志	值	含义
NULL	(void *)0	C指针的字面零值
nil	(id)0	Objective-C对象的字面零值
Nil	(Class)0	Objective-C类的字面零值
NSNull	[NSNull null]	用来表示零值的单独的对象

static inline 内联函数

看到这样一个宏 #define force_inline __inline__ __attribute__((always_inline))
挺好的一篇参考文章: http://www.cnblogs.com/wyk19910103/p/5660627.html

__unsafe_unretained

与weak类似但有本质不同
https://www.zhihu.com/question/55831650
https://blog.csdn.net/bsplover/article/details/7707964
https://blog.csdn.net/yueyansheng2/article/details/49813987

__bridge

OC与C指针的转换

命名对内对外

对内的加_前缀
对外的不加
CoreFoundation中也挺常见

CFDictionaryApplyFunction & CFDictionaryApplyFunction 函数

相对于 Foundation 的方法来说，CoreFoundation 的方法有更高的性能，用 CFArrayApplyFunction() 和 CFDictionaryApplyFunction() 方法来遍历容器类能带来不少性能提升，但代码写起来会非常麻烦。

性能优化Tips:

来自文章开头YY作者的文章,感觉相当重要这里Copy来方便看

1. 缓存
Model JSON 转换过程中需要很多类的元数据，如果数据足够小，则全部缓存到内存中。

2. 查表
当遇到多项选择的条件时，要尽量使用查表法实现，比如 switch/case，C Array，如果查表条件是对象，则可以用 NSDictionary 来实现。

3. 避免 KVC
Key-Value Coding 使用起来非常方便，但性能上要差于直接调用 Getter/Setter，所以如果能避免 KVC 而用 Getter/Setter 代替，性能会有较大提升。

4. 避免 Getter/Setter 调用
如果能直接访问 ivar，则尽量使用 ivar 而不要使用 Getter/Setter 这样也能节省一部分开销。

5. 避免多余的内存管理方法
在 ARC 条件下，默认声明的对象是 __strong 类型的，赋值时有可能会产生 retain/release 调用，如果一个变量在其生命周期内不会被释放，则使用 __unsafe_unretained 会节省很大的开销。

访问具有 __weak 属性的变量时，实际上会调用 objc_loadWeak() 和 objc_storeWeak() 来完成，这也会带来很大的开销，所以要避免使用 __weak 属性。
创建和使用对象时，要尽量避免对象进入 autoreleasepool，以避免额外的资源开销。

6. 遍历容器类时，选择更高效的方法
相对于 Foundation 的方法来说，CoreFoundation 的方法有更高的性能，用 CFArrayApplyFunction() 和 CFDictionaryApplyFunction() 方法来遍历容器类能带来不少性能提升，但代码写起来会非常麻烦。

7. 尽量用纯 C 函数、内联函数
使用纯 C 函数可以避免 ObjC 的消息发送带来的开销。如果 C 函数比较小，使用 inline 可以避免一部分压栈弹栈等函数调用的开销。

8. 减少遍历的循环次数
在 JSON 和 Model 转换前，Model 的属性个数和 JSON 的属性个数都是已知的，这时选择数量较少的那一方进行遍历，会节省很多时间。

参考

http://triplecc.github.io/blog/2016-06-05-yymodelyue-du-xiao-ji/
https://lision.me/yymodel_x01/
https://lision.me/yymodel_x02/

RYImagePicker-iOS图片视频选择器

Tue, 13 Oct 2020 00:00:00 GMT

导入:

pod 'RYImagePicker'

照片选择器

支持图片 视频选择

配置:

/**
 最大可选图片数量  默认9张   设置为0 的话也是9张
 */
@property (nonatomic, assign) NSInteger maxSelectedNumber;
/**
 超过最大限制后的提示文案   默认文案 : "选择图片不能超过XXOO张"
 */
@property (nonatomic, copy) NSString *overMaxInfo;
/**
 是否显示iCloud相册   默认NO 不显示
 */
@property (nonatomic, assign) BOOL showiCloud;
/**
 仅显示视频资源   默认 NO 只显示图片
 */
@property (nonatomic, assign) BOOL videoOnly;
/**
 是否显示  "原图" 按钮    默认NO   不显示原图按钮
 */
@property (nonatomic, assign) BOOL isShowOriginalImageButton;

方法:

+ (instancetype)sharedInstance;
/**
 *  使用Manager 在当前控制器下 Present 出图片选择控制器
 *
 *  @param finished 点击完成的回调 传回选取的UIImage原图数组
 *  @param canceled 点击取消的回调
 */
- (void)presentImagePickerControllerWithFinishedHandler:(finishedPickImageRY)finished cancelHandler:(canceledPickImageRY)canceled;

/**
 选择图片完成的回调

 @param selectedImages 已经选择的图片_用来展示的 100x100 的缩略图
 @param selectedAssets 已经选择的图片_PHAsset对象
 @param info           一些配置项
 */
typedef void(^finishedPickImageRY)(NSArray *selectedImages,NSArray *selectedAssets,NSDictionary *info);

回调说明:

/**
 完成的回调中的 info 字段_用户是否指定需要原图 1: 用户选择需要原图
 */
#define RY_ORIGINAL_IMAGE_NEEDED @"RY_ORIGINAL_IMAGE_NEEDED"

/**
 选择图片完成的回调
 
 @param selectedImages 已经选择的图片_用来展示的 100x100 的缩略图
 @param selectedAssets 已经选择的图片_PHAsset对象
 @param info           一些配置项
 */
typedef void(^finishedPickImageRY)(NSArray *selectedImages,NSArray *selectedAssets,NSDictionary *info);

使用:

RYImagePickerManager *imanager = [RYImagePickerManager sharedInstance];
imanager.maxSelectedNumber = self.maxImagesCount;
[imanager presentImagePickerControllerWithFinishedHandler:^(NSArray *selectedImages,NSArray *selectedAssets,NSDictionary *info) {
                //TODO: 点击完成的回调
            } cancelHandler:^{
                //TODO: 点击取消的回调
            }];

RYImagesScroller-iOS高度自定义的图片轮播器

Tue, 13 Oct 2020 00:00:00 GMT

之前在项目中遇到了需要图片和视频混合轮播的需求但是没找到合适的轮播器于是就自己撸了一个

项目地址: https://github.com/RyukieSama/RYImagesScroller

图片轮播

支持自定义分页图片支持自定义蒙版视图

混合轮播实现思路

外部传入自定义View数组和各个自定义View对应的index数组即可传入的View会被覆盖在对应的Cell上面

效果展示

上图效果示例代码: 上图在第一个和第三个添加了一个开关和滑动条


_svImages = [[RYImagesScrollView alloc] initWithFrame:CGRectMake(0, 20, [UIScreen mainScreen].bounds.size.width, [UIScreen mainScreen].bounds.size.width*3/7) pageStyle:RYImageScrollerPageStyleCustom];
        _svImages.autoScrollTimeInterval = 4.0f;
        _svImages.contentMode = UIViewContentModeScaleAspectFill;
        _svImages.normalPageImage = [UIImage imageNamed:@"outdoor_icon_carousel"];
        _svImages.currentPageImage = [UIImage imageNamed:@"outdoor_icon_carousel_selected"];

self.svImages.imageURLs = @[
                            @"http://cc.cocimg.com/api/uploads/20170407/1491531818350790.png",
                            @"http://cc.cocimg.com/api/uploads/20170407/1491531897388821.png",
                            @"http://cc.cocimg.com/api/uploads/20170407/1491531754597727.png",
                            @"http://cc.cocimg.com/api/uploads/20170407/1491531459990792.png",
                            @"http://cc.cocimg.com/api/uploads/20170407/1491531504501824.jpg"
                            ];
    
    //这里的意思是在第一页和第三页 添加自定义蒙版视图
    self.svImages.attachIndexArr = @[
                                     @0,
                                     @2
                                     ];
    //这里的意思是在第一页和第三页的 添加自定义蒙版视图数组   蒙版会自适应轮播控件的大小  如果需要自定义位置  最好用一个背景透明的容器装下
    self.svImages.attachViewArr = @[
                                    [[UISwitch alloc] init],
                                    [[UISlider alloc] init]
                                    ];

方法：

初始化:

/**
 初始化方法   并设置分页样式

 @param style 分页样式
 */
- (instancetype)initWithFrame:(CGRect)frame pageStyle:(RYImageScrollerPageStyle)style;

分页样式

typedef NS_ENUM(NSInteger, RYImageScrollerPageStyle) {
    /**
     系统分页样式
     */
    RYImageScrollerPageStyleNormal = 99,
    /**
     用户自定义分页样式
     */
    RYImageScrollerPageStyleCustom = 100
};

其他参数

/**
 *  图片数组
 */
@property (nonatomic, strong) NSArray <NSString *> *imageURLs;
/**
 *  需要添加辅助view的序号数组 与 attachViewArr 一一对应
 */
@property (nonatomic, strong) NSArray <NSNumber *> *attachIndexArr;
/**
 *  辅助View数组
 */
@property (nonatomic, strong) NSArray <UIView *> *attachViewArr;
/**
 *  滚动时间间隔   默认2s
 */
@property (nonatomic, assign) CGFloat autoScrollTimeInterval;
/**
 *  默认 UIViewContentModeScaleAspectFill
 */
@property (nonatomic, assign) UIViewContentMode contentMode;
/**
 非当前展示页的分页图片  仅在 RYImageScrollerPageStyleCustom 下生效
 */
@property (nonatomic, strong) UIImage *normalPageImage;
/**
 当前页的分页图片   仅在 RYImageScrollerPageStyleCustom 下生效
 */
@property (nonatomic, strong) UIImage *currentPageImage;
/**
 *  点击图片的回调
 */
@property (nonatomic, copy) ImageScrollHandler handler_imageClick;
/**
 *  每次滚动完的回调
 */
@property (nonatomic, copy) ImageScrollHandler handler_scrollCallBack;

RYPhotosBrowser

Tue, 13 Oct 2020 00:00:00 GMT

亮点

可高度自定义的图片浏览控件

支持多种图片传入类型: 本地文件路径 网络图片NSString UIImage对象或者三者混合

基于SDWebImage4.0

可自定义加载阶段HUD

导入方式

iOS 9+ pod 'RYPhotosBrowser'

两种弹出姿势

从图片容器放大恢复

[RYImageBrowser showBrowserWithImageURLs:arr atIndex:[obj integerValue] withPageStyle:RYImageBrowserPageStyleAuto fromImageView:weakSelf.vCover withProgress:^(NSInteger receivedSize, NSInteger expectedSize, NSURL *targetURL) {
                NSLog(@"withProgress");
                [SVProgressHUD show];
            } changImage:^(NSInteger receivedSize, NSInteger expectedSize, NSURL *targetURL) {
                NSLog(@"changImage");
                [SVProgressHUD dismiss];
            } loadedImage:^(NSInteger receivedSize, NSInteger expectedSize, NSURL *targetURL) {
                NSLog(@"loadedImage");
                [SVProgressHUD dismiss];
            }];

渐变放大

[RYImageBrowser showBrowserWithImageURLs:arr atIndex:[obj integerValue] withPageStyle:RYImageBrowserPageStyleAuto];

设置分页样式

typedef NS_ENUM(NSInteger, RYImageBrowserPageStyle) {
    /**
     9张以内显示点点点    大于9张显示文字序号
     */
    RYImageBrowserPageStyleAuto = 99,
    /**
     显示点点点
     */
    RYImageBrowserPageStylePoints = 100,
    /**
     显示文字
     */
    RYImageBrowserPageStyleText = 101,
};

调用方法

/**
 show   自定义分页样式

 @param imageURLs 图片数组  UIImage 和 URLString(webURL/本地路径) 都行  混合也行   @[UIImage ,UIImage UIImage , ...]  或  @[NSString, NSString ,NSString , ...]  或 @[UIImage ,NSString ,UIImage , ...]
 @param index 当前第几张   从0 开始
 @param style 页码样式
 */
+ (void)showBrowserWithImageURLs:(NSArray *)imageURLs atIndex:(NSInteger)index withPageStyle:(RYImageBrowserPageStyle)style;

/**
 show   自定义分页样式
 
 @param imageURLs 图片数组  UIImage 和 URLString(webURL/本地路径) 都行  混合也行   @[UIImage ,UIImage UIImage , ...]  或  @[NSString, NSString ,NSString , ...]  或 @[UIImage ,NSString ,UIImage , ...]
 @param index 当前第几张   从0 开始
 @param style 页码样式
 @param imageView 点击的图片容器
 */
+ (void)showBrowserWithImageURLs:(NSArray *)imageURLs atIndex:(NSInteger)index withPageStyle:(RYImageBrowserPageStyle)style fromImageView:(UIView *)imageView;

/**
 show   自定义分页样式
 
 @param imageURLs 图片数组  UIImage 和 URLString(webURL/本地路径) 都行  混合也行   @[UIImage ,UIImage UIImage , ...]  或  @[NSString, NSString ,NSString , ...]  或 @[UIImage ,NSString ,UIImage , ...]
 @param index 当前第几张   从0 开始
 @param style 页码样式
 @param imageView 点击的图片容器
 @param progress 加载图片中的回调  在此可自定义添加HUD等操作
 @param changed 切换图片的回调
 @param loaded 图片完成的回调
 */
+ (void)showBrowserWithImageURLs:(NSArray *)imageURLs atIndex:(NSInteger)index withPageStyle:(RYImageBrowserPageStyle)style fromImageView:(UIView *)imageView withProgress:(RYWebImageDownloaderProgressBlock)progress changImage:(RYWebImageDownloaderProgressBlock)changed loadedImage:(RYWebImageDownloaderProgressBlock)loaded;

数据库主键和外键

Tue, 13 Oct 2020 00:00:00 GMT

一: 什么是主键外键

学生表(学号,姓名,性别)

学号是主键课程表(课程号,课程名,学分) 课程号是主键成绩表(学号,课程号,成绩) 学号/课程号是外键

如果公共关键字在一个关系中是主关键字,呢么这个公共关键字被称为另一关系的外键
如果一个关系的外键作为主关键字的表被称为主表, 具有次此关键字的表被称为主表的从表

二: 外键的作用

外键用于保持数据一致性, 完整性
主要目的是控制存储在外键表中的数据

三: 主键的设计原则

主键应当是对用户无意义的
主键应该是单列的,以提高链接和筛选操作的效率
- 复合键的使用通常出于两点考虑
  - 主键应当具有意义
    - 这被认为破坏了数据库提供了方便
  - 在描述多对多关系的链接表中可与使用两个外部键作为主键
    - 该表可能成为其他从表的主表,并成为从表主键的一部分,使得之后的从表包含更多的列
永远不要更新主键
主键不应该包含动态变化的数据(时间戳等)
主键应当由计算机自动生成

四: 数据库主键选取策略

自动增长型
手动增长型
使用UniqueIdentifier SQL Server提供一个UniqueIdentifier数据类型（16字节），并提供一个生成函数NEWID()，生成一个唯一的UniqueIdentifier
使用COMB类型
- 保留UniqueIdentifier的前10字节，后6字节表示生成时间

五: 外键

外键的主要作用是用来控制数据库中数据的完整性,党对一个数据进行操作的时候,和他有关联的一个表或者多个表的数据能够同时发生改变

参考

https://www.cnblogs.com/buptlyn/p/4555206.html

死锁

Tue, 13 Oct 2020 00:00:00 GMT

  NSLog(@"之前 - %@", [NSThread currentThread]);

    dispatch_sync(dispatch_get_main_queue(), ^{
         NSLog(@"sync - %@", [NSThread currentThread]);
    });

    NSLog(@"之后 - %@", [NSThread currentThread]);

打印完第一句后，dispatch_sync 立即阻塞当前的主线程，然后把 Block 中的任务放到 main_queue 中， main_queue 中的任务会被取出来放到主线程中执行，但主线程这个时候已经被阻塞了，所以 Block 中的任务就不能完成，它不完成，dispatch_sync 就会一直阻塞主线程，这就是死锁现象。导致主线程一直卡死。当然这里只是一个例子,死锁并不只会发生在主线程

一: 概述

所谓死锁,指的是两个或者两个以上的进程在执行的过程中,由于竞争资源或彼此通信造成的一种阻塞现象.

如果一个线程需要并行处理多个任务，那么就可以创建多个线程，但是线程多了，往往会产生冲突，当一个线程锁定了一个资源A，而又想去锁定资源B，而在另一个线程中，锁定了资源B，而又想去锁定资源A以完成自身的操作，两个线程都想得到对方的资源，而不愿意释放自己的资源，造成两个线程都在等待，而无法执行，此时就是死锁。

死锁的规范定义
- 集合中的每一个进程都在等待只能由本集合中的其他进程才能引发的事件，那么该组进程是死锁的。

注意死锁与正常阻塞不一样正常阻塞：事务请求被其他事务锁定的资源的锁时，发出请求的事务一直等到该锁被释放。默认情况下，除非设置了LOCK_TIMEOUT，否则SQL Server事务不会超时。因为发出请求的事务未执行任何操作来阻塞拥有锁的事务，所以该事务是被阻塞，而不是陷入了死锁。最后，拥有锁的事务将完成并释放锁，然后发出请求地事务将获取锁并继续执行。

二: 四个必要条件

互斥(资源独占)
- 一个资源一次只能被一个进程使用
请求与保持(部分分配,占有申请)
- 一个进程在申请新的资源的同时保持对原有资源的占有（只有这样才是动态申请，动态分配）
不可剥夺(不可强占)
- 资源申请者不能强行地从资源占有者手中夺取资源，资源只能由占有者自愿释放
循环等待
- 若干进程之间形成一种头尾相连的循环等待资源关

三: 产生原因

系统资源不足,竞争不可剥夺资源引起的进程死锁
竞争临时资源引起的死锁
进程推进顺序不当引起死锁

四: 破坏死锁

需要破坏四个必要条件中的一个或几个

互斥(不能改变)
- 必然存在的,非共享设备所必须的
破坏请求与保持
- 对一个进程在请求资源时，它不能持有不可剥夺资源
破坏不可剥夺
- 对一个已经保持了某些不可剥夺资源的进程，提出新的资源请求而不能得到满足时，它必须释放已经保持的所有资源，待以后需要时再重新申请
破坏循环
- 对系统所有资源类型进行线性排列，并赋予不同序号。规定每个进程必须按序号递增的顺序请求资源。

五: 预防死锁

每个进程（事务）将所有要使用的数据全部加锁，否则，就不能继续执行
预先对数据对象规定一个封锁顺序，所有进程（事务）都按这个顺序加锁
保证进程处于安全进程序列
按同一顺序访问对象
避免事务中的用户交互
保持事务简短并在一个批处理中

参考

https://blog.csdn.net/weixin_39651041/article/details/79993975

堆栈的深度问题

Tue, 13 Oct 2020 00:00:00 GMT

关于栈深度问题通常会出现在递归中。因为程序在递归时，每一层递归的临时变量和参数，都是被保存在栈中的，所以递归调用的深度过多，就会造成栈空间存储不足。一般来说栈是向下生长的，堆是向上生长的。把内存地址像门牌号编号成 1 ~ 10000，栈的使用就是先用第 10000 号内存块，再用第 9999 号内存块，依次减小编号。而堆的话，是先用第 1 号内存块，再用第 2 号内存块，依次增加编号。堆内存可以认为是没有上限的（除非你的硬盘空间不足），如果消耗光了计算机的内存，操作系统还会用硬盘的虚拟内存为你提供更多的内存，虚拟内存和内存的读写速度几倍一致。但是如果大量程序占用了虚拟内存，很可能会出现内存泄露问题。这种情况，虚拟内存很快就会被消耗完毕。栈内存不同于堆内存，通常编译器都会指定程序的栈内存空间使用的大小，如果栈内存使用超出了限制，就会触发程序异常退出，即栈溢出错误（Stack Over flow）。但是iOS实际开发中很少出现栈溢出问题，这就从侧面反映出使用的递归比较少。苹果官方文档指明：对于主线程，栈内存为 1 MB；非主线程，栈内存为 512 KB。如果想测试这一点，在主线程创建一个大小为100万的数组，这是Xcode就会报错。

项目路由方案

Tue, 13 Oct 2020 00:00:00 GMT

组件化之路:去模型化与路由

先吐槽下... 去年年底来到新公司, 公司项目代码有四五年了, 经手了十几号人. 规范什么的基本不存在, 耦合混乱, 垃圾奇葩代码遍地. 印象最深的是UI让改一个到处都有的一个样式的按钮的颜色. MMP改的我要死不活的...连基本的复用都不存在过年前准备对项目进行组件化重构

目标

这次组件化方案需要解决的主要问题有两点 解耦 和 取模型化

去模型化

这里我采用的是使用 NSDictionary 来实现去模型化

使用模型有什么好处?

使用数据较为便捷
无须过多关心数据解析,交给第三方库即可

去模型话有什么好处?

解耦
极大减少项目文件数量

存在的问题

hardcode 这是解耦去模型必然会出现的问题

解耦_路由

隐藏导航栏下面的线

Tue, 13 Oct 2020 00:00:00 GMT

[self.navigationController.navigationBar setBackgroundImage:[UIImage new] forBarMetrics:UIBarMetricsDefault];
[self.navigationController.navigationBar setShadowImage:[UIImage new]];

autoreleasepool

Tue, 13 Oct 2020 00:00:00 GMT

自动释放池

系统
- 系统默认会在 main.m 文件中创建一个自动释放池。。。
手动
- 例如在for循环中产生大量无法及时释放的临时变量

for (int i = 0; i < largeNumber; ++i) {
	NSString *str = @"Hello World";
	str = [str stringByAppendingFormat:@" - %d", i];
	str = [str uppercaseString];
}

问：以上代码存在什么样的问题？如果循环的次数非常大时，应该如何修改？

    - 如果不在本次循环结束的时候消除的话节会一直存在直到程序运行过 } 才会被释放占用大量内存
    - 解决办法:

-(void)viewDidLoad {
	[super viewDidLoad];

    int largeNumber = 1000000;
	for (int i = 0; i < largeNumber; ++i) {
@autoreleasepool {
	NSString *str = @"Hello World";
	str = [str stringByAppendingFormat:@" - %d", i];
	str = [str uppercaseString];
		}// 循环执行到这里就会回头继续执行循环了
		//这样在循环内部就已经释放了自动释放池
	}
    // 不加自动释放池的话要执行到这里才会释放对象
}

自动释放池的创建 & 销毁

每一次主线程的消息循环开始的时候会创建自动释放池
消息循环结束前,会释放自动释放池
自动释放池销毁的时候会向其内部所有的对象发送一个 release 消息释放所有的对象

内存管理-OC

消息循环

保证应用程序不退出
实现: 一个死循环不断地监视事件 (方法,点击事件等),并执行对应的方法
[面试会问]app是如何运行的?
执行流程详细描述:
- 应用程序开启 -> 创建一个消息循环 -> 监视事件 -> 接收到事件 -> 执行创建自动释放次并执行相应操作 -> 将执行中产生的对象丢入刚才创建的那个自动释放池 -> 消息执行结束 -> 自动释放池销毁(对其中所有对象发送一个 release消息,销毁对象) -> 一次消息循环结束 -> 开始下一次消息循环

为什么用dispatch-once实现单例

Tue, 13 Oct 2020 00:00:00 GMT

iOS-为什么用dispatch_once实现单例

面试问到了自己说到了这点(猜的是线程安全的查了一下确实是这样)

+ (XXXX *)sharedInstance
{
    static id sharedInstance = nil;
    static dispatch_once_t onceToken;
    dispatch_once(&onceToken, ^{
        sharedInstance = [[self alloc] init];
    });
    return sharedInstance;
}

dispatch_once是线程安全的,可以确保

参考

http://www.cnblogs.com/hellocby/archive/2012/08/24/2654488.html https://blog.csdn.net/qqMCY/article/details/88648000 单例alloc 、 copy的处理

合适的线程数量

Tue, 13 Oct 2020 00:00:00 GMT

多线程挺好但是并不是越多越好线程也是有消耗的 iOS主线程堆栈大小1m,子线程512kb,并且不能通过编译器开关或线程API函数来更改

最优线程数计算理论依据

Venkat Subramaniam 博士在《Programming Concurrency on the JVM》中提到关于最优线程数的计算


The minimum number of threads is equal to the number of available
cores. If all tasks are computation intensive, then this is all we need. Having
more threads will actually hurt in this case because cores would be context
switching between threads when there is still work to do. If tasks are IO
intensive, then we should have more threads.

We can compute the total number of threads we’d need as follows:
  Number of threads = Number of Available Cores / (1 - Blocking Coefficient)

 

 

 To determine the number of threads, we need to know two things:
 • The number of available cores
 • The blocking coefficient of tasks


 The first one is easy to determine; we can look up that information, even at
 runtime, as we saw earlier. It takes a bit of effort to determine the blocking
 coefficient. We can try to guess it, or we can use profiling tools or the java.
 lang.management API to determine the amount of time a thread spends on
 system/IO operations vs. on CPU-intensive tasks.

线程数 = 可用核数 / (1 - 阻塞系数 )
阻塞系数 = 阻塞时间 / (阻塞时间 + CPU使用时间)

网友的一点补充

其实，如果全系统只运行你一个程序，只考虑测试代码，阻塞系数是0.5，当然是没错的，但是这个公式是针对全系统而言的，需要把全系统所有程序的线程占用的timeslice都计算在内考虑。理论计算是需要考虑所有细节的，这些细节占用的时间可一点不少哦。

当全系统线程数量远远大于执行核心数，则增加了线程的上下文环境交换时间等等，还有其他线程分走了许多CPU时间片，这部分时间可不少，可是却没有用在你的测试计算上。为简化理解，直接把这部分时间都划算到阻塞时间上，等于说阻塞系数变大，纯工作系数变小；分母就变小了，最佳线程数量就成倍增大了。

如果还不理解，我举个例子，用实际场景来解释就明白了。

一个加工厂有4条加工流水线，每一个人同时只能占用一条流水线加工自己的产品，假定一个人占据一条加工流水线完全饱和工作8小时能完成自己的加工，那么拆分到4条线上显然2小时可以加工完成，理论上。

再假定人的饱和工作时间和空闲时间各占50%呢（构造阻塞系数0.5），在不考虑交班交接的时间，显然8个人同时排队加工才能这2小时完成，（加工厂只安排你的8个人）。

但是事实工厂工况是怎么样的呢？这个加工厂有1000人在排队等着加工自己的产品(你安排了8个人过去加工你的产品 + 992个外人)，而且，一条流水线线上工作内容切换时，前一个人和后一个人交替交接需要占用不少时间，而且，992个外人也各自要加工自己的产品，分配给你那8个人的时间片机会就少了。为简化理解，那些时间都没为你的产品加工，都直接是划归到阻塞时间上去，阻塞系数变大，最佳线程数=CPU执行核心数/（1-阻塞系数），分母变小，结果自然变大。如果你要获得更多的时间片，你就要安排更多人过去，增大占时间片的机会。

所以你安排8个人去加工，肯定2小时完成不了，可能实际用了3小时才加工完成。但是你若安排16个人过去排队加工，可能2.5小时就能加工完成了。

参考

https://www.cnblogs.com/bobsha/p/6178995.html

FMDB-死锁问题

Tue, 13 Oct 2020 00:00:00 GMT

[queue inTransaction:^(FMDatabase *db, BOOL *rollback) {    
            [db executeUpdate:@"INSERT INTO myTable VALUES (?)", [NSNumber numberWithInt:1]];    
            [db executeUpdate:@"INSERT INTO myTable VALUES (?)", [NSNumber numberWithInt:2]];    
            [db executeUpdate:@"INSERT INTO myTable VALUES (?)", [NSNumber numberWithInt:3]];  
    [queue inDatabase:^(FMDatabase *db) {
        // do work B
    }];
            if (whoopsSomethingWrongHappened) {    
                    *rollback = YES; return;    
            }   
            // etc…    
            [db executeUpdate:@"INSERT INTO myTable VALUES (?)", [NSNumber numberWithInt:4]];    
    }];

使用fmdb进行数据库操作,出现inDatabase: was called reentrantly on the same queue, which would lead to a deadlock这样的崩溃错误.原因是在一个[queue inDataBase]的block中,又执行了一个inDataBase.这时第一个block需要执行结束才能出队列,第二个block才能执行.但是第一个block又包含了第二个block,也就是说第二个block不执行,第一个block就不能结束.于是就互相等待,也就是各种死锁

FMDB与WCDB

Tue, 13 Oct 2020 00:00:00 GMT

参考: https://cloud.tencent.com/developer/article/1005718 微信团队 http://blog.devtang.com/2012/04/22/use-fmdb/ 在iOS开发中使用FMDB

兼容性

都是基于SQLite的所有数据库是可以兼容的,迁移的话需要重新封装项目的数据库工具

性能

读写

SQLite的速度已经很快了,FMDB之做了最简单的封装,WCDB还做了ORM等封装,所以有了更多的步骤,性能稍劣于FMDB5%(官方给出的数据)
- 优于多携程读的优势,可以和FMDB持平了
写操作通常是性能的瓶颈,做了针对性优化使WCDB写操作优于FMDB28%,批量写优于180%
多线程读写优于FMDB62%
多线程写FMDB直接返回错误SQLITE_BUSY,无法完成

初始化

SQLite连接的初始化速度会随着数据库内表的数量增加而逐渐上升,WCDB也针对这个场景做了优化.相较于没有优化的FMDB,WCDB的初始化速度有107%的性能优势

ORM

Object Relational Mapping

有了ORM开发维护成本大大降低

数据库升级

SQLite 的数据库升级一直是一个比较繁杂的问题
通常的做法是，开发者自行定义一个版本号，并保存下来。数据库创建时每次检查版本号，若版本号较低，则对其字段进行升级，并更新版本号。但在多个版本的增增减减之后，版本的处理逻辑会越来越复杂，甚至可能弄错表内哪些字段是新增的，哪些是废弃的
WCDB将数据库升级和ORM结合起来，对于需要增删改的字段，只需直接在ORM层面修改，并再次调用 createTableAndIndexesOfName:withClass:接口即可自动升级

总结

与 FMDB 对比， WCDB 使得开发者可以写更少的代码，但能获得更高的性能。开发者不需要额外关注数据库升级和多线程操作的问题。同时， WCDB 还提供了加密、统计、修复等功能。

iOS重签名调研

Tue, 13 Oct 2020 00:00:00 GMT

要想保留原APP的bundleId不变，则重签名的证书的bundleId规则如下：原App的bundleId: com.abc.hell 用于重签名的bundleId:com.abc.hell.xyz 保证原APP的bundleId是重签名的bundleId的前缀

Step 1: 查看App证书情况

执行命令：

codesign -d -vv /Users/RyukieW/Inke/技术相关/重签名调研/sui/Payload/Finance.app

输出：

Executable=/Users/RyukieW/Inke/技术相关/重签名调研/sui/Payload/Finance.app/Finance
Identifier=com.feidee.myfinance
Format=app bundle with Mach-O thin (arm64)
CodeDirectory v=20400 size=67736 flags=0x0(none) hashes=2108+5 location=embedded
Signature size=4820
Authority=iPhone Developer: xiangdong Ren (23Z6TN7Z56)
Authority=Apple Worldwide Developer Relations Certification Authority
Authority=Apple Root CA
Signed Time=Nov 14, 2018 at 10:58:22 AM
Info.plist entries=37
TeamIdentifier=3Q47P4VEX9
Sealed Resources version=2 rules=10 files=446
Internal requirements count=1 size=180

Step 2: 查看是否被加密（是否破解）

gebiwangshushudeMacBook:Finance.app RyukieW$ otool -l Finance | grep cryp
     cryptoff 16384
    cryptsize 6897664
      cryptid 0

其中cryptid为0代表已经砸壳，即解密，为1或者2表示以第1类或者第2类加密方案加密。

Step 4：查看本地证书并记录需要用到的证书

security find-identity -v -p codesigning

iPhone Developer: kai chen (8SRJU35B8T)

找一个开发环境配置文件生成entitlements.plist文件，后面签名要用到：

security cms -D -i XX.mobileprovision > profile.plist
/usr/libexec/PlistBuddy -x -c 'Print :Entitlements' profile.plist > entitlements.plist
cat entitlements.plist

把准备好的开发环境配置文件复制到XX.app文件夹下：

cp XX.mobileprovision Payload/XX.app/embedded.mobileprovision

修改包Info.plist中的Bundle Identifier与配置文件中的Bundle Identifier保持一致：

/usr/libexec/PlistBuddy -c "Set :CFBundleIdentifier com.gdinke.meetstar.dev" Info.plist

移除之前的签名文件夹：

rm -rf _CodeSignature

Step 5: 重签名

重签名framework


codesign -f -s "iPhone Developer: kai chen (8SRJU35B8T)" Alamofire.framework

codesign -f -s "iPhone Developer: kai chen (8SRJU35B8T)" TZImagePickerController.framework

codesign -f -s "iPhone Developer: kai chen (8SRJU35B8T)" CryptoSwift.framework		
	
codesign -f -s "iPhone Developer: kai chen (8SRJU35B8T)" WCDBSwift.framework

codesign -f -s "iPhone Developer: kai chen (8SRJU35B8T)" FinanceAlert.framework	
		
codesign -f -s "iPhone Developer: kai chen (8SRJU35B8T)" XLActionController.framework


codesign -f -s "iPhone Developer: kai chen (8SRJU35B8T)" FinanceImagePicker.framework	

codesign -f -s "iPhone Developer: kai chen (8SRJU35B8T)" libswiftAVFoundation.dylib

codesign -f -s "iPhone Developer: kai chen (8SRJU35B8T)" FinanceKeyboard.framework		

codesign -f -s "iPhone Developer: kai chen (8SRJU35B8T)" libswiftAccelerate.dylib

codesign -f -s "iPhone Developer: kai chen (8SRJU35B8T)" FinanceKit.framework			

codesign -f -s "iPhone Developer: kai chen (8SRJU35B8T)" libswiftCore.dylib

codesign -f -s "iPhone Developer: kai chen (8SRJU35B8T)" FinanceLoadingView.framework	

codesign -f -s "iPhone Developer: kai chen (8SRJU35B8T)" libswiftCoreAudio.dylib

codesign -f -s "iPhone Developer: kai chen (8SRJU35B8T)" FinanceNotice.framework		

codesign -f -s "iPhone Developer: kai chen (8SRJU35B8T)" libswiftCoreData.dylib

codesign -f -s "iPhone Developer: kai chen (8SRJU35B8T)" FinancePoper.framework			

codesign -f -s "iPhone Developer: kai chen (8SRJU35B8T)" libswiftCoreFoundation.dylib

codesign -f -s "iPhone Developer: kai chen (8SRJU35B8T)" FinanceRefresh.framework		

codesign -f -s "iPhone Developer: kai chen (8SRJU35B8T)" libswiftCoreGraphics.dylib

codesign -f -s "iPhone Developer: kai chen (8SRJU35B8T)" FinanceRuler.framework			

codesign -f -s "iPhone Developer: kai chen (8SRJU35B8T)" libswiftCoreImage.dylib

codesign -f -s "iPhone Developer: kai chen (8SRJU35B8T)" FinanceVendors.framework		

codesign -f -s "iPhone Developer: kai chen (8SRJU35B8T)" libswiftCoreLocation.dylib

codesign -f -s "iPhone Developer: kai chen (8SRJU35B8T)" IQKeyboardManagerSwift.framework

codesign -f -s "iPhone Developer: kai chen (8SRJU35B8T)" libswiftCoreMedia.dylib

codesign -f -s "iPhone Developer: kai chen (8SRJU35B8T)" Iverson.framework			

codesign -f -s "iPhone Developer: kai chen (8SRJU35B8T)" libswiftDarwin.dylib

codesign -f -s "iPhone Developer: kai chen (8SRJU35B8T)" Kingfisher.framework			

codesign -f -s "iPhone Developer: kai chen (8SRJU35B8T)" libswiftDispatch.dylib

codesign -f -s "iPhone Developer: kai chen (8SRJU35B8T)" Messi.framework			

codesign -f -s "iPhone Developer: kai chen (8SRJU35B8T)" libswiftFoundation.dylib

codesign -f -s "iPhone Developer: kai chen (8SRJU35B8T)" Moya.framework				

codesign -f -s "iPhone Developer: kai chen (8SRJU35B8T)" libswiftMediaPlayer.dylib

codesign -f -s "iPhone Developer: kai chen (8SRJU35B8T)" Pageboy.framework			

codesign -f -s "iPhone Developer: kai chen (8SRJU35B8T)" libswiftMetal.dylib

codesign -f -s "iPhone Developer: kai chen (8SRJU35B8T)" PopoverKit.framework		

codesign -f -s "iPhone Developer: kai chen (8SRJU35B8T)" libswiftObjectiveC.dylib

codesign -f -s "iPhone Developer: kai chen (8SRJU35B8T)" Reachability.framework			

codesign -f -s "iPhone Developer: kai chen (8SRJU35B8T)" libswiftPhotos.dylib

codesign -f -s "iPhone Developer: kai chen (8SRJU35B8T)" Result.framework			

codesign -f -s "iPhone Developer: kai chen (8SRJU35B8T)" libswiftQuartzCore.dylib

codesign -f -s "iPhone Developer: kai chen (8SRJU35B8T)" SnapKit.framework			

codesign -f -s "iPhone Developer: kai chen (8SRJU35B8T)" libswiftSwiftOnoneSupport.dylib

codesign -f -s "iPhone Developer: kai chen (8SRJU35B8T)" SwiftSVG.framework		

codesign -f -s "iPhone Developer: kai chen (8SRJU35B8T)" libswiftUIKit.dylib

codesign -f -s "iPhone Developer: kai chen (8SRJU35B8T)" Swifty.framework			

codesign -f -s "iPhone Developer: kai chen (8SRJU35B8T)" libswiftos.dylib

codesign -f -s "iPhone Developer: kai chen (8SRJU35B8T)" SwiftyJSON.framework			

codesign -f -s "iPhone Developer: kai chen (8SRJU35B8T)" libswiftsimd.dylib

.app文件重签名

codesign -f -s "iPhone Developer: kai chen (8SRJU35B8T)" --no-strict --entitlements=entitlements.plist Finance.app

查看App签名信息

Step 6: 打包

zip -ry Finance.ipa Payload

// zip –ry 「输出文件名」 「输入文件名」

参考

iOS逆向微信

https://cloud.tencent.com/developer/article/1445897 https://www.jianshu.com/p/31232eef35c5 https://juejin.im/post/5c7e796351882532cd57adc4#heading-19 iOS应用程序的重签名(打包) https://blog.csdn.net/skylin19840101/article/details/60583893 iOS逆向必备绝技之ipa重签名 https://www.yangshebing.com/2018/01/06/iOS%E9%80%86%E5%90%91%E5%BF%85%E5%A4%87%E7%BB%9D%E6%8A%80%E4%B9%8Bipa%E9%87%8D%E7%AD%BE%E5%90%8D/?utm_source=tuicool&utm_medium=referral 超级签名-原理/机制/技术细节-完全解析 https://juejin.im/post/5cdeb72151882525cc707729

iOS多线程技术对比

Tue, 13 Oct 2020 00:00:00 GMT

一: NSThread

每个NSThread对象对应一个线程，真正最原始的线程

优点
- NSThread 轻量级最低，相对简单。
缺点
- 手动管理所有的线程活动，如生命周期、线程同步、睡眠等。

二: NSOperation

自带线程管理的抽象类。基于GCD

优点
- 自带线程周期管理，操作上可更注重自己逻辑。
- 提供了一些在GCD中不容易实现的特性，如：限制最大并发数量、操作之间的依赖关系
缺点
- 面向对象的抽象类，只能实现它或者使用它定义好的两个子类：NSInvocationOperation 和 NSBlockOperation。

三: GCD

Grand Central Dispatch (GCD)是Apple开发的一个多核编程的解决方法。

优点
- 最高效，避开并发陷阱。
- 用Block定义任务，使用起来非常灵活便捷
- 通过GCD，开发者不用再直接跟线程打交道，只需要向队列中添加代码块即可
- GCD在后端管理着一个线程池，GCD不仅决定着代码块将在哪个线程被执行，它还根据可用的系统资源对这些线程进行管理。从而让开发者从线程管理的工作中解放出来，通过集中的管理线程，缓解大量线程被创建的问题
- 使用GCD，开发者可以将工作考虑为一个队列，而不是一堆线程，这种并行的抽象模型更容易掌握和使用
缺点
- 基于C实现。

四: 场景

Operation queue 提供了更多你在编写多线程程序时需要的功能，并隐藏了许多线程调度，线程取消与线程优先级的复杂代码，为我们提供简单的API入口。从编程原则来说，一般我们需要尽可能的使用高等级、封装完美的API，在必须时才使用底层API。但是我认为当我们的需求能够以更简单的底层代码完成的时候，简洁的GCD或许是个更好的选择，而Operation queue 为我们提供能更多的选择。

参考

http://yoferzhang.com/post/20160830ConcurrencyProgrammingGuide/ https://www.jianshu.com/p/d09e2638eb27

iOS多线程方案

Tue, 13 Oct 2020 00:00:00 GMT

一: 总览

pthread
- 几乎不用
- C语言的,全部由程序员自己管理
NSThread
- 程序员自己管理线程,用得少
GCD
- 自动管理
NSOperation
- 基于GCD
- 比GCD多了一些使用功能
- 面向对象

二: GCD

特点

GCD会自动是用更多的CPU内核
自动管理线程生命周期(创建,调度,销毁等)
程序员只用高数GCD想要如何执行什么任务,不用编写线程管理代码

group

使用 enter leave 的时候一定要出入数量对等否则会崩溃的

dispatch_barrier_async

多个任务分两组完成

 // 并发队列
    dispatch_queue_t queue = dispatch_queue_create("test", DISPATCH_QUEUE_CONCURRENT);

    // 异步执行
    dispatch_async(queue, ^{
        for (int i = 0; i < 3; i++) {
            NSLog(@"栅栏：并发异步1   %@",[NSThread currentThread]);
        }
    });
    dispatch_async(queue, ^{
        for (int i = 0; i < 3; i++) {
            NSLog(@"栅栏：并发异步2   %@",[NSThread currentThread]);
        }
    });

    dispatch_barrier_async(queue, ^{
        NSLog(@"------------barrier------------%@", [NSThread currentThread]);
        NSLog(@"******* 并发异步执行，但是34一定在12后面 *********");
    });

    dispatch_async(queue, ^{
        for (int i = 0; i < 3; i++) {
            NSLog(@"栅栏：并发异步3   %@",[NSThread currentThread]);
        }
    });
    dispatch_async(queue, ^{
        for (int i = 0; i < 3; i++) {
            NSLog(@"栅栏：并发异步4   %@",[NSThread currentThread]);
        }
    });

dispatch_apply 并行遍历

和group关联的API,会在所有任务执行完成后执行后续操作 "完成"会在全部执行完成后打印出来

应用场景
- 可在某些场景代替for循环
  - 全部遍历,无顺序要求
- 不同文件并行iOS

 NSArray *array = [NSArray arrayWithObjects:@"/Users/chentao/Desktop/copy_res/gelato.ds",
                      @"/Users/chentao/Desktop/copy_res/jason.ds",
                      @"/Users/chentao/Desktop/copy_res/jikejunyi.ds",
                      @"/Users/chentao/Desktop/copy_res/molly.ds",
                      @"/Users/chentao/Desktop/copy_res/zhangdachuan.ds",
                      nil];
    NSString *copyDes = @"/Users/chentao/Desktop/copy_des";
    NSFileManager *fileManager = [NSFileManager defaultManager];
    dispatch_async(dispatch_get_global_queue(0, 0), ^(){
        dispatch_apply([array count], dispatch_get_global_queue(0, 0), ^(size_t index){
            NSLog(@"copy-%ld", index);
            NSString *sourcePath = [array objectAtIndex:index];
            NSString *desPath = [NSString stringWithFormat:@"%@/%@", copyDes, [sourcePath lastPathComponent]];
            [fileManager copyItemAtPath:sourcePath toPath:desPath error:nil];
        });
        NSLog(@"完成");
    });

三: NSOperation

基于GCD封装配合NSOperationQueue实现多线程

使用步骤
- 创建任务
  - 先将需要执行的操作封装到NSOperation对象中
- 创建队列
  - 创建NSOperationQueue
- 将任务加入队列
  - 将NSOperation加入到NSOperationQueue中
使用注意
- 由于NSOperation是抽象类需要使用其子类
  - NSInvocationOperation
    - 指定Target和Selectore
  - NSBlockOperation
    - 基于Block
  - 定义继承自NSOperation的子类

NSOperationQueue

暂停和取消不是立刻取消当前操作，而是等当前的操作执行完之后不再进行新的操作。

参考

http://www.cocoachina.com/articles/19769

源代码到IPA

Tue, 13 Oct 2020 00:00:00 GMT

iOS-源代码到IPA

进行编译
生成DSYM文件
- 储存了16进制的函数地址映射
- 崩溃日志中的地址通过此文件由地址映射到具体的函数位置

1. 编译

Clang + LLVM

把源代码转换为更为地址的LLVM IR(Intermedia Represention) LLVM根据上面转换的IR进行二进制文件的产出

预处理
- 处理源文件中的宏定义,将代码中的宏用对应的定义的具体内容进行替换
便已生成IR(中间代码)
汇编器生成汇编代码
生成机器码
链接
生成Image,也就是最后的可执行文件

2. 每次Command+B发生的事情(基于CocoaPod时)

编译信息写入辅助文件,创建.app文件
处理文件打包信息
执行CocoaPod编译前脚本,checkPods Manifest.lock
编译.m文件,使用CompileC和clang命令
链接需要的Framework
编译xib
拷贝xib,资源文件
编译ImageAssets
处理Info.plist
执行CocoaPod脚本
- Run custom shell script 'Embed Pods Frameworks'
- Run custom shell script 'Copy Pods Resources'
拷贝标准库
创建.app文件和签名

参考

https://www.jianshu.com/p/0df698478b39

load与-initialize

Tue, 13 Oct 2020 00:00:00 GMT

+ load

当类对象被引入时,runtime会向每一个类对象
load方法会在每一个类甚至分类被引入时仅调用一次.
调用的顺序是:
- 父类优先于子类,子类优先于分类
load方法不会被自动继承
- 子类中没有+load方法时系统不会多次调用父类+load

使用场景

Method Swizzle

+ initialize

第一次使用这个类的时候会调用这个方法-懒加载
- 会在第一次使用第一个类方法或实例方法之前被调用

使用场景

初始化全局变量或静态变量
load方法会被子类/分类继承
- 如果子类没有实现+initialize方法,会调用父类的+initialize方法

NSTimer与GCD

Tue, 13 Oct 2020 00:00:00 GMT

一: 常用延时调用的方式

NSObject的performSelector...
- 实际是在当前线程创建了一个Timer去执行任务
NSTimer
- +timerWithTimeInterval
- +scheduledTimerWithTimeInterval
GCDTimer
- dispatch_after

二: 非GCDTimer使用注意

必须有一个活跃的RunLoop

performSelector 和scheduledTimerWithTimeInterval 都是基于RunLoop的. 主线程没关系,因为不会停止如果在子线程的话需要手动开启RunLoop否则调用将会是无效的

NSTimer的创建于撤销必须在同一个线程操作
performSelector创建取消也必须在同一个线程操作
内存泄露问题
- Timer的target会被Timer强引用
- Timer被RunLoop强引用
- 所以想在dealloc里去invalidate Timer是不可能的
- 计时完成后手动去invalidate
  - RunLoop解除对Timer的引用
  - Timer解除对Target的引用

三: GCDTimer

系统会自动处理线程逻辑
无须关心RunLoop问题
- block的循环引用还是要注意下
缺点
- 没有repeats选项
- 直接使用代码比较多,最好封装一下

四: 时间准确性

NSTimer-较低

CFRunloopTimerRef 底层基于 mk_timer 实现基于RunLoop运行使用之前必须注册到RunLoop,但RunLoop为节省资源并不会在非常准确的时机调用定时器,执行任务时,可能错过一个时间点只能等下个时间点再执行 NSTimer有个tolerance属性可以用于设置宽容度,可提高精准度

GCDTimer-准确

CADisplayLink-较准确

CADisplayLink是一个执行频率（fps）和屏幕刷新相同（可以修改preferredFramesPerSecond改变刷新频率）的定时器，它也需要加入到RunLoop才能执行。与NSTimer类似，CADisplayLink同样是基于CFRunloopTimerRef实现，底层使用mk_timer（可以比较加入到RunLoop前后RunLoop中timer的变化）。和NSTimer相比它精度更高（尽管NSTimer也可以修改精度），不过和NStimer类似的是如果遇到大任务它仍然存在丢帧现象。通常情况下CADisaplayLink用于构建帧动画，看起来相对更加流畅，而NSTimer则有更广泛的用处。

参考

https://www.jianshu.com/p/0c050af6c5ee https://www.cnblogs.com/kenshincui/p/6823841.html

NSURLConnection-和-NSURLSession

Tue, 13 Oct 2020 00:00:00 GMT

AFNetworking2.0->3.0 用NSURLSession替换了NSURLConnection

一: 背景

iOS早期版本提供了了NSURLConnection来执行网络请求. 应用开发人员需要管理链接池,并处理应用后台/中断以及请求的恢复. 从iOS7开始,苹果发布了NSURLSession用来替代NSURLConnection

二: NSURLSession 优点

使用NSURLSession具有以下优点:

NSURLSession对预防如其中的相关请求而言是一个可配置的容器.
- 例如:对服务器的所有请求都可以配置成始终包含访问令牌
你可以得到后台联网的所有好处.这有助于提高电池寿命/支持UIKit的多任务/使用与过程传输相同的委托模型
热和网络任务都可以暂停/停止/重启.此处与NSURLConnection不同,此处不需要是NSOperation的子类
你可以使用NSURLSession来配置会话以便在每个会话的基础上使用专用存储(缓存/cookie jar等)
当使用NSURLConnection时,如果遇到了身份验证问题,问题会在任何一个请求中返回,你无法明确知道那个请求遇到了这个问题.使用NSURLSession,委托会处理身份验证
NSURLConnection有一些基于Block的异步方法,但委托不能使用它们.当发起一个请求时,要么成功,要么失败,即使它需要身份验证.
使用NSURLSession你可以混合使用.也就是说,可以使用基于Block的异步方法,还可以设置委托以处理身份验证

三: NSURLConnection vs NSURLSession

NSURLConnection
- 一个Connection对象代表一个任务,每个任务绑定一个configuration,所有的configuration共享一个全局储存器(global storage)
NSURLSession
- 一个Session绑定一个configuration,一个Session可以创建多个Task,每个Session都有一个自己的储存器(private storage)

四: NSURLSession API

NSURLSessionConfiguration

缓存,cookies,证书存储
电池使用,网络服务类型
请求的数量
资源/请求超时时间
TLS协议
HTTP代理,cookies,头部
子类话的存储器

Configuration对象默认是可变类型,它们被使用的时候相当于被copy了一份不可变的,在session中不能对中绑定的Configuration进行修改

类型:
- defaultSessionConfiguration : 系统默认
- ephemeralSessionConfiguration : 仅内存缓存, 不做磁盘缓存的配置
- backgroundSessionConfiguration : 这里需要指定一个identifier, identifier用来后台重连session对象. (做后台上传/下载就是这个config)

NSURLSessionTask

task被用来取代connection.一个task代表一个任务(相当于NSURLConnection对象)
提供任务的状态和进度属性
提供任务的取消/挂起/恢复功能
区分data和upload任务
提供断点续传的实现
分类:
- NSURLSessionTask : Task的抽象基类
- NSURLSessionDataTask : 以NSData的形式接收一个URLRequest的内容
- NSURLSessionUploadTask : 上传NSData或者本地磁盘中的文件, 完成后以NSData的形式接收一个URLRequest的响应
- NSURLSessionDownloadTask : 下载完成后返回临时文件在本地磁盘的URL路径
- NSURLSessionStreamTask : 用于建立一个TCP/IP连接

NSURLSessionDelegate

一个代理对象可以处理所有NSURLSession方法
- Session/task/dataTask/DownloadTask
强引用代理对象直到session无效(与平时代理对象weak引用不同),session就会把全部task都取消/完成
代理方法有可能会阻塞加载
- 记得调用completion handler这个block去让session继续工作, 否则会阻塞起来

四: Session分类

sharedSession: 全局session有局限性
自定义session: 自定义session,我们用的一般是这个
后台session: 也是一种自定义session,专门用来做后台上传下载任务

类型由Configuration来决定

五: 后台传输

只支持上传下载任务,data任务不支持只支持HTTPS 根据系统资源,很可能会取消掉后台任务,所以最好还是在前台完成后台任务最好支持断点续传,分段传输

系统创建一个守护进程
当你的app正在运行的时候, 正常调用代理方法传输数据给你
当你的app退出了(回到桌面/crash), 守护进程会继续他的工作, 直到需要重新认证或者完成所有任务
re-launch你的app, 然后re-create你的后台session, 然后后台session会re-connect守护进程.
守护进程此时就会把数据给你.
可以通过不同的identifier创建多个后台session.

线程安全

URLSession 的API全部都是线程安全的. 你可以在任何线程上创建session和tasks, task会自动调度到合适的代理队列中运行后台传输的代理方法URLSessionDidFinishEventsForBackgroundURLSession:可能会在其他线程中被调用. 在该方法中你应该回到主线程然后调用completion handler去触发AppDelegate中的application:handleEventsForBackgroundURLSession:completionHandler:方法.

参考

https://www.cnblogs.com/kakaluote123/articles/5426923.html https://www.jianshu.com/p/056b1817d25a https://www.jianshu.com/p/94d214129d4d <<高性能iOS应用开发>> GauravVaish

RunLoop

Tue, 13 Oct 2020 00:00:00 GMT

iOS App 运行原理

App启动

01_动态链接 `dyld`

将程序依赖的动态链接库递归加载进内存

02_ImageLoader

image 表示一个二进制文件（可执行文件或 so 文件），里面是被编译过的符号、代码等
ImageLoader 作用是将这些文件加载进内存，且每一个文件对应一个ImageLoader实例来负责加载
在程序运行时它先将动态链接的 image 加载
再从可执行文件 image 递归加载所有符号

03_runtime

dyld 开始将程序二进制文件初始化
交由 ImageLoader 读取 image，其中包含了我们的类、方法等各种符号
由于 runtime 向 dyld 绑定了回调，当 image 加载到内存后，dyld 会通知 runtime 进行处理
runtime 接手后调用 map_images 做解析和处理，接下来 load_images 中调用 call_load_methods 方法，遍历所有加载进来的 Class，按继承层级依次调用 Class 的 +load 方法和其 Category 的 +load 方法

RunLoop

01_什么是RunLoop

使程序一直运行并接受用户输入
决定程序在何时应该处理那些事件
消息队列
节省CPU时间

02_RunLoop 与线程

线程 和 RunLoop 之间是一一对应的(可嵌套)，其关系是保存在一个全局的 Dictionary 里
线程结束时销毁, 或手动退出

03_结构

struct __CFRunLoop {
    CFMutableSetRef _commonModes;     // Set
    CFMutableSetRef _commonModeItems; // Set<Source/Observer/Timer>
    CFRunLoopModeRef _currentMode;    // Current Runloop Mode
    CFMutableSetRef _modes;           // Set
    ...
};

Source

RunLoop 的数据源抽象类

RunLoop运行必须要在加入NSTimer或Source0、Sourc1、Observer输入后运行否则会直接退出

Source0: 处理App内部事件, App自行管理

包含了一个函数指针，它并不能主动触发事件
调用 CFRunLoopSourceSignal(source)，将这个 Source 标记为待处理
调用 CFRunLoopWakeUp(runloop) 来唤醒 RunLoop，让其处理这个事件

Source1: 由`RunLoop`内核管理, `MachPort`驱动(进程间通讯)

包含了一个 mach_port 和一个 函数指针
被用于通过内核和其他线程相互发送消息
如解锁/摇晃等

Timer

包含了时长和 函数指针

Observer

向外部报告 RunLoop 状态的变化

typedef CF_OPTIONS(CFOptionFlags, CFRunLoopActivity) {
    kCFRunLoopEntry         = (1UL << 0), // 即将进入Loop
    kCFRunLoopBeforeTimers  = (1UL << 1), // 即将处理 Timer
    kCFRunLoopBeforeSources = (1UL << 2), // 即将处理 Source
    kCFRunLoopBeforeWaiting = (1UL << 5), // 即将进入休眠
    kCFRunLoopAfterWaiting  = (1UL << 6), // 刚从休眠中唤醒
    kCFRunLoopExit          = (1UL << 7), // 即将退出Loop
};

Observer 与 AutoreleasePool(UIKit)

Observer 在RunLoop两次Sleep间 Pop旧的并释放对象 Push新的

Mode

struct __CFRunLoopMode {
    CFStringRef _name;            // Mode Name, 例如 @"kCFRunLoopDefaultMode"
    CFMutableSetRef _sources0;    // Set
    CFMutableSetRef _sources1;    // Set
    CFMutableArrayRef _observers; // Array
    CFMutableArrayRef _timers;    // Array
    ...
};

在同一时间必须且只能在一个Mode下运行
切换Mode必须退出RunLoop,重启
保证页面滑动流畅的关键

NSDefaultRunLoopMode // 默认状态 空闲状态
UITrackingRunLoopMode // 滑动
//私有Mode

当创建一个 Timer 并加到 DefaultMode 时，Timer 会得到重复回调，但此时滑动一个TableView 时，RunLoop 会将 mode 切换为 TrackingRunLoopMode，这时 Timer 就不会被回调，并且也不会影响到滑动操作。这两个 Mode 都已经被标记为Common

特殊Mode:

NSRunLoopCommonModes

有时你需要一个 Timer，在两个 Mode 中都能得到回调，一种办法就是将这个 Timer 分别加入这两个 Mode。还有一种方式，就是将 Timer 加入到顶层的 RunLoop 的 commonModeItems 中。commonModeItems 被 RunLoop 自动更新到所有具有 Common 的 Mode 里去。

基本操作

Tue, 13 Oct 2020 00:00:00 GMT

Runtime-基本操作

1. 反射 `NSString`,`Class`,`SEL`,`Protocol`

FOUNDATION_EXPORT NSString *NSStringFromSelector(SEL aSelector);
FOUNDATION_EXPORT SEL NSSelectorFromString(NSString *aSelectorName);

FOUNDATION_EXPORT NSString *NSStringFromClass(Class aClass);
FOUNDATION_EXPORT Class _Nullable NSClassFromString(NSString *aClassName);

FOUNDATION_EXPORT NSString *NSStringFromProtocol(Protocol *proto) API_AVAILABLE(macos(10.5), ios(2.0), watchos(2.0), tvos(9.0));
FOUNDATION_EXPORT Protocol * _Nullable NSProtocolFromString(NSString *namestr) API_AVAILABLE(macos(10.5), ios(2.0), watchos(2.0), tvos(9.0));

2. 动态创建一个类

创建一个继承NSObject的类,设定类名并初始化；
为这个类增加一个实例变量,通过KVC给这个实例变量赋值。
为这个类增加一个方法,在这个方法中打印一些值。
通过这个类的实例调用新增的方法。

3. 获取一个类的所有方法

class_copyMethodList

实例方法

#import <objc/runtime.h>
@implementation NSObject (Runtime)

+ (NSArray *)fetchInstanceMethodList
{
    unsigned int count = 0;
    Method *methodList = class_copyMethodList(self, &count);
    
    NSMutableArray *mutableList = [NSMutableArray arrayWithCapacity:count];
    for (unsigned int i = 0; i < count; i++)
    {
        Method method = methodList[i];
        SEL methodName = method_getName(method);
        [mutableList addObject:NSStringFromSelector(methodName)];
    }
    free(methodList);
    return [NSArray arrayWithArray:mutableList];
}

类方法

+ (NSArray *)fetchClassMethodList
{
    unsigned int count = 0;
    Method *methodList = class_copyMethodList(object_getClass(self), &count);
    
    NSMutableArray *mutableList = [NSMutableArray arrayWithCapacity:count];
    for (unsigned int i = 0; i < count; i++)
    {
        Method method = methodList[i];
        SEL methodName = method_getName(method);
        [mutableList addObject:NSStringFromSelector(methodName)];
    }
    free(methodList);
    return [NSArray arrayWithArray:mutableList];
}

4. 获取一个类的所有成员变量

class_copyIvarList

- (void) getAllVariable {
    unsigned int count = 0;
    //获取类的一个包含所有变量的列表，IVar是runtime声明的一个宏，是实例变量的意思.
    Ivar *allVariables = class_copyIvarList([self class], &count);
    for(int i = 0;i<count;i++)
    {
        //遍历每一个变量，包括名称和类型（此处没有星号"*"）
        Ivar ivar = allVariables[i];
        const char *Variablename = ivar_getName(ivar); //获取成员变量名称
        const char *VariableType = ivar_getTypeEncoding(ivar); //获取成员变量类型
        NSLog(@"(Name: %s) ----- (Type:%s)",Variablename,VariableType);
    }
    free(allVariables);
}

5. 获取一个类的所有属性变量

class_copyPropertyList

- (void) getAllPropertyList {
    unsigned int count = 0;
    objc_property_t *allVariables = class_copyPropertyList([self class], &count);
    for(int i = 0;i<count;i++)
    {
        //遍历每一个变量，包括名称和类型（此处没有星号"*"）
        objc_property_t property = allVariables[i];
        const char *Variablename = property_getName(property); //获取属性变量名称
        const char *VariableType = property_getAttributes(property); //获取属性变量的属性
        NSLog(@"(Name: %s) ----- (Type:%s)",Variablename,VariableType);
    }
    free(allVariables);
}
  //还有一种写法，注意 object_getClass 中的参数需要是一个对象实例，
  // 就是说 object_getClass([ChangePayPasswordViewController new]),
  //和 ChangePayPasswordViewController.Class 意义是一样的
  unsigned int a;
  objc_property_t * result = class_copyPropertyList(object_getClass([ChangePayPasswordViewController new]), &a);

6. 获取协议列表

+ (NSArray *)fetchProtocolList
{
   unsigned int count = 0;
   __unsafe_unretained Protocol **protocolList = class_copyProtocolList(self, &count);

   NSMutableArray *mutableList = [NSMutableArray arrayWithCapacity:count];
   for (unsigned int i = 0; i < count; i++ )
   {
       Protocol *protocol = protocolList[i];
       const char *protocolName = protocol_getName(protocol);
       [mutableList addObject:[NSString stringWithUTF8String:protocolName]];
   }
   return [NSArray arrayWithArray:mutableList];
}

7. 动态给一个类新增一个方法

/* 动态添加方法：
 第一个参数表示Class cls 类型；
 第二个参数表示待调用的方法名称；
 第三个参数(IMP)myAddingFunction，IMP一个函数指针，这里表示指定具体实现方法myAddingFunction；
 第四个参数表方法的参数，0代表没有参数；
 */
class_addMethod([person class], @selector(myAddingFunction), (IMP)myAddingFunction, 0);
//调用方法 【如果使用[per NewMethod]调用方法，在ARC下会报“no visible @interface"错误】
[person performSelector:@selector(myAddingFunction)];

//具体的实现（方法的内部都默认包含两个参数Class类和SEL方法，被称为隐式参数。）
int myAddingFunction(id self, SEL _cmd){
    NSLog(@"已新增方法:NewMethod");
    return 1;
}

8. 动态增加实例变量

BOOL isSuccess = class_addIvar(MyClass, "test", sizeof(NSString *), 0, "@");
// 三目运算符
isSuccess?NSLog(@"添加变量成功"):NSLog(@"添加变量失败");

参数一、类名
参数二、属性名称
参数三、开辟字节长度
参数四、对其方式
参数五、参数类型 “@” 官方解释 An object (whether statically typed or typed id) （对象 静态类型或者id类型)

9. 动态改变对象的某个变量值

可以是属性变量（注意加 _ ），也可以是私有的全局变量

Person *person = [[Person alloc]init];
person.name = @"asdas";
NSLog(@"%@",person.name);
[self editObjectIvar:person :@"_name" :@"新属性"];
NSLog(@"new :%@",person.name);

- (void)editObjectIvar :(id)object
                       :(NSString *)IvarStr
                       :(NSString *)IvarNewStr

{
    unsigned int count = 0;
    Ivar *allList = class_copyIvarList([object class], &count);
    for(int i = 0;i<count;i++)
    {
        //遍历每一个变量，包括名称和类型（此处没有星号"*"）
        Ivar ivar = allList[i];
        const char *Variablename = ivar_getName(ivar); //获取成员变量名称
        if ([[NSString stringWithUTF8String:Variablename] isEqualToString:IvarStr]) {
            object_setIvar(object, ivar, IvarNewStr); //name属性Tom被强制改为Mike。
        }
    }
    free(allList);
}

10. 属性关联

略

11. 交换方法

略

参考

https://www.jianshu.com/p/8225526096c7

重写description打印对象信息

Tue, 13 Oct 2020 00:00:00 GMT

Runtime-重写description打印对象信息

-(NSString *)description
{
    NSMutableDictionary *dictionary = [NSMutableDictionary dictionary];
    uint count;
    objc_property_t *properties = class_copyPropertyList([self class], &count);
    
    for (int i = 0; i<count; i++) {
        objc_property_t property = properties[i];
        NSString *name = @(property_getName(property));
        id value = [self valueForKey:name]?:@"nil";      
       [dictionary setObject:value forKey:name];
    }
    
    free(properties);
    return [NSString stringWithFormat:@"<%@: %p> -- %@",[self class],self,dictionary];
}

消息机制

Tue, 13 Oct 2020 00:00:00 GMT

Runtime-消息机制

OC中调用方法称为消息传递 OC中消息传递采用动态绑定机制来决定具体调用哪个方法,但OC不是在编译时决定调用什么方法而是在运行时决定

转换为CPP

将.m转换为.cpp的clang命令

clang -rewrite-objc xxx.m

int main(int argc, const char * argv[]) {
@autoreleasepool {
     //为了方便查看转写后的C语言代码，将alloc和init分两步完成
    Person *p = [Person alloc];
    p = [p init];
    p.name = @"Jiaming Chen";
    [p showMyself];
  }
  return 0;
}

int main(int argc, const char * argv[]) {
/* @autoreleasepool */ { __AtAutoreleasePool __autoreleasepool;

    Person *p = ((Person *(*)(id, SEL))(void *)objc_msgSend)((id)objc_getClass("Person"), sel_registerName("alloc"));
    p = ((Person *(*)(id, SEL))(void *)objc_msgSend)((id)p, sel_registerName("init"));
    ((void (*)(id, SEL, NSString *))(void *)objc_msgSend)((id)p, sel_registerName("setName:"), (NSString *)&__NSConstantStringImpl__var_folders_1f_dz4kq57d4b19s4tfmds1mysh0000gn_T_main_f5b408_mi_1);
    ((void (*)(id, SEL))(void *)objc_msgSend)((id)p, sel_registerName("showMyself"));

   }
  return 0;
}

调用方法时具体发生了什么呢?

现在本类的方法缓存列表中寻找有没有对应方法,如果有就执行
如果没有缓存的,就在本类的犯法列表中查找,找到了就执行
如果没找到,就到父类中查找,找到了就执行
没找到,进入下面的流程

消息处理-ResolveMethod

如果沿继承树没有找到相关方法则会向接受者所属的类进行一次请求,看能否动态添加一个方法
在相应的类及父类中找不到方法实现的话会执行+ (BOOL)resolveInstanceMethod:(SEL)sel这个方法,如果没重写的话会返回NO
在该方法中我们可以为找不到实现的SEL添加一个实现.这样就能防止调用一个不存在的方法时崩溃.

消息单项转发

当resolveInstanceMethod返回NO,就会进入消息转发阶段- (id)forwardingTargetForSelector: (SEL)aSelector
该方法会返回一个累的对象,该对象包含SEL对应的实现.如果返回nil或self的话说明找不到相应的转发进入下一步

消息多项转发

如果不将消息转发给其他对象就只能自己处理或者崩溃了

- (NSMethodSignature *)methodSignatureForSelector:(SEL)aSelector

获取方法的参数及返回数据类型,也就是说获取的是该方法的签名并返回,进入下一步
返回NSMethodSignature为nil的话不会进入下一步,抛出异常

具体的实现方式不再展开, 每种数据类型都有对应的符号代表,根据一定规则生成描述

- (void)forwardInvocation:(NSInvocation *)anInvocation

runtime将要转发的消息封装为NSInvocation调用- (void)forwardInvocation: (NSInvocation*)invocation;
在这个函数里可以将NSInvocation多次转发到多个对象中
调用这个方法如果不能处理就会调用父类的相关方法,一直到NSObject的这个方法
如果NSObject都无法处理就会调用doesNotRecognizeSelector:方法抛出异常

NSInvocation有点类似于java里的反射，它有一套完整的装备：target，selector，returnValue，ArgumentArray，有了它们，NSInvocation就可以动态的invoke任意对象的任意方法了。

参考

https://www.jianshu.com/p/a4a7e91d38f3

MethodSwizzling的问题

Tue, 13 Oct 2020 00:00:00 GMT

Runtime-MethodSwizzling的问题

使用 Method Swizzling 编程就好比切菜时使用锋利的刀，一些人因为担心切到自己所以害怕锋利的刀具，可是事实上，使用钝刀往往更容易出事，而利刀更为安全。 Method swizzling 可以帮助我们写出更好的，更高效的，易维护的代码。但是如果滥用它，也将会导致难以排查的bug。

看一下 RNSwizzle 的封装

//
//  RNSwizzle.m
//  MethodSwizzle

#import "RNSwizzle.h"
#import <objc/runtime.h>

@implementation NSObject (RNSwizzle)

+ (IMP)swizzleSelector:(SEL)origSelector 
               withIMP:(IMP)newIMP {
  Class class = [self class];
  Method origMethod = class_getInstanceMethod(class,
                                              origSelector);
  IMP origIMP = method_getImplementation(origMethod);
  
  if(!class_addMethod(self, origSelector, newIMP,
                      method_getTypeEncoding(origMethod)))
  {
    method_setImplementation(origMethod, newIMP);
  }
  
  return origIMP;
}

方法交换不是自动的

我所见过的使用method swizzling实现的方法在并发使用时基本都是安全的。95%的情况里这都不会是个问题。通常你替换一个方法的实现，是希望它在整个程序的生命周期里有效的。也就是说，你会把 method swizzling 修改方法实现的操作放在一个加号方法 +(void)load里，并在应用程序的一开始就调用执行。你将不会碰到并发问题。假如你在 +(void)initialize初始化方法中进行swizzle，那么……rumtime可能死于一个诡异的状态。

改变不是自己的代码

这是swizzling的一个问题。我们的目标是改变某些代码。swizzling方法是一件灰常灰常重要的事，当你不只是对一个NSButton类的实例进行了修改，而是程序中所有的NSButton实例。因此在swizzling时应该多加小心，但也不用总是去刻意避免。

想象一下，如果你重写了一个类的方法，而且没有调用父类的这个方法，这可能会引起问题。大多数情况下，父类方法期望会被调用（至少文档是这样说的）。如果你在swizzling实现中也这样做了，这会避免大部分问题。还是调用原始实现吧，如若不然，你会费很大力气去考虑代码的安全问题。

命名冲突

命名冲突贯穿整个Cocoa的问题. 我们常常在类名和类别方法名前加上前缀。不幸的是，命名冲突仍是个折磨。但是swizzling其实也不必过多考虑这个问题。我们只需要在原始方法命名前做小小的改动来命名就好，比如通常我们这样命名

+ (void)load {
    [self swizzle:@selector(setFrame:) with:@selector(my_setFrame:)];
}

这段代码运行正确，但是如果my_setFrame: 在别处被定义了会发生什么呢？这个问题不仅仅存在于swizzling，这里有一个替代的变通方法：

static void MySetFrame(id self, SEL _cmd, NSRect frame);
static void (*SetFrameIMP)(id self, SEL _cmd, NSRect frame);

static void MySetFrame(id self, SEL _cmd, NSRect frame) {
    // do custom work
    SetFrameIMP(self, _cmd, frame);
}

+ (void)load {
    [self swizzle:@selector(setFrame:) with:(IMP)MySetFrame store:(IMP *)&SetFrameIMP];
    }

看起来不那么Objectice-C了（用了函数指针），这样避免了selector的命名冲突。最后给出一个较完美的swizzle方法的定义：

typedef IMP *IMPPointer;

BOOL class_swizzleMethodAndStore(Class class, SEL original, IMP replacement, IMPPointer store) {
    IMP imp = NULL;
    Method method = class_getInstanceMethod(class, original);
    if (method) {
        const char *type = method_getTypeEncoding(method);
        imp = class_replaceMethod(class, original, replacement, type);
        if (!imp) {
            imp = method_getImplementation(method);
        }
    }
    if (imp && store) { *store = imp; }
    return (imp != NULL);
}

@implementation NSObject (FRRuntimeAdditions)

+ (BOOL)swizzle:(SEL)original with:(IMP)replacement store:(IMPPointer)store {
    return class_swizzleMethodAndStore(self, original, replacement, store);
}
@end

交换方法影响了方法调用

项目中调用不同方法名的问题上面讨论过了

交换的顺序

多个有继承关系的类的对象swizzle时，先从父对象开始
这样才能保证子类方法拿到父类中的被swizzle的实现
在+(void)load中swizzle不会出错，就是因为load类方法会默认从父类开始调用

实现NSCoding的自动归档和自动解档

Tue, 13 Oct 2020 00:00:00 GMT

Runtime-实现NSCoding的自动归档和自动解档

需要自定义模型持久化的时候我们往往需要为各个模型实现对应的encode``decode方法

借助Runtime我们可以对此进行封装

解档

- (instancetype)initWithCoder:(NSCoder *)aDecoder{
    
    if (self = [super init]) {
        Class c = self.class;
        // 截取类和父类的成员变量
        while (c && c != [NSObject class]) {
            unsigned int count = 0;
            Ivar *ivars = class_copyIvarList(c, &count);
            for (int i = 0; i < count; i++) {
                NSString *key = [NSString stringWithUTF8String:ivar_getName(ivars[i])];
                id value = [aDecoder decodeObjectForKey:key];
                if (value){// 容错
                     [self setValue:value forKey:key];
                }
            }
            // 获得c的父类
            c = [c superclass];
            free(ivars);
        }
    }
    return self;
}

这里需要注意的是如果版本升级后Model的属性发生了变化这里可能会发生崩溃所以需要在swtValueForKey的时候做判断

解档

- (void)encodeWithCoder:(NSCoder *)aCoder{
    
    Class c = self.class;
    // 截取类和父类的成员变量
    while (c && c != [NSObject class]) {
        unsigned int count = 0;
        Ivar *ivars = class_copyIvarList(c, &count);
        for (int i = 0; i < count; i++) {
            Ivar ivar = ivars[i];
            NSString *key = [NSString stringWithUTF8String:ivar_getName(ivar)];
            id value = [self valueForKey:key];
            if (value){
                 [aCoder encodeObject:value forKey:key];
             }
        }
        c = [c superclass];
        // 释放内存
        free(ivars);
    }
}

SQLite数据库修复

Tue, 13 Oct 2020 00:00:00 GMT

TODO:

参考

https://juejin.im/entry/58ff4c7544d9040069fb061e

Storyboard中UnwindSegue的使用

Tue, 13 Oct 2020 00:00:00 GMT

在最下层控制器中添加 `unwind segue` 的 `IBAction`

在一系列跳转关系的控制器中的根控制器中添加一个方法如下图,我就该在红框控制器中添加

之后在该控制器后续关联的控制器中点击 exit 可以看到这个 segue 了

想我这里联线的是按钮 toMain 点击按钮之后就会回到写有 unwindSwgue 的页面

当然传值操作和普通 segue 一样可以再下面的方法中进行

使用TTF字体

Tue, 13 Oct 2020 00:00:00 GMT

iOS 使用TTF字体

在项目的 Info.plist 中添加 Fonts provided by application 在其中填入字体文件名

可以通过下面的方式通过 fontName 设置 font

let familyNames = UIFont.familyNames
        for familyName in familyNames {
            print("++++++ " + familyName + " ++++++")
            let fontNames = UIFont.fontNames(forFamilyName: familyName)
            for fontName in fontNames {
                print(fontName)
            }
            print("=================================")
        }
        
        return UIFont(name: "hahahahahaah", size: fontSize)!

UI调试-UIDebuggingInformationOverlay

Tue, 13 Oct 2020 00:00:00 GMT

最近看到一篇关于使用Apple私有API进行UI调试的文章(http://ryanipete.com/blog/ios/swift/objective-c/uidebugginginformationoverlay/) 在这里简单说下怎么使用话说这玩意儿本身不是很稳定,有时在调试窗口中就会崩溃...

使用方法

直接上代码吧由于使用的是Apple的私有API所以只能通过下面的方式来调用写在AppDelegate里即可

- (BOOL)application:(UIApplication *)application didFinishLaunchingWithOptions:(NSDictionary *)launchOptions {
    // Override point for customization after application launch.
    [NSClassFromString(@"UIDebuggingInformationOverlay") performSelector:NSSelectorFromString(@"prepareDebuggingOverlay")];
    return YES;
}

注意: 只能在开发调试阶段使用上架之前一定要干掉不然会被拒掉的哦

调起调试窗口

在任意页面使用双指单击状态栏即可调起调试窗口通过按住调试窗口的顶部可以拖动调整调试窗口的位置也可以通过左上角按钮进行全屏和窗口模式的切换如图效果:

下面来看看都有哪些功能吧

View Hierarchy 视图集合

这里会显示当前Window下的视图集合,层级关系页十分清晰,点击后面的i图标还可查看对应View的详细信息你还可以在不同Window间切换查看

VC Hierarchy 控制器集合

这里的控制器集合和上面的视图集合差不多提供的信息也挺详细的

Ivar Explorer 变量

这里我们可以看到UIApplication的所有变量感觉实际用处不是很大,变量过多也没有筛选功能,而且...有时滑滑还会Crash掉😂

Measure 测量

挺实用的功能有几种模式可以选择使用方法: 手指长按屏幕移动,调试窗口中有个红色小方块对应的就是当前你按压的点

水平测量

不开启ViewMode

以你按压的点的位置水平方向,最近的两个可见的轮廓边缘最近距离,无视控件通过下面这张图可以明显的感觉到这个测量是根据轮廓来的...居然测了我老婆头发边缘到左边的距离

开启ViewMode 开启ViewMode后测量的就是按压所在控件的尺寸了

垂直测量

具体和水平测量差不多我就不多赘述了

不开启ViewMode
开启ViewMode

Spec Compare 效果对比

这个功能在对比UI效果还原度上真乃神器也~ 首先把UI妹纸给你的UI图发到手机上在需要对比的页面上双击状态栏唤起调试工具点击 Spec Compare 进入下面的页面点击右上 Add 从手机相册导入UI图点击导入的UI图即可进入对比模式调试工具会将导入的UI图覆盖在当前页面上通过单指上下滑动即可调整透明度,从而进行UI还原度的对比,效果如下双击屏幕即可退出对比模式

System Color Audit

还没发现有啥用...点进去啥都木有来着待发掘

UIWebView自适应高度

Tue, 13 Oct 2020 00:00:00 GMT

场景

最近项目中遇到Native页面内需要内嵌H5页面的需求内嵌的H5页面用来暂时运营后台动态配置的一些运营内容需要自适应H5内容的高度

思路

思路一: webViewDidFinishLoad

初遇这个问题时我首先想到的是在webViewDidFinishLoad 这个代理方法中通过获取webView的ScrollView的大小去改变内嵌部分的高度

- (void)webViewDidFinishLoad:(UIWebView *)webView {
    //TODO: 获取高度并改变容器大小
}

但是这个方法执行的时候页面可能还没有完全展示出来,web页面渲染是需要时间的所以在webViewDidFinishLoad中去获取到的高度并不准确

思路二: KVO

对! 监听webView的scrollView的contentSize的变化

添加监听

[self.hybridWebView.scrollView addObserver:self forKeyPath:@"contentSize" options:NSKeyValueObservingOptionNew context:nil];

触发

#pragma mark - KVO
- (void)observeValueForKeyPath:(NSString *)keyPath ofObject:(id)object change:(NSDictionary<NSKeyValueChangeKey,id> *)change context:(void *)context {
    if ([keyPath isEqualToString:@"contentSize"]) {
       //TODO: 获取高度并改变容器大小
    }
}

UIWebView和WKWebView

Tue, 13 Oct 2020 00:00:00 GMT

一: UIWebView的优缺点

优点

支持缓存和NSURLProtocol拦截

缺点

内存泄露
加载大数据资源时内存占用大,耗电量高

二: WKWebView的优缺点

优点

加载网页速度提升,内存占用低(UIWebView的1/3 ~ 1/4)
提供加载网页进度的属性
拥有高达60FPS滚动刷新率及内置手势
高效的App和web信息交换通道

缺点

没有缓存(WKWebsiteDataStore - iOS9之后)
不支持NSURLProtocol拦截(可通过私有方法实现桥接)
- 拦截的POST数据不完整基本等于没用

资源代理

iOS11开始 WKURLSchemeHandler 可用来加载自定义资源
注意：
- setURLSchemeHandler注册时机只能在WKWebView创建WKWebViewConfiguration时注册。
- WKWebView 只允许开发者拦截自定义 Scheme 的请求，不允许拦截 “http”、“https”、“ftp”、“file” 等的请求，否则会crash。
- WKWebView加载网页前，要在user-agent添加个标志，H5遇到这个标识就使用customScheme,否则就是用原来的http或https。

三: Cookie

WKWebView 上请求不会自动携带 Cookie ，解决方案是 loadRequest 时，从 NSHTTPCookieStorage 中获取对应的 cookie，通过 WKUserScript 设置到 WKWebView 界面中的 document.cookies 中，
注意的是，注入 cookie 的脚本执行时机需要设置为 WKUserScriptInjectionTimeAtDocumentStart 。

四: 跨域

WebKit框架对跨域进行了安全性检查限制，不允许跨域，比如从一个 HTTP 页对 HTTPS 发起请求是无效的(Safari支持)
解决办法
- 在该方法中特殊处理

- (void)webView:(WKWebView *)webView decidePolicyForNavigationAction:(WKNavigationAction *)navigationAction decisionHandler:(void (^)(WKNavigationActionPolicy))decisionHandler;

参考

https://www.jianshu.com/p/90a90bd13aac

iOS App秒开H5优化总结

https://mp.weixin.qq.com/s?__biz=MzA5NzMwODI0MA==&mid=2647762931&idx=1&sn=ce6e47875d8d278110fca1f18fec6f28&chksm=8887dcccbff055da059008e463bb26829dbb94ad7b94d1bf7f70231060498388832fc7f3d75c&scene=21#wechat_redirect

iOS App秒开H5实战总结

https://mp.weixin.qq.com/s/1Rfizwcn9EV2rby0btSMaw

WKWebVIew那些坑

https://mp.weixin.qq.com/s?__biz=MzA3NTYzODYzMg==&mid=2653578513&idx=1&sn=961bf5394eecde40a43060550b81b0bb&scene=21#wechat_redirect

为什么选VIPER

Tue, 13 Oct 2020 00:00:00 GMT

iOS-为什么选VIPER

一: 优点

拆分的职责更细,便于编写测试用例
VIPER内部通过Protocol解耦,能灵活应对变化

二: 和MV(X)系列的对比

这里的Presenter和MVP中的不同
- 这里的P并没有主要负责业务逻辑
- 主要是用来V/I间传递事件,以及管理一些View交互逻辑
- I承载业务及数据逻辑
- I的可测试性会更强
VIPER和MVX相比多了几个要维护的东西
- View事件管理
- 数据事件管理
- 事件和业务的转化
- 总结每个业务用例
- 模块内分层隔离
- 模块间通信

三: 好架构应该有的特点

能把代码按职责划分解耦
可测试性
易用,维护成本低,改动成本小

参考

https://juejin.im/post/5ad1b93d518825557b4d2d44

weak实现原理

Tue, 13 Oct 2020 00:00:00 GMT

iOS-weak实现原理

描述

系统维护了一个hash表,
- Key是所指对象的地址,
- Value是weak指针的地址数组
- 弱引用,应用对象的引用计数不会+1
- 并在对象被释放的时候自动设为nil,这是和assign本质的区别,用assign修饰对象的话会发生野指针的问题

实现过程

初始化时

runtime调用objc_initWeak函数创建一个新的weak指针指向修饰的对象的地址

//初始化weak表
/** 
 * Initialize a fresh weak pointer to some object location. 
 * It would be used for code like: 
 *
 * (The nil case) 
 * __weak id weakPtr;
 * (The non-nil case) 
 * NSObject *o = ...;
 * __weak id weakPtr = o;
 * 
 * @param addr Address of __weak ptr. 
 * @param val Object ptr. 
 */
id objc_initWeak(id *addr, id val)
{
    *addr = 0;
    if (!val) return nil;
    return objc_storeWeak(addr, val); // 存储weak对象
}

添加引用时

objc_initWeak会调用objc_storeWeak函数,更新指针指向,创建对应弱引用表

/** 
 * This function stores a new value into a __weak variable. It would
 * be used anywhere a __weak variable is the target of an assignment.
 * 
 * @param location The address of the weak pointer itself
 * @param newObj The new object this weak ptr should now point to
 * 
 * @return \e newObj
 */
id
objc_storeWeak(id *location, id newObj)
{
    id oldObj;
    SideTable *oldTable;
    SideTable *newTable;
    spinlock_t *lock1;
#if SIDE_TABLE_STRIPE > 1
    spinlock_t *lock2;
#endif

    // Acquire locks for old and new values.
    // Order by lock address to prevent lock ordering problems. 
    // Retry if the old value changes underneath us.
 retry:
    oldObj = *location;
    
    oldTable = SideTable::tableForPointer(oldObj);
    newTable = SideTable::tableForPointer(newObj);
    
    lock1 = &newTable->slock;
#if SIDE_TABLE_STRIPE > 1
    lock2 = &oldTable->slock;
    if (lock1 > lock2) {
        spinlock_t *temp = lock1;
        lock1 = lock2;
        lock2 = temp;
    }
    if (lock1 != lock2) spinlock_lock(lock2);
#endif
    spinlock_lock(lock1);

    if (*location != oldObj) {
        spinlock_unlock(lock1);
#if SIDE_TABLE_STRIPE > 1
        if (lock1 != lock2) spinlock_unlock(lock2);
#endif
        goto retry;
    }

    weak_unregister_no_lock(&oldTable->weak_table, oldObj, location);
    newObj = weak_register_no_lock(&newTable->weak_table, newObj, location);
    // weak_register_no_lock returns nil if weak store should be rejected

    // Set is-weakly-referenced bit in refcount table.
    if (newObj  &&  !newObj->isTaggedPointer()) {
        newObj->setWeaklyReferenced_nolock();
    }

    // Do not set *location anywhere else. That would introduce a race.
    *location = newObj;
    
    spinlock_unlock(lock1);
#if SIDE_TABLE_STRIPE > 1
    if (lock1 != lock2) spinlock_unlock(lock2);
#endif

    return newObj;
}

weak_unregister_no_lock旧对象解除注册 *
weak_register_no_lock新对象添加注册 *

释放时

调用objc_release
引用计数为0调用dealloc
dealloc中调用了_objc_rootDealloc函数
_objc_rootDealloc调用了object_dispose
调用objc_destructInstance
objc_destructInstance首先根据对象地址获取所有weak指针地址数组,遍历置为nil,然后把这weak表中所有该地址的记录删除

iOS-常见崩溃分析

Tue, 13 Oct 2020 00:00:00 GMT

1: 字典插入nil

通过Runtime替换,为系统方法添加容错
- 同时添加日志,上报记录错误
- 保证程序运行稳定的情况下,暴露错误

2: 越界

处理方式同上

3. unrecognized selector

可以再消息传递流程内进行防护

4. TableView & CollectionView cell代理方法存在返回 nil 的情况

别偷懒

5. EXC_BAD_ACCESS

开启僵尸对象调试选项进行调试

6. SIGPIPE 异常

经实验在多个ios版本下都不再触发SIGPIPE，完美解决问题。

对一个端已经关闭的socket调用两次write，第二次write将会产生SIGPIPE信号，该信号默认结束进程

在pch中:

// 仅在 IOS 系统上支持 SO_NOSIGPIPE
#if defined(SO_NOSIGPIPE) && !defined(MSG_NOSIGNAL)
    // We do not want SIGPIPE if writing to socket.
    const int value = 1;
    setsockopt(fd, SOL_SOCKET, SO_NOSIGPIPE, &value, sizeof(int));
#endif

7. 子线程UI操作崩溃

放主线程

8. SIGABRT 异常

这是一个让程序终止的标识，会在断言、app内部、操作系统用终止方法抛出。通常发生在异步执行系统方法的时候。如CoreData、NSUserDefaults等，还有一些其他的系统多线程操作。这并不一定意味着是系统代码存在bug，代码仅仅是成了无效状态，或者异常状态。

9. dispatch_group崩溃

enter 数量和 leave 数量要匹配

10. 对象释放的线程要和它处理事情的线程一致

参考

https://www.jianshu.com/p/c7efbc283480 https://www.jianshu.com/p/c4bd2960b3fa

使用KVC设置UIAlertAction按钮颜色的Crash

Tue, 13 Oct 2020 00:00:00 GMT

=> Start [<UIAlertAction 0x1702b63e0> setValue:forUndefinedKey:]: this class is not key value coding-compliant for the key _titleTextColor.
	-> translating『 0x1005eb9a0 』=> -[UsedHouseDetail firstCollectTip] QFangWang/HouseDetail/Controller/UsedHouseDetail.m: line 509
	-> translating『 0x1005eb668 』=> __39-[UsedHouseDetail RequestColletionData]_block_invoke.481 QFangWang/HouseDetail/Controller/UsedHouseDetail.m: line 472
	-> translating『 0x1007b0cfc 』=> -[YTKNetworkAgent handleRequestResult:] /Users/Fish/iOS-Client/QFangWang/Pods/YTKNetwork/YTKNetwork/YTKNetworkAgent.m: line 262
	-> translating『 0x1007b020c 』=> __33-[YTKNetworkAgent ytk_addRequst:]_block_invoke.145 /Users/Fish/iOS-Client/QFangWang/Pods/YTKNetwork/YTKNetwork/YTKNetworkAgent.m: line 156
	-> translating『 0x100227524 』=> main QFangWang/main.mm: line 13
=> End [<UIAlertAction 0x1702b63e0> setValue:forUndefinedKey:]: this class is not key value coding-compliant for the key _titleTextColor.
>------------------------------------------------------<

最近线上发现了如上面所示的bug

是为了实现改变 UIAlertAction 默认按钮颜色的地方使用了下面方式

[action setValue:[UIColor redColor] forKey:@"_titleTextColor"];

但是在某些系统版本中 UIAlertAction 中并没有 _titleTextColor 这个成员变量而导致了崩溃具体可以通过 runtime 获取成员列表来看看

fix

判断是否有 _titleTextColor 来设置或者通过设置 alertController.view.tintColor 来实现需要注意的是: 在8.4上由于层级结构的问题需要在 presentAlertVC 后设置 tintColor

参考

http://www.jianshu.com/p/8a2b5a3a9167

UICollectionView的一些问题

Tue, 13 Oct 2020 00:00:00 GMT

崩溃 [UICollectionViewData validateLayoutInRect:]

在部分系统上数据源有变更(例如清空了reloadData)的情况下会发生如上crash

参考链接: https://stackoverflow.com/questions/18339030/uicollectionview-assertion-error-on-stale-data

解决办法:

    [self.cvCollection reloadData];
    [self.cvCollection.collectionViewLayout invalidateLayout];
    //部分系统上 reload   [UICollectionViewData validateLayoutInRect:]  crash

iOS 8 上设置 sectionInset left 无效

只有在使用了适应尺寸时left才会失效

自适应尺寸

self.flLayout.estimatedItemSize = CGSizeMake(50, 50);

这是系统的bug,后面系统版本没发现这种问题

解决方法:

if (isIOS8) {
        self.cvCollection.contentInset = UIEdgeInsetsMake(0, 15, 0, 15);
    } else {
        self.flLayout.sectionInset = UIEdgeInsetsMake(0, 15, 0, 15);
    }

直播技术相关

Tue, 13 Oct 2020 00:00:00 GMT

一.原理

直播原理

将主播录制的音视频, 推送到服务器, 再由服务器分发给观众

直播环节

推流端: 采集处理编码推流
服务端处理: 转码录制截图审核
播放器: 拉流解码渲染
互动: 聊天室礼物赞

二.相关框架

采集端

数据采集
- AVFoundation
美颜
- GPUImage
音频压缩
- FFmpeg
视频压缩
- X264
推流
- libremp

播放端

播放
- ijkplayer
视频解码
- FFmepeg
视频硬解码
- VideoToolBox
音频硬解码
- AudioToolBox

三.流媒体

流媒体开发
- 网络层Socket负责传输
- 协议层RTMP或HLS负责网络打包
- 封装层FLV或TS负责编解码数据的封装
- 编码层h.264和acc负责图像视频的压缩
GOP
- 画面组,一个GOP就是一组连续的画面,每个画面都是一帧,一个GOP就是很多帧的集合
码率
- 图片压缩后每秒显示的数据量
- 常常看见视频播放软件中的1024，720、高清、标清和流畅等，指的就是各种码率
帧率
- 每秒帧数
- 人眼16帧的话看起来就是连贯的了
压缩比
- 压缩前的每秒数据量/码率
- 同一视频源,压缩比越高画质越差
视频封装格式和视频压缩编码标准
- 就好像项目工程和编程语言,封装格式就是一个项目的工程,视频编码方式就是编程语言,一个项目工程可以用不同语言开发

四.推流

数据传输框架

librtmp是用来传输RTMP协议格式的数据

数据传输协议

RTMP是实时消息传输协议，Adobe Systems公司为Flash播放器和服务器之间音频、视频和数据传输开发的开放协议，因为是开放协议所以都可以使用了
RTMP协议用于对象、视频、音频的传输。这个协议建立在TCP协议或者轮询HTTP协议之上。
RTMP协议就像一个用来装数据包的容器，这些数据可以是FLV中的视音频数据。一个单一的连接可以通过不同的通道传输多路网络流，这些通道中的包都是按照固定大小的包传输的。chunk是消息包。

五.拉流

直播协议选择

即时性要求高或有互动需求可以采用RTMP/RTSP
有回放或跨平台需求的HLS

直播协议对比

HLS

HLS是由Apple公司定义的用于实时流传输的协议，HLS基于HTTP协议实现，传输内容包括两部分，一是M3U8描述文件，二是TS媒体文件。可实现流媒体的直播和点播，主要应用在iOS系统。 HLS是以点播的技术方式来实现直播。
HLS是自适应码率流播，客户端会根据网络状况自动选择不同码率的视频流，条件允许的情况下使用高码率，网络繁忙的时候使用低码率，并且自动在二者间随意切换。这对移动设备网络状况不稳定的情况下保障流畅播放非常有帮助。
实现方法是服务器端提供多码率视频流，并且在列表文件中注明，播放器根据播放进度和下载速度自动调整。
HLS与RTMP对比：HLS主要是延时比较大，RTMP主要优势在于延时低。
HLS协议的小切片方式会生成大量的文件，存储或处理这些文件会造成大量资源浪费。
相比使用RTSP协议的好处在于，一旦切分完成，之后的分发过程完全不需要额外使用任何专门软件，普通的网络服务器即可，大大降低了CDN边缘服务器的配置要求，可以使用任何现成的CDN，而一般服务器很少支持RTSP。

HTTP-FLV

HTTP-FLV是基于HTTP协议流式的传输媒体内容。相对于RTMP，HTTP更简单和广为人知，内容延迟同样可以做到1~3秒，打开速度更快，因为HTTP本身没有复杂的状态交互。所以从延迟角度来看，HTTP-FLV要优于RTMP。

RTSP

RTSP：实时流传输协议，定义了一对多应用程序如何有效地通过IP网络传送多媒体数据。

RTP

RTP：实时传输协议，RTP是建立在UDP协议上的，常与RTCP一起使用，其本身并没有提供按时发送机制或其它服务质量（QoS）保证，它依赖于低层服务去实现这一过程。
RTCP：RTP的配套协议,主要功能是为RTP所提供的服务质量（QoS）提供反馈，收集相关媒体连接的统计信息，例如传输字节数，传输分组数，丢失分组数，单向和双向网络延迟等等。

六.解码

解封装

demuxing（分离）：从视频流、音频流，字幕流合成的文件(容器格式（FLV，TS）)中，分解出视频、音频或字幕，各自进行解码。

音频编码框架

fdk_aac：音频编码解码框架，PCM音频数据和AAC音频数据互转

编码介绍

硬解码

用GPU解码,减少CPU运算
- 优点:播放流畅,低功耗,解码速度快,
- 缺点:兼容不好

软解码

用CPU解码
- 优点:兼容好
- 缺点:加大CPU负担,解码速度慢,耗电增加,没有硬解码流畅

七.播放

`ijkplayer`

B站开源的一个基于FFmpeg的开源Android/iOS视频播放器
- API易于集成
- 编译配置可裁剪，方便控制安装包大小
- 支持硬件加速解码，更加省电
- 简单易用，指定拉流URL，自动解码播放

参考

http://www.woshipm.com/pd/408632.html/comment-page-1

Socket-Little-Endian-Big-Endian

Tue, 13 Oct 2020 00:00:00 GMT

socket编程为什么需要htons(), ntohl(), ntohs()，htons() 函数 https://blog.csdn.net/myyllove/article/details/83380209 关于Big Endian 和 Little Endian https://blog.csdn.net/sunshine1314/article/details/2309655 浅谈C语言中的联合体 https://www.cnblogs.com/dolphin0520/archive/2011/10/03/2198493.html 判断处理器是Big_endian的还是Little_endian的 https://www.cnblogs.com/codingmengmeng/p/7845958.html

网络理解

Tue, 13 Oct 2020 00:00:00 GMT

iOS-网络理解

一:网络层级结构

TCP/IP四层结构

应用层
传输层
网络层
网络接口层

OSI七层网络结构

应用层
表示层
会话层
传输层
网络层
数据链路层
物理层

二:HTTP协议-超文本传输协议

应用层面向对象的协议常基于TCP链接方式

特点:
- 支持客户端/服务端模式
- 简单快捷灵活
- 客户端每次发送的请求,都需要服务器回送响应,请求结束后主动释放链接.俗称短连接

三:TCP协议

传输层 提供面向链接的可靠的字节流服务,提供超时重发,丢弃重复数据,校验数据,流量控制等功能在正式收发数据前,需要建立三次握手建立可靠的链接

三次握手
- 客户端向服务器发送一个SYN报文(syn=j),计入SYN_SEND状态,等待服务器确认
- 服务器接收到客户端的SYN报文,确认客户端的SYN(ack=j+1),同时自己也发送一个SYN报文(syn=k),即SYN+ACK报文,服务器进入SYN_RECV状态
- 客户端收到服务器的SYN+ACK报文,向服务器发送确认报文ACK(ack=k+1),此包发送完毕,客户端服务端进入ESTABLISHED状态,完成三次握手

四:UDP协议

传输层 面向非链接,不保证可靠性的数据传输协议,没有超时重发等机制,故传输速度很快不与对方建立连接,直接把数据包丢过去,所以适合少量数据且可靠性要求不高的场景

五:Socket

IP地址+端口=Socket

应用程序通过Socket向网络发送请求或响应它是一个针对TCP/UDP编程的接口,基于它建立TCP/UDP连接. Socket连接就是所谓的长连接,一旦建立起连接,不会主动断掉

六:HTTP-Socket-TCP 的关系

HTTP协议提供了封装或者显示数据的具体形式
Socket连接提供了网络通信的能力
TCP连接提供如何在网络中传输
socket是纯C语言的,跨平台
HTTP协议是基于socket的,底层使用的就是socket
创建Socket连接时，可以指定使用的传输层协议(TCP或UDP),当使用TCP协议进行连接时，该Socket连接就是一个TCP连接

七:TCP/UDP的区别

基于连接和无连接
TCP对系统资源占用较多,UDP较少
UDP程序结构简单
TCP是字节流数据类型,UDP是用户数报文类型
TCP保证数据可靠性,UDP不保证,可能丢包

八.Socket工作流程

服务端创建一个socket
绑定服务器主机地址,监听一个端口
调用accept函数，一致初一阻塞状态
当客户端有客户端请求，并自己进入阻塞，一直到服务返回数据
服务端保存客户端的socket，然后向客户单的socket 写入数据
客户端接收后可以发送close消息断开链接，那么就完成一次完成的socket交流

九:HTTP和Socket的区别

HTTP连接是短连接,Socket连接是长连接
- 尽管HTTP1.1开始支持持久链接但仍无法保证始终链接
- Socket建立TCP三次握手后,除非一方自动断开链接否则链接将一直保持
HTTP服务端无法主动发送消息
- 采用请求-响应机制
应用场景
- HTTP
  - 双方不需要同时保持在线,如客户端资源获取,上传等
- Socket
  - IM APNs等

iOS-网络安全之HTTPS

Tue, 13 Oct 2020 00:00:00 GMT

一: 中间人攻击

概念

经常会提到的就是中间人攻击
Man-in-the-middle attack(MITM)
攻击者插入到原本直接通信的双方之间,双方已为还在直接跟对方通信,但实际是通过了攻击者这个中间人,信息会被它获取或篡改

时机

HTTPS在建立了TCP链接后,会进行SSL握手来校验证书,写上加密密钥.
所以一般中间人攻击分为
- SSL链接建立前的攻击
- HTTPS传输中的攻击

常见攻击

a. SSL证书欺骗攻击

较为常见的攻击通过ARP欺骗,DNS劫持甚至网管劫持,将客户端访问重定向到攻击者的服务器.让客户端与攻击者的机器建立HTTPS(伪造的证书)链接. 浏览器会提示证书不可信,用户不点击继续浏览就能避免被劫持.

防范措施
- iOS原生
  - 使用系统API建立HTTPS链接就没问题的,系统默认是没有信任相关伪造证书的不会SSL握手成功
- WebView
  - 如果忽略证书校验的话可能会被劫持

b. SSL剥离攻击(SSLSTrip)

将HTTPS链接降级为HTTP链接客户端直接访问HTTPS链接,攻击者是无法进行降级的攻击的主要方式是利用用户不会每次都会输入HTTPS://xxxx.xxx.com这样的链接来访问网站

防范措施
- 原生
  - 无法劫持App内部HTTPS会话
- WebView
  - 如果在全网HTTPS的情况下,可以对打开的链接做检查

c. 针对SSL算法进行攻击

上述两种攻击一般只能影响到WebApp,很难攻击到NativeApp. 牛逼的Hacker会对SSL算法相关的漏洞进行攻击,密码学相关了...

防范措施
- 最好对服务端的SSL/TLS配置进行升级
  - 只支持尽量高版本的TLS(最低TLSv1)
  - 禁用一些已经爆出安全隐患的加密方法
  - 使用2048位的数字证书

二: 打保证书校验

本地打保证书进App,使用SecTrustSetAnchorCertificates(SecTrustRef trust, CFArrayRef anchorCertificates)来设置Anchor Certificate进行校验

文档说明

Calling this function without also calling SecTrustSetAnchorCertificatesOnly disables the trusting of any anchors other than the ones specified by this function call.

https://developer.apple.com/library/mac/documentation/Security/Reference/certifkeytrustservices/#//apple_ref/c/func/SecTrustCopyAnchorCertificates

也就是说，单纯调用SecTrustSetAnchorCertificates方法后不调用SecTrustSetAnchorCertificatesOnly来验证证书，则只会相信SecTrustSetAnchorCertificates传入的证书，而不会信任其他锚点证书。关于这一点，SecTrustSetAnchorCertificatesOnly方法参数讲解中也有说明：

anchorCertificatesOnly:

If true, disables trusting any anchors other than the ones passed in with the SecTrustSetAnchorCertificates function. If false, the built-in anchor certificates are also trusted. If SecTrustSetAnchorCertificates is called and SecTrustSetAnchorCertificatesOnly is not called, only the anchors explicitly passed in are trusted.

只相信传入的锚点证书，也就只会验证通过由这些锚点证书签发的证书。这样就算被验证的证书是由系统其他信任的锚点证书签发的，也无法验证通过。

选择哪一级的CA证书就需要自行判断了如果选择末端的叶子证书,可能导致域名变化后无法访问,甚至证书过期的情况

参考

http://oncenote.com/2015/09/16/Security-2-HTTPS2/ Jaminzzhang博客 https://www.jianshu.com/p/86dcf94b43e2 WebView证书验证

SSL-TLS四次握手

Tue, 13 Oct 2020 00:00:00 GMT

一: 图解四次握手

二: 数字证书

数字证书是一个电子文档, 其中包含了持有者的信息/公钥/证明证书有效的数字签名. 数字证书室友证书认证机构(CA)来负责签发管理数字证书的类型有多种,HTTPS使用的是SSL证书

CA组织的结构

CA组织顶层是根CA
根CA下可以授权给多个二级CA
二级CA又可以授权给多个三级CA
- 那么是不是可以无限信任下去呢?
  - 显然不行(Basic Constraint校验漏洞)
  - X.509证书中的Basic Constraint包含了这是不是一个CA机构，以及有效证书路径的最大深度（即，这个CA还能否继续签发CA机构证书及其签发子CA证书的路径深度）

SSL证书市场,主要被Symantec(旗下有VeriSign和GeoTrust)、Comodo SSL、Go Daddy 和 GlobalSign 瓜分了

签发流程

数字证书的签发机构CA，在接收到申请者的资料后进行核对并确定信息的真实有效，然后就会制作一份符合X.509标准的文件。证书中的证书内容包含的持有者信息和公钥等都是由申请者提供的，而数字签名则是CA机构对证书内容进行hash加密后得到的，而这个数字签名就是我们验证证书是否是有可信CA签发的数据。

验证流程

接收到一份数字证书Cer1后,对证书内容做Hash得到数字摘要H1
从签发该证书的机构CA1的证书中找到公钥,对证书上的签名进行解密,得到证书Cer1签名的Hash摘要H2
对比H1 H2 如果相等表示证书没有被篡改(还未知有效性)
CA机构的数字证书是公开的,所有人都可以拿到.这个证书中的数字签名是上一级生成的,所以可以一直验证下去,直到根证书.根CA证书是自验证的(即数字签名是用自己的私钥生成了).合法的根CA证书会被浏览器和操作系统加入到信任CA列表中,这样完成了最终验证

注意: 一定要保护好自己的环境(浏览器,操作系统)中的根CA证书信任列表,信任了根证书就代表任何根证书下的字CA签发的证书,所以不要随便添加根CA证书信任

iOS中的验证流程
- 先获取到需要验证的信任对象
- 使用系统默认的验证方式验证(自建证书不用,不在信任列表中)
- 第二步验证通过后就可以直接通过了,建立连接
- 验证不通过,取消验证流程,拒绝连接请求

参考

http://oncenote.com/2014/10/21/Security-1-HTTPS/ Jaminzzhang博客 http://www.ruanyifeng.com/blog/2014/09/illustration-ssl.html 阮一峰 http://www.ruanyifeng.com/blog/2014/02/ssl_tls.html 阮一峰

逃逸闭包和非逃逸闭包

Tue, 13 Oct 2020 00:00:00 GMT

Swift-逃逸闭包和非逃逸闭包

逃逸闭包_@escaping

一个接受一个闭包作为参数的函数,如果参数需要在函数结束之后才被调用
也就是闭包脱离了函数的作用域

非逃逸闭包_@noescape

一个接受一个闭包作为参数的函数,闭包会在函数结束前被调用
非逃逸闭包

内存管理

非逃逸闭包不会存在循环引用,因为在函数作用域内就释放了
开发中使用非逃逸闭包有利于内存优化

自动逃逸

注意
- 当闭包被当做参数,包裹在其他类型中(元祖/枚举/case/Optional可选型)中会自动逃逸

向下向上取整

Tue, 13 Oct 2020 00:00:00 GMT

Swift 向下向上取整

ceil(x)返回不小于x的最小整数值（然后转换为double型）。

floor(x)返回不大于x的最大整数值。

round(x)返回x的四舍五入整数值。

使用Carthage替代CocoaPods

Tue, 13 Oct 2020 00:00:00 GMT

Swift使用Carthage替代CocoaPods

官方地址: https://github.com/Carthage/Carthage 参考文章: https://www.jianshu.com/p/76b9ff09f99c

集成

通过 `Homebrew` 安装

brew install carthage

项目配置文件

和使用CocoaPods一样, 这里也需要一个无后缀的配置文件 Carthfile

配置依赖库

熟悉Podfile的话这里就不会陌生了

github "Alamofire/Alamofire"

对于github指名后会去github上找对对应的库
- 格式: github Username/ProjectName
git 支持http:// git:// ssh://

== 毫无疑问是说必须为指定版本，如果没有，就不下载编译； >= 使用大于或等于指定版本的库，如果有最新，则使用最新的； ~> 则是一个开区间，如“~>1.1.0”则会返回“1.1.1~1.9.9”之间的版本，不包括2.0.0；

编译第三方库

类似pod install操作, cd 到工程目录执行下面命令

carthage update --platform iOS

一般这里指定一下平台好些,否则会编译出mac,tv,iOS个平台的,完全没必要
执行完成后会看到有个Carthage目录
- build中就是编译好的第三方库
- Checkouts中是第三方库的缓存

导入第三方库

手动将Carthage/Build中的framework加到项目中先在就阔以在项目中使用Alamofire咯

一些坑

01: has no shared framework schemes

*** Skipped building R.swift due to the error:
Dependency "R.swift" has no shared framework schemes for any of the platforms: iOS

因为Carthage需要库工程的Scheme需要为Shared
没有的话可能是因为git忽略了相应文件 xcuserdata

参考

https://stackoverflow.com/questions/35054788/carthage-no-shared-framework-schemes-for-ios-platform-for-my-own-framework https://www.jianshu.com/p/a7defcf2e327

Copy-on-write

Tue, 13 Oct 2020 00:00:00 GMT

Swift COW

什么是 COW

Copy on write

COW是一种常见的计算机技术，有助于在复制结构时提高效率
- 例如一个数组有100个元素，赋值到另一个数组，赋值所有元素，即最终两个数组内容相同
当使用COW的话
- 当将两个变量指向同一数组时，他们指向相同的底层数据。两个变量指向相同的数据可能看起来矛盾，当修改第二个变量的时候，Swift才会去复制一个副本，第一个不会改变。
通过延迟复制操作，直到实际使用到的时候才去复制，以此确保没有浪费的工作。

COW是特别添加到Swift数组和字典的功能，自定义的数据类型不会自动实现。

OC项目中加入Swift混编

Tue, 13 Oct 2020 00:00:00 GMT

年后项目准备引入 Swift 新的模块需求使用 Swift 编写需要支持与 OC 与 Swift 的混编这里描述一下前期准备的工作

Project_defines module 配置

Project_product module name 配置

这里的 Product Module Name 需要和 工程名称 一致

代码修改

在需要调用到 `Swift` 的地方 `import`

#import "工程名称-Swift.h"

注意点

这个文件 import 不会自动提示
而且如果项目汇总没有 swift 文件的话编译也会报错
不要自己去创建这个名字的文件
只需要在项目中创建一个 Swift 文件这个文件就会自动生成

需要暴露给 `Swift` 调用的

在 OC 项目中创建 swift 文件后会创建一个桥接文件 工程名-Bridging-Header.h 所有需要暴露给 swift 调用的文件都在这里 import 即可

注意点

需要注意的是: 如果 import 的 .h 中有用到 全局导入的引用 时,编译会报错,这时需要在该被 import 的 .h 文件中添加相关引用或者使用 @class 即可
项目中的 Swift 文件中使用上面 import 过的 OC类 无须再单独 import
如果在添加到桥接文件中后某些类型依旧报错可以尝试将其在桥接文件中的位置提前

Apple官方混编指南

https://developer.apple.com/library/content/documentation/Swift/Conceptual/BuildingCocoaApps/MixandMatch.html#//apple_ref/doc/uid/TP40014216-CH10-ID122

国内汉化

https://github.com/CocoaChina-editors/Welcome-to-Swift/blob/master/UsingSwiftwithCocoaandObjective-C中文手册.md

OC老项目Swift混编的一些坑

Tue, 13 Oct 2020 00:00:00 GMT

01: 桥接后 `Unknown type name` 问题

场景: 在桥接文件中添加了某OC类的引用编译时报错

#import "XXX.h"

在桥接文件中添加CoreLocation库的引用依旧出现上述错误

#import "XXX.h"
#import <CoreLocation/CoreLocation.h>

解决方法: 将 CoreLocation 的引用置顶

#import <CoreLocation/CoreLocation.h>
#import "XXX.h"

Optional实质

Tue, 13 Oct 2020 00:00:00 GMT

Swift-Optional实质

底层实现

我们先看看Swift中Optional是怎么实现的把

public enum Optional<Wrapped> : _Reflectable, NilLiteralConvertible {
    case None
    case Some(Wrapped)
    /// Construct a `nil` instance.
    public init()
    /// Construct a non-`nil` instance that stores `some`.
    public init(_ some: Wrapped)
    /// If `self == nil`, returns `nil`.  Otherwise, returns `f(self!)`.
    @warn_unused_result
    public func map<U>(@noescape f: (Wrapped) throws -> U) rethrows -> U?
    /// Returns `nil` if `self` is `nil`, `f(self!)` otherwise.
    @warn_unused_result
    public func flatMap<U>(@noescape f: (Wrapped) throws -> U?) rethrows -> U?
    /// Create an instance initialized with `nil`.
    public init(nilLiteral: ())
}

很明显可以看出，它实际是一个枚举。 .Some的关联值就是我们解包出来的

? & ！

在我们对一个Optional的变量进行赋值的时候，我们实际上是将初始值放到.Some中，取值是则是从.Some中取出。

!
- 强制解包，告诉系统这个变量不为nil 且 .Some中一定有值
- 如果为空则会崩溃
?
- 解包时会先判断是否为nil如果不为空则正常解包，否则会返回nil即默认初始值

R-Swift-安全的资源组织方案forSwift

Tue, 13 Oct 2020 00:00:00 GMT

官方链接: https://github.com/mac-cain13/R.swift 参考文章:

http://swifter.tips/safe-resource/ https://www.jianshu.com/p/6234e6e79b15

场景

在项目中经常会遇到通过字符串进行的一些资源操作比如图片什么的,维护修改成本较高

一般操作

let icon = UIImage(named: "settings-icon")
let font = UIFont(name: "San Francisco", size: 42)
let color = UIColor(named: "indictator highlight")
let viewController = CustomViewController(nibName: "CustomView", bundle: nil)
let string = String(format: NSLocalizedString("welcome.withName", comment: ""), locale: NSLocale.current, "Arthur Dent")

使用R.Swift

let icon = R.image.settingsIcon()
let font = R.font.sanFrancisco(size: 42)
let color = R.color.indicatorHighlight()
let viewController = CustomViewController(nib: R.nib.customView)
let string = R.string.localizable.welcomeWithName("Arthur Dent")

是不是显得十分清爽

导入`R.Swift`

pod 'R.swift'
install完成后添加 New Run Script Phase
添加脚本 "$PODS_ROOT/R.swift/rswift" generate "$SRCROOT"
Command+B编译一次后会在目录下生成一个R.generated.swift文件,将其拖入工程

一定不要选中Copy items if needed 因为每次编译都会重新生成该文件所以最好在.gitignore中添加忽略*.generated.swift

Struct与Class

Tue, 13 Oct 2020 00:00:00 GMT

Swift 中的类型

Types
- 命名类型
  - protocol
  - enum
  - struct
  - class
- 复合类型
  - tuple
  - function

实际上其他类型都是通过命名类型创建的

Struct Class Enum

Swift 提供了多种结构化存储数据的方式，他们是：Struct、Class、Enum Swift 表中库中绝大多数类型都是Struct，Class、Enum只有很小一部分

共同点：

都可以用 protocol
都可以使用 extension
都可以使用泛型

如何选择

根据对象生命周期形态，把使用的类型分成两大类

必须具有明确生命周期，被明确的初始化，使用，释放
- 用Class
- 例如：
  - 数据库连接，管理对象等
没有明确的生命周期
- 用Struct或Enum
- 例如：
  - 不用修改只是用来使用其值的

Struct值类型本质

某个属性诗歌结构体，改变其某个属性，也会重新赋值一个新对象

值类型和引用类型

差异对比

引用类型必须指明init方法
引用类型关注的是对象本身
- 使用值类型创建新对象时将会复制
- 使用引用类型时，新变量将引用同一个对象
引用类型的默认值是可以修改的
- 给Struct的方法默认是只读的。如果要修改要用mutating修饰
- class中不用

参考

https://www.jianshu.com/p/a10f554ac63b https://juejin.im/post/5c653aa6e51d457fbf5dc298

纯Swift路由方案探究

Tue, 13 Oct 2020 00:00:00 GMT

前言

OC 写了几年了到了新公司开始写Swift 项目正在成长期, 开始人也不多, 模块化程度不高于是就整了这套路由方案发现现在很多Swift路由方案很大程度上还是使用了OC的特性比如需要继承NSObject 作为一名Swift萌新, 这次路由方案的设计是很好的一次对Swift的探索

回顾历史 Objective-c

以往路由方案的核心主要是 +Load注册 反射 等

+ Load

+ (void)Load {
    // 注册唯一标示 
}

反射

生成类

    Class myClass = NSClassFromString(@"DetailViewController")

方法调用

    SEL action = NSSelectorFromString(selectorName);
    
    if (![self respondsToSelector:action]) {
        return;
    }
    
    IMP imp = [self methodForSelector:action];
    void (*func)(id, SEL, id) = (void *)imp;
    func(self, action, data);

调度形式


 // Target-Action
 [self performTarget:@"ModuleA" action:@"Func" params:@{ @"name":@"OldWang" }]
 
 // URL
 [self open:@"demo://ModuleA/showDetail?id=100"]
 
 // ...

问题

Swift中没有 +Load
Swift包含命名空间, 反射较为麻烦, 且必须继承NSObject才能反射
硬编码多维护成本较高, 无法编译检查

RYRouter

Swift性能分析

Tue, 13 Oct 2020 00:00:00 GMT

编译器优化

一般的编译过程中会把源文件先生成目标文件（.o文件）然后连接器将不同的目标文件组合起来，生成可执行文件。
Swift编译器引入了Whole Module Optimizations优化机制
- 如果有一个传入泛型的函数funcA，在整个项目中只传入了Int型，那么编译器就不会在编译成支持其他类型的方法了。
- 类似的优化还有很多，为编译器提供了更多信息，使编译器可以从全局角度出发做更多的优化

内存分配和引用计数优化

一般程序的内存区域，除了代码段和数据段之外，剩下的主要是堆内存和栈内存。

堆(heap)
- 堆内存一般由程序员自己申请、指明大小、释放，是用于存放进程运行中被动态分配的内存段,它的大小并不固定,可动态扩张或缩减。当进程调用malloc等函数分配内存时,新分配的内存就被动态添加到堆上(堆被扩张); 当利用free等函数释放内存时,被释放的内存从堆中被剔除(堆被缩减)。
栈 (stack heap)
- 又称堆栈, 由编译器自动创建/分配/释放，是用户存放程序临时创建的局部变量,也就是说我们函数括弧“{}” 中定义的变量(但不包括static声明的变量,static意味着在数据段中存放变量)。除此以外, 在函数被调用时,其参数也会被压入发起调用的进程栈中,并且待到调用结束后,函数的返回值也会被存放回栈中。由于栈的后进先出特点,所以栈特别方便用来保存/恢复调用现场。从这个意义上讲,我们可以把堆栈看成一个寄存、交换临时数据的内存区。

基于堆栈的优化

Swift中值类型存放在栈中，应用类型存放在堆中。苹果也明确指出建议使用值类型。苹果为何这么建议呢？

数据结构
- 存放在栈里的数据结构较为简单，只有一些值相关的东西
- 堆上的数据结构较为复杂，包含了type、retainCount等
数据的分配与读取
- 存放在栈中的数据从栈区底部推入 (push)，从栈区顶部弹出 (pop)，类似一个数据结构中的栈。由于我们只能够修改栈的末端，因此我们可以通过维护一个指向栈末端的指针来实现这种数据结构，并且在其中进行内存的分配和释放只需要重新分配该整数即可。所以栈上分配和释放内存的代价很小。
- 存放在堆中的数据并不是直接 push/pop，类似数据结构中的链表，需要通过一定的算法找出最优的未使用的内存块，再存放数据。同时销毁内存时也需要重新插值。
多线程处理
- 栈，是线程独有的不用考虑多线程问题
- 堆，数据时多线程共享的，需要同步锁来解决这个问题

所以基于内存分配方面的考虑，应该更多的使用栈而不是堆，达到优化效果

值类型的一个优化

有这样一个结构体

Struct User {
    var avatar = UIImage。。。
    var name = "老王"
}

var userA = User()
var userB = userA

这样结构体中的引用类型的引用计数会增加如果我们对其中的引用类型再进行一层封装的话就可以减少不必要的引用计数

方法调用的优化

Objective-C 中方法的调用，从本质上来说都是向相应的对象发送消息。方法经编译器编译过后一般就变成了objc_msgSend函数，该函数的第一个参数是接受消息的对象，第二个参数是消息的名字，后面的都是消息携带的名字，参数从0到 n 个不等。
正是基于这一点Objective-C 中，我们可以字符串去调用方法，就可以用变量来传递这个字符串，进而可以实现一些运行时动态调用，语言提供的 NSSelectorFromString 是一个很好的说明，runtime 也因此被开发者奉为神器，被广大开发这熟知的JSPatch 也是基于这点实现的。因为这种动态性的设计使得Objective-C 语言变得异常灵活。
但是，Objective-C语言动态化这种灵活性是以查表的方式找出函数地址，既然查表操作，当然要付出时间代价。苹果官网文档中介绍了方法调用时，函数地址查询过程，苹果也发现了这种方式调用起来会很慢，所以一种这种的办法就是缓存方法调用的查询结果，但即便是这样，性能上同将函数地址硬编码到代码中这种方式相比还是有一些差距。
相比于Objective-C，Swift语言直接放弃了Objective-C这个动态化机制。就这一方面而言，Swift如今算是和很多主流语言保持了一直。因为舍弃了动态特性，Swift语言势必比Objective-C快了一些，但在一定程度上丢失了灵活性。相信不久的将来，Swift势必会引入一些动态特性，不过目前而言这并不是它的首要目标。

协议类型

如有下面两个协议

protocol MyProtocol

struct Owner: MyProtocol {
    var name: String
}

struct User: MyProtocol {
    var name: String
    var url: String
}

let userA = User()
let owner = Owner()


var array: [MyProtocol] = [userA, owner]

这里的数组内的元素是不同类型的，占用空间不一致。无法高效的定位元素位置。

苹果的解决方案
- Existential Container
  - 这是一个额外的容器，大小一定
    - 分为5段（word）
      - 前三段用来存储元数据的值，如果存储不下则会在堆内存上开辟空间存放，而在第一段中存入指针
      - 第四段：Value Witness Table(VWT)。每个类型都对应这样一个表，用来存储值的创建，释放，拷贝等操作函数。(管理 Existential Container 生命周期)
      - 第五段：Protocol Witness Table(PWT)，用于存放协议（Protocol）对应的函数的实现函数地址

总结

为什么Swift编译很慢？
- 因为Swift在编译的时候做了很多事情，所以消耗时间比较多是正常的。如对类型的分析等。
为什么Swift相比较OC会更快？
- 编译器 Whole Module Optimizations 机制的全局优化、更多的栈内存分配、更少的引用计数、更多的静态、协议类型的使用等都是Swift比OC更快的原因。

参考

https://www.jianshu.com/p/0ca59322c08b

Swift5新特性

Tue, 13 Oct 2020 00:00:00 GMT

参考

https://juejin.im/post/5c4b3e91e51d452c8e6d6bcc#heading-1

SwiftPackage使用

Tue, 13 Oct 2020 00:00:00 GMT

官方文档: https://github.com/apple/swift-package-manager 当前不支持 iOS, watchOS, or tvOS.

查看当前版本

swift package --version

初始化项目

先在目标文件夹打开终端

01 初始化项目

swift package init --type executable

02 生成工程文件

此处初始话的项目名称会和目录名称一致
如: 目录名Demo 文件即为Demo.xcodeproj

swift package generate-xcodeproj

TODO:

突然发现不能用在iOS上就暂时搁置了...

Lab.Lawliet

不用加减乘除做加法

一、 题目

二、 解法

组件化

一、 CTMediator

二、 BeeHive

iOS独立开发者注册公司到App备案上架

一、 背景

二、 个人注册公司

三、 网站备案

3.1 购买服务器

3.2 企业信息

3.3 购买域名

3.4 域名备案、解析

3.5 企业邮箱（有坑）

四、 苹果个人开发账号转公司账号

4.1 邓白氏码

4.2 个人转企业账号

五、 APP 备案

5.1 APP 信息

5.2 APP 平台信息

获取 Xcode 自动管理的证书特征信息

5.3 审核

5.4 App Store 更新

六、 一些问题

6.1 个人可以备案么？

6.2 可以批量备案么？

6.3 不联网 App 可以不备案么？

参考资料

Swift编译流程

Swift方法调度

纯 Swift 类

普通函数

@objc、dynamic、@objc dynamic 关键字修饰的函数

extension

子类

override

final

sil_vtable

结构体

[译]编写高性能Swift代码-Writing High-Performance Swift Code(2022.8.25版)

编写高性能的 Swift 代码

一、 开启优化 - Enabling Optimizations

二、 整模块优化 - Whole Module Optimizations (WMO)

三、 减少动态派发 - Reducing Dynamic Dispatch

动态派发 - Dynamic Dispatch

建议：使用 final 当你确定被声明的不需要被重写

建议：使用 private 和 fileprivate 声明不需要被文件外界访问的内容

建议：如果启用了 WMO，在模块内部对不需要外部访问的内容使用 internal 关键字进行声明

四、 高效的使用容器类型 - Using Container Types Efficiently

建议：在数组中使用值类型

建议：不需要考虑 NSArray 桥接的时候可以使用 ContiguousArray 来存储引用类型

建议：使用引用修改而不是对象重新赋值 - Use inplace mutation instead of object-reassignment

五、 避免检查溢出的计算 - Wrapping operations

建议： 在已知不会溢出的情况下使用 wrapping arithmetic 进行不检查的整型计算 &+

六、 范型 - Generics

建议： 将范型声明放在需要使用它的模块内

七、 Swift 中较大值类型的开销 - The cost of large Swift values

建议： 较大的值类型使用写时复制 COW - Advice: Use copy-on-write semantics for large values

八、 不安全的代码 - Unsafe code

建议：使用非托管的引用来避免引用计数带来的开销

九、 协议 - Protocols

建议：将智能由 class 实现的协议标记为 class-protocol

十、 left/var 被逃逸闭包捕获的性能消耗

建议：如果闭包不是真的需要逃逸，使用 inout 参数传递 var

补充说明 - Footnotes

dealloc

Dealloc 的实现机制

1. Dealloc 调用流程

2. object_dispose() 调用流程

3. objc_destructInstance() 调用流程

4. clearDeallocating() 调用流程

知识点梳理：HTML和浏览器

一、 浏览器

1. Cookie、sessionStorage、localStorage

2. 说一下 web worker

3. Doctype 作用?

严格模式与混杂模式如何区分? 它们有何意义?

4. Cookie 如何防范 XSS 攻击

一、题目

二、解法

一、背景

二、个人注册公司

三、网站备案

四、苹果个人开发账号转公司账号

六、一些问题

一、开启优化 - Enabling Optimizations

二、整模块优化 - Whole Module Optimizations (WMO)

三、减少动态派发 - Reducing Dynamic Dispatch

建议：使用 `final` 当你确定被声明的不需要被重写

建议：使用 `private` 和 `fileprivate` 声明不需要被文件外界访问的内容

建议：如果启用了 `WMO`，在模块内部对不需要外部访问的内容使用 `internal` 关键字进行声明

四、高效的使用容器类型 - Using Container Types Efficiently

建议：不需要考虑 NSArray 桥接的时候可以使用 `ContiguousArray` 来存储引用类型

五、避免检查溢出的计算 - Wrapping operations

建议：在已知不会溢出的情况下使用 `wrapping arithmetic` 进行不检查的整型计算 `&+`

六、范型 - Generics

建议：将范型声明放在需要使用它的模块内

建议：较大的值类型使用写时复制 COW - Advice: Use copy-on-write semantics for large values

八、不安全的代码 - Unsafe code

九、协议 - Protocols

建议：如果闭包不是真的需要逃逸，使用 `inout` 参数传递 var

一、浏览器

1. 说一下盒子模型

16. position 属性比较

一、题目

二、解法

一、题目

二、解法

一、题目

二、解法

一、题目

二、解法

一、题目

二、解法