07.2.2.3 Hermes 引擎与启动性能
所属:全栈开发面试题库 / 07 端侧与桌面开发 / 07.2 跨平台移动开发 / 07.2.2 React Native
本节要解决的问题
- Hermes 与 JSC 在设计取舍上到底差在哪,为什么它能改善启动与内存?
- 字节码预编译(hermesc / .hbc)是怎么把"启动时的解析编译"挪到构建期的?
- RN 应用的启动链路分哪几段,TTI 的口径怎么定,怎么分段测量?
- inline requires、分包、模块预加载这些手段分别解决启动链路的哪一段?
- JS 包体积由什么构成,瘦身的常见手段与边界在哪?
- Hermes 下调试、sourcemap 与栈还原怎么做,线上崩溃怎么还原?
版本前提:本页以 RN 0.70 起 Android 默认 Hermes、iOS 默认化时间点以发布说明为准(待确认)为基线;新架构(Fabric/TurboModules)与 Hermes 是正交关系,详见 07.2.2.1。涉及具体命令、字段、默认开关均需按项目实际版本核对。
覆盖范围
| 知识域 | 关键内容 |
|---|---|
| 引擎差异 | Hermes 与 JSC 的设计取舍、字节码预编译、无 JIT、内存特征 |
| 启动链路 | 进程/原生壳、引擎初始化、JS 包加载执行、首屏渲染、TTI 口径 |
| 启动治理 | inline requires、分包、模块预加载、预热、懒加载与注册的关系 |
| 包体积 | JS 包构成、瘦身手段、源码映射与栈还原 |
| 调试监控 | Hermes 调试能力、sourcemap、启动监控指标与治理流程 |
题号索引
| 题号区间 | 主题 |
|---|---|
| 001-004 | Hermes 与 JSC 差异、字节码预编译、无 JIT、内存特征 |
| 005-007 | 启动链路分段、TTI 口径、首屏渲染与可交互定义 |
| 008-010 | inline requires、分包、模块预加载与预热 |
| 011-013 | JS 包体积构成、瘦身、源码映射与栈还原 |
| 014-016 | Hermes 调试、启动监控治理、综合题:启动慢治理 |
07.2.2.3-001 Hermes 与 JSC 的核心差异是什么?
一句话结论
JSC(JavaScriptCore)是苹果维护的通用 JS 引擎,带 JIT,启动慢、内存高但峰值性能好;Hermes 是 Meta 为移动端定制的引擎,不带 JIT、构建期预编译字节码,启动快、内存低,代价是峰值计算性能略逊。
概念解释
两者都是 ES 引擎,都能跑 React,但设计目标不同。JSC 是 Safari 同源引擎,为桌面浏览器设计,启动时要解析源码、生成字节码、再由 JIT 编译成机器码;在手机上冷启动阶段这套流程成本高。Hermes 反过来:把"解析 + 编译"挪到构建期,产出 .hbc 字节码文件,运行时直接加载字节码,不做 JIT。
取舍非常清晰:JSC 用启动与内存换峰值性能,Hermes 用峰值性能换启动与内存。对 RN 这种"启动敏感、峰值计算有限"的场景,Hermes 的设计更贴合。
原理流程
JSC 启动:
读 JS 源码 → 解析 → 生成字节码 → JIT 编译 → 执行
Hermes 启动:
构建期 hermesc → .hbc 字节码
运行时读 .hbc → 直接执行(无 JIT)
代码或图示
| 维度 | JSC | Hermes |
|---|---|---|
| JIT | 有 | 无 |
| 启动时解析 | 需要 | 不需要(构建期完成) |
| 包体 | 源码 bundle | 字节码 .hbc |
| 启动耗时 | 较高 | 较低 |
| 内存占用 | 较高 | 较低 |
| 峰值计算 | 较强 | 略弱 |
常见误区
- 以为 Hermes 是新架构的一部分:它是独立的 JS 引擎,可在旧架构下运行。
- 以为 Hermes 有 JIT:它刻意不做 JIT,启动与内存是主要收益。
追问
- Hermes 下哪些场景可能比 JSC 慢?答:长时间运行的热点计算、大量数值运算,因为没有 JIT 优化。
- 怎么确认项目用的是 Hermes?答:检查构建配置中引擎开关(字段以版本为准),或运行时打印引擎信息。
07.2.2.3-002 字节码预编译(hermesc / .hbc)是怎么工作的?
一句话结论
Metro 打包时把 JS 源码经 hermesc 编译成字节码文件(.hbc),原生壳加载时直接映射这段字节码到内存,省去运行时的词法分析、语法分析与字节码生成。
概念解释
普通 JS 引擎启动要做:源码 → AST → 字节码 → (JIT)机器码。Hermes 把前三步搬到构建期:Metro 产出 bundle 后,由 hermesc 编译器把 bundle 编译成 .hbc。运行时 Hermes 加载器直接把 .hbc 文件映射到内存,从字节码开始执行。
这里有几个工程要点:一是 .hbc 与 Hermes 引擎版本绑定,引擎升级后字节码要重新生成;二是字节码文件是二进制的,不能直接读源码,崩溃栈还原需要配套的 sourcemap;三是字节码可以 mmap,避免全量读入内存,对大 bundle 友好。
原理流程
Metro 打包:JS 源码 → 合并 bundle
→ hermesc → .hbc 字节码文件
运行时:
原生壳打开 .hbc → mmap 到内存 → 从字节码入口开始执行
代码或图示
构建产物对比:
JSC:index.bundle(可读 JS 文本)
Hermes:index.hbc(二进制字节码)+ 同名 .map(sourcemap)
常见误区
- 以为 .hbc 是加密或压缩:它是字节码,不是加密,引擎版本不匹配会加载失败。
- 以为字节码能跨版本复用:Hermes 引擎版本升级后必须重新编译。
追问
- 为什么 Hermes 不把字节码打进 APK 任意位置?答:字节码要随原生壳打包,且加载路径与引擎初始化逻辑绑定。
- 开发模式为什么不用字节码?答:开发模式要支持热更新与快速刷新,必须用源码 bundle。
07.2.2.3-003 无 JIT 的取舍是什么?
一句话结论
无 JIT 意味着没有机器码缓存、没有热点路径优化,峰值吞吐量会下降;但换来的是没有 JIT 代码段的内存开销、没有 JIT 编译线程的启动延迟,以及更可预测的性能曲线。
概念解释
JIT 的工作原理是:引擎在运行一段时间后识别热点函数,把它们编译成机器码缓存起来,后续调用走机器码。这套机制在桌面浏览器里收益巨大,但在移动端有两个代价:JIT 代码段占用内存、JIT 编译本身要花时间且需要可执行内存(在某些平台/版本上对内存与安全策略有要求)。
Hermes 放弃 JIT 后,所有代码都在解释器上跑。对 RN 而言,业务代码主要是 UI 逻辑与状态流转,热点计算有限,放弃 JIT 的代价在大多数场景下不明显;但如果有大量数值计算、大列表数据处理,会感知到性能差异。
原理流程
JIT 引擎:
解释执行 → 识别热点 → 编译机器码 → 走机器码
(越跑越快,但前期慢、内存高)
Hermes:
始终解释执行字节码
(性能曲线平稳,前期快、内存低)
代码或图示
| 维度 | 有 JIT | 无 JIT(Hermes) |
|---|---|---|
| 启动后性能 | 前期慢后期快 | 始终平稳 |
| 内存 | 多 JIT 代码段 | 少一块 |
| 可执行内存 | 需要 | 不需要 |
| 热点计算 | 收益大 | 收益小 |
常见误区
- 以为无 JIT = 引擎很慢:解释器本身也在持续优化,热点路径有内联缓存等手段。
- 以为任何性能问题都该换 JSC:先 profile 确认瓶颈真在解释器上。
追问
- Hermes 有哪些补偿手段?答:字节码层面的优化、内联缓存、隐藏类优化等(具体实现以版本源码为准)。
- 为什么移动端 JIT 还要考虑可执行内存?答:移动系统对 W^X 策略、JIT 内存区域有约束,早年 iOS 上 JIT 甚至受限。
07.2.2.3-004 Hermes 的内存特征与 JSC 有什么不同?
一句话结论
Hermes 内存占用更低、峰值更可预测:没有 JIT 代码段、字节码只读映射、GC 策略偏移动端低延迟;但对象模型与 GC 行为不同,长时运行后内存增长曲线与 JSC 不一致。
概念解释
Hermes 的内存收益主要来自三块:一是没有 JIT 代码段,省下一块可执行内存;二是字节码文件可以 mmap,只读部分共享;三是 GC 面向移动场景,目标是停顿短而不是吞吐高。代价是:Hermes 的对象头、字符串、闭包表示有自己的模型,与 JSC 不通用;且因为没有 JIT,某些临时对象分配模式在解释器下成本不同。
工程上需要注意:Hermes 下内存问题的 profile 工具链与 JSC 不同,不能直接套用 Web 或 JSC 的内存分析经验。
原理流程
JSC 内存:堆对象 + JIT 代码段 + 字节码 + 解析器状态
Hermes 内存:堆对象 + mmap 的只读字节码 + GC 管理的对象
代码或图示
| 内存项 | JSC | Hermes |
|---|---|---|
| JIT 代码段 | 有 | 无 |
| 字节码 | 运行时生成 | 构建期产物,mmap |
| GC 策略 | 偏吞吐 | 偏低延迟 |
| 内存峰值 | 较高 | 较低 |
常见误区
- 以为换 Hermes 内存问题就自动解决:业务侧的大图、缓存、监听器泄漏照样存在。
- 以为 Hermes 内存占用始终更低:长时运行后 GC 行为差异会导致曲线不同。
追问
- Hermes 的 GC 是什么策略?答:分代式 GC(具体实现与版本演进以官方文档为准,待确认)。
- 怎么测量 Hermes 内存?答:用 Hermes 自带的 heap dump 工具或平台内存分析工具,具体命令以版本为准。
07.2.2.3-005 RN 应用的启动链路分哪几段?
一句话结论
冷启动可拆成:原生壳进程初始化 → JS 引擎初始化 → JS 包加载与执行 → React 首屏渲染 → 首屏可交互(TTI);每一段的耗时构成与优化手段完全不同。
概念解释
很多"启动慢"的讨论笼统地把所有时间加在一起,无法定位问题。正确的分段是:
- 原生壳初始化:进程创建、Application.onCreate、首屏 Activity/ViewController 初始化、第三方 SDK 初始化。
- 引擎初始化:创建 JS 运行时(Hermes/JSC)、加载字节码、建立 JSI 绑定。
- JS 包执行:执行入口模块、执行根组件模块、模块注册。
- 首屏渲染:React 渲染首屏组件树、Yoga 布局、原生视图挂载。
- 首屏可交互:首屏内容出现且能响应输入,即 TTI。
每一段都可能成为瓶颈:原生 SDK 串初始化、引擎与字节码加载、JS 模块同步执行过多、首屏组件树过重。
原理流程
进程创建
→ Application.onCreate / 原生壳初始化
→ 创建 JS 引擎(Hermes)
→ 加载 .hbc 字节码
→ 执行 JS 入口模块(含 require 图)
→ React render 首屏组件树
→ Yoga 布局 + 原生视图挂载
→ 首屏像素出现(FP)
→ 可交互(TTI)
代码或图示
| 阶段 | 典型耗时来源 | 优化方向 |
|---|---|---|
| 原生壳初始化 | 第三方 SDK 串初始化 | 异步/延迟初始化 |
| 引擎初始化 | 字节码加载、JSI 绑定 | 引擎复用、预热 |
| JS 包执行 | 模块同步 require、顶层副作用 | inline requires、分包 |
| 首屏渲染 | 组件树过重、布局深 | 延迟渲染、骨架屏 |
| TTI | 首屏后还有同步任务 | 把首屏后任务挪到空闲 |
常见误区
- 把启动慢全部归因于 JS 包大:原生壳初始化可能占了一半时间。
- 用开发包测启动:开发包带调试逻辑,不能代表线上。
追问
- 热启动和冷启动差在哪?答:热启动进程已在、引擎已在,只做 Activity 重建;冷启动要走完整链路。
- 为什么要区分 FP 与 TTI?答:FP 是首屏像素出现,TTI 是能交互,中间可能有数据加载与同步任务。
07.2.2.3-006 TTI 的口径怎么定,怎么测量?
一句话结论
TTI(Time to Interactive)是从用户点击图标到首屏可响应输入的时间;口径必须统一(从哪一刻开始、到哪一刻算可交互),且要在真机、发布包、用户路径下测量,不能用开发包。
概念解释
TTI 没有唯一标准,团队内部必须约定:起点通常是进程创建(或 Activity onCreate),终点是首屏关键内容出现且用户操作有响应。工程上常见的口径是:原生壳打点 + JS 侧首屏渲染完成打点 + 首次可交互打点,全程上报。
测量的陷阱是:开发包带调试器、热更新、未压缩代码,测出来的启动时间比线上慢好几倍;模拟器性能与真机不同;低端机与旗舰机差异巨大。所以 TTI 必须在真机发布包上测,且分位数(P50/P90)才有意义。
原理流程
起点:进程创建(或 Activity onCreate)
→ 分段打点:引擎初始化完成、JS 执行入口、首屏渲染完成、首次可交互
→ 上报到性能监控
终点:首屏关键交互可用
代码或图示
| 口径 | 起点 | 终点 |
|---|---|---|
| 进程启动 | 进程创建 | 首屏 Activity 可用 |
| JS 引擎初始化完成 | 进程创建 | 引擎 ready |
| FP(首像素) | 进程创建 | 首屏内容上屏 |
| TTI | 进程创建 | 首屏可交互 |
常见误区
- 用开发包测 TTI:结果不可信,必须用发布包。
- 只报平均值:平均值会被长尾掩盖,P90/P95 才反映真实体验。
追问
- 怎么打点才准确?答:原生侧在关键节点埋点,JS 侧用性能 API,统一时间基准。
- TTI 与用户感知为什么可能不一致?答:用户看到了内容但首屏还有同步任务阻塞交互,TTI 会晚于视觉感受。
07.2.2.3-007 启动期模块注册与懒加载的关系是什么?
一句话结论
旧架构下所有原生模块在启动期全量注册与初始化,拖慢启动;TurboModules 把模块改为首次访问时才创建(懒加载),从而把启动期模块成本转移到使用时;但懒加载不是免费的,关键路径模块仍需预热。
概念解释
旧架构的模块系统在启动时遍历所有注册模块,实例化并登记到模块表,方法 ID 在这时分配。模块数量多了,这部分时间线性增长。TurboModules 改了模型:模块注册只是登记工厂,真正的实例在 JS 首次访问时才创建(详见 07.2.2.1)。
对启动优化而言,这意味着启动期不必初始化那些"首屏用不到"的模块。但代价是首次访问某模块时会有一次初始化开销;如果首屏恰好要用到该模块,反而会变成首屏卡顿。所以策略是:非关键路径模块懒加载,关键路径模块在启动后预热(pre-warm)。
原理流程
旧:启动期遍历所有模块 → 实例化 → 登记
新:启动期只登记工厂 → JS 首次访问 → 实例化(懒加载)
→ 关键路径模块启动后主动 pre-warm,把初始化成本挪到首屏后
代码或图示
| 策略 | 适用模块 | 代价 |
|---|---|---|
| 懒加载 | 首屏用不到的模块 | 首次访问有初始化延迟 |
| 预热 | 首屏或关键路径模块 | 启动后占用 CPU,但用户无感 |
| 全量初始化 | 旧架构默认 | 启动慢 |
常见误区
- 以为 TurboModules 自动解决启动:懒加载只是把成本转移,关键路径仍要预热。
- 以为预热越多越好:预热过多会抢首屏 CPU,反而拖慢 TTI。
追问
- 怎么判断哪些模块要预热?答:分析首屏路径上实际访问的模块,按访问频率与初始化成本排序。
- 预热在哪个线程做?答:必须在不阻塞 JS 与 UI 的线程做,具体 API 以版本为准。
07.2.2.3-008 inline requires 是什么,为什么能改善启动?
一句话结论
inline requires 把模块的 require 从"顶层一次性执行"改成"用到时才执行",让首屏只加载首屏必需的模块,其余模块在首次访问时才加载执行,从而减少启动期 JS 包执行时间。
概念解释
CommonJS 模块的 require 是同步的:顶层 import foo from 'foo' 会在模块加载时立刻执行 foo 及其依赖的整个模块树。如果入口文件顶层引入了大量首屏用不到的模块(例如设置页、关于页、未使用的工具库),这些模块在启动期全部执行,占用 JS 线程时间。
inline requires 的做法是:把 import 改为在函数内部 require('foo'),这样 foo 模块只有在该函数被调用时才执行。这在 React 里对应 React.lazy + Suspense 做代码分割,或在工具函数内部按需 require。
原理流程
入口顶层 import 大量模块
→ 启动期全部执行 → 首屏慢
inline requires:
入口只 import 首屏必需
其他模块在用到时 require
→ 启动期执行的模块数减少
代码或图示
// 差:顶层引入,启动期就执行
import { SettingsPage } from './settings';
// 好:用到时才加载
function openSettings() {
const { SettingsPage } = require('./settings');
}
常见误区
- 以为 inline requires 自动分包:它只是推迟执行,不减少包体积,要配合分包才能减少加载量。
- 在渲染路径上滥用 require:require 本身有成本,热路径上每次 require 会有额外开销。
追问
- inline requires 与 React.lazy 关系?答:React.lazy 是组件级代码分割,inline requires 是模块级,两者配合使用。
- 怎么发现哪些模块在启动期被无谓执行?答:用 Metro/React 的性能分析或 require 时间打点。
07.2.2.3-009 分包与模块预加载是怎么配合的?
一句话结论
分包把 JS 包切成"主包 + 次包",主包只含首屏必需代码,次包在需要时下载加载;模块预加载则是在首屏后、用户操作前主动加载次包,让用户真正进入时已经就绪。
概念解释
分包的本质是把"启动期必须执行"的代码和"后续才用"的代码分开。主包包含首屏组件、入口、核心模块;次包包含非首屏页面、非关键库。Hermes 下分包要处理 .hbc 字节码的加载与关联,不能只分 JS 文本。
预加载是策略:启动后空闲时间主动加载次包,但不执行;用户点击时再执行。这样把下载与加载成本从用户操作路径上挪走,代价是消耗流量与电量,需要按用户行为预测。
原理流程
启动:加载主包 .hbc → 首屏渲染
→ 空闲时间预加载次包 .hbc(下载但不执行)
→ 用户进入某页面 → 次包已就绪 → 执行次包 → 渲染
代码或图示
| 手段 | 解决的问题 | 代价 |
|---|---|---|
| 分包 | 启动期执行模块数 | 工程复杂度、加载协议 |
| 预加载 | 次包加载耗时 | 流量、电量 |
| inline requires | 顶层模块同步执行 | 代码写法变化 |
常见误区
- 以为分包能直接减包体积:它是把加载时机后移,总代码量没变。
- 预加载所有次包:浪费流量,要按用户行为预测。
追问
- Hermes 下次包字节码怎么加载?答:需要引擎支持额外的字节码段加载,具体协议以版本为准。
- 分包后版本不一致怎么办?答:主包与次包要做版本对齐,加载协议要处理回退。
07.2.2.3-010 启动预热(pre-warm)有哪些常见手段?
一句话结论
预热是把首屏后才需要的初始化工作提前到启动后空闲时间做,常见手段包括:JS 引擎预热、关键模块 pre-warm、首屏后数据预取、图片预热;目标是把成本移出用户可感知窗口。
概念解释
预热的前提是"用户首屏后大概率会用"。常见手段:引擎预热(在首屏渲染后创建引擎实例备用)、关键模块 pre-warm(主动触发 TurboModule 实例化)、数据预取(首屏渲染完成后预取次屏数据)、图片预热(预下载列表图片到缓存)。
预热的风险是:在首屏关键路径上做预热会抢 CPU,反而拖慢 TTI。所以预热必须放在首屏完成后,且要分优先级。
原理流程
进程启动 → 首屏渲染(关键路径,不做任何预热)
→ 首屏完成打点
→ 空闲时间按优先级预热:引擎备用实例、关键模块、次屏数据、图片
代码或图示
预热优先级示意:
P0:首屏后立即要用的(如次屏数据)
P1:用户高频路径(如列表图片)
P2:低频路径(如设置页模块)
常见误区
- 在首屏前做预热:抢 CPU,拖慢 TTI。
- 预热所有模块:初始化成本累加,得不偿失。
追问
- 怎么判断预热有没有拖慢 TTI?答:对比预热开关前后的 TTI 分位数。
- 引擎预热有收益吗?答:在多 Surface 或混合嵌入场景下,预热第二个引擎实例能让后续 RN 页面秒开。
07.2.2.3-011 JS 包体积由什么构成,怎么瘦身?
一句话结论
JS 包由业务代码、第三方依赖、polyfill、sourcemap 信息构成;瘦身手段包括剔除未用依赖、移除 polyfill、压缩混淆、按需引入,但要注意 Hermes 下是字节码,不是直接压缩文本。
概念解释
bundle 体积直接影响下载、字节码加载与内存。构成上:业务代码通常占小头,第三方依赖(尤其完整引入的 UI 库、工具库)占大头;polyfill 对现代 Hermes 可能已经不需要;sourcemap 不进发布包。
瘦身手敏:用 bundler 分析工具找出最大依赖;把完整库引入改为按需引入(如 lodash 按需);检查 polyfill 是否必要;移除调试代码与未使用的导出。Hermes 下还要注意字节码体积与源码体积的换算关系,不能只看源码包大小。
原理流程
bundle 分析:找出最大模块
→ 剔除未用依赖
→ 按需引入(避免 import 整个库)
→ 移除冗余 polyfill
→ 压缩混淆(发布构建)
→ hermesc → 字节码体积
代码或图示
| 构成 | 占比(典型) | 优化手段 |
|---|---|---|
| 业务代码 | 小 | 死代码删除 |
| 第三方依赖 | 大 | 按需引入、替换轻量库 |
| polyfill | 中 | 按目标引擎版本裁剪 |
| 调试代码 | 小 | 发布构建剔除 |
常见误区
- 只看源码包大小:Hermes 下要看字节码体积。
- 盲目替换小库:要考虑维护性与稳定性。
追问
- 怎么分析 bundle 构成?答:用 Metro 的 bundle 分析工具或可视化插件,具体以版本为准。
- tree-shaking 在 RN 里有效吗?答:对 ESM 依赖有效,对 CommonJS 依赖有限。
07.2.2.3-012 Hermes 下的 sourcemap 与崩溃栈还原怎么做?
一句话结论
Hermes 字节码不直接对应源码,线上崩溃栈是字节码地址或混淆后的函数名;需要构建期保存 .hbc 对应的 sourcemap,线上用 sourcemap 把栈还原成源码位置。
概念解释
发布包是字节码,崩溃栈里的函数名、行号都是字节码层面的。要还原成可读源码,必须有:构建产物 .hbc、对应的 sourcemap 文件、以及版本信息(版本号、构建号)。线上崩溃上报时,把字节码栈上报,后端用对应版本的 sourcemap 还原。
工程上必须做到:每次发版都归档该版本的 .hbc 与 sourcemap,与版本号一一对应;否则线上崩溃无法还原。Hermes 还支持在构建时保留可读函数名(--emit-call-sites 等选项,具体以版本为准),便于调试。
原理流程
构建期:bundle → hermesc → .hbc + sourcemap
→ 归档:版本号 ↔ .hbc ↔ sourcemap
线上崩溃:上报字节码栈
→ 后端按版本号取 sourcemap
→ 还原成源码位置
代码或图示
归档示意:
v1.0.3+100
├─ index.android.hbc
├─ index.android.hbc.map
├─ index.ios.hbc
└─ index.ios.hbc.map
常见误区
- 不归档 sourcemap:线上崩溃无法还原。
- 用最新版 sourcemap 还原旧版崩溃:版本对不上,还原位置错误。
追问
- Hermes 栈与 JSC 栈格式不同吗?答:不同,还原工具链要按引擎区分。
- 怎么确保 sourcemap 不泄漏到客户端?答:sourcemap 不上线,只在服务端保留。
07.2.2.3-013 Hermes 下怎么调试?
一句话结论
Hermes 下通过 Chrome DevTools 协议调试(Flipper 或官方 DevTools),支持断点、调用栈、作用域检查;但因为是字节码,调试体验与 JSC 有差异,且某些高级功能(如内存 profiling)工具链不同。
概念解释
Hermes 提供了自己的调试协议,支持 Chrome DevTools 连接。调试时可以在源码上打断点,引擎把字节码位置映射回源码。但 Hermes 调试器与 JSC 调试器不是同一套,Flipper 在官方体系中曾经是主力工具,近年官方调试入口有调整(具体工具链现状以官方文档为准,待确认)。
需要注意:发布包不能调试,调试只能在开发包或带调试开关的包上做;线上问题靠 sourcemap + 日志,不能靠 attach debugger。
原理流程
开发包 → Hermes 开启调试服务
→ Chrome DevTools / Flipper 连接
→ 断点、调用栈、作用域、控制台
发布包 → 无调试服务 → 靠日志与 sourcemap 还原
代码或图示
| 调试场景 | 工具 |
|---|---|
| 开发期断点 | Chrome DevTools / 官方 RN DevTools |
| 原生模块调试 | 平台原生调试器(Android Studio / Xcode) |
| 线上崩溃 | sourcemap 还原 |
| 性能分析 | Hermes profiler / 平台性能工具 |
常见误区
- 以为 Hermes 不能调试:可以调试,只是工具链与 JSC 不同。
- 在发布包上 attach 调试:发布包不开放调试端口。
追问
- Flipper 现在还是首选吗?答:官方工具链在调整,Flipper 的支持状态以最新文档为准(待确认)。
- 怎么调试启动期 JS 代码?答:启动期代码运行早,调试器连接前可能已执行,需要打点或离线复现。
07.2.2.3-014 Hermes 下的性能分析怎么做?
一句话结论
Hermes 性能分析分两层:JS 层用 Hermes profiler 看函数耗时与调用栈,原生层用 Systrace/Perfetto 看线程与渲染;两者结合才能定位是 JS 长任务还是原生侧耗时。
概念解释
Hermes 提供采样 profiler,可以导出函数级耗时数据。但它只能看 JS 层,看不到原生模块的 C++/Java/ObjC 实现耗时。要完整定位,必须同时看:JS profiler(函数耗时)、平台 trace(线程调度、渲染、GC)。
常见分析路径:先看 JS profiler 是否有单函数长耗时;再看 trace 里 JS 线程是否被同步原生调用阻塞;最后看 UI 线程的挂载与绘制。
原理流程
复现问题 → 同时启动:
├─ Hermes profiler(JS 函数采样)
└─ Systrace/Perfetto(全线程 trace)
分析:
├─ JS 函数长耗时 → 优化业务逻辑
├─ JS 线程被同步原生阻塞 → 改异步
└─ UI 线程耗时 → 优化视图与绘制
代码或图示
| 工具 | 看什么 | 局限 |
|---|---|---|
| Hermes profiler | JS 函数耗时、调用栈 | 看不到原生实现 |
| Systrace/Perfetto | 线程调度、渲染、GC | 不看 JS 函数内部 |
| 平台内存工具 | 内存、GC | 引擎相关项有限 |
常见误区
- 只看 JS profiler 就下结论:同步原生阻塞在 JS profiler 上表现为一个函数长,但根因在原生。
- 用模拟器分析性能:模拟器性能与真机差异大。
追问
- Hermes GC 停顿怎么观测?答:在 trace 里看 GC 事件,具体工具以版本为准。
- 怎么定位 JS 长任务?答:profiler 里看单帧内耗时最长的函数,结合调用栈找根因。
07.2.2.3-015 启动监控的口径与治理流程是什么?
一句话结论
启动治理是一个闭环:定义指标口径 → 线上分位数监控 → 回归分析 → 定位瓶颈段 → 优化 → 验证 → 固化;不能靠一次性优化,要持续监控防止退化。
概念解释
启动指标必须在全量用户上监控,分 P50/P90/P95,因为平均值掩盖长尾。监控要有分维度:机型档位、系统版本、网络、冷/热启动、是否首装。治理流程是:每次发版看启动指标是否退化,退化时用分段打点定位是哪一段变慢,然后针对性优化。
常见的治理手段是:建立启动预算(每段耗时上限)、CI 中跑启动 benchmark、灰度发版看启动指标。
原理流程
1. 定义口径:起点、终点、分段打点
2. 全量上报:P50/P90/P95 分维度
3. 发版对比:新版本 vs 旧版本分位数
4. 退化定位:分段打点找出变慢段
5. 优化:针对该段做工作
6. 验证:灰度后再看分位数
7. 固化:启动预算 + CI 回归
代码或图示
| 指标 | 用途 |
|---|---|
| P50 启动耗时 | 大多数用户体验 |
| P90/P95 | 长尾与低端机体验 |
| 分段耗时 | 定位瓶颈段 |
| 分机型 | 低端机针对性优化 |
常见误区
- 只看平均值:长尾被掩盖。
- 一次性优化后不再监控:后续发版会退化。
追问
- 启动预算怎么定?答:按机型档位分别定预算,低端机放宽,旗舰机收紧。
- 怎么发现某次发版启动退化?答:CI 跑 benchmark + 灰度期看分位数曲线。
07.2.2.3-016 综合题:某 App 升级 Hermes 后启动变慢了,怎么排查?
一句话结论
先确认对比口径是否一致(开发包 vs 发布包、机型、版本),再分段量:引擎初始化、字节码加载、JS 执行、首屏渲染;重点怀疑字节码体积异常、初始化副作用、同步原生调用,而不是"Hermes 本身慢"。
概念解释
这类问题最常见的根因不是 Hermes 引擎本身,而是对比口径错误或工程配置问题。第一步是确认:用的是发布包还是开发包?机型一致吗?升级 Hermes 时是否同步升级了 RN 版本?是否重新编译了字节码?
第二步分段量:如果引擎初始化段变慢,可能是字节码文件损坏或版本不匹配;如果 JS 执行段变慢,可能是 Hermes 下某些模块行为差异(如正则、JSON 解析性能);如果首屏渲染段变慢,与 Hermes 无关,是渲染层问题。
第三步怀疑配置:是否开启了调试?是否字节码未压缩?是否有 sourcemap 被错误打进包?
原理流程
1. 对齐口径:发布包、真机、同机型、同版本
2. 分段打点量:
├─ 引擎初始化慢? → 检查字节码版本、文件大小
├─ 字节码加载慢? → 检查 .hbc 是否损坏、是否过大
├─ JS 执行慢? → Hermes profiler 找热点函数
└─ 首屏渲染慢? → 与 Hermes 无关,按渲染管线查
3. 检查配置:调试开关、压缩、sourcemap
4. 对比 JSC 基线:确认是 Hermes 特有问题还是工程问题
代码或图示
判定树:
升级 Hermes 后启动慢
→ 对比口径一致?(开发包/机型/版本)
├─ 否 → 先对齐口径再测
└─ 是 → 分段量
├─ 引擎初始化慢 → 字节码版本/文件
├─ JS 执行慢 → profiler 热点
└─ 渲染慢 → 渲染层问题,与 Hermes 无关
常见误区
- 直接换 JSC 回滚:没定位根因,回滚后仍可能复发。
- 用开发包对比:开发包带调试,结果不可信。
追问
- Hermes 下哪些 JS 代码可能变慢?答:复杂正则、大量 JSON、密集数值运算,因为无 JIT。
- 怎么确认字节码是否正确生成?答:对比 .hbc 文件大小、检查构建日志、用 hermes 反汇编验证。