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

07.2.2.6 状态管理、导航与数据层

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

本节要解决的问题

  • 状态管理到底选 Redux Toolkit、Zustand、Jotai、Context 还是 MobX?决策依据是什么?
  • 为什么 Context 一更新整棵树重渲染,选择器(selector)在其中到底解决了什么?
  • React Navigation 的嵌套栈与原生导航栈是什么关系,深链、Universal Link、路由守卫怎么落地?
  • 请求层为什么要统一封装拦截器、重试、超时与取消,而不是在业务里直接 fetch?
  • 本地缓存用 AsyncStorage、MMKV 还是 SQLite?缓存策略与失效机制怎么设计?
  • 登录态与 token 刷新在并发请求下怎么避免"刷新风暴"?
  • 数据层为什么要分 UI、状态、仓库、数据源四层,而不是组件里直接发请求?

版本前提:本页涉及的第三方库(Redux Toolkit、Zustand、Jotai、MobX、React Navigation、axios、MMKV、AsyncStorage、WatermelonDB 等)均独立演进,API 名与默认行为以各库最新文档为准;凡涉及具体 API、字段名、默认开关处均标注「待确认」,落地前需按项目实际版本核对。

覆盖范围

知识域 关键内容
状态管理方案 Redux Toolkit、Zustand、Jotai、Context、MobX 的取舍与选择器、重渲染控制
跨组件与跨页通信 事件总线、全局 store、ref 共享、导航参数透传的边界
导航体系 React Navigation 的 Stack/Tab/Drawer 嵌套、原生导航栈、深链与 Universal Link、路由守卫、页面懒加载
请求层 fetch/axios 封装、拦截器、重试与超时、取消、错误归一化
本地数据 AsyncStorage/MMKV/SQLite/ORM 取舍、缓存策略、TTL 与失效
一致性与登录态 乐观更新、冲突合并、token 刷新、错误分层、数据层分层

题号索引

题号区间 主题
001-005 状态管理方案取舍、选择器、Context 重渲染、跨组件通信
006-010 React Navigation 结构、嵌套栈、深链、路由守卫、页面懒加载
011-014 请求层封装、重试超时取消、错误归一化、登录态与 token 刷新
015-018 本地缓存方案取舍、缓存策略与失效、乐观更新、数据层分层
019-020 离线优先综合题、电商 App 数据层设计综合题

07.2.2.6-001 Redux Toolkit、Zustand、Jotai、Context、MobX 怎么选?

一句话结论

没有银弹,决策依据是「状态粒度、更新频率、团队熟悉度、调试与时间旅行需求」。大型复杂应用、需要严格单向数据流与可追踪性选 Redux Toolkit;中小型、偏好极简 API 与细粒度订阅选 Zustand;原子化、渲染性能敏感选 Jotai;低频、穿透式传递(主题、用户配置)用 Context;团队已熟悉 OOP/响应式且接受可变模型选 MobX。

概念解释

Redux Toolkit(RTK)在经典 Redux 之上提供了 slice、immutable 更新工具(Immer)、序列化中间件与 RTK Query,它强制单向数据流:action → reducer → store → 视图,调试工具链(时间旅行、action 日志)最成熟,但样板代码与心智成本仍在。Zustand 用一个或多个 hook store 替代 provider,组件通过 selector 订阅切片,不存在 provider 嵌套,API 极小,重渲染只在选中的切片变化时触发。Jotai 把状态拆成原子(atom),组件订阅哪个原子就只对哪个原子变化敏感,适合大量独立 UI 状态(输入框、开关、弹窗可见性)。Context 本质是「依赖注入容器」而非状态管理:任何 value 变化都会让所有消费组件重渲染,不适合高频更新。MobX 用 observable + 响应式依赖收集,写法接近 OOP,运行时自动追踪依赖并精确更新,但可变模型与调试工具不如 Redux 直观。

原理流程

状态变化触发链路:
  方案A:dispatch(action) → reducer 纯函数 → 新 store → 订阅组件对比后重渲染(RTK)
  方案B:setState(partial) → store 内部更新 → 对该切片订阅的组件重渲染(Zustand)
  方案C:atom.set(v) → 依赖该 atom 的组件重渲染(Jotai)
  方案D:context value 变化 → 所有 useContext 的组件无条件重渲染

代码或图示

维度 RTK Zustand Jotai Context MobX
样板代码 中 极少 少 少 中
重渲染控制 selector 浅比较 selector + shallow 原子级 全量消费 依赖收集
时间旅行调试 强 弱 弱 无 弱
异步方案 thunk / RTK Query 自由写 自由写 自由写 action / flow
适用规模 大型复杂 中小到大型 UI 状态密集 低频穿透 熟悉 OOP 团队

常见误区

  • 误区:把所有状态都塞全局 store;正解:组件局部状态(useState/useReducer)仍是首选,全局只放跨页共享、真跨组件状态。
  • 误区:Context 包一层 Provider 就是状态管理库;正解:Context 不带更新订阅切片,高频更新场景必须配合外部 store 或拆分多个 Context。

追问

  • Q:RTK Query 与手写 fetch 封装的差异?A:RTK Query 内置缓存、失效、重试、乐观更新,代价是把请求语义也纳入 store 体系,适合接口形态稳定的业务。
  • Q:Zustand 怎么避免 selector 返回新引用导致的重渲染?A:用 useStore(selector, shallow) 或 selector 只返回原始值,避免每次返回新对象(具体 API 以版本为准,待确认)。

07.2.2.6-002 Context 为什么一更新就整树重渲染,怎么破?

一句话结论

Context 的 value 一旦变化,所有消费它的组件都会重渲染,无论它们实际用到了 value 的哪一部分;要破这个局,要么把 value 拆小并配合 memo,要么改用外部 store + useSyncExternalStore,要么把高频状态从 Context 里剥离。

概念解释

React 在渲染期调用 useContext 时会记录依赖的 Context 对象,只要 Provider 的 value 引用变化,React 就会调度所有消费组件重渲染。React 无法知道消费组件用了 value 的哪个字段——这是设计上的简化。常见错误是把 { user, theme, locale } 三个完全无关的对象放进同一个 Context,任何一个字段更新都会触发整棵消费树。

外部 store 之所以能做到「切片订阅」,是因为组件自己通过 useSyncExternalStore 注册了对 store 的订阅,并在 store 变化时用 selector 计算快照,只有快照引用变化才重渲染——这是 React 官方提供的外部 store 一致性接口。

原理流程

Context 方案:
  <Provider value={v}>  ──v 变化──▶  所有 useContext(Context) 组件重渲染
外部 store 方案:
  store.set(patch) ──▶ 订阅者回调 ──▶ 跑 selector 取快照
                                    ├─ 快照未变 ──▶ 不重渲染
                                    └─ 快照变了 ──▶ 只重渲染该组件

代码或图示

// 示意:错误用法 —— value 是每次渲染新建的对象
<AppContext.Provider value={{ user, theme }}>{children}</AppContext.Provider>
// 即使 user/theme 都没变,value 引用每次都变,消费组件全部重渲染

// 修正:拆 Context + useMemo 固定 value
<UserContext.Provider value={user}>{children}</UserContext.Provider>
<ThemeContext.Provider value={theme}>{children}</ThemeContext.Provider>

常见误区

  • 误区:给 Provider 外面包一层 React.memo 就能阻止整树重渲染;正解:memo 挡的是父组件重渲染,挡不住 value 引用变化带来的消费方重渲染。
  • 误区:把主题、登录用户、国际化文案全塞一个 Context;正解:按更新频率拆 Context,低频 Context 穿透高频树。

追问

  • Q:useSyncExternalStore 解决了什么?A:解决外部 store 在并发渲染下可能读到撕裂快照的问题,是 React 18 官方推荐的外部 store 接入方式(具体 API 以 React 版本为准)。
  • Q:什么时候 Context 仍然是正确选择?A:低频、全局、穿透式的配置(主题、地区、是否暗色),且消费方对重渲染不敏感。

07.2.2.6-003 Zustand 的 selector 与浅比较机制是什么?

一句话结论

Zustand 的 hook 允许组件只订阅 store 的某个切片,selector 返回值变化才触发重渲染;当 selector 返回新对象/数组时必须用浅比较(shallow)或返回原始值,否则会陷入"每次渲染都重渲染"的陷阱。

概念解释

Zustand 内部用 Object.is 比较 selector 上次返回值与本次返回值。如果 selector 写 useStore(s => ({ a: s.a, b: s.b })),每次都会返回一个新对象,Object.is 永远不等,组件就会在任何 store 更新时都重渲染。解决办法是要么分别选择:const a = useStore(s => s.a); const b = useStore(s => s.b),要么用官方提供的 shallow 比较器:useStore(s => ({ a: s.a, b: s.b }), shallow)。

这与 Redux 的 useSelector 默认浅比较一脉相承:只要切片内部结构没有变化,浅比较认为切片相等。

原理流程

store 任意字段 set
  ├─ 对每个订阅者:调用 selector(state) 取 nextSlice
  ├─ 与 prevSlice 用 Object.is 比较
  │    ├─ 相等 ──▶ 跳过
  │    └─ 不等 ──▶ 若传入比较器则用比较器;否则标记需要重渲染
  └─ 触发对应组件更新

代码或图示

// 示意:错误写法 —— selector 返回新对象,任何 store 更新都重渲染
const user = useUserStore(s => ({ name: s.name, id: s.id }));

// 修正一:分两次选择
const name = useUserStore(s => s.name);
const id = useUserStore(s => s.id);

// 修正二:用 shallow 比较(API 以版本为准)
import { shallow } from 'zustand/shallow';
const user = useUserStore(s => ({ name: s.name, id: s.id }), shallow);

常见误区

  • 误区:selector 只在 store 变化时才被调用;正解:每次 store 更新所有订阅者的 selector 都会执行,selector 本身要轻量,不要在里面做复杂计算。
  • 误区:Zustand 天然不会重渲染;正解:selector 写法不当比 Context 还容易触发重渲染。

追问

  • Q:selector 里做 map/filter 怎么办?A:把结果放到 store 里缓存,或用 useMemo 在组件里计算,不要在 selector 里每次返回新数组。
  • Q:Zustand 中间件怎么加日志与持久化?A:通过 create( persist( middleware(...) ) ) 组合,具体 API 以官方文档为准。

07.2.2.6-004 跨组件、跨页面通信有哪些方式,边界在哪?

一句话结论

按"耦合方向"分四类:父子用 props/回调,兄弟用共同父组件或提升状态,跨页面用全局 store 或导航参数,完全无关联的模块用事件总线。事件总线是最后手段,因为它会破坏数据流可追踪性。

概念解释

跨页面在 RN 中特指"两个不同路由下的页面实例"。它们之间没有 React 树的父子关系,props 传递不到。可选方案:

  • 全局状态(Zustand/RTK):可追踪、可持久化,但要避免把临时 UI 状态塞进去。
  • 导航参数:通过 navigation.setParams 或 navigate 时传参,适合"从 A 跳 B,B 返回 A 时带回结果"。
  • 事件总线(DeviceEventEmitter、Node 风格 EventEmitter):适合原生 → JS 推送(传感器、SDK 回调),但 JS 内部模块间滥用会让数据流变成蜘蛛网。
  • URL 深链参数:从外部唤起 App 时,参数是天然的全局通信载体。

原理流程

场景1:子组件改父组件状态 ── props 回调
场景2:兄弟组件同步       ── 状态提升到共同父组件
场景3:页面A → 页面B 返回结果 ── navigation.navigate('B', { onResult }) 或 setParams
场景4:完全无关模块广播    ── 全局 store / 事件总线(慎用)

代码或图示

场景 推荐方案 不推荐
父子传值 props 事件总线
兄弟同步 状态提升 全局 store
跨页返回结果 导航参数 / setParams 事件总线
原生 SDK 推送 DeviceEventEmitter 全局 store
全局登录用户 全局 store URL 参数

常见误区

  • 误区:事件总线是万能解;正解:监听与发射点分散,调试时很难追踪"谁改了我的状态"。
  • 误区:把导航参数当作全局存储;正解:离开页面参数就被销毁,不能依赖它做持久化。

追问

  • Q:原生模块怎么主动通知 JS?A:通过 DeviceEventEmitter 或 TurboModule 暴露的事件订阅 API(具体 API 以版本为准),JS 侧必须在卸载时 removeListener。
  • Q:两个页面都在导航栈里同时存活,怎么通知?A:用全局 store 让两个页面各自订阅同一切片,避免直接调用对方的 navigation。

07.2.2.6-005 Redux 的中间件、thunk、saga 有什么区别?

一句话结论

中间件是 dispatch 与 reducer 之间的拦截器链;thunk 让 action 可以是函数并在里面做异步;saga 用 Generator 把异步流程写成可中断的"协程",适合复杂编排(轮询、并发取消、重试)。中小型项目 thunk 足够,复杂业务流程才上 saga。

概念解释

Redux 中间件签名是 store => next => action => ...,可以在 action 到达 reducer 之前做日志、埋点、节流、异步。thunk 中间件识别 typeof action === 'function',把 dispatch 与 getState 注入进去,让开发者在函数里发请求、再 dispatch 真正的 action。RTK 默认包含 thunk,且 RTK Query 已经覆盖了大多数服务端缓存场景。

saga 把异步副作用写成 Generator:takeEvery、takeLatest、race、fork 这些 effect 让"等待某个 action 然后并发请求然后取消"这种流程可以声明式表达,且可以用单元测试模拟 effect 执行流。代价是心智成本高,Generator 调试不如 async/await 直观。

原理流程

dispatch(action)
  → 中间件链:logger → thunk / saga → ...
  → 若 thunk:执行 action(dispatch, getState),内部再 dispatch 真正的 action
  → 若 saga:监听到匹配 action,启动对应 Generator,effect 由 saga 解释器执行
  → reducer 纯函数计算新 state

代码或图示

维度 thunk saga RTK Query
写法 async/await 函数 Generator effect 声明式 endpoints
复杂编排 手写 takeLatest/race/fork 内建 有限
测试 普通异步测试 effect 断言测试 自动
适用 大多数异步 复杂流程编排 接口驱动型业务

常见误区

  • 误区:saga 是 Redux 的必备组件;正解:大多数业务 thunk 加 RTK Query 已足够。
  • 误区:在 thunk 里写死所有业务逻辑;正解:thunk 只做"发请求 → dispatch action",业务规则放 selector 或工具函数。

追问

  • Q:Redux 为什么要求 action 可序列化?A:中间件链与时间旅行调试依赖 action 能被记录与重放,塞函数/Promise 进去会破坏调试工具。
  • Q:saga 怎么处理并发请求取消?A:用 takeLatest 自动取消前一次,或手动 fork + cancel 任务(具体 API 以版本为准)。

07.2.2.6-006 React Navigation 的整体结构与原生导航栈是什么关系?

一句话结论

React Navigation 是 JS 侧的导航状态机,它通过 react-native-screens 把每个 Stack 屏幕映射为平台原生 ViewController/Activity,从而在手势、转场动画、返回行为上贴近原生;它不是"在 JS 里画一个假导航栏"。

概念解释

React Navigation 的核心是一个嵌套的导航器树:NavigationContainer 持有全局状态,下面可以挂 Stack、Tab、Drawer、Native Stack 等导航器。每个导航器维护自己的路由栈(route name + params + key)。JS 侧维护的是"路由状态",真正的视图切换通过 react-native-screens 渲染成原生屏幕组件(iOS 上对应 UINavigationController 的 push/pop,Android 上对应 Fragment/Activity 转场)。

@react-navigation/native-stack 直接使用原生导航栈,性能与手势体验最佳;@react-navigation/stack(JS stack)是纯 JS 实现的转场动画,可定制性强但性能与手势不如原生栈。

原理流程

navigation.navigate('Detail', { id })
  → 导航器状态更新:栈 [Home, Detail]
  → NavigationContainer 重渲染
  → Screens 渲染器:用 react-native-screens 挂载 Detail 屏幕
  → iOS:UINavigationController push 一个新 VC;Android:Fragment/转场动画
  → 返回手势/返回键:原生侧触发 → 通知 JS 栈 pop

代码或图示

导航器 实现 适用
native-stack 原生 VC/Activity 栈 主页面栈,性能与手势最佳
stack(JS) JS 实现转场 需要完全自定义动画
bottom-tabs JS 底部 Tab
drawer JS 侧滑菜单
native-drawer 原生 侧滑性能敏感

常见误区

  • 误区:React Navigation 就是一个 JS 路由表;正解:它背后是原生导航栈的映射,转场与手势由原生提供。
  • 误区:所有页面都该用 native-stack;正解:模态、自定义复杂转场仍可能用 JS stack。

追问

  • Q:为什么推荐 native-stack?A:它复用原生导航的转场、边缘返回手势、状态栏行为,JS 只负责路由状态。
  • Q:嵌套导航器时谁来处理返回?A:默认由最内层的导航器先消费返回事件,未消费才冒泡到外层,具体行为以版本为准。

07.2.2.6-007 Stack/Tab/Drawer 嵌套有哪些常见坑?

一句话结论

嵌套导航器的核心坑是「导航状态归属」与「返回事件冒泡」:Tab 里的某个 Stack 想要返回,要先 pop 内层 Stack 再切 Tab,直接 navigation.goBack 不会按预期走。

概念解释

典型结构是 NavigationContainer → Stack(主) → Tab(首页) → Stack(首页内部)。当用户在 Tab 内的详情页按返回时,JS 栈的行为是:先尝试 pop 内层 Stack,内层栈只有一个页面时就冒泡到 Tab,Tab 不会自动切到第一个 tab——这与用户预期"返回到首页 Tab"可能不一致。

另一个坑是 navigation.navigate 与 navigation.push 的差异:navigate 会复用已存在的同名路由(在栈中向上找),push 总是新加一个实例。详情页无限 push 同一个 Detail 是常见 bug。

原理流程

返回事件触发:
  ├─ 内层 Stack 栈深 > 1 → pop
  ├─ 内层 Stack 栈深 = 1 → 冒泡到 Tab
  │    └─ Tab 默认不切;需自定义 tabBarOnPress 或用 getParent() 主动切
  └─ 冒泡到最外层 Stack → pop

代码或图示

// 示意:从深层 Tab Stack 跳回首页 Tab 的正确写法
navigation.getParent()?.jumpTo('HomeTab');
// 或更直接:
navigation.navigate('MainStack', { screen: 'HomeTab' });

常见误区

  • 误区:Tab 嵌套 Stack 时,Tab 切换会保留 Stack 状态;正解:默认保留,但要确认配置项(unmountOnBlur 之类的开关以版本为准),否则会出现"切 Tab 后列表状态还在但数据已过期"。
  • 误区:navigate('Detail') 每次都新起一个页面;正解:它会复用栈中已有的 Detail,要 push 新实例必须用 push。

追问

  • Q:怎么自定义 Android 实体返回键行为?A:用 BackHandler 订阅,根据当前路由状态决定是 pop、切 Tab 还是退出 App。
  • Q:Tab 切换时如何避免重新请求数据?A:保留屏幕组件挂载(默认行为),配合数据层缓存,不要用 unmountOnBlur。

一句话结论

深链分三层:自定义 URL Scheme(如 myapp://detail/123)、Android App Link / iOS Universal Link(从网页直接唤起 App)、路由内路径解析。三层都要配置,且匹配优先级与回退行为必须明确。

概念解释

自定义 Scheme 简单,但任何 App 都能注册同名 Scheme,安全性低。Universal Link / App Link 要求 App 在 apple-app-site-association(iOS)或 assetlinks.json(Android)里声明域名与路径映射,用户在浏览器点 https://m.example.com/detail/123 时系统会校验域名归属并直接打开 App,未安装则回退网页。

在 RN 内部,NavigationContainer 的 prefixes 配置接收 Scheme 与 Universal Link 域名,config 把路径映射到路由名与参数。

原理流程

外部 https://m.example.com/detail/123
  → iOS/Android 校验关联文件 → 唤起 App
  → NavigationContainer 收到 initialURL / linking 事件
  → 用 linking.config 映射:/detail/:id → Detail 路由,params { id: 123 }
  → 导航器 stack push Detail

代码或图示

// 示意:linking 配置(字段以版本为准)
const linking = {
  prefixes: ['myapp://', 'https://m.example.com'],
  config: {
    screens: {
      Home: 'home',
      Detail: 'detail/:id',
    },
  },
};

常见误区

  • 误区:只配置了 prefixes 就以为 Universal Link 生效;正解:还必须在服务端部署 apple-app-site-association / assetlinks.json,且经过系统校验。
  • 误区:深链直接打开目标页就完事;正解:目标页需要登录态时要做路由守卫(见下一题),未登录要先跳登录再回跳。

追问

  • Q:App 已在后台时深链怎么处理?A:系统会触发 deep link 事件,NavigationContainer 通过 linking 接收并导航,需要监听 initialUrl 与后续 url 事件(具体 API 以版本为准)。
  • Q:Universal Link 打不开怎么办?A:排查关联文件是否 HTTPS、是否被 CDN 缓存、路径是否覆盖、App 中 Associated Domains 配置是否正确。

07.2.2.6-009 路由守卫与登录态拦截怎么落地?

一句话结论

不要在每个页面里写 if (!user) navigation.replace('Login');正确做法是把导航器按"未登录栈 / 已登录栈"切成两个根 Stack,登录态变化时整体切换,路由自然守卫。

概念解释

守卫的本质是"根据全局状态决定渲染哪棵导航树"。如果登录用户渲染 MainStack,未登录用户渲染 LoginStack,那么未登录用户根本看不到 MainStack 里的任何路由,自然不存在"漏一个页面没拦"的问题。深链进入时也按同一逻辑判断:未登录 → 存下目标路径 → 跳登录 → 登录成功后按存储路径回跳。

这种"条件渲染导航树"是 React Navigation 官方推荐模式,避免在每个页面散写判断。

原理流程

user 状态变化:
  ├─ null → <NavigationContainer><LoginStack /></NavigationContainer>
  └─ 存在 → <NavigationContainer><MainStack /></NavigationContainer>

深链 /detail/123 且未登录:
  1. 拦截器保存待回跳路径
  2. 渲染 LoginStack
  3. 登录成功 → 渲染 MainStack → 按保存路径 navigate

代码或图示

// 示意:条件渲染根导航器(API 以版本为准)
const isLoggedIn = useAuthStore(s => s.isLoggedIn);
return (
  <NavigationContainer linking={linking}>
    {isLoggedIn ? <MainStack /> : <LoginStack />}
  </NavigationContainer>
);

常见误区

  • 误区:用 navigation.addListener('beforeRemove') 拦所有路由;正解:那是阻止用户主动离开某页(如未保存表单),不是登录守卫。
  • 误区:登录成功后直接 replace('Home');正解:要检查是否有待回跳路径,有则回跳,否则回首页,否则用户会觉得"我点的链接去哪了"。

追问

  • Q:Token 过期与未登录怎么区分?A:未登录是用户态为 null;token 过期是有用户但 access token 失效,走请求层 401 刷新,刷新失败再登出。
  • Q:多角色权限怎么拦?A:在 MainStack 内部再按角色条件渲染子 Stack,不要在每个页面里判断 role !== 'admin'。

07.2.2.6-010 页面级代码分割与懒加载在 RN 里怎么做?

一句话结论

RN 没有 Web 那样的"运行时按需下载 chunk",但可以通过 React.lazy + Suspense 在 JS 包内做组件级拆分(首次渲染时才加载模块),真正的"分包下载"需要 Metro 配置 + 自建更新体系,不是开箱即用。

概念解释

Metro 默认把所有 JS 打进一个 bundle。React.lazy 依赖 ESM 动态 import(),Metro 支持按 import 切分模块,但这只影响"加载时机"(模块在首次引用时才执行),不影响 bundle 大小——所有模块仍打进同一个产物。在新架构 + 并发渲染下,Suspense 可以与 React.lazy 配合做页面级占位。

真正的"分包加载"需要两个条件:一是把 JS 拆成多个 bundle(Metro 可以配置多个 entry,但组织成本高);二是在运行时动态加载远程 bundle(这与 OTA 热更新体系强相关,见 07.2.2.8),且受平台合规约束。

原理流程

开发模式:
  React.lazy(() => import('./Detail'))
    → Metro 把 Detail 模块打入主 bundle
    → 首次渲染 Detail 时才执行模块代码(而非启动时)

生产分包(需要自建):
  主 bundle + 子 bundle(远程)
    → 主包启动 → 路由到子包页面时动态加载远程 bundle
    → 受 OTA 合规约束

代码或图示

方案 是否减小主 bundle 是否减小启动耗时 合规
React.lazy 否 略(延迟执行) 无
Metro 多 entry 是 是 无
远程 bundle 加载 是 是 受 OTA 规则约束(待确认)

常见误区

  • 误区:React.lazy 能像 Web 一样减小包体积;正解:Metro 仍会把模块打进 bundle,只是延迟执行。
  • 误区:新架构下 Suspense 可以直接等数据;正解:数据获取需要结合支持 Suspense 的库(如 React Query),且新架构支持矩阵以官方为准。

追问

  • Q:启动慢但首屏不需要的大模块怎么处理?A:用 require() 在交互回调里延迟引入,配合 InteractionManager.runAfterInteractions(具体 API 以版本为准)。
  • Q:远程 bundle 加载风险?A:版本不匹配、下载失败、平台合规,必须有兜底回退到主包。

07.2.2.6-011 fetch/axios 封装与拦截器应该长什么样?

一句话结论

统一封装一个 request 函数,承担 baseURL、header 注入、token 附加、错误归一化、loading 状态、上报;业务侧只调用 api.get<T>(path, params),不允许业务代码直接 fetch 或 axios.create。

概念解释

封装的核心价值是「错误路径只写一次」:401 刷新、403 跳登录、5xx 上报、网络错误降级、业务错误码(如 code !== 0)归一化,这些逻辑散在业务里一定会漂移。拦截器分请求拦截器(加 token、埋点)与响应拦截器(解包 data、识别错误、统一 Toast)。

fetch 原生不支持超时(要用 AbortController 手动包)、不支持请求/响应拦截器、错误只有 network 错误才 reject(HTTP 404/500 都 resolve),所以一般用 axios 或自封装 fetch。axios 在 RN 中可用,但其默认 adapter 与取消 API 在不同版本上有差异(CancelToken 已 deprecated,推荐 AbortController,待确认)。

原理流程

业务调用 api.get('/detail', { id })
  → 请求拦截器:注入 token、traceId、loading
  → 实际 HTTP 请求
  → 响应拦截器:
       ├─ HTTP 2xx 且业务 code === 0 → 返回 data
       ├─ 401 → 进入 token 刷新队列
       ├─ 业务错误码 → 抛归一化 ApiError + Toast
       └─ 网络错误 → 抛 NetworkError + 降级提示

代码或图示

// 示意:统一封装(API 以实际版本为准)
api.interceptors.request.use(cfg => {
  cfg.headers.Authorization = `Bearer ${auth.getAccessToken()}`;
  return cfg;
});
api.interceptors.response.use(
  resp => resp.data.code === 0 ? resp.data.data : Promise.reject(new ApiError(resp.data)),
  err => handleError(err)
);

常见误区

  • 误区:拦截器里直接 navigation.replace('Login');正解:拦截器不应该直接依赖导航,应该通过事件或 store 通知导航层。
  • 误区:把所有错误都 Toast 出来;正解:分页加载失败、静默轮询失败不该打断用户,错误分级处理。

追问

  • Q:axios 在 RN 中用什么 adapter?A:默认用基于 XHR 的 adapter,因为 RN 没有 Node http 模块,具体以 axios 文档为准。
  • Q:怎么取消请求?A:用 AbortController(axios 新版支持),在页面卸载时 abort,避免 setState on unmounted 警告。

07.2.2.6-012 重试、超时与取消怎么设计?

一句话结论

超时用 AbortController 统一控制,重试只对幂等请求(GET/部分 DELETE)做且要有指数退避与最大次数,取消在页面卸载、组件卸载、重复请求发出时触发。三者都要在请求层统一实现,不要业务里各自写。

概念解释

重试最常见的坑是「非幂等请求也重试」:POST 下单重试一次可能产生两笔订单。所以重试白名单必须按 method 与接口语义配置。指数退避(1s、2s、4s)避免对故障服务造成雪崩。

取消的典型场景:用户在详情页快速点进另一个商品,前一个请求回来时组件已卸载,setState 会报警告或操作已销毁的 store;输入框联想搜索时,慢的请求后到会覆盖快的请求结果,要用「最后一次请求生效」策略。

原理流程

发出请求:
  1. AbortController 启动超时定时器(如 10s)
  2. 若请求失败且 method 幂等且未超过最大次数 → 退避后重试
  3. 页面卸载 / 新请求发出 → controller.abort()
  4. abort 触发 reject,业务层识别 abort 不报错

代码或图示

场景 重试 超时 取消
GET 列表 可重试 10-15s 页卸载取消
POST 下单 不重试 10s 不取消(事务已发起)
搜索联想 不重试(用最后一次) 5s 新输入取消旧请求
上传 不重试 长超时 不取消

常见误区

  • 误区:超时时间越短越好;正解:弱网下短超时会导致大量误杀,要按接口语义分级。
  • 误区:所有失败都重试三次;正解:401、403、参数错误(4xx 除 408/429)都不该重试。

追问

  • Q:怎么避免请求竞态?A:为每个请求生成 requestId,响应回来时校验是否是最新 id,过期响应直接丢弃。
  • Q:上传下载怎么处理?A:用原生模块(如 RNFS、社区上传库),进度回调走事件,不走 axios。

07.2.2.6-013 AsyncStorage、MMKV、SQLite 怎么选?

一句话结论

KV 级、小数据、需要跨端一致选 AsyncStorage;对性能与同步读写敏感选 MMKV;结构化查询、关系数据、大数据量选 SQLite(或 ORM 封装)。三者不是互斥,可以在同一项目里分层使用。

概念解释

AsyncStorage 是 RN 官方推荐的异步 KV 存储,底层 Android 用 RocksDB/legacy 实现(版本不同实现不同,待确认),iOS 用原生序列化,API 全异步,容量小、适合存用户配置、token、缓存索引。它不适合存大 JSON,因为每次读写都要序列化整串。

MMKV 是腾讯开源的 mmap 存储,内存映射文件,读写直接操作内存页,异步但接近同步性能,支持加密(AES),适合高频小数据(登录态、开关、KV 缓存)。缺点是查询能力弱,只能按 key 取。

SQLite 是真正的关系型数据库,支持事务、索引、复杂查询,适合离线数据(聊天记录、离线购物车、本地缓存列表)。在 RN 中常见方案是 react-native-quick-sqlite、op-sqlite(WASM 性能路径)或 WatermelonDB(ORM 封装)。

原理流程

数据特征 → 选型:
  ├─ key-value,小,高频读写 → MMKV
  ├─ key-value,跨端一致,低频 → AsyncStorage
  ├─ 结构化,需要查询/事务 → SQLite / WatermelonDB
  └─ 大文件(图片、视频) → 文件系统(documentDir / cacheDir)

代码或图示

维度 AsyncStorage MMKV SQLite
数据模型 KV KV 表/关系
性能 一般 高(mmap) 取决于查询
查询能力 无 无 SQL
事务 无 无 有
适用 配置、token 高频小数据 离线数据

常见误区

  • 误区:把整个列表 JSON 序列化存 AsyncStorage;正解:列表数据走 SQLite 或内存缓存,AsyncStorage 只存索引。
  • 误区:MMKV 是同步 API 所以阻塞 JS 线程;正解:MMKV 读写在 JS 线程确实是同步操作,但因为是 mmap 所以很快,超大批量写入仍要注意。

追问

  • Q:敏感信息怎么存?A:token 用 MMKV 加密或原生 Keychain/Keystore 封装,不要明文存 AsyncStorage。
  • Q:WatermelonDB 的优势?A:它在 SQLite 之上提供响应式查询(observe),UI 层订阅后数据变化自动重渲染,适合离线优先 App。

07.2.2.6-014 缓存策略与失效机制怎么设计?

一句话结论

按数据"新鲜度要求"分级:强实时数据(价格、库存)不缓存或短 TTL;准实时数据(首页 feed)用 TTL + 后台刷新;弱实时数据(用户资料、字典)用长 TTL + 主动失效。失效分 TTL、版本号、标签失效、主动刷新四种。

概念解释

缓存三层:内存(页面/store)→ 磁盘(MMKV/SQLite/AsyncStorage)→ 网络。命中内存直接用,命中磁盘先渲染再后台刷新(stale-while-revalidate),未命中走网络。

失效策略:

  • TTL:固定时间过期,最简单。
  • 版本号:App 发版时缓存结构变了,统一丢弃旧缓存。
  • 标签失效:比如"商品详情页"缓存挂 product:123 标签,商品更新时让该标签下所有缓存失效。
  • 主动刷新:页面聚焦(AppState / useFocusEffect)时重新拉一次。

原理流程

请求 /detail/123:
  1. 内存有? → 立即返回
  2. 磁盘有且未过期? → 立即返回 + 后台静默刷新
  3. 磁盘有但已过期? → 返回旧数据(loading 骨架可选)+ 强制刷新
  4. 都没有 → loading → 网络 → 写内存/磁盘

代码或图示

数据类型 TTL 失效策略
价格/库存 0-30s 不缓存或短 TTL
首页 feed 1-5min 后台刷新 + 下拉刷新
用户资料 1h 标签失效
字典/枚举 24h 版本号失效

常见误区

  • 误区:缓存永不过期;正解:用户会永远看到旧数据,必须有 TTL 或主动失效。
  • 误区:把缓存当离线数据库用;正解:缓存是性能优化,离线数据要走 SQLite 并设计同步协议。

追问

  • Q:stale-while-revalidate 的风险?A:用户看到旧数据后突然跳变,关键页面(价格、库存)不适用。
  • Q:怎么批量失效?A:用标签,每个资源类型一个标签,写操作时在响应拦截器里让对应标签失效。

07.2.2.6-015 乐观更新与冲突合并怎么做?

一句话结论

乐观更新是"先改本地 UI 再发请求",失败时回滚;冲突合并用于多端并发写同一资源,按字段合并或按版本号拒绝。两者都要在数据层统一实现,不能散在业务里。

概念解释

典型场景:点赞按钮点击后立即变成已赞,再发请求;请求失败则回滚并 Toast。实现上是先更新 store,再发请求,catch 里把 store 改回旧值。复杂场景(文章编辑)需要保存快照,回滚时用快照还原。

冲突合并:多端同时编辑同一商品标题,A 端改完 B 端再改会覆盖 A 的修改。解法一是向量时钟/版本号(后端返回 version,写时带 version,不一致则 409);二是字段级合并(只提交改动字段,后端按字段 merge)。

原理流程

乐观更新:
  1. 记录旧值快照
  2. 立即 set 新值到 store(UI 先变)
  3. 发请求
     ├─ 成功 → 用服务端返回值校准
     └─ 失败 → 回滚到快照 + Toast + 上报

冲突合并:
  写请求带 version
     ├─ version 一致 → 写入成功,version +1
     └─ version 不一致 → 409,提示用户或自动合并

代码或图示

操作 乐观更新 回滚
点赞/取消 立即切换 失败切回
购物车数量 立即改数 失败改回
文章编辑 不乐观 保存草稿
下单 不乐观 按钮 loading

常见误区

  • 误区:所有操作都乐观更新;正解:涉及钱、不可逆操作(下单、删除)不能乐观。
  • 误区:乐观更新失败后只 Toast 不回滚;正解:UI 与服务端状态不一致比慢一点更糟。

追问

  • Q:乐观更新期间用户又改了怎么办?A:用队列合并:第一次失败回滚,第二次操作基于最新 store 重新发起,不要直接覆盖。
  • Q:离线场景的乐观更新?A:操作先入本地队列,网络恢复后按序重放,失败按业务规则处理。

07.2.2.6-016 登录态与 token 刷新怎么避免"刷新风暴"?

一句话结论

access token 短时效(如 15min),refresh token 长时效;401 时所有并发请求进入等待队列,只发一次刷新请求,刷新成功后重放队列,刷新失败则统一登出。

概念解释

没有队列会发生什么:页面同时发 5 个请求,access token 过期,5 个请求都 401,每个都去调 refresh,refresh token 被用了多次,服务端可能让 refresh token 失效(旋转 refresh token 模型),结果全部登出。

正确做法是一个「刷新单例」:模块级 refreshing Promise 标志,第一个 401 触发刷新,其他 401 把请求挂到这个 Promise 上等待。刷新成功后用新 token 重放;刷新失败(refresh 也过期)则清空登录态、跳登录。

原理流程

请求A 401 → 发现 refreshing === null
  → 创建 refreshing = refreshToken()
  → 请求B 401 → 发现 refreshing 已存在 → await refreshing
  → refreshing 成功:
       用新 token 重放 A、B
  → refreshing 失败:
       清登录态 → 跳登录 → A、B reject

代码或图示

// 示意:刷新队列(伪代码)
let refreshingPromise: Promise<string> | null = null;
function refresh() {
  if (!refreshingPromise) {
    refreshingPromise = api.refreshToken().finally(() => { refreshingPromise = null; });
  }
  return refreshingPromise;
}
// 响应拦截器 401 分支:await refresh() → 重放原请求

常见误区

  • 误区:refresh token 也存 MMKV 就行;正解:refresh token 是高敏凭据,原生侧 Keychain/Keystore 封装更安全。
  • 误区:刷新成功后直接让原请求用新 token 重发;正解:要重发,不是把新 token 塞回原响应,因为原请求已经被服务端拒绝。

追问

  • Q:refresh token 也要过期怎么办?A:refresh token 有自己的有效期,过期即登出,不要静默续期无限制。
  • Q:多端登录怎么处理?A:服务端按设备管理 refresh token,某端登出不影响其他端,刷新时校验设备 id。

07.2.2.6-017 错误分层与降级怎么做?

一句话结论

错误分四层:网络错误(断网、超时)、HTTP 错误(4xx/5xx)、业务错误(code !== 0)、JS 错误。每层处理方式不同,降级也分级:页面级骨架、组件级占位、操作级 Toast、全局白屏兜底。

概念解释

不分级的错误处理会导致两个极端:要么所有错误都弹 Toast 吵死用户,要么所有错误都静默导致数据不一致。正确做法是在请求层把错误归一化成 ApiError(带 kind 字段),业务侧按 kind 决定怎么处理。

降级的目标是"不要让一个模块的失败拖垮整个 App":商品详情页推荐区失败不应该影响详情主体;首页 Feed 失败应该展示缓存 + 重试按钮,而不是白屏。

原理流程

错误归类:
  NetworkError    → 弱网提示,自动重试
  HttpError(4xx)  → 401 走刷新,403 跳登录,其他 Toast
  HttpError(5xx)  → 上报,Toast 或静默
  BusinessError   → 按 code 处理(弹窗、跳页、静默)

降级:
  组件级失败 → 组件内展示占位/重试
  页面级失败 → 整页错误态 + 重试
  全局失败 → ErrorBoundary 兜底 UI

代码或图示

错误类型 用户感知 处理
断网 提示 重试按钮
超时 弱提示 自动重试
5xx 静默或 Toast 上报
业务错误码 按业务 Toast/弹窗
JS 异常 白屏 ErrorBoundary

常见误区

  • 误区:catch 住所有错误就不报了;正解:错误被用户看到的同时必须上报,否则线上出问题无法定位。
  • 误区:降级 UI 与正常 UI 长得一样;正解:降级要明确告知用户"这是缓存/失败态",避免误导。

追问

  • Q:ErrorBoundary 为什么抓不到异步错误?A:它只能捕获渲染期同步错误与生命周期错误,网络请求错误要在请求层处理。
  • Q:弱网怎么实测?A:用模拟器/真机网络节流工具,或用代理拦截延迟,专门跑降级路径。

07.2.2.6-018 数据层为什么要分 UI、状态、仓库、数据源四层?

一句话结论

分层让"数据从哪来"和"UI 怎么展示"解耦:组件不直接发请求,仓库(Repository)统一协调远程与本地数据源,状态层把仓库数据接到 store,UI 只消费状态。这样换 API、加缓存、做离线都不用改组件。

概念解释

典型分层:

  • UI 层:组件,调用 useXxxQuery 或 hook,不关心数据来源。
  • 状态层:store / React Query cache,管理 loading、error、data。
  • 仓库层:UserRepository,对外暴露 getDetail(id),内部决定先读缓存还是发请求。
  • 数据源层:RemoteUserDataSource(HTTP)、LocalUserDataSource(SQLite/MMKV),每个数据源只懂一种存储。

好处是测试时可以 mock 仓库,UI 不用动;加离线支持时只改仓库,不动 UI。

原理流程

组件 → useDetail(id)
  → 状态层:查缓存 / loading
  → Repository.getDetail(id)
       ├─ LocalDataSource 命中 → 内存/磁盘数据
       └─ RemoteDataSource 拉取 → 写 Local → 返回
  → 数据回到状态层 → 组件重渲染

代码或图示

UI 组件(只消费 hook)
   ↑
状态层(store / React Query)
   ↑
仓库层(协调缓存与远程)
   ↑
数据源层(HTTP / SQLite / MMKV)

常见误区

  • 误区:在组件里 useEffect 直接 fetch;正解:那是脚手架阶段的写法,项目一大就散。
  • 误区:仓库层暴露太多接口;正解:仓库按业务聚合(User、Order、Product),不要按数据源拆分。

追问

  • Q:React Query / SWR 这种库在分层里处于什么位置?A:它本身就是状态层 + 缓存层,仓库层退化为"queryFn",适合中小项目。
  • Q:大型项目还需要手写仓库吗?A:如果服务端接口多变、需要离线与合并,手写仓库更可控;接口稳定用 React Query 足够。

07.2.2.6-019 离线优先 App 的数据同步怎么设计?

一句话结论

离线优先的核心是"UI 永远读本地数据,网络只负责同步":所有写操作先入本地队列,网络恢复后按序重放;读操作直接读 SQLite,UI 不阻塞在网络上。冲突按业务规则处理(最后写入胜出 / 字段合并 / 提示用户)。

概念解释

这是一个从根上不同于"在线优先 + 失败降级"的架构:在线优先是先写网络、失败再存本地;离线优先是先写本地、网络是后台同步。好处是弱网与离线时 UI 完全不卡,代价是要设计操作队列、重试、冲突合并、版本号。

实现上常见栈:WatermelonDB(SQLite 响应式)+ 操作队列 + 后端增量同步 API(基于 updated_at 或版本号)。

原理流程

用户操作:
  1. 立即写本地 SQLite(UI 立即响应)
  2. 操作入 outbox 队列(带 id、payload、attempts)
  3. 网络恢复 / App 回到前台 → 队列 worker 按序重放
     ├─ 成功 → 出队
     ├─ 失败可重试 → 退避重试
     └─ 冲突 → 按业务规则 merge / 标记人工处理

读:UI observe SQLite → 同步完成后 SQLite 变 → UI 自动更新

代码或图示

决策 在线优先 离线优先
UI 响应 网络慢则卡 永远立即
离线 不可用 可用
写冲突 即时 同步时处理
复杂度 低 高

常见误区

  • 误区:离线优先 = 离线时也能正常用,联网后数据自动一致;正解:冲突处理是业务问题,技术栈只能提供机制。
  • 误区:所有操作都该进 outbox;正解:读操作不需要 outbox,写操作中"读已提交数据"的操作也不进。

追问

  • Q:outbox 重放失败超过最大次数怎么办?A:标记为"需要人工处理",在设置页提供"待同步"列表让用户看到并重试。
  • Q:怎么测离线?A:真机飞行模式操作 → 恢复网络 → 观察 outbox 重放,包括中途切换网络、App 杀死重启。

07.2.2.6-020 综合题:设计一个电商 App 的状态与数据层

一句话结论

按"页面局部状态用组件 state、跨页共享用 Zustand、服务端数据用 React Query 类库 + 仓库层、本地持久化用 SQLite + MMKV"组合;登录态用根导航器条件渲染守卫;请求层统一处理 token 刷新、重试、错误归一化;长列表用分页缓存 + 失效标签。

概念解释

这道题考察的是把前面所有知识点拼成一张图。不要上来就说"用 Redux",而要按"数据属于谁"分层:

  • 临时 UI 状态(弹窗、输入框、开关):useState。
  • 跨页共享(购物车数量、登录用户、主题):Zustand。
  • 服务端数据(商品、订单、用户资料):React Query 管理缓存与失效,queryFn 走仓库。
  • 持久化:MMKV 存 token 与开关,SQLite 存购物车与浏览历史。
  • 导航:native-stack 主栈 + Tab,未登录渲染 LoginStack,深链接 linking 配置。
  • 请求层:axios 实例 + 拦截器(token、401 队列、错误归一化、上报)。

原理流程

架构图:
  UI 组件
   ├─ useState / 局部 hook
   ├─ useAuthStore(Zustand,跨页)
   └─ useProductQuery(id)(React Query,服务端缓存)
        ↓ queryFn
     ProductRepository
        ├─ LocalProductSource(SQLite 购物车/历史)
        └─ RemoteProductSource(axios 实例)
             ↓ 拦截器
        token 注入 / 401 刷新队列 / 错误归一化 / 上报

代码或图示

数据类型 状态管理 持久化
弹窗可见性 useState 无
登录用户 Zustand MMKV(加密)
商品详情 React Query 内存缓存
购物车 Zustand + SQLite SQLite
首页 Feed React Query 内存 + 磁盘
浏览历史 SQLite SQLite

常见误区

  • 误区:一上来就选 Redux;正解:先问团队规模、状态复杂度、调试需求,再选方案。
  • 误区:所有数据都走 React Query;正解:本地操作(购物车数量加减)是状态,不是服务端查询,应该用 store。

追问

  • Q:购物车数量在 Tab 角标要实时变,怎么做?A:购物车数据放 Zustand,Tab 角标订阅该切片,加购时改 store,角标自动更新;同时后台同步到服务端。
  • Q:怎么设计灰度与回滚?A:请求层按版本号上报,监控看板按版本对比错误率;出问题时远程开关关闭某接口或降级策略,不需要发版(开关存在 MMKV 并由配置中心下发)。