前年做一个商城前台,用户信息放在一个模块里,购物车写在 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 规范的项目,切到别的方案要付出培训和代码迁移的成本;反过来,从零开始的小团队上来就上重型方案,学习成本会拖慢迭代。选型要算这两笔账。
最危险的不是选错库,而是「一半状态在 store、一半在组件、还有一半在 localStorage」,三份数据没有单一来源。排查串号问题时,先画出每个字段的写入路径,比换库更快找到原因。

小结与练习

收几句:判断要不要全局,看消费者数量和生命周期,不看「放全局方不方便」;组件树内用 props 和依赖注入,跨路由、要在守卫里读的才进 store;服务端数据按缓存处理,别和客户端状态混在一起;持久化必须带用户标识和版本号,并且监听跨标签变化;库的差别主要在约束强度,选型要算团队账,不是算跑分。

下面几条可以当天验证,不需要真实业务:

  1. 建两个 Pinia store,一个认证一个购物车。登录后按用户 id 装载购物车,退出时清空,刷新页面确认读到的是当前用户的数据,再换一个 id 登录确认不串。
  2. 手动把 localStorage 里购物车对象的版本字段改成 2,刷新页面,确认代码走的是丢弃分支而不是直接报错;再把解析内容改成一个坏字符串,确认 try 生效。
  3. 开两个标签页,在 A 页加购,观察 B 页是否通过 storage 事件同步;再把监听删掉,对比行为差异。
  4. 写一个 router.beforeEach,在里面读 store 判断登录和权限,确认未登录会跳转,并且刷新后不会先渲染一帧受保护页面。
  5. 把同一份购物车需求用 Redux Toolkit 的 slice 再写一遍,比较两边的代码行数、状态更新方式和调试体验,记录你自己的结论。

下一篇讲前端路由。这不是随便选的顺序:这一篇里已经出现了两次「路由守卫里读 store」,而守卫能不能读到、什么时候读、读到的状态是不是已经恢复,取决于路由是怎么组织的。跨页面状态有了之后,紧接着要解决的就是页面之间怎么跳、嵌套路由怎么匹配、权限在哪一层拦、刷新和前进后退为什么会出现白屏或死循环。状态是数据放在哪,路由是页面怎么走,这两件事必须一起想。想补基础可以回看模块和浏览器存储,store 的组织方式和持久化的底层行为都在那里。