2021 年我接手一个商品详情页。单文件 1200 行,里面同时有轮播图、SKU 选择、价格计算、优惠券、库存轮询、评价摘要和推荐位。三个人一起改了两周,冲突不断,于是决定“组件化”。

我们按页面上看得见的块来切:价格一块、库存一块、SKU 一块、优惠券一块、配送一块、服务承诺一块,加上若干小标签,最后拆出了 40 个组件。目录一下子整齐了,评审时大家都觉得结构清楚了。

两个月后需求来了:价格字段从 price 改成 salePrice 加 originalPrice。我改了 8 个文件。数据从页面组件一路往下传,中间经过 ProductMain、ProductInfo、PriceBlock、PriceRow,最后才到 PriceText,整整六层。中间那几层根本不关心价格,但每一层都得把 props 声明出来、解构出来、再原样传下去,少写一个就断链。

那天我意识到:拆组件拆错了方向。这篇讲的就是那次返工之后,我对“什么时候拆、按什么拆、拆到什么程度”的理解。

翻车现场:拆完比拆之前更难改

先把那次的问题摆清楚,后面才好讲原则。拆完之后,团队遇到的是四类具体的麻烦,不是“感觉不优雅”这种虚的。

第一类是改字段要跨文件。价格改名涉及 PriceText 的入参、PriceRow 的透传、PriceBlock 的组合、ProductInfo 的透传、ProductMain 的透传、页面组件的数据组装、mock 数据和两条测试。八处里只有三处是真的要改逻辑,另外五处纯粹是搬运。

第二类是中间组件被迫知道它不该知道的东西。为了把价格传到叶子,ProductInfo 必须接收 price、originalPrice、currency、memberLevel 四个字段并继续往下传。它的职责本来只是“把商品信息排版”,结果变成了数据管道。新人读这个组件,会以为它真的在用这些值。

第三类是调试变难。用户反馈“点加入购物车没反应”,我从按钮往上找,调用栈里排着六层组件,日志分散在三处,最后发现是中间某一层把回调改名时漏传了。拆之前这段逻辑就在一个文件里,二十行就能看完。

第四类是复用没发生。PriceText 的合约是“接收整个商品对象”,另一个页面要用,得先改造自己的数据结构。所谓复用,最后变成复制一份改改。

当时是怎么拆的
按视觉区块切分页面
每个区块建一个组件
数据留在最外层页面
props 一层层往下转手

这条链路的问题出在第三步和第四步之间:数据留在最外层没错,但没有定义“谁拥有它、谁只需要读、谁负责改”。于是所有东西都靠转手,层数一多就必然断。

组件边界:按“什么会一起变”切,不按视觉切

视觉区块是最容易看见的边界,所以新手(包括当时的我)第一反应就是按它切。但视觉区块和代码的变化边界经常不重合:一个卡片里可能塞着三块独立变化的东西,两个看起来毫不相干的区域可能永远一起改。

我现在的判断顺序是三个问题。第一,这份数据归谁所有,谁读它,谁写它。第二,这块逻辑的改动频率和旁边那块一样吗。第三,把这段代码单独拿出去,另一处还会不会用到。

拿商品详情页举例。价格和库存来自同一个接口,看起来应该放一个组件里,但它们的展示规则完全不同:价格随 SKU、会员等级、活动变化,规则由商品中台维护;库存要每三十秒轮询一次,还要区分现货、预售、缺货。两者的改动节奏、依赖来源、出错后果都不一样,所以应该是两个组件,各自接收算好的展示值。

反过来,页面顶部的“服务承诺”和底部的“售后说明”视觉上隔得很远,但内容都来自同一份配置,改的时候永远一起改,那它们可以放在同一个组件里,用一个配置对象驱动。视觉距离不是边界,变化节奏才是。

这里和语义化结构的思路相通:先想清楚这块内容承担什么职责,再决定它是不是独立单元。但语义讲“这是什么”,组件边界讲“它和谁一起变”,一个 section 未必需要一个组件。

页面容器层:拿路由参数、发请求、做权限判断,决定这一页能用哪些数据
业务组件层:按领域划分,比如 SKU 选择、优惠券计算,知道自己这块业务的规则
通用展示层:价格、库存提示、空状态,只接收算好的值,不知道数据从哪来
基础 UI 层:按钮、输入框、弹层,只关心外观和交互,不含业务含义

依赖方向只能是上层找下层,不能反过来。基础按钮不该知道订单状态,展示组件不该自己去发请求。这条约束比目录怎么建重要得多。

组件合约:先定输入输出,再写内部

组件合约指的是它对外暴露的那一小圈东西:接收哪些 props,通过哪些回调把变化通知出去。内部用了什么状态、怎么排版、调不调接口,都属于实现细节,调用方不该依赖。

我们当时的写法是把整个商品对象传进去:<PriceText product={product} />。看着省事,实际上有三个代价。依赖是隐形的,组件内部读 product.salePrice,字段改名时没有任何类型或调用点提示你。测试成本高,为了测一个价格展示,要造一份完整的商品数据。复用困难,任何想用它的地方都得先有那个对象。

改成只传展示需要的三个值之后,合约就稳定了:

// 改之前:组件知道整个商品的结构
<PriceText product={product} />

// 改之后:组件只知道三个数字
<ProductPrice
  amountCents={view.amountCents}
  payableCents={view.payableCents}
  originalCents={view.originalCents}
/>

回调也是合约的一部分,而且更容易写坏。常见问题是把 DOM 事件原样往外抛,比如 onChange(event),让上层去 event.target.value。这等于把“我用的是 input”这个实现细节写进了合约,以后换成自定义选择器,上层全得改。更好的写法是把语义提炼出来:onSkuChange(skuId)、onQuantityChange(nextQuantity),上层只关心“变成了什么”,不关心你是怎么变的。

合约还有一个作用:让“替换实现”变成可能。只要合约不变,内部换库、换数据来源,调用方一行都不用动。反过来,合约变更就是破坏性的,必须搜全仓确认调用点。这也是我不赞成传整对象的原因:它把合约的稳定性绑在了数据结构上。

容器与展示:分开的真实用途

“容器组件 / 展示组件”这个说法被讲得有点像教条。它真正的价值不是分层好看,而是把环境依赖隔离在一处。网络请求、路由参数、登录态、埋点、本地缓存,这些东西都带副作用,也都不好测;把它们集中到少数几个容器里,剩下的组件就变成“输入什么就渲染什么”的纯函数式组件。

一个组件全干

请求、计算、渲染写在一起。上手快,文件少,改一个小页面很顺手。代价是测试必须 mock 接口,换个数据来源要动渲染代码,路由参数散落在各处,复用基本靠复制。

容器加展示

容器负责“数据从哪来、出错怎么办”,展示组件只负责“长什么样”。多了一两个文件,但展示组件可以直接喂数据渲染,也可以被另一个容器复用,测试不需要网络。

但不必所有组件都强行分两层。判断标准是:内部有没有环境依赖。只接几个值画个样子的,直接就是展示组件;要发请求、读路由、判权限的,单独拎出来,一个页面一到两个容器通常够了。

在 React 18 的函数组件里,容器不一定非得是组件,很多时候写成一个自定义 hook 更轻:hook 负责取数和状态,页面组件负责组装展示。这个做法在 Hooks 那篇会展开。这里只要记住一句话:容器存在的意义是隔离副作用,不是为了让目录多一层。

拆的顺序:先数据,再交互,最后样式

顺序错了,后面全是返工。我们当时的顺序是“先按样式拆,再往里塞数据”,结果每个组件都得自己去拿数据,拿不到就让父级传,最后形成六层管道。

正确的顺序是反过来。第一步,把页面所有状态列出来,给每个状态标上拥有者、读者、写者。比如“当前选中的 SKU”由页面拥有,SKU 选择器写它,价格、库存、配送都读它;“优惠券列表”由优惠券组件自己拥有,页面只读结果。这一步做完,组件树基本就有了骨架。

第二步,定交互边界。事件往上走,状态往下走。谁触发事件谁不负责结果,只把“用户想干什么”告诉上层;上层决定要不要改状态、要不要发请求。这样按钮组件永远不需要知道取消订单之后列表怎么刷新。

第三步才是样式。样式大多数时候根本不需要新组件,一个 CSS 变量、一个修饰类、一个 variant 参数就够了。只有“结构不同、行为不同”才值得新组件。样式差异用组件来表达,是组件数量失控的主要原因。

我现在的拆分顺序
列状态,标拥有者与读写方
定事件方向,往上抛语义
决定谁发请求、谁算展示值
最后用样式变体解决外观差异

命名和目录也影响边界。目录按业务域分,不要按文件类型分,components/ 下平铺两百个文件,三个月后就没人找得到。我按 features/product/price/ 组织,名字用业务名:ProductPrice 比 PriceText 好,后者改成图片或徽标就得改名。

命名和模块组织还会影响打包。ES 模块的静态结构让构建工具能做 tree-shaking,但如果你在每个目录都放一个 index.js 全量 re-export,很容易把没用的组件也拉进包里,还可能绕出循环依赖。我的做法是:跨域引用才走入口文件,域内部直接引具体文件。

什么不该拆,以及拆坏了的信号

有些场景我明确不建议拆。第一种是一次性页面,比如三天后上线的活动页,拆完没有任何复用价值,只增加文件数。第二种是强联动表单,八个字段互相校验、互相禁用,拆成八个组件之后,校验规则要么上提到一个巨大的父组件,要么在每个子组件里重复一遍,两种都更糟;这类表单更适合整体交给表单库管理。第三种是过度原子化,把按钮、文字、图标全部包一层,最后为了改一个内边距要穿过三层 props。

还有一种更隐蔽的:为了“以后可能复用”提前抽象。复用应该由第二次真实出现来驱动。第一次出现时你并不知道哪些部分会变,抽出来的边界大概率是错的,而错误的抽象比没有抽象更难改,因为调用方已经按它写死了。

怎么判断已经拆坏了?下面这张表是我在项目里实际对过的信号,按“看到什么、真实原因、先查哪里”整理:

现象真实原因第一步查什么
改一个字段要动五六个文件,其中大半只是转手 组件边界按视觉切,数据只能靠逐层透传 搜这个字段名,看它出现在哪些组件的解构和 props 声明里
中间层组件完全不用某个 prop,却必须声明它 数据从顶层直达叶子,缺少组合或就近放置 数一下组件树里纯转手的层数,超过两层就要处理
点按钮没反应,找不到是谁处理的 回调在多层传递中被改名或漏传,语义丢失 从按钮的 onClick 往上逐层核对回调名字和参数
同一个接口在三个组件里各请求一次 数据所有权不清,每个组件都以为该自己取 Network 面板看重复请求,再搜 fetch 出现在哪些文件
改一个圆角要动基础组件和五个调用点 基础组件过度抽象,样式差异被写成了组件差异 看这个改动能不能用一个 CSS 变量或修饰类解决
拆完之后测试几乎全部重写 合约不稳定,props 传了大对象,测试被迫造整份数据 看测试里 mock 对象的字段数量,超过五个说明合约太宽

最后一行值得多说一句:测试的痛感是合约质量的体温计。如果每个组件测试都要造一大坨数据,说明这个组件知道的太多了,不是测试写得笨。

完整场景走查:商品详情页返工

需求是这样的:详情页要支持三类商品,实物、虚拟和套餐。实物显示运费和预计送达,虚拟不显示运费但显示有效期,套餐的价格是子商品之和并且不能单独选 SKU。价格在切换 SKU、切换会员等级时要实时变,库存每三十秒刷新一次。

第一版我们按视觉拆,PriceBlock 接收整个 product,在组件内部用 useState 初始化价格,只在挂载时算一次;SkuPanel 自己发请求查库存;DeliveryInfo 直接读 localStorage 里的地址。上线前测出三个问题:切换 SKU 价格不动,因为价格只在初始化时算过一次;虚拟商品下面挂着“满 99 包邮”;套餐商品显示的是最低子商品价格,不是总和。

返工的第一步不是改代码,是把状态重新归属。商品数据、当前 SKU、会员等级提到页面容器;展示值由一个纯函数算出来;库存请求也从 SkuPanel 提到容器,切换 SKU 时由容器发起。PriceBlock 退化成一个只接收三个数字的展示组件。

先写纯函数。它不依赖 React,也不发请求,输入商品、SKU、会员等级,输出这一屏需要的所有展示值:

// viewModel.js
export function buildProductView(product, sku, memberLevel) {
  const isPackage = product.type === "package";
  const baseCents = sku ? sku.priceCents : product.minPriceCents;
  const amountCents = isPackage
    ? product.children.reduce((sum, item) => sum + item.priceCents, 0)
    : baseCents;
  const payableCents = memberLevel === "gold"
    ? Math.round(amountCents * 0.92)
    : amountCents;
  const originalCents = sku && sku.originalPriceCents > amountCents
    ? sku.originalPriceCents
    : null;

  return {
    amountCents,
    payableCents,
    originalCents,
    showShipping: product.type === "physical",
    stockText: sku && sku.stock > 0 ? "现货" : "缺货"
  };
}

注意价格用的是“分”这个整数单位,不是浮点数。金额用浮点相加会出现 0.1 + 0.2 那种经典误差,展示层再格式化成两位小数。这个函数可以单独写单元测试,喂三组数据断言三个结果,不需要渲染任何东西。

然后是展示组件。它不知道商品对象长什么样,也不知道会员折扣怎么算:

// ProductPrice.jsx
export function ProductPrice({ amountCents, payableCents, originalCents }) {
  return (
    <div className="price">
      <strong>{formatCents(payableCents)}</strong>
      {originalCents ? <del>{formatCents(originalCents)}</del> : null}
    </div>
  );
}

function formatCents(cents) {
  return "¥" + (cents / 100).toFixed(2);
}

最后是容器,全页只有它知道请求和状态:

// ProductDetail.jsx
export function ProductDetail({ productId }) {
  const [product, setProduct] = useState(null);
  const [skuId, setSkuId] = useState(null);
  const [memberLevel, setMemberLevel] = useState("normal");

  useEffect(() => {
    const controller = new AbortController();
    fetch("/api/products/" + productId, { signal: controller.signal })
      .then((res) => res.json())
      .then((data) => {
        setProduct(data);
        setSkuId(data.skus[0].id);
      })
      .catch((err) => {
        if (err.name !== "AbortError") setProduct({ error: true });
      });
    return () => controller.abort();
  }, [productId]);

  if (!product) return <p>加载中</p>;
  if (product.error) return <p>商品加载失败,请重试</p>;

  const sku = product.skus.find((item) => item.id === skuId) || product.skus[0];
  const view = buildProductView(product, sku, memberLevel);

  return (
    <section>
      <ProductPrice
        amountCents={view.amountCents}
        payableCents={view.payableCents}
        originalCents={view.originalCents}
      />
      <SkuPicker
        skus={product.skus}
        value={sku.id}
        onSkuChange={setSkuId}
      />
      {view.showShipping ? <DeliveryInfo /> : null}
      <StockHint text={view.stockText} />
    </section>
  );
}

返工之后的效果很直接。后来加“活动价”,只改了 buildProductView 和 ProductPrice 两个文件;加“虚拟商品不显示运费”,只在纯函数里加了一行条件;另一个频道页要复用价格展示,直接传三个数字过去就行,不用构造商品对象。改动的文件数从 8 降到 2,不是因为我们更勤快,是因为数据的路只有一条。

代价也要说清楚:文件数从 1 变成了 6,新人要先进容器看数据流,再去展示组件看排版。这在小页面上是负收益,在会持续迭代的详情页上才划算。

边界与代价

这套做法不是没有上限。我的经验是:单个页面里的业务组件在 8 到 12 个之间比较舒服,超过 20 个就要停下来重新看状态归属,超过 50 个基本说明需要状态管理方案和更严格的目录约定,光靠拆组件解决不了。

副作用主要有四个。文件数和跳转成本增加,读一个功能要在三四个文件之间来回看。props 链变长,超过三层就开始难受,需要靠组合(把子节点当参数传进去)或者上下文来打断。调试调用栈变深,一个点击可能穿过六层组件,报错位置和业务位置对不上。新人上手变慢,他得先理解组件树,才能找到某个文案写在哪。

什么时候不该用这套东西:一次性活动页、只有一两个人维护两周的临时后台、页面本身没有任何复用和持续迭代需求。这些场景下单文件写完更快,也更容易删。拆分是为了应对变化,如果没有变化,拆分就是纯成本。

还有一条代价:调试 CSS 时看到的是编译后的类名,得回头找组件文件。选择器越依赖层级,来回越痛。我的做法是组件内部用稳定的语义类名,跨组件共享走 CSS 变量,避免写 .product-info .price-row span 这种一改结构就失效的选择器。

拆分不会自动带来复用。如果合约里塞的是整对象、整页面状态,拆出来的组件只是被搬走了,没有被解耦。判断标准很简单:能不能在不知道调用方数据结构的情况下,只看 props 名字就正确使用它。

小结

拆的是变化边界和职责,不是视觉区块。先问谁拥有数据、谁读、谁写,再决定组件形状。
合约比实现重要。只传展示需要的值,回调传语义而不是 DOM 事件,内部实现才能随便换。
容器隔离环境依赖,展示组件保持纯粹;顺序是先数据、再交互、最后样式,反过来会返工。
复用由第二次真实出现驱动。一次性页面、强联动表单、过度原子化,都不适合拆。

下面几条当天就能拿你手上的项目验证,不需要新需求:

  1. 挑一个你负责的页面,把里面所有 useState 列出来,每个写上拥有者、谁读、谁写。写完你会发现至少有一个状态放错了层。
  2. 找一个传了三层以上的 prop,试着用“把子节点作为参数传进去”的方式消掉中间那一层,看代码少多少行。
  3. 找一个“只因为样式不同”而新建的组件,把它改成一个 variant 参数或一个修饰类,确认外观不变。
  4. 找一处接收整个对象的组件,改成只接收三个展示值,然后把它的测试数据从一份大 mock 缩成三个数字。
  5. 复盘最近一次需求,数它动了几个文件。超过三个,就在纸上画出这几个文件之间的数据流,看看哪一段是纯转手。

组件边界定下来之后,下一个问题就落在组件内部了:props 是只读的,那组件自己怎么改数据、改了之后界面为什么没更新。下一篇讲React 起步:组件、props 与 state,从一个“点了取消订单却没反应”的 bug 开始,把 JSX、props、不可变更新、批处理和 key 这几件事串起来。这篇里反复出现的“数据只有一条路”,到下一篇会变成具体的代码规则。