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

07.2.2.2 渲染管线、Yoga 布局与样式体系

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

本节要解决的问题

  • React 组件树是怎么一步步变成平台原生视图的,中间经过了哪些树、哪些线程?
  • Yoga 在 RN 里到底承担什么角色,它的 Flexbox 和 Web CSS Flex 差在哪里?
  • RN 样式系统(StyleSheet、单位、百分比、定位、文本、阴影圆角)是怎么被计算和下发的?
  • onLayout、measure 这些测量 API 在什么时机触发,有哪些容易踩的坑?
  • 布局深度、过度嵌套、视图扁平化为什么会成为性能问题?
  • iOS 与 Android 在样式表现上有哪些常见差异,和 Web CSS 的心智模型差在哪?

版本前提:本页以 RN 0.70 以后的事实为基线,新架构(Fabric)自 RN 0.76 起逐步默认开启,旧架构在后续版本被冻结(具体冻结版本与兼容窗口以官方发布说明为准,标注待确认)。涉及具体 API 名、字段名、默认开关处均需按项目实际版本核对。渲染管线在新旧架构下的差异详见 07.2.2.1 架构演进:Bridge、JSI 与新架构。

覆盖范围

知识域 关键内容
树映射 React 组件树 → shadow 树 → 原生视图树的映射、节点创建与复用、根视图与 Surface
Yoga 布局 Flexbox 子集、布局算法、布局线程、宽高约束与 measure
样式系统 StyleSheet 注册、单位与百分比、定位与层级、文本与字体、阴影圆角变换成本
测量与时机 onLayout 触发时机、measure 同步测量、陷阱与跨线程问题
平台差异 iOS/Android 样式差异、与 Web CSS 的心智模型差异
性能与排查 布局深度、过度嵌套、视图扁平化、首屏布局慢的排查顺序

题号索引

题号区间 主题
001-004 树映射、节点复用、根视图与 Surface、新旧架构布局线程
005-009 Yoga 布局模型、样式系统、单位与百分比、定位与层级
010-013 文本字体、阴影圆角变换、视图扁平化、布局深度代价
014-016 onLayout、measure 测量 API、平台差异与 Web CSS 心智模型
017-018 综合题:首屏布局慢排查、跨平台样式不一致排查

07.2.2.2-001 React 组件树到原生视图的完整映射过程是怎样的?

一句话结论

React 侧维护一棵 JS 组件树,渲染产出后交给渲染器(旧架构为 UIManager,新架构为 Fabric)转换成 shadow 树,再经过 Yoga 布局算出每节点的位置尺寸,最后由挂载层在 UI 线程把指令应用到真实的 UIView / android.view.View 上。

概念解释

这里有三棵容易混淆的树:第一棵是 React 自己的虚拟组件树(JS 侧),它描述"界面应该是什么",每次 setState 都会重新 render 并 diff;第二棵是 shadow 树(旧架构在 Shadow 线程、新架构在 C++ 核心),它把 React 组件对应到一个轻量的、不带平台类型的节点对象,专门承载 props、布局结果与父子关系;第三棵是真正的原生视图树,它是平台对象,只能在 UI 线程创建和修改。

映射不是"整棵替换",而是 diff:渲染器对比新旧 shadow 树,产出 create/update/delete 的挂载指令(mount items),再由挂载层逐条执行。理解这三棵树的分工,才能解释为什么"JS 里 setState 一次"会变成"原生侧只改了几个属性",而不是重建整个页面。

原理流程

JS:React render → 虚拟组件树 diff
  → 生成 shadow 节点变更(旧:Shadow 线程;新:C++ 核心)
  → Yoga 计算每节点的 frame(x/y/width/height)
  → 生成挂载指令:create / update / delete
  → UI 线程应用到原生视图树
  → 平台渲染管线绘制上屏

代码或图示

React 虚拟树(JS)          shadow 树(布局信息)        原生视图树(平台对象)
<View>                       ViewShadowNode             UIView / ViewGroup
  <Text>           ──▶       TextShadowNode       ──▶    UILabel / TextView
  <Image>                     ImageShadowNode            UIImageView / ImageView

常见误区

  • 以为 RN 像 Web 一样操作 DOM:RN 没有浏览器 DOM,目标是平台原生视图树。
  • 以为每次状态变化都重建原生视图:重建的只是 shadow 节点,原生视图按指令差异更新。

追问

  • shadow 节点和原生视图的数量是一一对应的吗?答:概念上是,但 Fabric 会对纯布局容器做扁平化(view flattening),实际原生视图数可能少于 shadow 节点数。
  • 旧架构下这棵 shadow 树在哪个线程?答:旧架构在独立的 Shadow 线程;新架构把它并入 C++ 渲染阶段,不再有独立的 Shadow 线程。

07.2.2.2-002 原生视图节点是如何被创建、复用和销毁的?

一句话结论

渲染器根据 shadow 节点的类型与挂载指令创建对应原生视图;组件卸载时销毁视图;在长列表等场景下,配合稳定的 key 与回收机制减少视图重建,但 RN 本身不做 Web 那种 DOM 节点池复用,复用主要靠列表组件内部的虚拟化。

概念解释

旧架构下 UIManager 收到 createView 指令后,根据组件名在 ViewManager 注册表中找到对应的工厂方法创建原生视图实例;deleteView 指令则把视图从父视图移除并释放引用。新架构 Fabric 的 MountingManager 做同样的事,但指令来源是 commit 后的 mount items,且因为 shadow 树不可变,节点的复用判断更精确。

需要强调:RN 的"复用"和 Android RecyclerView 的 view holder、iOS UITableView 的 reuseIdentifier 不是一回事。FlatList 等虚拟列表组件在 JS 侧通过 keyExtractor 维持组件与数据的对应关系,配合窗口化渲染减少挂载项数量;离开列表场景,普通 View 不会自动跨位置复用。

原理流程

挂载指令 create(tag, viewName, rootTag, props)
  → ViewManager / ComponentDescriptor 查表
  → new 原生视图实例
  → 设置初始 props
  → addView 到父视图

挂载指令 delete(tag)
  → 从父视图 removeView
  → 释放引用(等待 GC / 平台回收)

代码或图示

长列表场景:
数据 [A,B,C,D,E,F...]
窗口只挂载可见区 [B,C,D]
滑动 → A 出窗被卸载,E 入窗被创建
key 稳定 → 同 key 数据更新时走 update 而不是 create+delete

常见误区

  • 以为 RN 视图有自动的对象池:普通 View 没有自动复用,跨位置移动视图仍走 create/delete。
  • 以为 key 只用于列表:key 是 React 协调器判断节点身份的依据,错误的 key 会导致状态串台与不必要的重建。

追问

  • 为什么 keyExtractor 要用稳定 id 而不是数组下标?答:下标随数据插入删除会变化,导致 React 误判节点身份,出现状态错位与重建。
  • 频繁挂载卸载的视图为什么贵?答:原生视图创建涉及平台对象分配、measure 与首次绘制,在滚动帧内做会直接掉帧。

07.2.2.2-003 根视图(RootView)与 Surface 是什么关系?

一句话结论

RootView(旧架构)/ Surface(新架构)是 RN 内容挂载到平台窗口的锚点:每个 Surface 对应一棵独立的 React 根树,有自己的 rootTag、尺寸与生命周期;一个原生壳可以同时承载多个 Surface,分别对应不同业务页面。

概念解释

旧架构下,开发者通过 AppRegistry.registerComponent 注册组件入口,原生侧创建一个 ReactRootView 并把它作为普通原生 view 加到布局里,JS 侧在这个 rootTag 下渲染整棵树。新架构下对应的是 Surface:SurfaceRenderer 负责在给定原生容器上创建并渲染一个 Surface,Surface 有自己的大小、上下文与生命周期,并且可以在不重启 JS 运行时的前提下被销毁与重建。

这个概念对混合嵌入(一个原生 App 里嵌多个 RN 页面)至关重要:多个 Surface 可以共享同一个 JS 运行时与模块实例,从而摊薄引擎初始化成本;但它们各自的 React 状态是隔离的。

原理流程

原生侧准备一个容器 view
  → 创建 Surface(旧:ReactRootView + startReactApplication)
  → JS 侧 AppRegistry / SurfaceRenderer 在 rootTag 上 render
  → 渲染产物挂载到该容器
  → 页面关闭时销毁 Surface,释放对应 shadow 树与原生视图

代码或图示

维度 旧架构 RootView 新架构 Surface
锚点对象 ReactRootView Surface / SurfaceRenderer
多实例 通常一个 App 一个 可多 Surface 共享运行时
尺寸来源 布局后固定 可主动设置尺寸、支持 resize
销毁 随 ReactInstance 生命周期 独立销毁,运行时可复用

常见误区

  • 以为一个 RN App 只能有一个入口:可以注册多个组件,原生侧按需创建多个 RootView / Surface。
  • 以为多 Surface 之间共享 React 状态:它们共享 JS 运行时与模块实例,但各自 React 树与状态隔离。

追问

  • 混合嵌入时为什么要复用 JS 运行时?答:引擎初始化与 JS 包执行是启动大头,复用运行时能让第二个 RN 页面秒开。
  • Surface 的尺寸什么时候确定?答:创建时由原生容器决定,容器尺寸变化时需要通知 Surface 重新 layout(具体 API 以版本为准,待确认)。

07.2.2.2-004 新旧架构下布局分别在哪个线程做?

一句话结论

旧架构布局由独立的 Shadow 线程用 Yoga 计算,算完结果再经桥回到主线程挂载;新架构把 Yoga 布局并入 C++ 渲染阶段,与 JS 渲染在同一提交节奏上完成,UI 线程只负责挂载与绘制,不再有独立的 Shadow 线程这一跳。

概念解释

旧架构的三线程分工(详见 07.2.2.1)里,Shadow 线程专门跑 Yoga:JS 侧提交的 shadow 节点变更被送到这里,Yoga 递归计算每个节点的 flex 布局,产出 frame 后再序列化成消息送回主线程。这意味着一帧内布局结果要多跨一次线程与一次桥。

新架构把 shadow 树和 Yoga 都放进 C++ 核心:React 渲染在 JS 线程触发 commit 时,同一份 shadow 树就在 C++ 里完成布局,结果直接交给挂载层。布局不再阻塞主线程,但 JS 线程在一次 commit 里的工作量变大了——这也是新架构下"JS 长任务"依然是最常见卡顿源的原因。

原理流程

旧:JS 线程 render ──桥──▶ Shadow 线程(Yoga) ──桥──▶ UI 线程挂载
新:JS 线程 render ──▶ C++ shadow 树 commit(含 Yoga) ──mount items──▶ UI 线程挂载

代码或图示

阶段 旧架构 新架构
组件树 diff JS 线程 JS 线程
shadow 树构建 Shadow 线程 C++(随 commit)
Yoga 布局 Shadow 线程 C++(随 commit)
视图挂载 UI 线程 UI 线程
跨边界次数 至少 2 次消息 无字符串序列化

常见误区

  • 以为新架构把布局搬到了 UI 线程:布局仍在 C++ 渲染阶段,UI 线程只做挂载与绘制。
  • 以为新架构下布局免费:布局复杂度本身没变,只是少了一次跨线程往返。

追问

  • 为什么旧架构要把布局放到独立线程?答:避免递归布局阻塞主线程导致掉帧,代价是多一次跨线程。
  • 新架构下布局阻塞 JS 线程会怎样?答:一次 commit 的 JS 侧耗时变长,输入响应与动画一起被拖慢。

07.2.2.2-005 Yoga 是什么,它的 Flexbox 与 Web CSS Flex 差在哪?

一句话结论

Yoga 是 Facebook 开源的 C 实现的 Flexbox 布局引擎,RN 用它统一计算 Android 与 iOS 的布局;它只实现了 CSS Flexbox 的一个子集,且在方向、默认值、百分比解析上与 Web CSS 有系统性差异。

概念解释

Yoga 把每个节点当作一个 flex item:主轴方向由 flexDirection 决定,主轴尺寸由 flexGrow/flexShrink/flexBasis 分配,交叉轴对齐由 alignItems/alignContent 控制。它的目标是"一套布局算法在两端跑出一致结果",所以 RN 的样式系统不是浏览器 CSS,而是 Yoga 定义的一个子集。

关键差异包括:RN 默认 flexDirection: column(Web 默认 row)、RN 默认 position: relative 行为与 Web 不同、RN 没有 display: inline 概念、flex 在 RN 里是缩写且数值语义与 Web 不完全一致、百分比在 RN 里只相对父节点对应尺寸且受 boxSizing 影响、RN 的 width/height 是固定值不存在 auto 的复杂解析。

原理流程

Yoga 布局分两阶段:
1. measure pass:自底向上,递归计算每节点的内容尺寸
2. layout pass:自顶向下,按 flex 规则分配每节点的 frame

代码或图示

维度 Web CSS Flex RN Yoga
默认 flexDirection row column
默认 display block/inline 仅 flex
单位 px/rem/%/vw 等 无单位 dp + 百分比
绝对定位 相对最近 positioned 祖先 相对父节点
gap 较新版本支持 支持范围以版本为准

常见误区

  • 以为 RN 样式就是 CSS 复制:它是 Yoga 子集,很多 CSS 属性不存在或语义不同。
  • 以为 Yoga 只算 flex:绝对定位、文本 measure、图片尺寸都走 Yoga 的节点树。

追问

  • RN 里 flex: 1 等价于 Yoga 的什么?答:等价于 flexGrow: 1, flexShrink: 1, flexBasis: 0%,即占用主轴剩余空间(语义以版本为准)。
  • Yoga 为什么要自己实现而不是用平台布局?答:保证两端布局结果一致,避免 Android 用 LinearLayout、iOS 用 AutoLayout 带来的分歧。

07.2.2.2-006 StyleSheet.create 到底做了什么,和内联样式有什么区别?

一句话结论

StyleSheet.create 把样式对象注册成一份可复用的引用,主要收益是稳定引用(避免子组件因 props 变化而重渲染)与序列化去重,而不是"性能优化魔法";内联样式每次 render 都会生成新对象。

概念解释

在 RN 里,样式最终是一个普通对象 { width: 100, height: 50 }。直接写 style={{ width: 100 }} 在每次 render 时都会创建一个新对象,即使内容相同,引用也不同。StyleSheet.create 在模块加载时把这些对象"登记"一次,后续引用稳定;配合 React.memo / shouldComponentUpdate,子组件 props 比较时能识别出样式引用没变,从而跳过重渲染。

序列化层面,旧架构下样式对象要过桥,去重能减少编解码量;新架构下这部分收益减小,但稳定引用的收益仍然存在。

原理流程

const styles = StyleSheet.create({ card: { width: 100 } })
  → 模块加载时生成一份对象引用
组件每次 render 引用 styles.card
  → 引用稳定 → memo 比较通过 → 跳过重渲染

代码或图示

// 内联:每次 render 新对象
<View style={{ width: 100 }} />

// StyleSheet:引用稳定
const styles = StyleSheet.create({ card: { width: 100 } });
<View style={styles.card} />

常见误区

  • 以为 StyleSheet.create 会自动加速布局:它只解决引用稳定与去重,布局计算照样发生。
  • 以为所有样式都必须写进 StyleSheet:动态样式(根据 props 计算)本来就是新对象,写不写 create 都一样。

追问

  • 数组样式 style={[styles.a, active && styles.b]} 怎么处理?答:运行时合并成最终对象,数组成员引用稳定仍有收益。
  • 样式表和原生层样式表有关系吗?答:RN 侧的 StyleSheet 不是 Android style 或 iOS asset catalog,它只是 JS 层对象。

07.2.2.2-007 RN 的单位、百分比与宽高约束是怎么解析的?

一句话结论

RN 样式数值默认就是 dp(密度无关像素),不需要写 px;百分比相对父节点对应尺寸解析;undefined 尺寸由 Yoga 按内容与 flex 规则自动决定,不存在 Web 的 auto 复杂语义。

概念解释

RN 的样式单位体系刻意做了简化:一个数字就是一个 dp,平台会按屏幕密度换算成像素;不支持 rem、vw/vh、calc。百分比只在父节点对应维度已知时有效,例如 width: '50%' 相对父节点宽度;如果父节点宽度本身是 wrap content,百分比在 Yoga 里的解析结果要按布局规则判断,常见问题是"父没定宽时子百分比失效"。

宽高约束有三态:固定值、百分比、undefined(由内容或 flex 决定)。measure 流程中,父节点会给子节点一个最大尺寸约束,子节点在约束内决定自己的尺寸,这是 Yoga measure pass 的核心。

原理流程

父节点确定可用空间
  → 给子节点传递 measure 约束(min/max width/height)
  → 子节点在约束内计算自己的尺寸(内容 / 固定值 / 百分比 / flex)
  → 逐层向上汇报

代码或图示

写法 解析结果
width: 100 100 dp
width: '50%' 父节点宽度的一半(父须已知宽度)
width: undefined 由内容与 flex 决定
flex: 1 主轴方向占满剩余空间

常见误区

  • 以为 RN 里要写 px:数字即 dp,写 px 反而是错误用法。
  • 以为百分比总能工作:父节点对应尺寸未定时时,百分比可能拿不到预期值。

追问

  • aspectRatio 怎么参与布局?答:它在另一维尺寸确定后约束当前维,是 Yoga measure 阶段的一条规则。
  • 为什么 RN 没有 calc()?答:刻意简化布局模型,复杂计算放到 JS 侧算好再传固定值。

07.2.2.2-008 定位、层级与 overflow 在 RN 里怎么表现?

一句话结论

RN 用 position: 'absolute' 脱离 flex 流,用 zIndex 控制堆叠顺序(受平台差异影响),overflow: 'hidden' 决定子节点是否被裁剪;它和 Web CSS 的定位模型相似但有系统性差异。

概念解释

RN 默认 position: 'relative' 即参与 flex 流;absolute 后节点脱离流,按 top/left/right/bottom 相对父节点定位。堆叠顺序上,RN 用 zIndex 控制,但 Android 与 iOS 的实现差异明显:Android 上 view 的绘制顺序受 elevation、父视图绘制顺序影响,zIndex 在跨 ViewGroup 时表现不一致;iOS 上默认按视图层级顺序,zIndex 行为更接近 Web。

overflow: 'hidden' 不只是裁剪子节点,它还会影响是否让子节点超出边界绘制;在新旧架构下文本溢出、图片裁剪的行为也有细微差别。

原理流程

relative 节点:参与 flex 计算,占据主轴空间
absolute 节点:不参与 flex,按 top/left 锚定父节点
绘制顺序:按兄弟节点顺序 + zIndex;跨容器时受平台层级影响

代码或图示

属性 RN 表现
position: 'absolute' 脱离 flex 流,相对父节点
zIndex 同层兄弟排序;跨容器行为有平台差异
overflow: 'hidden' 裁剪子节点;visible 为默认
elevation(Android) 阴影与 z 轴高度,影响绘制顺序

常见误区

  • 以为 zIndex 在两端完全一致:Android 跨 ViewGroup 时 zIndex 可能失效,需要用 elevation 或重排视图。
  • 以为 absolute 元素可以相对任意祖先定位:RN 里只相对父节点。

追问

  • iOS 上怎么实现阴影?答:用 shadowColor/shadowOffset/shadowOpacity/shadowRadius,性能成本高于 Android 的 elevation。
  • overflow 对性能有什么影响?答:开启 hidden 后裁剪区域由平台裁剪,避免超出部分绘制,但嵌套裁剪会增加合成成本。

07.2.2.2-009 文本与字体布局在 RN 里有什么特殊之处?

一句话结论

Text 是 RN 里少数支持嵌套的组件,文本测量由平台原生字体引擎完成,Yoga 不负责文本内部排版;numberOfLines、onTextLayout、动态字体尺寸都有平台相关的行为差异。

概念解释

与普通 View 不同,Text 可以嵌套 Text 形成富文本结构,RN 会把整段文本交给平台(iOS 的 TextKit / Android 的 StaticLayout)做排版,然后把测量结果作为一个节点尺寸告诉 Yoga。这意味着文本节点的尺寸不是 Yoga 算出来的,而是平台文本引擎 measure 出来的——这也是 RN 布局里少数"内容驱动"的节点。

特殊点包括:Text 嵌套时样式会继承(类似 Web 的 font inherit);numberOfLines 截断与省略号在两端的字距处理不同;中文字体在两端的默认字体不同,行高、emoji 表现都可能有差异。

原理流程

Text 节点 → 收集嵌套子 Text 的样式与字符串
  → 交给平台文本引擎 measure 文本块尺寸
  → 把尺寸作为 Yoga 节点内容尺寸返回
  → Yoga 继续按 flex 规则分配

代码或图示

<Text>
  普通文本
  <Text style={{ fontWeight: 'bold' }}>加粗片段</Text>
  <Text onPress={onLink}>链接</Text>
</Text>

常见误区

  • 以为 Text 里可以塞任意 View:RN 旧版不支持 Text 内嵌 View(新版有 TextInlineView 类能力,支持范围以版本为准)。
  • 以为两端字体渲染一致:默认字体、字距、emoji 字形都有差异。

追问

  • onTextLayout 回调里能拿到什么?答:每行的位置、尺寸、可见行信息,用于做逐行动画或截断检测。
  • 长文本性能瓶颈在哪?答:文本 measure 在滚动帧内反复发生,是长列表滑动卡顿的常见来源之一。

07.2.2.2-010 阴影、圆角、变换的绘制成本为什么高?

一句话结论

这些效果不是"改个样式"那么简单:阴影涉及离屏渲染与模糊,圆角涉及裁剪与合成,变换涉及矩阵变换与光栅化;在滚动帧内频繁变化会直接吃掉 GPU 预算。

概念解释

iOS 上 shadow 系列属性会触发图层离屏渲染(offscreen rendering),因为阴影需要在单独的缓冲里画完再合成;圆角 borderRadius 配合 overflow: hidden 也会触发裁剪路径。Android 上 elevation 阴影由系统渲染线程处理,成本低于 iOS 但仍有开销。变换(transform matrix、旋转、缩放)本身是 GPU 操作,但如果 transform 作用在包含大量子视图的容器上,会让 GPU 重新光栅化该层。

面试里高频出现的结论是:阴影、圆角配合裁剪、动态变换这三类属性,在静态页面上无所谓,但在长列表项、动画帧内要避免每帧变化。

原理流程

普通绘制:视图直接绘制到屏幕缓冲
阴影:先离屏绘制视图 → 模糊 → 合成到屏幕
圆角裁剪:构建裁剪路径 → 子视图按路径裁剪
变换:矩阵变换 → 触发重新光栅化(内容变化时)

代码或图示

效果 iOS 成本 Android 成本 建议
shadowColor/Offset/Opacity 离屏渲染高 由 elevation 控制 列表项避免每帧变化
borderRadius + overflow hidden 裁剪路径 裁剪路径 控制层级
transform 动画 GPU 合成 GPU 合成 静态内容走原生动画

常见误区

  • 以为圆角只是样式属性零成本:它配合裁剪会触发合成层开销。
  • 以为用 RN 动画跑 transform 一定流畅:如果内容本身在变化,光栅化成本仍然存在。

追问

  • 怎么验证是否触发离屏渲染?答:用平台的离屏渲染调试工具(iOS Color Offscreen-Rendered Yellow、Android 渲染分析)观察。
  • 阴影能不能用图片代替?答:静态阴影可以用切图模拟,避免每帧离屏渲染。

07.2.2.2-011 视图扁平化(view flattening)是什么,为什么能省性能?

一句话结论

视图扁平化是渲染器的一种优化:当一个中间容器节点没有任何视觉属性(没有背景、边框、圆角、事件、变换)时,不创建对应的原生视图,直接把它的子节点挂到父视图上,从而减少真实视图树的深度与数量。

概念解释

在 RN 业务里非常常见的写法是"为了 flex 布局套一层 View",这层 View 往往只是布局容器,没有任何视觉表现。如果每个这种容器都创建一个原生 View,真实视图树会比 React 树深很多,而每次布局、事件分发、绘制都要遍历这棵树。

Fabric 与旧渲染器都做了扁平化:判断一个 shadow 节点是否"纯布局容器",如果是就跳过它的原生视图创建,把它的子视图直接挂到上一个有原生视图的节点下。这意味着业务代码里写多少层布局 View,对真实视图树的影响比想象中小。

原理流程

shadow 节点:ViewA(有背景) → ViewB(纯布局) → ViewC(有文字)
真实视图树:ViewA(原生) ──▶ ViewC(原生)
                      ViewB 被扁平化跳过

代码或图示

判断是否扁平化(示意):
节点无 backgroundColor / border / borderRadius / overflow
  且无 native 事件监听 / transform / elevation
  → 纯布局容器 → 不创建原生视图

常见误区

  • 以为套多少层 View 都无所谓:扁平化只解决"无视觉属性"的容器,一旦加了背景或事件就失效。
  • 以为扁平化是免费优化:判断本身有成本,且调试时视图树和 React 树不一致,增加排查难度。

追问

  • 怎么知道某个容器是否被扁平化?答:用开发者工具的视图层级查看器对比 React 树与原生视图树。
  • 扁平化失败的常见原因?答:容器上挂了 onLayout、背景色、border 或 elevation,任何一项都会让它变成"有原生视图"节点。

07.2.2.2-012 布局深度与过度嵌套为什么会成为性能问题?

一句话结论

每次布局都是从根到叶的递归遍历,树越深、节点越多,一次布局的耗时越长;在滚动、动画、方向切换等频繁触发布局的场景下,布局深度直接吃掉帧预算。

概念解释

Yoga 的 measure pass 自底向上、layout pass 自顶向下,两层递归都要遍历所有节点。嵌套层级每增加一层,递归深度、临时对象创建、跨节点约束传递都会累积。在首屏,整棵树要一次性布局完;在滚动列表,每个新入窗的 item 都要走一遍完整布局;在屏幕旋转,整棵树重新布局。

更深层的问题是:过度嵌套往往伴随着"为了一个对齐要求套三层 View",这种结构既影响布局性能,也让事件分发、命中测试(hit test)变慢——触摸事件要从根到叶逐层判断。

原理流程

一次布局 = measure(自底向上) + layout(自顶向下)
节点数 N、深度 D
  → 时间复杂度随 N 线性增长
  → 递归深度影响栈帧与缓存局部性
首屏:N 全量布局
滚动:入窗 item 局部布局
旋转:N 全量重新布局

代码或图示

场景 布局触发频率 深度敏感点
首屏 一次全量 整棵树
长列表滚动 每个入窗 item item 内部深度
屏幕旋转 一次全量 整棵树
动画 每帧(transform 除外) 动画作用子树

常见误区

  • 以为布局是 JS 侧成本:布局主要在原生侧(旧 Shadow 线程、新 C++),但它阻塞首屏与帧。
  • 以为扁平化后嵌套就完全免费:扁平化只减少原生视图数,shadow 树递归照样发生。

追问

  • 怎么衡量一个页面布局是否过深?答:看原生视图树层级、用平台布局耗时工具,定位递归最长的子树。
  • 有哪些常见的"无谓嵌套"?答:只为居中套一层 View、为 flex 方向套一层 View、为间距套一层 View,都可以用 margin/padding/alignSelf 替代。

07.2.2.2-013 onLayout 什么时候触发,有哪些陷阱?

一句话结论

onLayout 在节点完成布局且尺寸或位置变化时触发,回调在 JS 线程执行;它不是"每次 render 都触发",也不能用来做高频测量,且在首次布局、动画期间有易踩的时机陷阱。

概念解释

当 Yoga 完成一次 layout pass,某个节点的 frame 相对上次发生变化时,渲染器会把 onLayout 事件送到 JS 线程。它的常见用途是:动态计算兄弟节点尺寸、实现自定义布局、做手风琴展开动画。

陷阱主要有三个:一是首次布局时 onLayout 会在组件挂载后立即触发一次,若此时 setState 又会触发新一轮布局,形成"布局—setState—布局"循环;二是滚动过程中,onLayout 随容器尺寸变化频繁触发,在 JS 线程做重活会掉帧;三是 onLayout 拿到的是相对父节点的坐标(x/y/width/height),不是屏幕坐标,要做屏幕定位还得 measureInWindow。

原理流程

Yoga layout pass 完成
  → 对比每节点 frame 与上次
  → 变化节点打包成事件
  → 跨边界送 JS 线程
  → 调用 onLayout 回调(event.nativeEvent.layout)

代码或图示

<View onLayout={(e) => {
  const { x, y, width, height } = e.nativeEvent.layout;
  // 这里在 JS 线程,不要做重计算
}} />

常见误区

  • 以为 onLayout 每帧都触发:只有 frame 变化才触发,静态位置不会反复回调。
  • 以为 onLayout 里 setState 是安全的:它会引发新一轮布局,必须做防抖与收敛判断。

追问

  • onLayout 的 x/y 相对谁?答:相对父节点的坐标系,不是屏幕坐标。
  • 想在动画期间实时拿尺寸怎么办?答:不要用 onLayout,用动画值驱动或在原生侧处理。

07.2.2.2-014 measure、measureInWindow、measureLayoutToWindow 有什么区别?

一句话结论

这些命令式测量 API 让 JS 侧主动查询某个节点在屏幕或父容器中的位置尺寸;measure 是旧架构异步命令,新架构下 Fabric 提供了同步测量能力,但用错线程会有代价。

概念解释

旧架构里 ref.measure(callback) 是一个异步桥调用:JS 侧发起,原生侧测量后把结果经桥送回 JS。measureInWindow 拿的是相对屏幕窗口的坐标,measureLayoutToWindow 相对某个祖先。这些 API 都是"命令式、跨边界",不能在 render 期间同步依赖。

新架构 Fabric 下,因为 C++ 核心直接持有 shadow 树,测量可以在 commit 阶段同步完成,这对"需要根据子节点尺寸决定自身布局"的交互(如跟随手指的气泡、自动居中)非常关键。但同步测量要求 JS 线程不被阻塞,否则同样掉帧。

原理流程

旧:JS ref.measure(cb) → 桥 → 原生测量 → 桥 → JS cb 回调
新:Fabric 可在 commit 阶段同步读取 shadow 节点 frame

代码或图示

API 坐标基准 旧架构 新架构
measure 父节点 异步桥 可同步
measureInWindow 屏幕窗口 异步桥 可同步
measureLayoutToWindow 指定祖先 异步桥 可同步

常见误区

  • 以为 measure 可以在 render 阶段同步拿到尺寸:旧架构下它是异步的,render 期间拿不到。
  • 以为 measure 调用零成本:它跨边界,高频调用会挤爆帧预算。

追问

  • 什么场景必须用 measure?答:自定义手势、跟随手指的浮层、需要根据子节点实际尺寸布局父节点的场景。
  • 怎么避免 measure 滥用?答:用 flex 规则尽量让布局自洽,measure 只作为最后手段。

07.2.2.2-015 iOS 与 Android 在样式表现上有哪些常见差异?

一句话结论

Yoga 保证了布局尺寸一致,但视觉表现受平台原生渲染影响:默认字体、阴影模型、安全区、圆角裁剪、滚动条、zIndex 行为都有差异,业务侧必须做平台适配。

概念解释

布局一致 ≠ 视觉一致。iOS 用 shadow* 系列属性做阴影,Android 用 elevation;iOS 默认字体是 San Francisco 系,Android 默认是 Roboto,中文字体两端都不同;安全区(刘海、底部 home 指示条)需要用 SafeAreaView 处理,两端 inset 来源不同;Android 的 elevation 同时影响 z 轴高度与绘制顺序,iOS 的 zIndex 只影响兄弟排序;TextInput、ScrollView 的默认样式、滚动bar 表现都不同。

工程上常见做法是:用 Platform.OS 做条件样式,把两端差异收敛到统一的主题组件里,而不是在业务页面里散落判断。

原理流程

Yoga 布局:两端一致
  ↓
平台渲染:
  iOS:Core Animation / TextKit
  Android:Canvas / RenderNode / TextLayout
  → 字体、阴影、裁剪、安全区各自不同

代码或图示

差异点 iOS Android
阴影 shadowColor/Offset/Opacity/Radius elevation
默认字体 San Francisco Roboto(中文随系统)
安全区 SafeAreaView / inset 系统 WindowInsets
zIndex 兄弟排序 受 elevation 影响
滚动条 默认隐藏 默认显示

常见误区

  • 以为布局尺寸一致就视觉一致:字体度量、阴影、点击反馈都有差异。
  • 以为 Platform.OS 写一次就够:差异往往分散在多个组件,需要统一主题层。

追问

  • SafeAreaView 在两端怎么工作?答:它读取平台提供的安全区 inset,给内容加 padding,具体实现以版本为准。
  • 怎么发现两端视觉不一致?答:在同尺寸模拟器/真机上并排放页面,重点检查字体、阴影、圆角、安全区。

07.2.2.2-016 RN 样式与 Web CSS 的心智模型差在哪里?

一句话结论

RN 样式是"Yoga 子集 + 平台原生渲染",它不是 CSS 引擎:没有继承、没有选择器、没有 calc、没有媒体查询,所有样式都是内联对象;开发者要从"DOM+CSS"思维切换到"组件+布局规则"思维。

概念解释

Web CSS 里大量能力在 RN 里不存在:CSS 选择器、继承(除文本样式外)、伪类、媒体查询、calc、单位体系、层叠。RN 的样式是"写在组件上的对象",所有样式必须显式声明。这反而让布局更可控,但要求开发者重新理解:样式是数据,不是表;布局是 Yoga 规则,不是浏览器布局引擎。

事件系统也不同:RN 的 touch 事件是合成事件系统,没有 Web 的事件冒泡默认行为(实际有冒泡,但命名与阻止方式不同);触控、手势、滚动冲突都要按 RN 手势系统理解。

原理流程

Web:HTML 结构 + CSS 选择器 + 浏览器布局引擎
RN:组件树 + 样式对象 + Yoga 布局 + 平台原生渲染

代码或图示

维度 Web CSS RN 样式
选择器 支持 无,样式写在组件上
继承 大量属性继承 仅文本相关样式
单位 px/rem/%/vw 等 dp + 百分比
媒体查询 支持 无,用 Dimensions/useWindowDimensions
伪类 hover/active/focus 无,用状态驱动样式

常见误区

  • 以为 Web React 代码改改标签就能跑 RN:DOM API、选择器、单位体系都不通用。
  • 以为 RN 有 CSS-in-JS 库就能写 CSS:它最终还是编译成 RN 样式对象,能力边界不变。

追问

  • RN 里怎么做响应式?答:用 useWindowDimensions 或响应式 hook,按 JS 侧判断后传固定样式。
  • 为什么 RN 不做 CSS 引擎?答:刻意保持轻量,让布局由 Yoga 统一计算、视觉由平台原生渲染。

07.2.2.2-017 综合题:某 RN 页面在低端 Android 机上首屏布局慢,你怎么排查?

一句话结论

按"先量后拆"的顺序:先确认慢在 JS 渲染、Yoga 布局还是 UI 线程挂载绘制,再分别定位是首屏节点过多、嵌套过深、文本 measure 频繁,还是阴影/圆角触发离屏渲染,最后用对比实验验证优化收益。

概念解释

这类问题最容易陷入"凭感觉改样式"。正确做法是把"首屏慢"翻译成可分段的指标:首屏 TTI 是从进程启动到首屏可交互的总时间,但渲染管线内部要拆成 JS render 耗时、Yoga 布局耗时、UI 线程挂载耗时、首次绘制耗时。每一段都有对应的工具:JS 侧用 Performance API / 浏览器 profiling,布局与挂载用 Systrace / Perfetto / Instruments。

常见根因排序:首屏节点数过多(一次性渲染了全部内容)、布局嵌套过深(递归深度大)、长文本 measure(首屏就有大量富文本)、阴影圆角在首屏触发离屏渲染、图片尺寸未定导致二次布局。

原理流程

1. 量:在低端机上分段录 trace,定位最大耗时段
2. 拆:
   ├─ JS render 长 → 检查首屏组件树、是否同步渲染了非首屏内容
   ├─ Yoga 布局长 → 数首屏节点数与深度,找最深子树
   ├─ UI 挂载长 → 检查视图数、是否有昂贵的原生视图(MapView/WebView)
   └─ 绘制长 → 检查阴影、圆角、离屏渲染
3. 改:按根因优化
4. 验:同机型同场景对比指标,不凭主观感觉

代码或图示

判定树:
首屏慢 → trace 显示 JS render 长?
          ├─ 是 → 首屏是否渲染了非首屏内容? → 懒加载/延迟渲染
          └─ 否 → trace 显示布局长?
                    ├─ 是 → 节点数/深度/文本 measure → 扁平化、减嵌套
                    └─ 否 → trace 显示挂载/绘制长?
                              ├─ 是 → 阴影圆角离屏渲染、昂贵原生视图
                              └─ 否 → 检查图片尺寸、二次布局

常见误区

  • 不量就直接改:凭感觉改样式往往没改到根因。
  • 在不同机型上对比:低端机问题在旗舰机上可能完全不可见。

追问

  • 首屏"慢"和首屏"白屏"是一回事吗?答:不是,白屏是 Surface 创建后没有内容可绘,慢是内容在但耗时;两者根因不同。
  • 优化后怎么判断收益?答:同机型、同数据、同网络下对比 P50/P90 启动到首屏可交互时间,而不是单次手动测试。

07.2.2.2-018 综合题:某个弹窗在 Android 上位置不对,iOS 正常,怎么定位?

一句话结论

先分清是布局计算错了还是渲染层级错了:用 onLayout / measure 拿到两端的 frame 对比,再检查 zIndex、elevation、父容器 overflow 与命中测试,最后看是否依赖了 Web CSS 思维下的绝对定位假设。

概念解释

这类问题是 RN 跨平台样式差异的典型代表。第一步是量:在两端分别打印弹窗 anchor 节点与弹窗本身的 onLayout frame,看数值是否一致。如果数值一致但视觉位置不对,说明问题在绘制层级(zIndex/elevation/父容器裁剪);如果数值就不一致,说明问题在布局规则(父节点尺寸、百分比、绝对定位基准)。

第二步是排查层级:Android 上跨 ViewGroup 的 zIndex 经常失效,需要用 elevation 或把弹窗提到根层级;iOS 上则要注意父容器 overflow: hidden 是否裁剪了弹窗。第三步是检查是否有"按 Web CSS 假设"的写法,例如以为 absolute 相对某个祖先、以为百分比总能工作。

原理流程

1. 量两端 frame:anchor 与弹窗
   ├─ frame 不一致 → 布局规则问题(父尺寸/百分比/定位基准)
   └─ frame 一致 → 绘制层级问题
2. 绘制层级排查:
   ├─ 父容器 overflow: hidden? → 裁剪
   ├─ Android 跨容器 zIndex? → elevation / 提升层级
   └─ 父容器 transform? → 创建新合成层,子层级错位
3. 修复后两端对比

代码或图示

判定树:
弹窗位置错 → onLayout frame 两端一致?
              ├─ 否 → 父节点宽度/百分比/绝对定位基准差异
              └─ 是 → 视觉错位
                        ├─ Android 上被盖住? → zIndex/elevation 问题
                        ├─ iOS 上被裁剪? → 父容器 overflow
                        └─ 两边都偏? → 安全区/导航栏未计入

常见误区

  • 以为 frame 一致视觉就一定一致:Android elevation 与 iOS 合成层差异会导致视觉错位。
  • 直接用 Platform.OS 写死坐标:治标不治本,换屏幕尺寸又坏。

追问

  • 为什么 Android 跨 ViewGroup zIndex 会失效?答:Android 视图层级由 ViewGroup 的绘制顺序决定,zIndex 只在同组内有效(具体行为随版本变化,待确认)。
  • 弹窗最佳实践是什么?答:把弹层提到根层级(如使用 Portal 模式),避免受父容器裁剪与层级影响。