前年做一个商城前台,用户信息放在一个模块里,购物车写在 localStorage,权限是每个页面进路由时各自拉一次。三个地方各管各的,平时看着挺正常。直到客服提了一个工单:在某台公共电脑上,A 账号退出登录,B 账号登录后,页头购物车角标还挂着 A 留下的三件商品,点进去连收货地址都是 A 的。
复现下来是这样:退出登录只清了 token 和用户信息,购物车那份 localStorage 没动;权限判断只看当前页面有没有拿到菜单,不看登录人是谁;用户在另一个标签页重新登录后,第一个标签页也不会刷新,还是旧数据。三个问题单独看都不严重,叠在一起就是数据串号。
这篇聊的是状态管理,但不打算把 Pinia 和 Redux 的 API 抄一遍。真正难的不是写 defineStore,而是判断这份状态该放在哪、活多久、谁能改。API 查文档十分钟就会,放错位置带来的问题可能三个月后才爆出来。文中会拿同一个购物车需求,用 Pinia 和 Redux Toolkit 各写一小段做对照,目的只是看思路差异,不是让你照着选。
先承认一件事:大部分状态不该进全局
很多项目上全局状态,不是因为需要,而是因为「放全局就不用想传给谁了」。这个偷懒在页面少的时候很舒服,页面一多就变成没人敢删的黑盒:不知道谁在读、不知道谁在写、删一个字段全靠全局搜索和运气。
判断一份状态该放哪,我一般问四个问题:有几个消费者?生命周期到哪结束?有几个人会写它?丢了会不会影响业务?四个答案基本能定位到下面某一层。
注意第三层和第四层是两种东西。跨页面共享的是「客户端自己拥有的真相」,比如用户点了什么、购物车里放了什么;服务端数据是「别人那边的事实,我手里只是一份快照」。后者塞进全局 store,就会把缓存策略的活儿也一起揽过来,而大部分团队并没有为此做好准备。
还有一条容易被忽略的判断:写入者数量。一份状态如果只有登录接口能写,放全局很安全;如果十个组件都能直接改,那不管放哪都会乱。限制写入入口,比换什么库更重要。
Context 和依赖注入能走多远
在 Vue 里,上一篇讲的 provide/inject 已经能做跨层共享;React 里对应的是 Context。它们常被当成轻量状态管理,确实能省掉一个库,但边界要清楚。
第一,它们只存在于组件树里。路由守卫、请求拦截器、独立的工具函数都拿不到注入的值,而这些地方恰恰最需要读登录态和权限。第二,没有开发者工具的写入记录,出问题只能靠打断点。第三,没有持久化和跨标签同步,刷新就没了。第四,Context 在 React 里还会带来消费者重渲染的问题,值一变,所有读它的组件都要重新渲染,得靠拆分和 memo 才能控制住。
所以在 React 项目里,Context 适合主题、语言、表单上下文、表格行上下文这种「环境」;在 Vue 里,provide/inject 适合弹窗的关闭能力、当前表格的选中态这种「局部环境」。一旦这份数据要跨路由、要在守卫里读、要活过刷新,它就已经超出组件树的范围了。
export const state = reactive({...}),任何组件 import 就能改。它比 Context 更隐蔽,连组件树关系都没有,调试时看不到谁改的。小项目能用,但至少把写操作收进函数里,别让外部直接改字段。三种库,三种思路
Pinia、Redux Toolkit、Zustand 经常被拿来对比参数,其实它们的差别主要在「约束强度」和「心智负担」。选哪个,更多取决于团队现状,而不是基准测试。
Pinia 是 Vue 生态里的默认选择。它的 store 就是一个组合式函数,状态、getter、action 写在一起,直接改 this.xxx,配合 Vue 的响应式,用起来和普通模块差不多。它没有 mutation 这一层,模块是扁平的,互相引用要自己控制。体积小,开发者工具能看时间线。
Redux Toolkit 是 React 生态里的事实标准。它要求所有修改都通过 action,reducer 里用 Immer 写「看起来像直接改」的代码,实际生成新对象。好处是每次变更都有名字、可回放、可序列化,时间旅行调试很扎实;代价是概念多,slice、action、selector、middleware,新人上手要花时间,包体也更大。
Zustand 更轻,一个 create 就是一个 hook,不需要 Provider 包裹,按需订阅。它适合中小型 React 项目,或者只想解决「跨组件共享一点状态」而不想引入整套规范的情况。约束最少,也意味着团队要自己定规矩,否则同样会写乱。
Pinia 的取舍
贴近 Vue 的使用习惯,样板代码少,模块扁平,调试面板能看状态变化。适合 Vue 项目、团队规模中等、希望快速上手的情况。风险是太自由,容易有人绕过 action 直接改 state。
Redux Toolkit 的取舍
约束强,所有变更走 action,调试和回放能力强,适合多人协作、状态复杂、需要严格审计的项目。代价是概念和样板更多,包体更大,小项目容易显得笨重。
体积上,Pinia 压缩后是几 KB 的量级,Redux Toolkit 加上 react-redux 是十几 KB 的量级,具体数字随版本变化,别拿几年前文章里的数当准。但这点差异对一个已经加载了几百 KB 业务代码的项目来说,通常不是决定因素。真正决定用的是团队约定:已经有成熟 Redux 规范的后台,换 Pinia 省下的那点代码量,抵不过重新培训的成本。
下面拿同一个需求写两段:购物车加商品、算总件数、退出时清空。这不是 API 手册,只是看两种写法的手感。
// stores/cart.js(Pinia)
import { defineStore } from "pinia";
export const useCartStore = defineStore("cart", {
state: () => ({ userId: null, items: [] }),
getters: {
count: (s) => s.items.reduce((n, i) => n + i.qty, 0)
},
actions: {
add(product, qty = 1) {
const hit = this.items.find((i) => i.id === product.id);
if (hit) hit.qty += qty;
else this.items.push({ id: product.id, name: product.name, qty });
},
clear() {
this.items = [];
}
}
});
// cartSlice.js(Redux Toolkit)
import { createSlice } from "@reduxjs/toolkit";
const cartSlice = createSlice({
name: "cart",
initialState: { userId: null, items: [] },
reducers: {
added(state, action) {
const { product, qty } = action.payload;
const hit = state.items.find((i) => i.id === product.id);
if (hit) hit.qty += qty;
else state.items.push({ id: product.id, name: product.name, qty });
},
cleared(state) {
state.items = [];
}
}
});
export const { added, cleared } = cartSlice.actions;
export default cartSlice.reducer;
Pinia 里 this.items.push 是真的改原数组,Redux Toolkit 里同样的写法由 Immer 拦下来生成新 state。看起来几乎一样,但背后规则不同:前者允许直接改,后者只在 reducer 的 draft 里成立,出了这个函数再改就会被当成错误。理解这一点,比记住 API 名字重要。
服务端数据与持久化:两个最容易放错的地方
服务端数据不是「全局状态」,是缓存
很多团队把订单列表、商品详情也放进 store,然后手动在十几个地方调 fetchOrders。接着出现三个典型问题:同一个接口并发请求好几次;页面 A 改了数据,页面 B 的列表不刷新;请求乱序,旧结果覆盖新结果。
这些不是状态管理库的强项。缓存需要的是:按 key 存储、过期时间、请求去重、失败重试、取消、分页合并、失效通知。用 TanStack Query、SWR 这类查询库,或者至少自己写一层薄缓存,都比把裸数据塞进 store 靠谱。
判断方法很简单:这份数据是「用户操作产生的」,还是「从服务器读来的」?前者归 store,后者归缓存层。购物车、草稿、界面偏好属于前者;订单列表、商品详情、库存属于后者。混在一起的结果是 store 里一半字段有失效逻辑、一半没有,谁都不敢清理。
持久化要带版本号,还要带用户身份
localStorage 只认字符串,写进去容易,读出来要处理三件事:解析失败、结构过时、换人登录。解析失败好办,try 一下,坏了就重置。结构过时才麻烦:上个版本存的是数组,这个版本要对象,直接读出来用就是运行时错误。
做法是给存进去的数据加一个版本字段,读的时候校验:
const CART_KEY = (uid) => "czgrzx:cart:" + uid;
function readItems(uid) {
try {
const data = JSON.parse(localStorage.getItem(CART_KEY(uid)) || "null");
if (!data || data.v !== 1) return []; // 版本不符,丢弃重来
return data.items;
} catch (e) {
return [];
}
}
版本号不是为了好看,是为了让你在改结构时有一个明确的「旧数据怎么处理」入口。较真一点的项目会写迁移函数,把 v1 的数组转成 v2 的对象;数据不重要的话,直接丢掉重来更省事,但要在代码里写清楚这是有意为之。
key 里必须带用户标识。用 czgrzx:cart 这种全局 key,A 退出、B 登录就会读到 A 的数据,开头那个工单就是这么来的。key 里还要带业务前缀,避免和同域下其他系统的存储撞名。
还有几个细节:只存必要字段,别把整个 store 序列化进去,既占空间又容易把敏感信息落盘;令牌这类东西尽量别放 localStorage,它能被页面脚本读到,XSS 一旦发生就直接失守,具体取舍在浏览器存储那篇讲过;写入可以做个短防抖,购物车连续加购没必要每加一件就写一次。
完整场景走查:登录、购物车与多标签同步
需求有六条:登录后拉取用户和权限;退出登录要清空所有与该用户相关的本地数据;购物车在页头、详情页、结算页三处同时显示;刷新页面不能先闪一下未登录状态;两个标签页的商品数量要一致;切换账号不能读到上一个人的购物车。
第一版就是开头说的那样:三个模块各存各的,购物车写入一个固定 key,退出只清 token。它满足了「能跑」,但六条需求里只满足了两条。第二版开始收拢,先定两个 store,认证和购物车,权限作为认证的一部分。
// stores/auth.js
import { defineStore } from "pinia";
import { useCartStore } from "./cart.js";
export const useAuthStore = defineStore("auth", {
state: () => ({ token: "", user: null, permissions: [] }),
getters: {
isLoggedIn: (s) => Boolean(s.token)
},
actions: {
async login(form) {
const data = await api.login(form);
this.token = data.token;
this.user = data.user;
this.permissions = data.permissions;
useCartStore().load(data.user.id); // 按用户装载购物车
},
async fetchPermissions() {
this.permissions = await api.permissions();
},
logout() {
this.token = "";
this.user = null;
this.permissions = [];
useCartStore().reset(); // 清空并解除当前用户
}
}
});
购物车那边,读写都按用户 key,并且把「谁的数据」记在 store 里,避免清空时清错人:
// stores/cart.js
import { defineStore } from "pinia";
export const CART_KEY = (uid) => "czgrzx:cart:" + uid;
export const useCartStore = defineStore("cart", {
state: () => ({ userId: null, items: [] }),
getters: {
count: (s) => s.items.reduce((n, i) => n + i.qty, 0)
},
actions: {
load(uid) {
this.userId = uid;
this.items = readItems(uid);
},
add(product, qty = 1) {
if (!this.userId) return; // 未登录不加购
const hit = this.items.find((i) => i.id === product.id);
if (hit) hit.qty += qty;
else this.items.push({ id: product.id, name: product.name, qty });
this.save();
},
save() {
const payload = { v: 1, items: this.items };
localStorage.setItem(CART_KEY(this.userId), JSON.stringify(payload));
},
reset() {
if (this.userId) localStorage.removeItem(CART_KEY(this.userId));
this.userId = null;
this.items = [];
}
}
});
刷新不闪那一条,靠的是时序:应用启动时先把持久化的登录态恢复,再挂载路由;守卫里如果发现没有权限,等接口回来再放行,而不是先渲染页面再补权限。用 Pinia 时,在 main.js 里安装好 pinia 实例之后,守卫里可以直接调用 useAuthStore(),不需要在组件里绕一圈。
router.beforeEach(async (to) => {
const auth = useAuthStore();
if (!auth.token) return { name: "login", query: { from: to.fullPath } };
if (!auth.permissions.length) await auth.fetchPermissions();
if (to.meta.role && !auth.permissions.includes(to.meta.role)) {
return { name: "forbidden" };
}
});
多标签同步靠 storage 事件。它只在「别的标签页」写入时触发,当前页自己写不会触发,正好避免自激循环:
window.addEventListener("storage", (e) => {
if (!e.key || !e.key.startsWith("czgrzx:cart:")) return;
const uid = e.key.split(":")[2];
const cart = useCartStore();
if (String(cart.userId) !== uid) return;
cart.items = readItems(uid); // 重新读,别直接信 e.newValue
});
这里没有直接用 e.newValue,因为它可能来自别的标签页的旧版本数据,重新走一遍 readItems 的版本校验更稳。退出登录也可以复用这套机制:一个标签页退出,把 token 清掉并广播,另一个标签页收到后强制回到登录页,避免两个页面状态割裂。
最后是页面读数据的方式。页头只关心件数,用 storeToRefs 取 getter;详情页要加购,调 action;结算页要明细,读 items。三处都指向同一个 store,不再各自维护一份。这里有一个容易踩的点:购物车 store 和认证 store 互相 import 时,别在文件顶层形成循环引用,把 useCartStore() 的调用放进 action 函数体内,模块加载顺序就不会出问题。
错误现象对照
下面这些现象在做过两三个商城或后台之后基本都会遇到,共同点是「状态放错了层」,而不是库不好用。
| 现象 | 真实原因 | 第一步查什么 |
|---|---|---|
| 退出登录后购物车还在,换个账号能看到别人的商品 | 持久化 key 没有用户标识,退出时也没清空对应数据 | 看 localStorage 的 key 命名,以及 logout 里清了哪些字段 |
| 两个标签页数量不一致,刷新一下才对 | 只写了存储,没有监听 storage 事件 |
搜有没有 addEventListener("storage"),确认 key 匹配规则 |
| 刷新后先闪一下未登录,再跳回原页面 | 路由先挂载、状态后恢复,或者守卫没有等待权限请求 | 检查应用初始化顺序和守卫里的 await |
| 同一个商品详情接口被请求三四次 | 每个组件各自发请求,没有统一缓存和请求去重 | Network 面板看重复请求,查有没有缓存层 |
| 列表页改了数据,另一个页面还是旧的 | 服务端数据被当成普通全局状态,没有失效机制 | 检查是否有 key、过期时间、失效通知这套东西 |
| 改了 store 结构后,老用户一打开就白屏 | 持久化数据没有版本号,读到旧结构直接报错 | 看存储里有没有版本字段,读取有没有 try 和兜底 |
| Devtools 里看不到某次状态变化是谁改的 | 有人绕过 action 直接改了 store 的字段 | 搜对 store 属性的直接赋值,统一收进 action |
边界与代价
全局状态不是免费的。它在某个规模之前很省事,过了那个规模就开始收利息。
- 模块数量。三五个领域模块还能靠命名约定维持秩序,超过十个、彼此还互相引用时,依赖图会变成一张网。按领域拆、只允许上层引用下层,比换库有用。
- store 里放组件状态。弹窗开关、当前 hover 的行、输入框草稿,这些放进去之后组件销毁了状态还在,多实例还会互相覆盖。它们应该跟着组件走。
- 无限制的写入。谁都能
store.items.push(),等于没有状态管理。至少要约定「组件只调 action,不直接改 state」,Pinia 的自由度反而更需要这条纪律。 - 持久化整个 store。把几十个字段序列化进 localStorage,写入变慢、体积变大、迁移成本翻倍,还容易把不该落盘的字段带出去。只挑真正需要跨刷新存活的字段。
- 用全局 store 替代服务端缓存。没有失效、去重、取消,最后一定会出现「数据不新鲜」和「请求风暴」,这类问题不该由状态库背。
- 小项目或页面内共享。为了两三个组件传值引入一整套 store,收益是负的。先用 props、provide/inject,等真的跨页面了再上库。
- 团队约束。已经有成熟 Redux 规范的项目,切到别的方案要付出培训和代码迁移的成本;反过来,从零开始的小团队上来就上重型方案,学习成本会拖慢迭代。选型要算这两笔账。
小结与练习
收几句:判断要不要全局,看消费者数量和生命周期,不看「放全局方不方便」;组件树内用 props 和依赖注入,跨路由、要在守卫里读的才进 store;服务端数据按缓存处理,别和客户端状态混在一起;持久化必须带用户标识和版本号,并且监听跨标签变化;库的差别主要在约束强度,选型要算团队账,不是算跑分。
下面几条可以当天验证,不需要真实业务:
- 建两个 Pinia store,一个认证一个购物车。登录后按用户 id 装载购物车,退出时清空,刷新页面确认读到的是当前用户的数据,再换一个 id 登录确认不串。
- 手动把 localStorage 里购物车对象的版本字段改成 2,刷新页面,确认代码走的是丢弃分支而不是直接报错;再把解析内容改成一个坏字符串,确认
try生效。 - 开两个标签页,在 A 页加购,观察 B 页是否通过
storage事件同步;再把监听删掉,对比行为差异。 - 写一个
router.beforeEach,在里面读 store 判断登录和权限,确认未登录会跳转,并且刷新后不会先渲染一帧受保护页面。 - 把同一份购物车需求用 Redux Toolkit 的 slice 再写一遍,比较两边的代码行数、状态更新方式和调试体验,记录你自己的结论。
下一篇讲前端路由。这不是随便选的顺序:这一篇里已经出现了两次「路由守卫里读 store」,而守卫能不能读到、什么时候读、读到的状态是不是已经恢复,取决于路由是怎么组织的。跨页面状态有了之后,紧接着要解决的就是页面之间怎么跳、嵌套路由怎么匹配、权限在哪一层拦、刷新和前进后退为什么会出现白屏或死循环。状态是数据放在哪,路由是页面怎么走,这两件事必须一起想。想补基础可以回看模块和浏览器存储,store 的组织方式和持久化的底层行为都在那里。