【探秘 Jetpack Compose 框架深水区】第6课:derivedStateOf 的边界在哪里?

35 阅读36分钟

摘要:本文围绕 derivedStateOf 的适用边界展开,先拆解其底层机制——依赖集由计算路径动态决定、重算发生在读取 .value 时、通知时机由 SnapshotMutationPolicy 决定;再逐一划清它与普通 remember、remember(key)、直接读取、snapshotFlow 的边界,并指出“非状态变量不能成为依赖”这一经典陷阱;最后给出“输入频率高于输出频率”的收益条件与五问决策框架,配 15 道习题与知识点总结,帮助读者判断何时该用、何时不该用 derivedStateOf。

目录

前言

一个需要先放在桌面上的结论:derivedStateOf 不是“性能优化开关”。它是一个精确的过滤器,只在一种特定形状下成立——输入变化的频率显著高于输出变化的频率。形状不对,它不但不优化,还会多一层快照订阅开销,让代码更难推理。

第3课讲 remember 时,我们讨论过“值存在哪个组合位置上”。第4课讲 effect 时,我们讨论过“动作拴在哪个生命周期锚点上”。第5课讲组合身份时,我们讨论过“哪儿本身由什么定义”。这三课有一个共同的隐含前提:状态和动作的边界,是由你显式声明或显式放置的。

derivedStateOf 打破了这个前提。它的依赖集不是由你传入的参数决定的,而是由计算过程中实际读取了哪些 State 动态决定的。这意味着它可以做一件普通 remember 做不到的事:读很多高频变化的输入,但只在计算结果真正变化时才通知下游。代价是它的行为依赖于一个你从签名上看不见的机制——快照读取追踪。

这一课要回答三个问题:derivedStateOf 到底追踪什么、什么时候重算、什么时候通知;它和 remember(key)、直接读取、snapshotFlow 的边界分别在哪里;以及“派生状态”这个模式在快照系统中应该被放在哪一层。


一、底层机制:它追踪什么,什么时候重算,什么时候通知

官方 API 文档对 derivedStateOf 的表述很短,但每一句都值得拆开:

创建一个 State 对象,其 State.value 是 calculation 的结果。计算结果会被缓存,使得重复调用 State.value 不会导致 calculation 执行多次;但读取 State.value 会导致 calculation 期间读取的所有 State 对象在当前 Snapshot 中被读取,这意味着如果在被观察的上下文中(例如 Composable 函数)读取该值,它会正确地订阅这些派生状态对象。没有 mutation policy 的派生状态在每次依赖变化时触发更新;要避免更新时失效,可以通过 derivedStateOf 的重载提供合适的 SnapshotMutationPolicy。

这段描述包含三个精确的行为层。把它们分开,后面的所有边界才站得住。

下面这张图把 derivedStateOf 的三个行为层串起来,后面的所有边界都从这三层推导出来:

mermaid diagram

依赖追踪:计算路径决定依赖集,不是参数列表决定

derivedStateOf 的追踪是动态的、由实际执行路径决定的。官方文档在讨论“在界面之外使用 Compose 状态”时把这一点说得更直白:读取状态的 .value 会自动将该状态注册为代码块的依赖项;因为追踪是动态的,依赖项在运行时由执行的代码路径决定;如果某个条件分支没有被采用(例如 if 检查或提前 return 之后),该分支内的状态不会被读取,对这些状态的更改也不会触发不必要的重新计算。

这意味着 derivedStateOf 的依赖集可能随着每次重算而变化。一个计算如果是 if (flag.value) a.value else b.value,第一次可能只依赖 flag 和 a,第二次可能只依赖 flag 和 b。运行时记录的是“这一次计算读了哪些 State”,而不是“你希望它依赖哪些 State”。

这条机制带来一个直接后果,也是后面要反复回到的边界:derivedStateOf 只观察快照状态,不观察 Composable 参数。 如果计算里读了一个普通的函数参数,或者读了一个没有用 State 包裹的普通对象,derivedStateOf 不会把它当作依赖。参数变化不会触发重算,计算会继续使用闭包捕获的旧值,或者依赖你手动用 remember(key) 重建 derivedStateOf 本身。

重算时机:读取 .value 时,而不是依赖变化时

一个常见的误解是“依赖变了,derivedStateOf 就自动重新计算”。不是。官方文档的表述是:结果被缓存,重复读取 .value 不会导致重复计算。重算发生在读取 .value 的时候,并且只有当依赖在某个快照中发生了变化、当前缓存被标记为需要重新求值时,读取才会触发一次新的计算。

这个时机边界有两层含义。第一,如果不读 .value,计算永远不会执行;derivedStateOf 是惰性的,它不是一个主动推送的观察者。第二,如果在同一个快照中多次读取 .value,计算只执行一次,后续读取拿到的是缓存值。这与第2课讨论的“快照隔离”是同一套语义:你在一个一致的快照视图里读到的是一个稳定的结果。

通知时机:结果不等才失效,但“不等”由 SnapshotMutationPolicy 决定

derivedStateOf 的下游(通常是读取它的 Composable)只在派生结果发生变化时才被无效化。这正是它作为“过滤器”的价值:输入可以变化很多次,但只要计算结果没变,下游不会重组。

但“结果是否变化”不是由你直接控制的,而是由 SnapshotMutationPolicy 决定的。官方文档明确:没有 mutation policy 的派生状态在每次依赖变化时触发更新;要避免更新时失效,提供合适的 policy。默认策略是 structuralEqualityPolicy(),它用 equals 判断新旧结果是否相等。如果计算返回的是一个每次新建的列表或数据类实例,而 equals 没有正确实现,默认策略会把“结构相同但引用不同”的结果当成变化,过滤器就失效了。反过来,如果你确实希望“每次依赖变化都通知”,可以传入 referentialEqualityPolicy() 或自定义策略,但那就等于放弃了过滤器的核心价值。

一句话收束这一节:derivedStateOf 是一个“读时重算、按结果去重”的惰性状态对象。它的依赖集是运行时由执行路径决定的快照读取集;它的通知时机由 mutation policy 决定;它不观察非快照参数。


二、边界一:derivedStateOf 与普通 remember、remember(key) 的分界

这是实际代码中最容易混用的一组工具。三者在“什么时候重算”和“依赖什么”上的语义完全不同。

三种写法在“依赖来源”和“是否结果去重”上的差异,可以用一张图对齐:

mermaid diagram

普通 remember { ... }:只计算一次,不追踪任何依赖

remember { derivedStateOf { ... } } 中的 remember 负责让 derivedStateOf 创建的 State 对象在重组之间存活。如果没有 remember,每次重组都会创建一个新的 derivedStateOf 对象,它的缓存和依赖订阅全部重置,派生语义完全失效。官方和社区实践都把 remember { derivedStateOf { } } 当作强制包装,而不是可选的优化。

但 remember { ... } 本身不追踪依赖。它只是“在这个组合位置上记住一个值,重组时不重新创建”。依赖追踪是 derivedStateOf 内部的事情,不是 remember 的事情。

remember(key) { ... }:依赖由 key 声明,变化时重建整个值

remember(key) { ... } 的依赖集是显式声明的:只有 key 变化时,remember 才重新计算,并返回新值。它不关心计算过程中读了哪些 State,也不关心这些 State 是否变化。

这里有一个关键的边界对比。假设你要从一个频繁变化的状态中派生一个布尔值:

// 方案 A:remember(key)
val showFab = remember(listState.firstVisibleItemIndex) {
    listState.firstVisibleItemIndex > 0
}
// 方案 B:remember + derivedStateOf
val showFab by remember {
    derivedStateOf { listState.firstVisibleItemIndex > 0 }
}

方案 A 的依赖是 listState.firstVisibleItemIndex 的当前值。每次索引变化,remember 的 key 变化,整个 lambda 重新执行,返回一个新的布尔值。如果 showFab 被读取,读取它的 Composable 会重组——每一次索引变化都会导致读取位置重组,即使布尔值从 true 到 true 没有变化。remember(key) 没有“结果去重”的能力,它的语义是“key 变了就重建”。

方案 B 的依赖是 derivedStateOf 内部对 listState.firstVisibleItemIndex 的快照读取。索引变化时,derivedStateOf 的缓存被标记为需要重算;但只有当 showFab 被读取时,它才重新计算,并且只有当新结果与旧结果不相等时,读取它的 Composable 才会被无效化。布尔值从 true 到 true 时,下游不重组。

这就是“输入频率高于输出频率”这条规则的精确含义。当输入和输出的变化频率相同时,derivedStateOf 是纯开销:它多了一层快照订阅和缓存检查,却没有过滤掉任何一次重组。社区文档把这一点说得毫不含糊:如果形状不对,derivedStateOf 就是“额外的快照订阅,没有过滤收益”。

直接读取:不是“更差”,而是形状不同

如果派生结果只在读取它的那个 Composable 内部使用,而该 Composable 本来就因为其他原因高频重组,或者输入变化频率并不高,那么直接读取可能是更诚实的写法:

// 直接读取:每次索引变化,读取它的 Composable 都会重组
val showFab = listState.firstVisibleItemIndex > 0

这里的边界不是“直接读取一定更好”,而是:derivedStateOf 的价值来自“拦截下游重组”,如果下游本来就会因为其他依赖重组,或者输入变化并不频繁,拦截就没有收益。 先确认重组确实由这个读取驱动,再决定是否需要过滤器。

一句话记住这条边界:remember(key) 声明依赖并重建值,derivedStateOf 追踪运行时读取并只通知结果变化;输入频率不超过输出频率时,后者是多余的一层。


三、边界二:derivedStateOf 与 snapshotFlow 的分界——读侧派生 vs 副作用桥接

这两个 API 经常被放在一起讨论,因为它们的依赖追踪机制在底层有相似之处。但它们的消费模型完全不同,边界也由此划开。

两者的消费模型差异,可以这样对照:

mermaid diagram

derivedStateOf 是“读侧”的派生状态

derivedStateOf 返回一个 State<T>。它的消费者是读取 .value 的组合位置。当派生结果变化时,读取它的 Composable 被无效化并重组。整个机制发生在组合的读取阶段,不涉及协程,不涉及 Flow,不涉及任何“事件”语义。

它适合的场景是:UI 需要根据一个高频变化的输入,决定是否渲染某个东西。比如“列表是否滚过了第一项,决定是否显示 FAB”。这里 showFab 是一个当前状态:用户在任何时刻问“现在该不该显示 FAB”,答案由当前滚动位置决定。derivedStateOf 把这个问题的答案从“每次索引变化都变”压缩成“只在布尔值翻转时变”。

snapshotFlow 是“副作用侧”的事件桥

snapshotFlow 返回一个冷 Flow<T>。它的消费者是收集这个 Flow 的协程,通常在一个 LaunchedEffect 里。它把快照读取转换成 Flow 的发射,并且发射语义是 distinctUntilChanged 式的:只有结果与上一次不相等时才发射。

但官方文档对 snapshotFlow 的定位有一个更深层的区分,值得完整引用:

snapshotFlow 把快照变化建模为事件,但事件不能被有效地建模为可观察状态。可观察状态是对产生它的事件的“有损压缩”。可观察事件发生在某个时间点并被丢弃;事件流中的所有单个事件都被假定为相关的,重复的相等事件也有意义。可观察状态在状态从一个值变为一个新的、不等的值时引发变化事件;状态变化事件被合并,只有最新状态重要。状态变化的观察者必须是幂等的;跳过中间状态或对同一状态运行多次是合法的。

这段区分直接划出了 derivedStateOf 和 snapshotFlow 的边界:

  • derivedStateOf 建模的是状态。 它关心“当前派生值是什么”。跳过中间值、对同一状态不重复通知,都是合法的,因为状态观察者被假定为幂等的。
  • snapshotFlow 建模的是事件。 它关心“发生过什么变化”。虽然它内部也用 equals 去重,但它的设计意图是把快照变化桥接到 Flow 操作符链上,用于副作用:analytics、日志、Snackbar、分页触发等。

一个具体的边界后果是:如果你需要在派生值变化时执行一个动作,derivedStateOf 本身做不到。 它只提供一个 State,读取它只会触发重组,不会触发任何回调。如果你在 derivedStateOf 的计算块里写副作用,那是在一个可能被多次执行、也可能不被执行的计算过程中写副作用,违反了读侧派生的基本契约。动作应该走 snapshotFlow + LaunchedEffect,或者走第4课讨论的一次性事件通道。

反过来,如果你需要的是一个在组合中读取的当前值,用 snapshotFlow 是越界的:它需要一个协程收集器,它的发射是异步的,它不会让读取它的 Composable 自动重组。snapshotFlow 不替代 derivedStateOf 的读侧职责。

社区文档把这两条路径并列得很清楚:Composition 层用 derivedStateOf 处理 UI 可见性;Side channel 用 snapshotFlow 在 LaunchedEffect 中做 analytics 或日志。

一句话记住这条边界:derivedStateOf 是读侧的状态过滤器,让 UI 在派生结果变化时重组;snapshotFlow 是副作用侧的桥,让快照变化进入 Flow 操作符链去执行动作。用前者做动作,是越界;用后者替代读侧重组,也是越界。


四、边界三:依赖集是动态的,所以“非状态变量”不能成为依赖

这是 derivedStateOf 最隐蔽的一条边界,也是社区文档反复标记的“经典陷阱”:捕获非状态变量时,捕获的是初始值,而不是最新值。

考虑下面这段代码:

@Composable
fun Greeting(first: String, last: String) {
    val fullName by remember {
        derivedStateOf { "$first $last" }
    }
    Text(fullName)
}

first 和 last 是普通的 String 参数,不是 State。derivedStateOf 的计算块读取了它们,但不会把它们注册为依赖——因为它只追踪快照状态读取,不追踪参数变化。结果:derivedStateOf 在首次组合时计算出一个 fullName,之后 first 或 last 变化,derivedStateOf 不会重算,Text 永远显示第一次组合时的名字。

修复方式不是“把参数放进某个 key”,而是让 derivedStateOf 的计算块读取快照状态,或者用 remember(first, last) 重建整个派生对象:

// 方案 A:参数作为 remember 的 key,重建 derivedStateOf
val fullName by remember(first, last) {
    derivedStateOf { "$first $last" }
}
// 方案 B:把参数提升为 State,让 derivedStateOf 追踪它们
val firstState = rememberUpdatedState(first)
val lastState = rememberUpdatedState(last)
val fullName by remember {
    derivedStateOf { "${firstState.value} ${lastState.value}" }
}

方案 A 的语义是“参数变化时,重建派生对象”,依赖集由 remember 的 key 显式声明。方案 B 的语义是“派生对象保持存活,依赖集由 derivedStateOf 内部追踪的 State 决定”。两种方案都对,但边界不同:方案 A 的重建成本更高(每次参数变化都重建 derivedStateOf),方案 B 更细粒度,但要求参数确实被 State 包裹。

社区文档给出的标准修复就是 remember(param) { derivedStateOf { ... } }:当参数是依赖来源时,用 remember 的 key 把参数变化纳入派生对象的生命周期。但要注意,这个修复的语义是“参数变,派生对象换”,不是“参数变,派生对象内部重算”。如果你的参数变化非常频繁,而派生结果很少变,方案 B 才是真正的过滤器;方案 A 只是把“参数变化导致重建”换了一个位置,并没有拦截重组。

这条边界可以总结为:derivedStateOf 只认识快照状态。普通参数、普通对象、闭包捕获的外部变量,都不是它的依赖。要让它们成为依赖,要么把它们提升为 State,要么用 remember 的 key 把它们的生命周期绑定到派生对象上。


五、边界四:输入频率与输出频率——它不是“总是更快”,只在特定形状下成立

derivedStateOf 经常被当作“性能优化”的万能标签,但它的收益是有条件的。社区文档用一个简洁的规则概括:输入频率必须超过输出频率;否则 derivedStateOf 是纯开销。

这句话需要拆成两个方向来理解。

方向一:输入高频、输出低频。 这是 derivedStateOf 成立的形状。典型例子是滚动位置驱动一个布尔值:firstVisibleItemIndex 可能在用户滚动时每秒变化几十次,但“是否显示 FAB”只在跨过第一项时翻转一次。derivedStateOf 把几十次输入变化压缩成一次下游通知。官方性能指南也把这个场景作为 derivedStateOf 的标准用例。

方向二:输入频率与输出频率相同,或输入频率更低。 这是 derivedStateOf 不成立的形状。比如把两个 State 相加,每次任一输入变化,结果必然变化——输入频率等于输出频率,derivedStateOf 不会过滤掉任何一次重组,只会增加快照订阅和缓存检查的开销。社区文档明确把“first 和 last 两个名字状态拼字符串”列为不该使用 derivedStateOf 的例子:输入频率等于输出频率,直接读取或普通 remember 就够了。

一个更隐蔽的“不成立”形状是:派生结果被一个本来就因为其他原因高频重组的 Composable 读取。即使输入频率高于输出频率,如果读取位置每次输入变化都因为其他依赖而重组,derivedStateOf 的过滤器就没有拦截到任何东西。在这种情况下,先解决“为什么这个位置在重组”,比套一层 derivedStateOf 更根本。社区文档也提醒,derivedStateOf 不解决“读取阶段错误”的问题,比如在 Modifier.alpha(state.value) 中直接读状态导致的每帧无效化;这类问题应该用延迟读取或 graphicsLayer 解决,而不是派生状态。

这条边界可以总结为:derivedStateOf 的收益 = 输入变化次数 − 输出变化次数。差值越大,过滤器越有意义;差值接近零,它只是一层额外的快照订阅。

频率比与收益的关系可以直观表示为:

mermaid diagram


六、决策框架:什么时候用 derivedStateOf,什么时候不用

把前五节的边界收拢成一个可操作的判断流程。

把五问画成一条判断链,实际写代码时可以顺着走一遍:

mermaid diagram

第一问:这个值是从快照状态派生出来的吗? 如果输入不是 State,而是普通参数或普通对象,derivedStateOf 不会追踪它们。要么把它们提升为 State,要么用 remember(key) 重建派生对象,而不是指望 derivedStateOf 自动感知参数变化。

第二问:输入的変化频率是否显著高于输出的变化频率? 如果输入和输出同步变化,derivedStateOf 是纯开销。直接读取或普通 remember 是更诚实的边界。

第三问:这个值是“读侧”的 UI 状态,还是“副作用侧”的事件? 如果是 UI 读取的当前值,derivedStateOf 是正确工具。如果是需要在变化时执行动作(analytics、Snackbar、分页触发),应该用 snapshotFlow + LaunchedEffect,而不是在 derivedStateOf 里写副作用。

第四问:是否已经用 remember 包裹了 derivedStateOf? 没有 remember 的 derivedStateOf 每次重组都会重建,缓存和订阅全部重置,派生语义失效。这是强制包装,不是可选优化。

第五问:结果类型的 equals 是否可靠? 默认的 structuralEqualityPolicy 用 equals 判断结果是否变化。如果结果是一个每次新建但结构相同的对象,而 equals 没有正确实现,过滤器会把“没变”当成“变了”。需要时提供合适的 SnapshotMutationPolicy,或者让结果类型保持稳定。


七、习题:15 道派生状态边界检验

第 1 题(选择)

derivedStateOf 的依赖集是由什么决定的? A. 创建时传入的参数列表 B. 计算过程中实际读取了哪些 State C. 外层 remember 的 key D. 调用 derivedStateOf 的组合位置

参考答案:B。

解读: 官方文档明确:依赖追踪是动态的,由执行的代码路径决定;如果某个分支没有被采用,该分支内的状态不会被读取,也不会成为依赖。参数列表、remember 的 key、组合位置都不直接定义 derivedStateOf 的内部依赖集。这正是它和 remember(key) 最根本的区别:后者的依赖由 key 显式声明,前者的依赖由运行时实际读取决定。

第 2 题(判断)

derivedStateOf 在依赖变化时会立即重新计算,并立即通知下游。

参考答案:错。

解读: 重算发生在读取 .value 的时候,不是依赖变化的时候。官方文档:结果被缓存,重复读取 .value 不会导致计算执行多次。通知下游也取决于派生结果是否因 mutation policy 而被视为“变化”。derivedStateOf 是惰性的读侧派生,不是主动推送的观察者。把它想象成“依赖变了就自动跑计算并通知”,是把 derivedStateOf 和 snapshotFlow 或某种响应式流的语义混为一谈。

第 3 题(代码分析)

下面代码在 first 或 last 变化时,fullName 会更新吗?为什么?

@Composable
fun Greeting(first: String, last: String) {
    val fullName by remember {
        derivedStateOf { "$first $last" }
    }
    Text(fullName)
}

参考答案: 不会更新。first 和 last 是普通 String 参数,不是快照 State。derivedStateOf 只追踪计算过程中读取的 State,不追踪参数变化。fullName 在首次组合时计算一次,之后参数变化不会触发重算,Text 永远显示初始值。修复方式:用 remember(first, last) { derivedStateOf { ... } } 重建派生对象,或者把参数提升为 State 并在计算块中读取 .value。

解读: 这是社区文档标记的“经典陷阱”:捕获非状态变量时,捕获的是初始值。根源在于 derivedStateOf 的追踪边界:它只认识快照状态,不认识组合参数。很多人会把“derivedStateOf 追踪依赖”误解为“它追踪计算块里提到的所有变量”,实际上它追踪的是“计算块里实际读取的 State 对象”。普通参数只是闭包捕获,不参与快照依赖注册。

第 4 题(简答)

remember(key) { ... } 和 remember { derivedStateOf { ... } } 在“什么时候重算”上有什么本质区别?

参考答案: remember(key) 的重算由 key 变化触发,重算时整个 lambda 重新执行并返回新值;它没有“结果去重”能力,key 一变,读取该值的位置就会重组,即使新值与旧值相等。derivedStateOf 的重算由“读取 .value 且缓存需要重新求值”触发,它内部追踪快照依赖;只有当新结果与旧结果在 mutation policy 下不相等时,读取它的位置才会被无效化。前者是“key 变就重建”,后者是“读时按需重算,结果变才通知”。

解读: 这道题考的是把两者从“性能工具”的模糊印象还原为不同的语义机制。remember(key) 的依赖是显式的、声明式的;derivedStateOf 的依赖是隐式的、运行时追踪的。remember(key) 不做结果去重,所以它不能替代 derivedStateOf 的过滤器角色;derivedStateOf 不观察参数,所以它不能替代 remember(key) 的“参数变化重建”角色。两者不是同一件事的两种写法,而是两个不同语义的工具。

第 5 题(选择)

下列哪个场景最适合使用 derivedStateOf? A. 把两个频繁同步变化的 State 相加 B. 根据滚动位置判断是否显示“回到顶部”按钮 C. 在某个值变化时发送 analytics 事件 D. 替代 ViewModel 保存跨配置变更的业务状态

参考答案:B。

解读: 滚动位置高频变化,布尔值低频翻转,是 derivedStateOf 的标准形状:输入频率显著高于输出频率,过滤器有实际收益。A 是输入频率等于输出频率,derivedStateOf 是纯开销。C 是副作用,应该用 snapshotFlow + LaunchedEffect,而不是在读侧派生里写动作。D 是生命周期持久化,属于 ViewModel 或 rememberSaveable 的职责;derivedStateOf 不提供跨组合实例或跨进程的状态存活。

第 6 题(判断)

derivedStateOf 可以在计算块里安全地执行副作用,比如打日志或发网络请求。

参考答案:错。

解读: 计算块是一个可能被多次执行、也可能不被执行的读侧计算。derivedStateOf 的契约是:读取 .value 时按需重算,结果被缓存。在计算块里写副作用,意味着副作用的执行次数和时机由读取行为决定,这是不可预测的。官方对 snapshotFlow 的 block 明确要求“幂等且无副作用”;derivedStateOf 的计算块同理,它是派生值的地方,不是执行动作的地方。动作应该走 effect 通道,而不是寄生在派生计算里。

第 7 题(代码分析)

下面代码想“只在 count 跨过 10 时显示一条日志”。它有什么问题?应该怎么改?

val showLog by remember {
    derivedStateOf {
        if (count > 10) {
            Log.d("Count", "crossed 10")
            true
        } else false
    }
}
Text(if (showLog) "big" else "small")

参考答案: 问题在于副作用被放在了 derivedStateOf 的计算块里。count 每次变化,读取 showLog 时计算块可能重新执行;count 在 10 附近波动时,日志会被反复打印,且打印次数取决于下游读取频率,不可控。正确做法:用 snapshotFlow { count > 10 }.distinctUntilChanged().filter { it }.collect { Log.d(...) } 放在 LaunchedEffect 中,让“跨越阈值”作为一个事件被消费;UI 显示仍然用 derivedStateOf 或直接读取布尔值。

解读: 这道题把“读侧派生”和“副作用桥接”的边界放到了具体代码里。derivedStateOf 只能回答“当前派生值是什么”,它不回答“派生值什么时候发生了变化、变化了几次”。后一个问题属于事件模型,应该用 snapshotFlow 的 Flow 操作符来处理。社区文档把这两条路径并列得很清楚:Composition 层用 derivedStateOf 处理可见性,Side channel 用 snapshotFlow 处理 analytics 或日志。把副作用塞进派生计算,是把读侧工具当成了事件工具用,行为不可预测。

第 8 题(简答)

derivedStateOf 和 snapshotFlow 都能“在依赖变化时做点什么”,它们的消费模型有什么本质不同?

参考答案: derivedStateOf 返回 State<T>,消费者是读取 .value 的组合位置;结果变化时,读取位置被无效化并重组。它是读侧的、同步的、面向 UI 当前状态的。snapshotFlow 返回 Flow<T>,消费者是收集它的协程;它把快照变化建模为事件,发射到 Flow 操作符链中,用于执行副作用。它是副作用侧的、异步的、面向“发生过什么”的。derivedStateOf 建模状态,状态观察者被假定为幂等的;snapshotFlow 建模事件,事件流中的单个事件被假定为相关的。

解读: 这道题考的是官方文档里一个容易被跳过的深层区分:状态和事件是两种不同的建模对象。derivedStateOf 处在状态这一侧:它关心“现在是什么”,跳过中间值、对同一状态不重复通知都是合法的。snapshotFlow 处在事件这一侧:它关心“发生了什么变化”,虽然内部也用 equals 去重,但它的设计意图是把变化交给 Flow 操作符去执行动作。把两者互换使用,会同时破坏两边的语义:用 derivedStateOf 做动作用户无法控制执行次数;用 snapshotFlow 替代读侧重组则缺少“读取即订阅”的机制。

第 9 题(判断)

“输入变化频率高于输出变化频率”是使用 derivedStateOf 的充分必要条件。

参考答案:错(过于绝对)。 它是一个必要的形状条件,但不是充分条件。还需要满足:依赖是快照状态、derivedStateOf 被 remember 包裹、结果类型的 equals 可靠、读取位置确实会因为派生结果变化而重组(而不是因为其他依赖高频重组)。如果读取位置本来就在高频重组,derivedStateOf 的过滤器拦截不到东西;如果结果 equals 不稳定,过滤器会把“没变”当成“变了”。频率比是判断的起点,不是全部。

解读: 社区文档把“输入频率必须超过输出频率”作为核心规则,但这道题考的是不要把它变成新的万能口诀。derivedStateOf 的收益是“拦截下游重组”,如果下游本来就因为其他原因在重组,或者结果比较机制失效,频率比满足也不产生实际过滤。决策框架里的五问是并列的,不是只有频率一问。

第 10 题(选择)

derivedStateOf 默认的 SnapshotMutationPolicy 是? A. referentialEqualityPolicy(),引用不等就视为变化 B. structuralEqualityPolicy(),equals 不等就视为变化 C. neverEqualPolicy(),总是视为变化 D. 没有默认策略,必须显式传入

参考答案:B。

解读: 官方文档:没有 mutation policy 的派生状态在每次依赖变化时触发更新;要避免更新时失效,提供合适的 policy。默认策略是结构相等(structuralEqualityPolicy),用 equals 比较新旧结果。这意味着如果结果类型的 equals 实现不当,派生状态的“结果去重”会失效:结构相同但引用不同的对象会被当成变化,下游收到不必要的通知。referentialEqualityPolicy 和 neverEqualPolicy 是可选策略,不是默认。C 是最反过滤的策略,会让 derivedStateOf 退化成“每次依赖变化都通知”。D 错误:derivedStateOf 有一个接受 policy 的重载,也有不带 policy 的默认重载。

第 11 题(代码分析)

下面代码在功能上是否正确?如果 firstVisibleItemIndex 变化很快,它的性能收益是否一定成立?请指出它真正依赖的边界条件。

val showFab = remember {
    derivedStateOf { listState.firstVisibleItemIndex > 0 }
}

参考答案: 功能上是正确的:remember 让派生对象跨重组存活,derivedStateOf 追踪 firstVisibleItemIndex 的快照读取,布尔值只在翻转时通知下游。但性能收益不一定成立。它依赖两个边界条件:第一,读取 showFab.value 的 Composable 不能同时直接读取 firstVisibleItemIndex——如果直接读取,该 Composable 每次索引变化都会重组,derivedStateOf 的过滤器被绕过;第二,读取位置本身不能因为其他依赖高频重组。如果这两个条件不满足,derivedStateOf 的缓存检查和快照订阅就是纯开销。

解读: 这道题故意设置了一个“语法正确但边界不一定成立”的场景。很多教程把 derivedStateOf 当成“只要套上就优化”的工具,但它的收益取决于消费关系:谁在读它、读它的位置是否本来就会重组。官方文档在讨论 derivedStateOf 时强调,它不解决“读取阶段错误”的问题——比如在绘制阶段直接读状态导致的每帧无效化,应该用延迟读取解决。这道题的真正考点是:derivedStateOf 的过滤器只对“读取它的位置”生效,不对“同一个 Composable 里的其他直接读取”生效。

第 12 题(场景设计)

一个搜索框需要在用户输入时实时显示结果数量,但结果数量只在变化时才更新 UI;同时,每次数量变化需要上报一次 analytics。请分别设计“UI 显示”和“analytics 上报”的实现,并说明为什么不能只用一个 derivedStateOf 同时完成两件事。

参考答案: UI 显示用 derivedStateOf:val count by remember { derivedStateOf { results.size } },在 Composable 中读取 count;只有 size 变化时,读取它的位置才重组。Analytics 上报用 snapshotFlow { results.size }.distinctUntilChanged().collect { size -> analytics.track("result_count", size) } 放在 LaunchedEffect 中。不能只用一个 derivedStateOf 的原因:derivedStateOf 是读侧状态,它的计算块可能在读取时执行多次,也可能在没人读取时不执行;它不提供“每次结果变化执行一次动作”的语义。如果在计算块里发 analytics,上报次数会取决于下游读取频率和快照调度,不可控。

解读: 这道题把第4课的一次性事件边界和本课的派生状态边界放在一起。derivedStateOf 回答“当前数量是多少”,适合驱动 UI;snapshotFlow 回答“数量变化的事件流”,适合驱动副作用。两者不是替代关系,而是读侧和副作用侧的分工。社区文档把这个模式列为标准实践:Composition 层用 derivedStateOf,Side channel 用 snapshotFlow。

第 13 题(判断)

derivedStateOf 的计算块里读取的 State 越多,它的性能开销就一定越大。

参考答案:错(不准确)。 计算块读取的 State 数量影响依赖集的规模,但 derivedStateOf 的核心开销不在于“读了多少个 State”,而在于:每次读取 .value 时的缓存检查、依赖变化后的重算成本、以及结果比较的成本。如果计算本身很轻(比如布尔比较),读几个 State 不是主要问题;如果计算很重,或者结果比较的 equals 很昂贵,即使只读一个 State,开销也可能显著。更准确的表述是:derivedStateOf 的开销应该与“它拦截掉的重组次数”比较;如果拦截收益大于缓存和重算成本,它才值得用。

解读: 社区文档把 derivedStateOf 描述为“额外的快照订阅”,但“订阅开销”不是一个与依赖数量简单成正比的量。这道题考的是避免把性能问题简化为“少读几个 State”。真正的决策依据是频率比和拦截收益,不是依赖数量的绝对值。另外,如果计算块里有条件分支,实际依赖集是动态的,某次计算可能读得少,某次可能读得多;这不是“读得越多越慢”的线性关系,而是“执行路径决定依赖集”的机制。

第 14 题(简答)

如果 derivedStateOf 的计算结果是一个 List,而这个 List 每次计算都新建但内容相同,会发生什么?如何修复?

参考答案: 默认的 structuralEqualityPolicy 用 equals 比较新旧 List。如果 List 的 equals 正确实现(ArrayList、listOf 等标准实现会按元素比较),内容相同的两个列表会被视为相等,下游不会因为“新实例”而被通知。但如果结果是一个自定义类型且没有正确实现 equals,或者结果是一个数组(数组的 equals 是引用比较),默认策略会把“内容相同但实例不同”当成变化,derivedStateOf 的过滤器失效。修复方式:让结果类型使用可靠的 equals(数据类、标准集合、或手动实现),或者提供一个按内容比较的 SnapshotMutationPolicy,而不是依赖默认的引用比较行为。

解读: 这是 derivedStateOf 的“结果比较”边界。它的通知语义不是“只要重算了就通知”,而是“重算后,新结果与旧结果在 mutation policy 下不相等才通知”。如果结果类型的相等性不可靠,过滤器就会漏掉本应被拦截的通知。官方文档在讨论 mutation policy 时明确指出,没有 policy 的派生状态在每次依赖变化时触发更新;提供合适的 policy 可以避免更新时失效。对于集合或自定义类型,选择正确的 policy(或确保 equals 可靠)是让 derivedStateOf 按预期工作的前提。

第 15 题(综合简答)

有人说:“derivedStateOf 就是 Compose 版的 Flow.map,把输入状态映射成输出状态。”评价这个说法,并说明 derivedStateOf 在架构上不可替代的职责是什么。

参考答案: 这个说法方向对了一半,但混淆了两类模型。derivedStateOf 确实做“从输入状态计算输出状态”,但它不是 Flow.map:它是同步的、读侧的、由读取行为驱动的,输出是一个 State,消费者是组合位置;Flow.map 是异步的、流侧的,输出是冷数据流,消费者是收集器。derivedStateOf 不提供 Flow 操作符链(debounce、flatMapLatest、catch),也不建模事件顺序。它在架构上不可替代的职责是:在组合的读取阶段,把一个高频变化的快照输入压缩成一个低频变化的派生状态,使 UI 只在语义结果变化时重组,而不需要在每次输入变化时重组。 这个职责属于读侧状态派生,不能由 snapshotFlow(副作用侧)或 remember(key)(无结果去重)替代。

解读: 这道题的价值在于防止把 derivedStateOf 泛化成“任何状态转换工具”。derivedStateOf 的不可替代性恰恰来自它的限制:它只做读侧、只追踪快照、只按结果去重。如果把这些限制去掉,它要么变成 Flow.map(失去“读取即订阅”的组合语义),要么变成 remember(key)(失去过滤器能力)。社区文档把 derivedStateOf 和 snapshotFlow 并列,而不是把它们说成同一类工具,正是因为读侧状态和副作用侧事件是两种不同的建模对象。理解这个区分,才能理解 derivedStateOf 在架构中的位置:它是组合读取阶段的一个过滤器,不是通用状态转换管道。


八、本节课知识点总结

底层机制。 derivedStateOf 创建一个惰性的 State,其 .value 是计算块的结果。依赖集由计算过程中实际读取的快照 State 动态决定,不受参数列表控制;重算发生在读取 .value 且缓存需要更新时;下游只在结果按 SnapshotMutationPolicy 被视为变化时才被无效化。默认策略是 structuralEqualityPolicy,用 equals 比较结果。

与 remember 的边界。 remember { derivedStateOf { } } 中的 remember 负责让派生对象跨重组存活,是强制包装;derivedStateOf 负责依赖追踪和结果去重。remember(key) 声明依赖并重建值,不做结果去重;它不能替代 derivedStateOf 的过滤器角色。derivedStateOf 只观察快照状态,不观察普通参数;参数依赖需要 remember(param) 重建派生对象,或把参数提升为 State。

与 snapshotFlow 的边界。 derivedStateOf 是读侧的状态过滤器,消费者是读取 .value 的组合位置;snapshotFlow 是副作用侧的事件桥,消费者是收集 Flow 的协程。derivedStateOf 建模状态,观察者幂等、可跳过中间值;snapshotFlow 建模事件,用于动作,不应与读侧派生混用。

频率边界。 derivedStateOf 的收益来自“输入频率高于输出频率”;频率比不满足时,它是一层额外的快照订阅,没有过滤收益。它不解决读取阶段的问题,也不替代延迟读取或稳定性修复。

结果比较边界。 默认策略用 equals 判断结果是否变化。结果类型的相等性不可靠时,过滤器会把“没变”当成“变了”。必要时提供合适的 SnapshotMutationPolicy,而不是假设默认行为总是符合预期。

决策框架。 五问:输入是快照状态吗;输入频率是否高于输出频率;是读侧 UI 状态还是副作用侧事件;是否用 remember 包裹;结果的 equals 是否可靠。

一句话收束: 第3课的 remember 回答“值存在哪儿”,第4课的 effect 回答“动作拴在哪儿”,第5课的组合身份回答“哪儿本身由什么定义”,这一课回答的是:一个值如何从别的值中派生出来,而这个派生过程只在“读时重算、结果去重、输入频率高于输出频率”这三条边界同时成立时,才是一个过滤器,而不是一层多余的开销。 derivedStateOf 不是“更聪明的 remember”,它是读侧状态压缩的专用工具。知道它不做什么,比知道它能做什么更重要。


九、下期预告

第7课:Modifier 的边界在哪里?——绘制阶段、布局阶段与“状态读取发生在哪一层”

第6课讲的是“值如何派生”,但派生值最终要落到 UI 上。derivedStateOf 解决的是“读取时不要读太早、不要读太多”的问题,而 Compose 中另一个更深的阶段边界在 Modifier 里:同一个 State 读取,放在组合阶段、布局阶段还是绘制阶段,代价完全不同。

Modifier.offset { }、Modifier.graphicsLayer { }、Modifier.drawBehind { } 这些 lambda 式 modifier 把状态读取推迟到了布局或绘制阶段,从而绕过了组合和重组。但“推迟”不是免费的:它改变了无效化的范围,也改变了你能否在 modifier 内部安全地读取某些状态。Modifier.alpha(state.value) 和 Modifier.alpha { state.value } 看起来只差一对花括号,实际决定了每一帧是触发重组还是只触发重绘。

下一课拆三件事:Compose 的“阶段”(组合 → 布局 → 绘制)如何决定状态读取的代价;lambda modifier 为什么能把高频读取挡在组合之外;以及 derivedStateOf 和 lambda modifier 在“减少重组”这件事上的分工——一个管“读时去重”,一个管“读在正确的阶段”。第6课讲的是派生值的过滤器,第7课讲的是读取行为发生在哪一层,以及为什么“在哪一层读”比“读什么”更决定性能。