罗罗编程学习记录
本页内容 展开查看

07.2.2.7 列表、图片与动画性能

所属:全栈开发面试题库 / 07 端侧与桌面开发 / 07.2 跨平台移动开发 / 07.2.2 React Native

本节要解决的问题

  • VirtualizedList 的渲染窗口到底怎么工作,为什么 ScrollView 包全部数据会卡死?
  • key、extraData、getItemLayout、initialNumToRender、windowSize 这些参数各自解决什么问题?
  • FlashList 比 FlatList 快在哪里,什么场景下收益不明显?
  • 图片在 RN 里是怎么解码的,为什么列表头像墙会让内存暴涨?
  • Animated 与 useNativeDriver 的原理是什么,为什么它能让动画在 JS 掉帧时依然流畅?
  • Reanimated 的 worklets 到底把代码搬到了哪里执行?
  • 帧率怎么度量,JS 帧率与 UI 帧率分别是什么口径?
  • 性能问题来了,定位顺序到底是先看 JS、先看 UI、先看图片还是先看视图数量?

版本前提:本页涉及的 VirtualizedList/FlatList 参数语义、FlashList、Reanimated、Lottie、gesture-handler 均独立演进,具体字段名、默认值、新架构下行为以各库最新文档为准;版本敏感项标注「待确认」。

覆盖范围

知识域 关键内容
虚拟化原理 VirtualizedList 渲染窗口、CellRenderer、回收复用、参数调优
FlatList/SectionList 常见坑、onEndReached、separators、空态
FlashList 复用机制、收益边界、与 FlatList 迁移
图片 解码时机、缓存层级、尺寸控制、渐进式加载、头像墙
动画 Animated、useNativeDriver、Reanimated worklets、LayoutAnimation、Lottie
手势与度量 手势与滚动协同、帧率口径、性能定位顺序

题号索引

题号区间 主题
001-003 VirtualizedList 原理、关键参数、回收复用
004-006 FlatList 常见坑、SectionList、FlashList 对比
007-009 长列表内存、图片解码、图片库选型与缓存层级
010-012 Animated 与 useNativeDriver、Reanimated worklets
013-014 LayoutAnimation、Lottie、手势与滚动协同
015-016 帧率口径、性能定位顺序
017-018 综合题:电商长列表首页卡顿排查、列表项重渲染治理

07.2.2.7-001 VirtualizedList 的虚拟化原理是什么?

一句话结论

VirtualizedList 只渲染"渲染窗口"内的条目(屏幕可见区 + 上下缓冲区),窗口外的条目从原生视图树卸载,回收给新进入窗口的条目复用;这样无论数据有多少条,原生视图树里同时存在的节点数是常数。

概念解释

核心概念有三个:

  • 渲染窗口(render window):由 initialNumToRender(首屏渲染数)、windowSize(窗口外缓冲,单位是屏幕高度倍数)、maxToRenderPerBatch(每批渲染上限)共同决定。它不是"可见区",而是"可见区 + 缓冲区",让快速滚动时新条目已经准备好。
  • CellRenderer:每个条目外层包一个 CellRenderer,它负责测量条目布局、决定何时挂载/卸载、处理 focus 等。这层抽象让 VirtualizedList 可以在不同平台上优化挂载。
  • 回收复用:在旧架构下,视图是"创建即创建,卸载即销毁";在新架构(Fabric)下,视图可以被回收(view recycling),进入窗口的条目复用已有原生视图而不是新建。具体回收策略与版本、平台有关(待确认)。

数据流上:数据数组本身不虚拟化,全量存在内存里;虚拟化的是"原生视图树"里挂载的条目数。

还要注意:VirtualizedList 默认假设条目高度不均匀,会在滚动过程中动态测量。如果条目高度固定,提供 getItemLayout 可以跳过测量,大幅提升定位性能。

原理流程

列表滚动:
  1. 计算当前可见 offset 与可见范围
  2. 扩展 windowSize 倍得到渲染窗口
  3. 窗口内的 data[i] 对应 React 组件(若未挂载则挂载)
  4. 窗口外的条目卸载(或回收)
  5. 新进入窗口的条目复用已卸载的视图(若开启回收)

代码或图示

data = [1,2,3,...,10000]
屏幕可见:[100, 101, 102]
渲染窗口(windowSize=3):[97 ... 105]
原生视图树里只挂载这 9 个条目,其余 9991 条不占视图节点

常见误区

  • 误区:数据数组也会被虚拟化;正解:data 全量在内存,虚拟化的是视图挂载。
  • 误区:窗口外的条目数据被丢弃;正解:数据还在,只是没渲染。

追问

  • Q:为什么长列表滚动会掉帧?A:滚动过程中新条目不断进入窗口,每帧要创建/更新视图、跑布局、解码图片,超过 16.7ms 就掉帧。
  • Q:windowSize 越大越好吗?A:大则滚动更流畅但内存占用高、首屏渲染多,默认值(21,待确认)是权衡,要按场景调。

07.2.2.7-002 key、extraData、getItemLayout 各解决什么问题?

一句话结论

key(或 keyExtractor)是条目的身份,让 VirtualizedList 能正确复用组件而不是重建;extraData 是"列表之外的变化",它变化时强制重渲染所有条目;getItemLayout 让列表跳过测量直接定位条目,长列表滚动定位更快。

概念解释

keyExtractor 必须返回稳定且唯一的字符串 id。如果用 index 当 key,当数据排序变化、删除插入时,组件会被错误地复用到别的条目上,导致状态错乱(输入框串、图片错)。稳定 key 是 React 复用组件的基础。

extraData 是当列表数据 data 引用没变但条目内容依赖外部变量(如列表的选中态、主题)时,需要把那个外部变量传给 extraData,列表才会重渲染。常见错误是直接在 renderItem 里闭包了一个外部变量,但 data 没变化,列表不重渲染。

getItemLayout 是"我知道第 i 条的精确位置":{ length, offset, index }。提供后列表不需要逐条目测量就能滚动到指定位置(scrollToIndex),首屏定位也更快。代价是条目高度必须固定,动态高度不能用。

原理流程

滚动到 index=1000:
  无 getItemLayout:
    从 index=0 开始逐条测量高度累加 → 慢,且可能闪烁
  有 getItemLayout:
    offset = getItemLayout(data, 1000).offset → 直接跳

代码或图示

参数 作用 不提供的后果
keyExtractor 条目身份 复用错误、状态串
extraData 外部变化触发重渲染 选中态/主题不刷新
getItemLayout 跳过测量 scrollToIndex 慢或报警

常见误区

  • 误区:用 item.id 但 id 可能重复;正解:必须全局唯一,重复会导致 React 报错或复用语义错误。
  • 误区:extraData 传整个对象;正解:传会变化的那个原子值(如 selectedId),否则引用每次都变等于无效优化。

追问

  • Q:动态高度列表怎么优化?A:用 onLayout 测量并缓存每条高度,或用 onViewableItemsChanged 配合估算;不要用 getItemLayout。
  • Q:key 用 id 还是 id+index?A:用 id;只有 id 本身在条目中不稳定时才加 index,但那样会失去复用。

07.2.2.7-003 initialNumToRender、windowSize、maxToRenderPerBatch 怎么调?

一句话结论

这三个参数决定"首屏渲染多少、缓冲区多大、每批最多建多少":首屏要够一屏多一点,缓冲区保证快滑不白屏,每批数控制单次 JS 工作量。调参的目标是首屏快、滚动不白屏、滚动时不卡。

概念解释

initialNumToRender 是首屏挂载的条目数。太小会出现首屏下面一片空白要等下一批;太大会拖慢首屏。经验值是"一屏能显示的条目数 × 1.5"。

windowSize 是缓冲区高度的屏幕倍数。它决定离屏多远的条目就开始渲染。大则快速滚动不白屏,但内存与视图节点多;小则省内存但快滑时白屏。

maxToRenderPerBatch 是滚动过程中每帧最多新增渲染的条目数。它控制"一帧内 JS 工作量",避免滚动时一帧要建 20 个视图导致掉帧。

原理流程

首屏:渲染 initialNumToRender 条
滚动:每批最多 maxToRenderPerBatch 条
缓冲区:windowSize 屏高
三者共同决定"在任何时刻视图树里有多少条目"

代码或图示

参数 默认值(待确认) 调大的影响 调小的影响
initialNumToRender 10 首屏慢 首屏白屏
windowSize 21 内存高 快滑白屏
maxToRenderPerBatch 10 每帧重 快滑跟不上

常见误区

  • 误区:把 windowSize 调到 100;正解:那等于把整个列表都渲染了,虚拟化失效。
  • 误区:maxToRenderPerBatch 调大让滚动更快;正解:单帧 JS 工作量变大,反而掉帧。

追问

  • Q:怎么知道当前参数合不合适?A:开发者工具里观察视图树节点数、首屏时间、滚动时白屏比例,调参后对比。
  • Q:新架构下这些参数还重要吗?A:视图回收更高效了,但 JS 渲染工作量与首屏时间依然由这些参数决定。

07.2.2.7-004 FlatList 有哪些高频坑?

一句话结论

最常见的坑:用 ScrollView 包全部数据、onEndReached 触发时机不对、renderItem 内联函数导致全列表重渲染、extraData 缺失、空态与错误态未处理。

概念解释

ScrollView 不虚拟化,传入 1000 条数据会一次性挂载 1000 个原生视图,首屏慢且内存爆炸。这是入门最常见错误。

onEndReached 在列表滚动到距底部 onEndReachedThreshold(如 0.5 即半屏)时触发,不是"滚到底才触发"。它会被连续触发,必须用 loading 标志防止重复请求。

renderItem={({item}) => <Row item={item}/>} 这种内联箭头函数每次列表渲染都会新建,FlatList 内部的 PureComponent 比较失效,导致所有条目重渲染。要把 renderItem 提到组件外或用 useCallback。

原理流程

错误模式:
  <ScrollView>{data.map(<Row/>)}</ScrollView>   ← 全部挂载
  <FlatList renderItem={({item}) => ...} />    ← 每次新建函数
  onEndReached={loadMore}                      ← 无 loading 防重

正确模式:
  <FlatList data renderItem={Row} onEndReached={...} refreshing />

代码或图示

坑 现象 修复
ScrollView 包数据 首屏慢、内存高 换 FlatList
onEndReached 重复 重复请求 loading 标志
renderItem 内联 全列表重渲染 提为外部组件
无 extraData 选中态不更新 传 extraData
空态 空白屏 ListEmptyComponent

常见误区

  • 误区:FlatList 不能嵌套 ScrollView;正解:可以,但要锁方向,且嵌套垂直滚动要谨慎。
  • 误区:ItemSeparatorComponent 每次渲染都新建;正解:要把它定义为外部组件,否则每条都新建。

追问

  • Q:下拉刷新怎么加?A:用 refreshing 与 onRefresh props,不要自己包 ScrollView。
  • Q:置顶功能怎么实现?A:用 scrollToOffset ref,配合 getItemLayout 定位,不要自己维护滚动位置。

07.2.2.7-005 SectionList 适合什么场景,有什么坑?

一句话结论

SectionList 是带分组标题的列表,每组一个 section 对象({ title, data })。它适合联系人列表、商品分类、设置页;坑在于分组数量多时头部粘性行为与 section 切换性能。

概念解释

SectionList 在 FlatList 之上增加了 section 概念:sections prop 是数组,每项是 { title, data, key },renderSectionHeader 渲染组头。粘性头部由 stickySectionHeadersEnabled 控制(Android 默认 true,iOS 默认 true,待确认)。

性能坑:当 section 数量很多(如联系人按字母分 26 组)时,section 头切换、section 之间的 separator 会成为额外开销;每组内部数据量差异大时要注意 getItemLayout 不能简单用统一高度。

原理流程

sections = [
  { title: 'A', data: [联系人1, 联系人2] },
  { title: 'B', data: [...] },
]
渲染:A头 → A1 → A2 → B头 → B1 ...
粘性:滚动时当前 section 头吸顶

代码或图示

<SectionList
  sections={[{ title: 'A', data: listA, key: 'A' }]}
  renderItem={({ item }) => <Row item={item} />}
  renderSectionHeader={({ section }) => <Header title={section.title} />}
  stickySectionHeadersEnabled
/>

常见误区

  • 误区:SectionList 就是 FlatList 加表头;正解:它内部是独立实现,行为差异(如 section 之间的复用)要单独测。
  • 误区:粘性头部在两端行为完全一致;正解:Android 与 iOS 的粘性头部动画与层级略有差异,以实测为准。

追问

  • Q:分组很多时怎么优化?A:减少每组内 separator 数量、用 FlashList 替代(若支持 section,待确认)、避免组头复杂布局。
  • Q:联系人侧边索引怎么实现?A:自定义悬浮字母条,点击调 scrollToLocation 定位到对应 section。

07.2.2.7-006 FlashList 比 FlatList 快在哪,什么时候收益不明显?

一句话结论

FlashList(Shopify 开源)用更强的视图回收机制(条目视图回收 + 布局缓存)替代 FlatList 的"卸载即销毁",在长列表与复杂条目场景下显著降低首屏与滚动开销;但当条目极简单、数据量小、或瓶颈在图片解码而非视图创建时,收益不明显。

概念解释

FlatList 在旧架构下视图离开窗口就被销毁,进入窗口要重新创建原生视图。FlashList 的核心是"视图回收池":离开窗口的视图不销毁,标记为可用,新进入窗口的条目直接复用,省去创建与挂载成本。同时它改进了布局缓存,避免重复测量。

收益边界:当瓶颈不在视图创建而在图片解码、JS 计算、过度绘制时,换 FlashList 不会有明显提升。条目极其简单(一行文字)时,FlatList 本身也够快,FlashList 收益有限。

原理流程

FlatList:
  条目出窗 → 销毁原生视图
  条目进窗 → 创建新视图 → 挂载 → 布局

FlashList:
  条目出窗 → 视图标记可用
  条目进窗 → 从回收池取视图 → 更新 props → 上屏

代码或图示

维度 FlatList FlashList
视图回收 弱(旧架构) 强(回收池)
布局缓存 一般 改进
迁移成本 - 中等(API 对齐)
收益场景 短列表 长列表、复杂条目

常见误区

  • 误区:换 FlashList 就自动解决图片问题;正解:图片解码与缓存要单独优化。
  • 误区:FlashList 完全兼容 FlatList API;正解:部分 props(如 onEndReachedThreshold 语义)与行为有差异,迁移要回归。

追问

  • Q:新架构下 FlashList 还必要吗?A:Fabric 自带视图回收,FlashList 的相对优势会缩小,但布局与测量优化仍有价值(待确认)。
  • Q:迁移 FlashList 风险?A:先在非关键页面试点,对比帧率与内存,再全量。

07.2.2.7-007 长列表的内存与视图数量怎么控制?

一句话结论

内存来自三部分:数据数组本身、图片解码缓存、原生视图节点数。视图节点数由渲染窗口决定,图片缓存要主动设上限,数据数组大时考虑分页或窗口化数据。

概念解释

每个原生视图节点占内存(视图对象、layout、绘制缓存)。即使条目"看不见",只要还在渲染窗口里就占内存。所以 windowSize 不能盲目调大。

图片是另一个大头:一张 1080×1920 的图解码成 Bitmap 后占内存是 宽×高×4字节(约 8MB),即使显示在 100×100 的 ImageView 里。列表里 100 张这样的图就是 800MB,必崩。

原理流程

内存构成:
  数据数组(JS 堆)  ← 分页 / 窗口化
  图片解码缓存       ← 尺寸适配 + 缓存上限
  原生视图节点       ← windowSize 控制

代码或图示

内存来源 量级 控制手段
数据数组 中 分页加载
图片解码 大 服务端返回尺寸适配图
视图节点 中 windowSize + 回收

常见误区

  • 误区:图片显示小就不占内存;正解:内存按解码后尺寸算,与显示尺寸无关。
  • 误区:列表滚出屏幕图片自动释放;正解:缓存策略决定释放时机,默认缓存可能保留很久。

追问

  • Q:怎么知道是图片还是视图导致内存高?A:用开发者工具看内存增长曲线,滚到不同位置观察峰值,截图取 native heap。
  • Q:OOM 崩溃怎么定位?A:看崩溃栈与机型内存配置,重点怀疑大图与未释放的图片缓存。

07.2.2.7-008 RN 的图片是怎么解码的?

一句话结论

图片显示流程是"下载 → 磁盘缓存 → 解码成位图 → 上传 GPU 纹理 → 绘制";解码是 CPU 操作、发生在显示前,尺寸过大时会阻塞 JS 线程或工作线程,是长列表卡顿的常见元凶。

概念解释

RN 原生 Image 组件默认在加载时解码。Android 用 BitmapFactory,iOS 用 ImageIO。关键问题:一张大图即使显示尺寸很小,也会按原始尺寸解码。服务端如果不做尺寸适配,客户端就必须自己降采样。

现代图片库(如 expo-image、FastImage)支持:渐进式加载(先显示模糊图再显示清晰图)、降采样(按显示尺寸解码)、缓存优先级(LRU)、GIF/WebP 动图优化。

原理流程

URL → 下载 → 磁盘缓存
  → 解码:原始位图(CPU)
  → 缩放到显示尺寸(若支持降采样)
  → 上传 GPU 纹理
  → 绘制到视图

代码或图示

阶段 位置 成本
下载 工作线程 网络
解码 工作线程/JS CPU
上传 GPU GPU 显存
绘制 UI 线程 合成

常见误区

  • 误区:图片加载慢是网络问题;正解:很多时候是解码慢,特别是大图。
  • 误区:用 resizeMode 就能降采样;正解:resizeMode 只是绘制时缩放,解码仍是原始尺寸。

追问

  • Q:怎么让图片按显示尺寸解码?A:用支持降采样的图片库,或服务端返回按尺寸的 URL(如加 width/height 参数)。
  • Q:列表里的头像墙怎么优化?A:头像用小尺寸 URL(如 100×100),不要用原图;用统一头像组件带缓存。

07.2.2.7-009 图片库怎么选型,缓存层级怎么设计?

一句话结论

原生 Image 能用但功能弱;复杂场景选社区图片库(expo-image、react-native-fast-image 等,具体可用性与维护状态待确认),缓存分三级:内存(LRU 位图)、磁盘(下载文件)、网络;命中率与缓存上限要主动配置。

概念解释

原生 Image 的问题:默认缓存策略弱、不支持降采样、动图支持差、错误处理简陋。社区库通常补齐:

  • 内存缓存:LRU 位图,控制大小(如 50MB),避免 OOM。
  • 磁盘缓存:下载的文件存沙盒,按容量 LRU 清理。
  • 失败重试:网络失败自动重试。
  • 占位与淡入:显示体验更好。

选型要看:是否支持新架构(Fabric)、维护活跃度、动图支持、缓存 API 可控性。不要选一个多年不更新的库。

原理流程

图片 URL:
  1. 内存缓存命中? → 直接显示
  2. 磁盘缓存命中? → 读盘 → 解码 → 显示
  3. 都没有 → 下载 → 写磁盘 → 解码 → 显示

代码或图示

维度 原生 Image 社区库(待确认)
内存缓存 弱 可配置 LRU
磁盘缓存 弱 可配置
降采样 否 是
动图 弱 强
新架构 跟随 RN 需验证

常见误区

  • 误区:图片缓存永远不清理;正解:磁盘缓存要有上限与清理策略,否则越用越大。
  • 误区:所有图片都用占位图;正解:小图(头像、图标)直接显示更快,占位图反而增加闪烁。

追问

  • Q:怎么调试图片缓存?A:用开发者工具观察磁盘缓存目录大小,滚一屏看内存增长。
  • Q:WebP 与 PNG/JPG 怎么选?A:WebP 体积小、解码快,两端支持良好(具体支持矩阵以平台版本为准),动图用 WebP 或 GIF 视库而定。

07.2.2.7-010 Animated 与 useNativeDriver 是什么原理?

一句话结论

Animated 是 RN 的声明式动画库:你描述动画值与目标值,动画帧驱动由原生驱动;useNativeDriver: true 让动画在原生线程跑,不经过 JS 线程,JS 掉帧时动画依然流畅。

概念解释

默认情况下(useNativeDriver: false),每一帧动画都要:JS 线程算出当前值 → 过桥 → 原生视图更新属性。JS 线程一卡,动画就停。

useNativeDriver: true 时,动画"配置"在启动时一次性传给原生,之后由原生在 UI 线程直接驱动视图属性,不再经过 JS。这就是为什么 loading、进度条、折叠动画即使 JS 忙也丝滑。

边界:native driver 只能驱动能直接传给原生的属性(transform、opacity),不能驱动布局属性(width、height 变化会触发布局);也不能在动画过程中调用 JS 回调(onAnimationEnd 例外,会在结束时回 JS)。

原理流程

非 native driver:
  每帧:JS 计算 value → 过桥 → 原生更新 → JS 卡则动画卡

native driver:
  启动:把动画配置(起止值、时长、曲线)一次性传给原生
  每帧:原生 UI 线程直接更新 transform/opacity
  结束:回调 JS 一次

代码或图示

维度 useNativeDriver: false true
驱动线程 JS UI 原生
JS 卡顿影响 动画掉帧 不影响
可驱动属性 全部 transform/opacity 等
过程回调 可 不可

常见误区

  • 误区:所有动画都该开 native driver;正解:布局动画、需要 JS 逐帧回调的不能开。
  • 误区:开了 native driver 就完全不经过 JS;正解:启动配置与结束回调仍在 JS,只是中间帧不经过。

追问

  • Q:layout 动画怎么办?A:用 LayoutAnimation(全局)或 Reanimated 的 layout animations,它会触发布局更新。
  • Q:手势驱动动画怎么开 native?A:用 Reanimated + gesture-handler,手势事件也在 UI 线程,整条链不过 JS。

07.2.2.7-011 Reanimated 的 worklets 是什么?

一句话结论

Reanimated 让你用 JS 语法写"worklet",它会被编译并在原生 UI 线程执行,而不是 JS 线程;这样手势、动画、事件回调都在 UI 线程跑,不阻塞 JS,也不经过 Bridge。

概念解释

普通 JS 函数在 JS 线程执行,要改原生视图必须过桥。worklet 是一种特殊函数:Reanimated 在构建时把它编译成可在 UI 线程独立运行的代码片段(包括它闭包引用的值)。在 UI 线程上,worklet 可以直接操作共享值(shared value),直接更新视图属性。

典型用法:GestureDetector 捕获手势事件 → UI 线程 worklet 处理 → 更新 shared value → 视图属性自动动画。整条链不过 JS。

边界:worklet 里不能随便调用 JS 库(那些库在 JS 线程),只能用 worklet 白名单内的 API;共享值要通过 useSharedValue 声明。

原理流程

触摸事件(原生 UI 线程)
  → Reanimated worklet 处理(UI 线程)
  → shared.value 变化
  → 视图属性动画(UI 线程)
  → 需要时通过 runOnJS(...) 切回 JS 线程

代码或图示

维度 普通 Animated Reanimated
执行线程 JS(默认) UI 线程(worklet)
手势链 经过 JS 整条在 UI 线程
桥接次数 每帧 启动一次
复杂度 低 中高

常见误区

  • 误区:worklet 就是异步函数;正解:它是编译到 UI 线程执行的代码块,与 async/await 无关。
  • 误区:worklet 里可以调任意 JS 库;正解:只能用 worklet 上下文可用的 API,复杂逻辑要 runOnJS 切回 JS。

追问

  • Q:新架构下 Reanimated 还必要吗?A:Fabric 改善了渲染,但手势与动画在 UI 线程的收益依然存在,主流方案仍是 Reanimated(具体版本以官方为准)。
  • Q:怎么调试 worklet?A:日志要通过 runOnJS(console.log) 打,worklet 内部不能直接 console。

07.2.2.7-012 LayoutAnimation 与 Lottie 各是什么场景?

一句话结论

LayoutAnimation 让"下一次布局变化"自动带动画(插入/删除/位置移动),全局一次性调用;Lottie 是把 After Effects 导出的矢量动画 JSON 原样渲染,适合复杂品牌动画。两者成本与适用场景完全不同。

概念解释

LayoutAnimation.configureNext(...) 在一次状态更新前调用,下次渲染产生的布局变化(新组件插入、组件移除、位置变化)会自动插入动画。它简单但全局,且动画类型有限,Android 上需要开启实验开关(待确认)。

Lottie 把设计软件导出的 JSON 动画描述在 RN 上原生渲染,矢量、跨端一致、文件小。它适合启动页、空状态、引导页、营销动画;不适合长列表里每个 item 都放一个 Lottie(初始化与渲染成本高)。

原理流程

LayoutAnimation:
  setState 前调用 configureNext → React 渲染 → 布局变化自动补间动画

Lottie:
  设计稿导出 JSON → Lottie 组件加载 → 原生按 JSON 描述逐帧渲染

代码或图示

维度 LayoutAnimation Lottie
适用 布局变化 品牌/复杂动画
文件 无 JSON 动画文件
成本 低 中
定制 有限 设计可控

常见误区

  • 误区:LayoutAnimation 适合所有过渡动画;正解:它是粗粒度工具,精细交互要用 Reanimated。
  • 误区:Lottie 随便用;正解:复杂 Lottie 动画帧率与内存都不低,长列表慎用。

追问

  • Q:LayoutAnimation 与 Reanimated layout animations 区别?A:后者在新架构下更可控、跨端行为更一致,是趋势(具体 API 以版本为准)。
  • Q:Lottie 怎么减体积?A:矢量元素少做、减少嵌套、导出时压缩 JSON,不要嵌位图。

07.2.2.7-013 手势与滚动怎么协同?

一句话结论

用 react-native-gesture-handler 替代原生手势系统,让手势事件在原生 UI 线程处理,再配合 Reanimated 做手势驱动动画;普通 PanResponder 走 JS 线程,复杂手势会卡。

概念解释

RN 自带的手势响应系统(PanResponder)在 JS 线程处理触摸事件,每次触摸移动都过桥,复杂手势(如横向滑动切换 Tab、拖拽排序)会掉帧。

react-native-gesture-handler 让手势在原生层识别,与 RN 视图树协调(如抽屉、滑动删除、底部弹窗),并配合 Reanimated 在 UI 线程驱动动画。它是社区复杂手势的事实标准。

原理流程

普通 PanResponder:
  触摸事件 → 过桥 → JS 线程处理 → 过桥 → 视图更新

gesture-handler + Reanimated:
  触摸事件 → 原生识别 → worklet 处理(UI 线程)→ 视图动画

代码或图示

场景 推荐方案
简单点击 TouchableOpacity
拖拽 gesture-handler + Reanimated
滑动删除 gesture-handler Swipeable
手势驱动动画 Reanimated gesture

常见误区

  • 误区:PanResponder 够用就不升级;正解:复杂手势(多指、嵌套、与滚动协同)用 PanResponder 会写得很痛苦。
  • 误区:手势与滚动可以随便叠加;正解:要配置 simultaneousWithExternalGesture 或 fail 关系,否则手势互相打架。

追问

  • Q:抽屉与列表滚动冲突怎么办?A:用 gesture-handler 的抽屉容器,它内部处理手势优先级,不要自己包 PanResponder。
  • Q:新架构下手势栈变了吗?A:gesture-handler 适配新架构,具体版本与 API 以官方文档为准。

07.2.2.7-014 帧率怎么度量,JS 帧率与 UI 帧率分别是什么?

一句话结论

RN 有两条独立帧率线:JS 帧率(JS 线程每秒渲染多少帧)与 UI 帧率(原生 UI 线程每秒绘制多少帧);JS 帧率低说明 JS 线程有长任务,UI 帧率低说明视图挂载/绘制/图片有问题。

概念解释

iOS 60fps、Android 高刷屏可能到 90/120fps。一帧预算 16.7ms(60fps)或 11.1ms(90fps)。JS 帧率低:JS 线程在单帧内跑了超过 16.7ms 的同步代码(大列表 diff、复杂计算、同步原生调用),UI 帧率再高也没用,因为 React 渲染不出来。

UI 帧率低:JS 没事做但原生视图挂载慢、过度绘制、图片解码慢、布局复杂。两条线要分别看。

原理流程

单帧预算 16.7ms:
  JS 线程:渲染、diff、业务逻辑
    └─ 超预算 → JS 帧率低
  UI 线程:挂载、布局、绘制、图片
    └─ 超预算 → UI 帧率低

代码或图示

指标 含义 低的原因
JS 帧率 JS 线程渲染帧 长任务、大 diff
UI 帧率 UI 线程绘制帧 视图多、图片、过度绘制
掉帧(jank) 单帧 > 预算 两者都可能

常见误区

  • 误区:只看一个 FPS;正解:JS 与 UI 分开看,定位完全不同。
  • 误区:60fps 就够;正解:高刷屏设备要追更高,且用户对掉帧的感知是相对的。

追问

  • Q:开发者工具怎么看?A:RN 自带的 Performance 面板或 Systrace/Perfetto(具体工具以版本为准)。
  • Q:怎么量化掉帧?A:统计每帧耗时分布,P95 或 P99 帧耗时,而不是只看平均 FPS。

07.2.2.7-015 性能问题的定位顺序是什么?

一句话结论

先看 JS 帧率(JS 长任务),再看 UI 帧率(视图挂载与绘制),再看图片(解码与尺寸),最后看视图数量与布局深度。不要一上来就换 FlashList 或怀疑新架构。

概念解释

这是一个排除法:

  1. JS 帧率低 → 查 JS 长任务:大列表 renderItem 做了什么计算、组件 render 是否过重、是否有同步原生调用、是否有大 JSON 解析。
  2. JS 正常但 UI 帧率低 → 查视图:视图树深度、每层是否有不必要的嵌套、overflow: hidden、阴影、圆角、遮罩这些绘制成本。
  3. 滚动时特定帧卡 → 查图片:图片是否过大、是否在列表进入窗口时同步解码。
  4. 首屏慢 → 查首屏渲染条目数、首屏图片、启动链路。

原理流程

卡顿 → JS 帧率低?
  ├─ 是 → 查长任务、render、重渲染
  └─ 否 → UI 帧率低?
       ├─ 是 → 查视图树、过度绘制、图片
       └─ 否 → 查事件频率、同步调用、网络阻塞

代码或图示

顺序 检查项 工具
1 JS 长任务 Performance 面板
2 UI 挂载/绘制 Systrace/Perfetto
3 图片解码 内存与帧耗时
4 视图数量 视图树检查器

常见误区

  • 误区:一上来就怀疑 Bridge 或新架构;正解:绝大多数卡顿是业务代码、图片、视图层级问题。
  • 误区:在低端机上测不出就觉得没问题;正解:性能问题要在中低端机上测,高端机会掩盖。

追问

  • Q:怎么复现偶发卡顿?A:录屏 + 性能 trace,反复操作同一轨迹,看栈里哪个函数长。
  • Q:怎么防止回归?A:把关键页面的帧率、首屏时间纳入 CI 或灰度看板,版本对比。

07.2.2.7-016 列表项的重渲染怎么治理?

一句话结论

列表项重渲染治理三板斧:renderItem 用外部组件、条目组件用 React.memo 包裹、回调用 useCallback 稳定引用;同时检查父组件是否每次渲染都新建对象/数组作为 props。

概念解释

列表里几百个条目,任何一个父级状态变化都会触发整个 FlatList 重渲染,进而每个条目都重渲染。如果条目本身没 memo,即使数据没变也会重跑 render。

三板斧:

  • renderItem={Row} 而不是内联函数。
  • const Row = React.memo(({ item }) => ...),props 没变就跳过。
  • 传给 Row 的回调用 useCallback,引用稳定。
  • props 里不要传新对象/数组,要传原始值或 memo 对象。

原理流程

父组件 setCount → FlatList 重渲染
  → 每个 Row 都收到新 props
  ├─ Row 是 memo 且 props 浅比较相等 → 跳过
  └─ Row 未 memo 或 props 引用变了 → 重渲染

代码或图示

措施 作用
renderItem 外部化 避免每次新建函数
memo 包裹 Row props 未变跳过
useCallback 回调引用稳定
避免内联对象 不破坏 memo 浅比较

常见误区

  • 误区:给所有组件包 memo;正解:memo 有浅比较成本,加在列表项这种高频组件上才有意义。
  • 误区:memo 包了就万事大吉;正解:props 里有新对象(如 style={{}})会让 memo 失效。

追问

  • Q:怎么定位哪个条目重渲染了?A:用 Why Did You Render 类工具或在 render 里打日志(生产关闭)。
  • Q:memo 失败的常见原因?A:父组件每次渲染传 style={{...}}、onPress={() => ...}、data={[]} 这种新引用。

07.2.2.7-017 综合题:电商长列表首页卡顿,怎么排查?

一句话结论

按"指标 → 视图 → 图片 → 业务代码"四步排查:先量 JS/UI 帧率定位是哪侧问题,再数视图节点与图片数量,再看 renderItem 是否做了重计算,最后看是否有过度绘制与同步调用。

概念解释

电商首页典型结构:搜索栏 + 轮播 + 分类宫格 + 秒杀 + 推荐 Feed。这种页面有多个滚动容器嵌套、大量图片、复杂条目。卡顿可能来自:

  • 首屏渲染条目太多(initialNumToRender 过大)。
  • 轮播组件自动播放触发整个列表重渲染。
  • 条目内图片原图尺寸过大。
  • 宫格/秒杀区用 ScrollView 渲染了全部数据。
  • 每次 setState 都带着整个列表重渲染。

排查顺序:录屏看是首屏慢还是滚动卡;切 Performance 看 JS 长任务;开视图检查器数节点;看图片加载日志。

原理流程

1. 量指标:JS 帧率?UI 帧率?
2. JS 低 → 查 renderItem 计算、父组件重渲染
3. UI 低 → 数视图节点、查图片
4. 滚动时卡 → 查 windowSize、条目复杂度
5. 首屏慢 → 查 initialNumToRender、首屏图片

代码或图示

现象 怀疑点 验证
首屏慢 首屏条目多/图片大 减少 initialNumToRender 对比
滚动卡 renderItem 重计算 注释条目内容对比
图片位置卡 大图解码 换小图对比
自动轮播后卡 状态提升 轮播状态下沉

常见误区

  • 误区:换 FlashList 就能解决;正解:如果是图片或业务代码问题,换库没用。
  • 误区:在高端机测没问题就上线;正解:必须在中低端机上验证。

追问

  • Q:如果发现是轮播组件每帧 setState 导致整个列表重渲染,怎么修?A:把轮播的状态隔离到轮播组件内部,不要提升到列表父级。
  • Q:推荐 Feed 分页加载后越滚越卡,怎么处理?A:检查是否有"加载更多"时把新数据与旧数据合并导致全列表重渲染,以及旧条目是否被回收。

07.2.2.7-018 综合题:动画与手势场景怎么保证不卡?

一句话结论

所有高频动画与手势都走 Reanimated + gesture-handler,让整条链在 UI 线程;JS 线程只处理离散事件(点击、结束)。避免在动画过程中 setState 触发 React 渲染。

概念解释

典型反面:用 PanResponder 跟手拖拽,每帧 setState 一个偏移量,JS 线程一卡动画就卡。正面:用 GestureDetector + useSharedValue,触摸在原生识别,worklet 改 shared value,视图属性自动动画。

另一类坑:动画过程中调用 setState 更新列表数据,每帧都触发 React render,动画与渲染互相抢帧。动画过程中的视觉更新要走 shared value,不要走 React state。

原理流程

手势:
  触摸 → gesture-handler 原生识别
  → worklet 改 shared.value
  → 视图属性动画(UI 线程)

结束:
  识别为"完成" → runOnJS(业务回调)
  → JS 线程更新数据 → React 渲染

代码或图示

错误做法 正确做法
每帧 setState 偏移 shared value
PanResponder gesture-handler
动画中 setState 列表 结束后再 setState
JS 线程动画 Reanimated worklet

常见误区

  • 误区:动画属性可以是任何值;正解:UI 线程动画只能驱动 transform/opacity 等原生可直接更新的属性。
  • 误区:worklet 里可以打日志;正解:要用 runOnJS(console.log)。

追问

  • Q:为什么动画结束后再 setState?A:动画过程中 setState 会触发 React 重渲染,与动画抢帧,且动画期间用户看到的是瞬时值,重渲染无意义。
  • Q:复杂手势(如拖拽排序)怎么实现?A:用 gesture-handler 的组合手势 + Reanimated 的 layout animation,库提供现成的方案(具体 API 以版本为准)。