备忘录

更加 Swifty 的 UICollectionView

又一次站在 UICollectionView 面前,这次我的选择是?

又一次轮回

此前负责过一个复杂的 AI Chat 项目,它大概是最容易把人逼疯的场景之一:Socket 在不断推送新的 Markdown Chunk、文字正在打字机效果流式刷新、键盘在弹起、用户还在往下拉取、历史消息在顶部异步插入……

页面里的 UICollectionView 随着业务一路野蛮生长,状态与视图更新互相踩踏,到了后期,每一次改动都如履薄冰。

当时为了自救,我参考 IGListKit 手写过一套 Swift 版本的翻版。SectionController 的思想帮了大忙:让每个模块拥有自己的组织者,页面不必关心每个格子背后的琐事。替换之后,大泥球被拆开了,各处责任清晰了,增量更新也变快了。

太阳底下无新事,换了新环境,相似的困境又一次摆在眼前。当年的代码留在了老公司,如今再复盘,我总觉得那份仓促写就的代码更像是一个 Objective-C 风格的粗暴临摹。这一次,我更想借此机会彻底想清楚:

  • 哪些组织方式真正跨越了时间与语言,历经十年依然值得保留?
  • 在现代 Swift 的泛型、协议与类型擦除面前,我们是否还要忍受旧时代 Any 的妥协?
  • 曾经参与过 IGListKit 的前人,在今天又是如何重新审视这些设计的?

一次沟通

不过,一上来就聊架构难免太空泛。先看一个 Collection 怎样把数据变动更新到视图上。

更新「早上好」

消息列表里有四条消息,按 A、B、C、D 排列。字母是消息 ID,每条消息都有自己的正文。对照更新前后的界面,看看发生了哪些变化:

更新前:普通消息依次是 A「早上号」、B「今天开会吗?」、C「会议室还没定」、D「十点开始,会议室在三楼」。更新后:普通消息依次是 A「早上好」、B「今天开会吗?」、D「十点开始,会议室在三楼」、E「ok,了解」。

先看 A、C 和 E,界面应该怎样处理?

消息身份内容要做什么
A新旧都有把错字「早上号」改成「早上好」更新原来那条消息
C新列表没有旧消息「会议室还没定」删除旧消息
E旧列表没有新消息「ok,了解」插入一条新消息

所以需要两种判断:身份用来匹配同一项,内容用来判断匹配后是否需要更新。只按文字匹配,会把 A 的修改认成旧消息消失、新消息出现;只比较 ID,又会漏掉 A 的正文变化。

对 Swift 比较熟悉的人,会想到 Identifiable 和 Equatable 所表达的概念。写 SwiftUI 时经常需要考虑这些;写 UIKit 时可能没有那么直接,因为 UIView 是 class,天然具有实例身份。但 Cell 会复用,消息的身份仍然需要另外确定。

其它框架,大同小异
  • DifferenceKit 用 differenceIdentifier 和 isContentEqual(to:) 表达这两种判断。1
  • IGListKit 用 diffIdentifier 和 isEqual(toDiffableObject:) 表达它们。2
  • UICollectionViewDiffableDataSource 的 Snapshot 保存 Hashable 标识,可以对应这里的稳定 ID;现有项的内容变化则需要另外标记。3

身份与内容分清了,接下来才是:怎样把两份数据之间的变化算出来?

比较序列

接着,把消息 D「十点开始,会议室在三楼」置顶,为元素标上下标:

旧序列:A(0)   B(1)   D(2)   E(3)
新序列:D(0)   A(1)   B(2)   E(3)

消息没有增减,正文也没变,只需要把 D 移到最前面。要算出这样的结果,我们应该怎么做?

这次参考了 Heckel 的匹配思路:先配对两边只出现一次的元素,再借助相邻关系继续寻找对应项。45 这里已有稳定、唯一的展示 ID,系统的 Diffable DataSource 也采用了这种身份约定。

把最终输出抽象一下,就是四类变化,位置从 0 开始计数:

deleted:删除项的旧位置
inserted:新增项的新位置
moved:移动项的旧位置 → 新位置
updated:内容变化项的新位置

D 置顶这次,只有 moved 里的一条 2 → 0,其余为空。你可能会好奇:A 和 B 的位置不是也往后顺延了一格吗?为什么它们不算 moved?因为在原序列里,A、B、E 的相对顺序并没有改变;只要把 D 抽出来插到最前面,其余项自然顺延即可。这也是后续借助 LIS(最长递增子序列)的目的:锁住保持相对顺序的存活项,只移动真正需要位移的元素,避免无意义的全局重排。

内容比较与位置变化独立,同一项可以同时出现在 moved 和 updated 中。这份结果描述的是变化,还不是 UIKit 的调用安排。

关于其他算法

Myers 是序列差异计算中的经典算法,寻找的是最短的增删编辑路径。Android 的 DiffUtil 和 Swift/iOS 生态中的 Differ 都采用了这条路线,调研时的 Swift 标准库实现也能看到它的身影。6

Myers 的增删结果不直接表达移动,需要在此基础上另外识别,DiffUtil 就补了这一步。因此,采用 Myers 并不意味着界面只能执行删除和插入。这里已有稳定、唯一的 ID,可以直接建立新旧项的对应关系,再用 LIS 选择哪些存活项不必显式移动,因此采用了这条实现路径。

算法本身就不展开了,因为接下来会看到,算出变化只是完成更新的一部分。

至此,算法告诉了我们哪些项发生了变化,却还没有决定这些变化应该怎样更新到页面上。

始于算法,但不终于算法

补充一些 UICollectionView 的相关常识:

  1. 消息由 Cell 呈现,消息可以分别放在不同的 Section,类似二维数组。
  2. 更新页面时,需要配合完成两件事:更新数据源中的数组,以及对视图执行对应的操作。 UIKit 会通过 DataSource 查询内容和数量,因此数组提供的数据必须与这些操作严格对得上。

下文把这种一次共同提交的操作称为一个「批次」(batch)。

如何操作 UIKit

如果把 D 放进新建的置顶 Section,同时将正文里的「十点」改成「十点半」,这次更新就同时涉及结构和内容。这里选择分两步执行:

  1. 结构阶段:用 insertSections 建立置顶 Section,再用 moveItem(at:to:) 把 D 移进去,暂时保留旧正文。建组与移动可以在同一批提交,D 的身份不变。7
  2. 内容阶段:安装目标内容,按最终位置更新 D。原来的 Cell 仍然兼容,就用 reconfigureItems(at:);Cell 类型或注册方式不兼容,才用 reloadItems 替换。8

为什么分开?内容更新不总是修改文字,也可能需要重新加载 Cell 或整个 Section。重新加载与移动混在同一个批次时,需要额外处理操作之间的冲突。因此,这里统一先完成结构更新,再按最终位置处理内容更新,集中处理这些组合限制。

改成「十点半」只需要重新配置原来的 Cell,本身不一定需要拆开;分阶段是这套实现采用的统一策略。有动画时,等待结构批次完成,再提交内容批次。

关于总耗时

聊到这里就比较清楚了:算法耗时只是总耗时的一部分,它算出的操作还会影响 UIKit 的更新成本,所以比较完整更新时,必须把 UIKit 的耗时也算进去。

数据不会说谎,下面就是我们愉快的 Benchmark Time。这次在 100、1,000、10,000 项数据规模下做了对比,覆盖增删、内容更新、重排与跨 Section 迁移。9

2026.11.09 · 同一轮复测
从准备数据,到更新与布局完成

身份与顺序不变,只修改五项内容。

  • 自研 DataSource0.916 ms
  • 系统主线程1.673 ms
  • 系统后台实验1.418 ms
  • ListKit1.149 ms
查看本组波动与可见 Cell 保留情况

自研 DataSource:三轮范围 0.498–0.930 ms; 同身份、更新前后均可见的 Cell 保留数中位数 12/12。

系统主线程:三轮范围 0.939–1.882 ms; 同身份、更新前后均可见的 Cell 保留数中位数 12/12。

系统后台实验:三轮范围 1.005–1.802 ms; 同身份、更新前后均可见的 Cell 保留数中位数 12/12。

ListKit:三轮范围 0.772–1.478 ms; 同身份、更新前后均可见的 Cell 保留数中位数 12/12。

Cell 检查在计时外进行,只检查实际可见对象。

横条越短,耗时越少。细线为三轮中位数的范围,不是置信区间。每组刻度随数据调整,从零开始。

模拟器、无动画、简单 Cell。四条路径共享展示适配;不含业务捕获、外层排队与屏幕呈现。系统后台为 completion 入口实验。

全部 31 个场景与复现记录

测了一些常见场景,也尽可能想了很多 Test Case,与系统方案以及我认为社区里比较优秀的开源实现做了对比。这轮测试里,自研在绝大多数场景下的完整更新耗时更低。

此外,系统 Diffable DataSource 的后台使用方式也做过实验。10 不过,比起性能,我更在意数据怎样组织:系统通过统一的 Snapshot 管理整个列表,模块独立维护的数据最终仍需要汇总到这份快照里。

这并不妨碍外面再封装一层模块管理,但这里希望 Section 能持有自己的状态、组织内容并提交更新,再由底层协调到整个列表。这也是选择自行组织 DataSource 的原因之一。

但这些其实都不是我一定要自己重新实现的原因,对我影响很大的一句话是:What I cannot create, I do not understand.

可插拔算法

默认路径选择了唯一 ID 匹配与 LIS,这是本次调研后的取舍。11 算法和执行方式仍然留有替换入口,分别对应两个公开协议。

public protocol SectionedDiffAlgorithm {
    func diff<Section: DiffableSection>(
        from source: [Section],
        to target: [Section]
    ) throws -> SectionedChanges
}

如果想替换的不只是算法,而是整套 DataSource,也可以自己实现 CollectionDataSource 协议,甚至通过适配 UICollectionViewDiffableDataSource,接入系统的更新实现。

更新怎样计算、怎样执行,以及哪里可以替换,到这里都有了安排。接下来回到业务侧:谁组织这些数据,谁持有状态,又由谁发起更新?

如何让角色分工

我希望我设计的一套系统足够灵活,默认实现能够满足绝大部分要求,有特殊需求时,也能替换其中的某一部分。同时,也希望这个 Package 用起来接近 DSL(domain-specific language),让使用者直接表达和组合自己的需求。

这里把列表展示分成三个角色:

角色负责什么
Cell具体控件、内部排版、复用清理,以及按压、动画等短暂视觉状态(纯粹的 UI)
CellPresenter单个展示项这一版的展示快照:声明 Cell 类型、负责配置与绑定、提供身份与内容比较
SectionController模块级组织者:在模块存续期间持有业务状态,协调网络监听,组织内容并提交更新

有了这层明确的分工,接下来我们从最底层的 Cell 开始,逐层看看它们是如何协同工作的。

让 Cell 变得纯粹

在 UIKit 里,一个稍微复杂的 Cell 内部往往已经堆满了子视图层级、Auto Layout 约束、高亮手势与微交互动画——它的 UI 逻辑本身就已经足够重了。如果再把数据模型转换、Diff 比较甚至状态存储全塞进去,Cell 就会迅速膨胀成另一个难以维护的“大泥球”。

借鉴现代声明式 UI(如 SwiftUI)的理念,Cell 应当尽可能保持纯粹的呈现职责:它只专注具体控件、内部排版与复用清理。

但与此同时,Cell 在 UIKit 里是被反复复用的池化对象,不能留存历史状态;而 Diff 算法又必须依赖一份不可变且稳定的数据,才能准确比较前后两版的变化。

这正是 CellPresenter 存在的意义:它充当了数据与视图之间的安全快照。它负责提供稳定的身份(id)与内容比较规则(Equatable),声明自己需要配置哪一种 Cell,并在视图出场时完成装配:

public protocol CellPresenter: Equatable {
    associatedtype Id: Hashable
    associatedtype Cell: UICollectionViewCell

    var id: Id { get }

    @MainActor func configure(_ cell: Cell)
    @MainActor func bind(to cell: Cell)
}

Presenter A 声明使用 Cell A,配置时拿到的就是强类型的 Cell A。类型关系已经在编译期被协议锁死,业务再也不用写那句繁琐的

guard let cell = cell as? MyCell else { return }

Cell 负责呈现,Presenter 描述这一版怎样呈现。那模块持续变化的状态放在哪里,谁根据状态生成这些 Presenter,又由谁决定什么时候提交新内容?这就回到了 Section 的取舍。

对 Section 的取舍

Section 可以只是一份分组数据,也可以由一个持续存活的 SectionController 来管理。这里需要决定的是:模块的状态和更新职责放在哪里?

ReactiveCollectionsKit 选择用轻量的数据描述 Section,没有沿用 IGListKit 的 SectionController。这也让我想试试,能不能省掉这层对象和相关接线。

早期版本只用一个轻量的 SectionPresenter 包装一组 CellPresenter,数据变了就重新生成快照。但实际接入后,有两个问题需要补上:

  • 状态由谁保留? 当时接入的嵌套组件,会在外层容器复用时销毁重建内部视图,滚动位置也随之丢失。模块还在,视图却换了一份,需要有一个比视图活得更久的对象保留这些状态。
  • 更新由谁发起? 有些模块需要持续监听数据变化,再生成新的 Presenter 并提交更新。这些工作需要一个持续存活的对象来承担,仅有一份展示快照还不够。

这并不意味着纯数据的 Section 做不到。状态和监听可以交给外部对象,滚动位置也不是所有接入方式都会丢失。只是这些职责总得有人承担,而我希望模块自己能说清楚:有哪些内容、何时请求数据、何时提交更新,不必把这些事情继续搬到页面里。

再参考了 Composed / ComposedUI 的实践后,我还是把 SectionController 请了回来:由它持有模块状态、协调请求与监听,再组织 Presenter、提交更新。这些需求并不罕见,也不必等到业务足够复杂才考虑。

保留这层职责,不代表接线方式也要照搬。这一次,希望通过类型约束,让编译器检查模块内部的配对关系,减少使用者在运行时强转模型的地方。

开始接线

到这里,Cell、Presenter 与 SectionController 的职责各自明确,类型关系也能在模块内部确定。可一旦放在同一个集合视图里,框架该如何统一管理这些具体类型完全不同的模块?

先看 SectionController 协议中的身份约定,这里只摘出相关的两行:

associatedtype Id: Hashable
var id: Id { get }

每个 SectionController 可以使用自己的 ID 类型,只要支持哈希与相等比较。不同的 SectionController 可以放在同一个数组里,但各自的 ID 类型仍然不同,框架怎样用它们统一查找和匹配模块?

这里用 AnyHashable 做类型擦除:

id = AnyHashable(section.id)

它隐藏了 ID 的具体类型,仍然保留哈希与相等比较的能力。协议约定需要什么能力,类型擦除让不同的身份类型可以共同参与管理。这里并不需要彻底消灭 Any,而是保留各自实现需要的类型,在统一管理时隐藏不需要区分的部分。

SectionController 收集不同的 Presenter 时,也面临着相同的困境。Presenter A 与 Presenter B 可以配置完全不同的 Cell,最后由 AnyCellPresenter 统一包装。

类型擦除后,Diff 算法该如何判断两个 AnyCellPresenter 的内容是否相等?

我们可以避免在最外层写满类型穷举,借助 Swift 的协议扩展,我们可以把具体的比对工作“推回”给内部持有的具体类型:

public struct AnyCellPresenter: Equatable {
    public let id: AnyHashable
    let underlyingPresenter: any CellPresenter

    public static func == (lhs: Self, rhs: Self) -> Bool {
        lhs.underlyingPresenter.equals(rhs.underlyingPresenter)
    }
}

extension CellPresenter {
    func equals(_ other: any CellPresenter) -> Bool {
        guard type(of: self) == type(of: other),
              let other = other as? Self else { return false }
        return self == other
    }
}

往上一层,CollectionOrchestrator 负责统一调度这些模块。如果把整套接线逻辑画出来,它就像一个分层的标准化快递箱:

Parade 类型擦除与接线全景:对外通过 AnyHashable 与 AnyCellPresenter 抹平异构差异方便统一调度;对内保留具体的强类型 Presenter 独立配置与绑定 Cell。
分层包装:对外抹平类型差异方便统一调度,对内保留强类型精准绑定。
  • 在外层:无论是 Section 还是 Cell,身份都被收敛为 AnyHashable,异构的展示项也被统一收进 AnyCellPresenter 这个通用箱子里。最外层的列表容器不需要关心任何具体类型,只管按顺序编排和调度。
  • 在内层:一旦进入具体的渲染与事件触发,箱子拆开,各个 Presenter 立刻还原回自己的强类型世界,专心伺候对应的 Cell,安全且干净。

身份与 Cell 的具体类型,都可以在统一管理的位置隐藏起来。但 SectionController 还要提供布局。到了这里,还能沿用同样的处理方式吗?

可是布局呢

前面通过类型擦除,把不同的身份和 Presenter 放在了一起。但布局还有一个问题:不同的原生 Layout,需要 Section 提供的东西并不一样:

  • Compositional Layout:提供构造 NSCollectionLayoutSection 的闭包。
  • Flow Layout:通过 UICollectionViewDelegateFlowLayout 回答尺寸、间距等查询。

自定义 Layout 还可能有自己的接口,不能都套进 Flow Layout 的代理里。

两套 API 的输入不同,没有必要强行统一成同一种接口。但如果直接用 Any 装起来,Section 提供的布局信息能不能被当前 Layout 使用,就要等到运行时才能检查。这里希望保留各自的接口,同时让编译器检查两端是否匹配。

这一点想透了其实很清晰,但如果想不透,怎么抽都抽不好:不强求接口一致,各自抽成桥接中间适配器

// 1. 声明式:装载返回 NSCollectionLayoutSection 的构造闭包
public struct CompositionalSectionLayout {
    public let build: @MainActor (NSCollectionLayoutEnvironment) -> NSCollectionLayoutSection
}

// 2. 问答式:装载提供尺寸间距查询的 delegate 工厂
public final class FlowSectionLayout {
    public init(_ makeDelegate: @escaping (...) -> some UICollectionViewDelegateFlowLayout)
}

另一端,CollectionLayout<Layout> 负责创建原生 Layout 和配套代理,把 Section 提供的布局信息接到 UIKit。具体的几何计算仍然由原生 Layout 完成。

CollectionLayout<CompositionalSectionLayout>
CollectionLayout<FlowSectionLayout>

接下来,让 Section 提供的布局类型,与集合使用的布局类型保持一致:

@MainActor
public protocol SectionController<Layout>: AnyObject {
    associatedtype Id: Hashable
    associatedtype Layout
    associatedtype Content: SectionContent where Content.Layout == Layout

    var id: Id { get }
    var updateContext: SectionUpdateContext { get }
    func captureContent() -> Content
}

Content.Layout == Layout 约束了 Section 交出的布局类型,CollectionOrchestrator<Layout> 再把 Section 和 CollectionLayout<Layout> 接到一起。选用 Compositional 时,所有接入的 Section 都必须提供 CompositionalSectionLayout,类型不匹配就无法通过编译。

代价是相关的公开类型都要携带 Layout 参数。换来的是,两套 API 可以保留各自的使用方式,Section 与布局桥接的类型配对由编译器检查。自定义布局也可以定义自己的输入类型,再提供对应的桥接。12

最后再看使用处

前面拆开讨论了算法、DataSource、Cell、Section 和 Layout,最后把它们放回同一个调用处,看看这些设计用起来是什么样。

假设 Section A、B 已经准备好,都提供 Compositional 布局。把选择写出来,接入是这样:

let orchestrator = CollectionOrchestrator(collectionView: collectionView)

默认使用 Compositional 布局和分阶段更新实现。想换一种组合,please enjoy:

let orchestrator = CollectionOrchestrator(
    collectionView: collectionView,
    layout: .compositional(),       // 或替换为自定义桥接
    diffAlgorithm: SectionedDiff()  // 或替换为其他算法
)
try await orchestrator
    .compose([sectionA, sectionB])
    .apply()

Section A、B 可以组织不同的 Presenter,各自配置不同的 Cell。前面确定的类型关系,到这里仍然有效。页面只需要把模块放在一起,不必重新判断每个 Presenter 应该交给哪一种 Cell,也不必接管模块内部的状态。

不过,把模块放在一起,和更新模块的内容,是两件可以分别发生的事情。只有 A 的状态变化时,它可以直接更新:

try await sectionA.update()

如果同时要把 B 放到 A 前面,并展示 A 的新内容呢?当然可以分别提交:

try await orchestrator.compose([sectionB, sectionA]).apply()
try await sectionA.update()

但这是两次更新。第一次调整组成,存活的 A 保留之前接受的展示内容;等它完成,第二次才提交 A 的新内容。两次 await 把先后顺序说清楚了,却也让页面先经过一个「顺序已变,内容还没变」的中间状态。

如果业务希望把顺序变化和内容变化一起提交,就可以这样写:

try await orchestrator
    .compose([sectionB, sectionA])
    .updating([sectionA])
    .apply()

compose 描述最终有哪些 Section、按什么顺序排列,updating 指定哪些 Section 需要带上新内容。前两步只构造更新描述,到 apply 才捕获内容并提交。这样,新的组成与 A 的新内容进入同一个目标,不必由调用者分两次推进。13

链式调用就是从这里长出来的:组成可以单独变,内容也可以单独变,有时又需要一起变。把这些动作分开,再允许它们组合,就有了现在的写法。单个 Section 的更新仍然保留直接入口,没有必要为了链式,再让模块绕回页面。

这一行 apply 背后,前面讨论的几部分也就串起来了:

  1. 捕获内容:需要更新的 Section 交出这一版的 Presenter 和布局信息,组成目标快照;
  2. 推进更新:DataSource 根据新旧快照计算变化,协调数据源中的数组与 UIKit 操作;
  3. 呈现内容:Presenter 配置 Cell、绑定行为,布局桥接提供所需信息,原生 Layout 完成几何排布。

一次提交可以包含多个 UIKit 批次。调用方表达的是一个完整的更新目标,具体怎样分阶段执行,由 DataSource 负责。

再回头看,公开 API 做的就是前面划分的那些事情:选择实现、组合模块、更新内容、提交结果。协议、类型擦除和泛型把内部接好,调用处才可以把这些动作直接写出来。到这里,最初希望它用起来接近 DSL 的想法,也算有了落点。

为什么叫「游行」

回头看整个过程,这其实是我第三次认真面对 UICollectionView。

在小宝宝时期,每天都在琢磨它怎么用 API,项目中的基类为什么是要这么设计的,在越来越庞杂的业务里撞得满头包,开始察觉到官方实现的种种瓶颈;后面借助 AI 翻写了一套 Swift 版本。那一次更多是从社区优秀的第三方库里借鉴思路,虽然刷新变快了、页面逻辑清楚了,但坦白讲,当时我并没有真正吃透底层的每一个细节,代码能跑,却不知道哪块地方碰了就会崩,本质上还是一份带有侥幸心理的语言翻译版。

而到了这一次,如果有人指着现在的这套实现问我:这段逻辑是干什么的?我可能不会逐行给你背出语法细节,但我一定能清清楚楚地告诉你——它承担了什么责任、为什么要创造它、以及为什么它必须立在那个边界上。

都快 2027 年了,在苹果生态里,集合视图依然是 UIKit 乃至整个 iOS 开发中最复杂、最难伺候的一块拼图。哪怕如今有了 SwiftUI、有了 UIHostingConfiguration,只要你需要极致的高性能与复杂的动态编排,你依然无法绕开 UIKit 的底层原理。

这个库的名字叫 Parade。因为从立项的第一天起,我脑海里浮现的画面就是一场盛大的方阵检阅:Section 是整齐的方队,Cell 是排头的队员,无论数据怎样变动、状态如何起伏,它们都能步伐一致、整整齐齐地往前走。

而这篇文章,就是现在的我给这个老难题交出的一份完整答卷。很多涉及扩展性和架构权衡的细节,全都是一次次实战换来的经验之谈。受限于篇幅,许多内部协议和分支无法在文中一一穷尽,就留给源码吧。如果它也能为你带来一点启发,这一路的颠沛流离便有了更多的意义。

完整源码与基准测试见 Parade14,欢迎体验。

脚注

Footnotes

  1. 固定版本源码:ContentIdentifiable、ContentEquatable、Differentiable。 ↩

  2. IGListKit Getting Started 中的 Diffing 部分,以身份不变、名字变化的模型说明身份与内容比较。 ↩

  3. Updating collection views using diffable data sources,Snapshot 保存标识,现有项的内容更新由调用方显式标记。 ↩

  4. DifferenceKit 的算法说明介绍了它与 Carbon、Heckel 的关系,以及为 UIKit 分阶段应用变化的原因。本次实验固定在 02ca1968b10305d4d6771f4005a7ce2c507a8539。 ↩

  5. Paul Heckel,A Technique for Isolating Differences Between Files,1978。原文通过唯一元素及相邻匹配建立对应关系,并讨论移动块的识别;不能将它概括为只输出最少增删。 ↩

  6. Swift 标准库 Diffing.swift 中的线性空间 Myers 实现,以及 CollectionDifference.swift 中单独的移动推断。这里引用调研时的源码版本,不据此断言实验所用 SDK 的内部实现版本。 ↩

  7. 复杂 Section 合并实验保留 UIKit 操作、选中状态、Cell 对象与内容核验;ListKit 的迁移探针也记录了新建/删除 Section 与已有 Section 之间迁移的差别。 ↩

  8. 结构阶段保留存活项旧内容、最后安装目标内容的执行约定延续自 1.1.1 的分阶段 DataSource。本轮内部路径减少结构批次,无动画内容更新直接配置并完成同步布局,动画路径仍等待完成;详见整合实现与 164 项测试说明。 ↩

  9. 2026-11-09 整合后的统一复测:方法与边界、全部 31 个场景、逐轮中位数、原始样本与复现源码。每规模三次独立进程,每组预热 3 次、正式 10 次,共 11,160 个正式样本;图中取三轮中位数的中位数,细线是三轮中位数范围,不是置信区间。M4 Max,Xcode 27.1,iPhone 18 Pro/iOS 27.0 模拟器,320 × 480 视口、36 pt Label Cell,无动画与预取。计时含目标准备、apply 完成等待与最终同步布局,不含业务 SectionController 捕获、外层排队和屏幕呈现。ListKit 固定于 Iron-Ham/Lists 221e1513f2786a4e5e836c9b76092c3bd6e61575,使用精确批次路径;全部正式样本计时内 reloadData 为零。记录保留测试当时的「临时版」称呼;其前四轮优化现已合入本地 Parade 6306d4c3,第五轮未加入。 ↩

  10. 后台与 ListKit 对照实验。系统后台版本使用固定串行队列与 completion 等待,是运行时实验,并未作为绕过当前 SDK MainActor 注解的生产方案。后续统一复测沿用这一口径。 ↩

  11. 最初的公开 SectionedDiff采用唯一身份匹配与贪心。此次 LIS 位于默认 DataSource 的内部整数规划路径;公开 SectionedDiff 本身及自定义算法契约没有改写,也没有切换默认 DataSource。新实现与校验可查整合补丁,完整源码与测试在同目录的复现包中。 ↩

  12. 布局接入说明。当前不提供自动混合不同布局、通用滚动位置恢复或交互拖拽排序。 ↩

  13. 引入可组合提交的变更,包括最终目标校验、在 apply 捕获内容,以及保持 Section 局部更新入口的选择。 ↩

  14. 源码地址 ↩