什么是组件

组件是界面上「独立、可复用的一块 UI 及其行为的封装」。从形态上看它就是一个函数:

props  ──▶  [ 组件 ]  ──▶  UI(React 元素 / 一段描述)

输入是 props(外部传进来的数据与回调),输出是描述界面该长什么样的 React 元素。组件本身不直接操作真实 DOM,它只负责「根据当前输入算出 UI」,剩下的交给框架。

// 最小可用组件:不接收任何输入
function Badge() {
  return <span className="badge">新</span>;
}
 
// 接收输入的组件
type AvatarProps = {
  src: string;
  alt: string;
  size?: number;   // 可选
};
 
function Avatar({ src, alt, size = 40 }: AvatarProps) {
  return <img src={src} alt={alt} width={size} height={size} />;
}

使用组件和写 HTML 标签很像,但属性名是 JS 的 camelCase,值用 {} 传表达式:

<Avatar src="/a.png" alt="头像" />
<Avatar src="/b.png" alt="头像" size={64} />
 
// 字符串可以省略引号写法,其它类型必须用 {}
<button disabled={isBusy} tabIndex={-1}>提交</button>

三条最基本的原则:

  • 组件名首字母必须大写,否则会被当成原生 HTML 标签;
  • 一个组件只负责一块 UI 及其交互,职责单一才谈得上复用;
  • 组件返回的是描述(React 元素),不是已经创建好的 DOM 节点。

props 是组件对外暴露的「接口」。它在组件的整个生命周期里只读,组件不能自己修改。

形态 写法示例 说明
必填 name: string 调用方少传就报错
可选 size?: number 可以省略,读出来可能是 undefined
默认值 size = 40 解构参数时给默认值,只对 undefined 生效
回调 onClick?: () ⇒ void 把「发生了什么」告诉父组件
内容插槽 children: React.ReactNode 标签之间的内容
原生属性透传 React.ComponentProps<“button”> 一次性拿到某个原生标签的全部属性
其余属性 …rest 收集未显式声明的属性,再原样透传
type ButtonProps = {
  label: string;
  variant?: "primary" | "ghost";   // 联合类型:只允许这几个取值
  disabled?: boolean;
  onClick?: () => void;
};
 
function Button({ label, variant = "primary", disabled, onClick }: ButtonProps) {
  return (
    <button
      className={`btn btn-${variant}`}
      disabled={disabled}
      onClick={onClick}          // 直接透传,不用自己造事件对象
    >
      {label}
    </button>
  );
}
 
// 使用
<Button label="保存" variant="primary" onClick={() => save()} />
<Button label="取消" variant="ghost" />

数据向下、事件向上:父组件通过 props 把数据和「处理函数」传给子组件;子组件只管在合适的时机调用那个函数,并不关心父组件会怎么处理。这样数据流向是单向的,容易推理,也容易调试。

props 是只读的:

function Title({ text }: { text: string }) {
  text = "改一下";   // ❌ 不要这样:props 属于调用方
  return <h2>{text}</h2>;
}
 
// 想「改」,就让父组件通过回调去改它自己的 state
function Title({ text, onRename }: { text: string; onRename: (v: string) => void }) {
  return <h2 onClick={() => onRename("新标题")}>{text}</h2>;
}

children 是一个特殊的 prop:写在组件标签之间的内容,会自动作为 children 传进去。它让组件从「内容写死的组件」变成「可装东西的容器」。

type PanelProps = {
  title: string;
  children: React.ReactNode;   // 元素、字符串、数组、null 都可以
};
 
function Panel({ title, children }: PanelProps) {
  return (
    <section className="panel">
      <h3 className="panel-title">{title}</h3>
      <div className="panel-body">{children}</div>
    </section>
  );
}
 
// 使用
<Panel title="提示">
  <p>这里是任意内容</p>
  <Button label="知道了" />
</Panel>

当容器需要多个插槽时,就把它们写成普通 prop:

type LayoutProps = {
  header: React.ReactNode;
  footer?: React.ReactNode;
  children: React.ReactNode;
};
 
function Layout({ header, footer, children }: LayoutProps) {
  return (
    <div className="layout">
      <header>{header}</header>
      <main>{children}</main>
      <footer>{footer}</footer>
    </div>
  );
}

要点:children 只是「一个位置」;需要几个位置就定义几个 prop,而不要用一堆 xxxChildren 之类的隐式约定。

这是 TS 项目里组件部分最实际的工作:把 props 的形状写清楚,编辑器就能在调用处提示参数名、参数类型,并在写错时立刻报错。

1. 先声明 props 类型,再解构使用

interface CardProps {
  id: string;
  subtitle?: string;
  onSelect: (id: string) => void;
}
 
function Card({ id, subtitle, onSelect }: CardProps) {
  return (
    <div className="card" onClick={() => onSelect(id)}>
      <strong>{id}</strong>
      {subtitle ? <p>{subtitle}</p> : null}
    </div>
  );
}

2. 组件的返回类型交给推断

// 推荐:只标注参数类型,返回值由 TS 推断
function Card(props: CardProps) { /* ... */ }
 
// 需要显式写组件类型时也可以,但注意 React.FC 在 18 之后不再隐含 children
const Card: React.FC<CardProps> = (props) => { /* ... */ };

3. 回调与事件对象的类型要写对

type Props = {
  // 推荐:定义语义化回调,事件细节留在子组件里
  onChange: (value: string) => void;
  // 需要用到事件对象时才暴露它,并写清元素类型
  onClick: (e: React.MouseEvent<HTMLButtonElement>) => void;
  onInput: (e: React.ChangeEvent<HTMLInputElement>) => void;
};

4. 组合原生属性,避免一个个手写

type InputProps = React.ComponentPropsWithoutRef<"input"> & {
  label: string;
};
 
function Input({ label, ...rest }: InputProps) {
  return (
    <label>
      {label}
      <input {...rest} />
    </label>
  );
}
 
// 调用方既能用 label,也能用 type、placeholder、value 等原生属性
<Input label="邮箱" type="email" placeholder="you@example.com" />

5. 泛型组件:类型跟随数据走

type ListProps<T> = {
  items: T[];
  renderItem: (item: T) => React.ReactNode;
};
 
function List<T>({ items, renderItem }: ListProps<T>) {
  return <ul>{items.map((it, i) => <li key={i}>{renderItem(it)}</li>)}</ul>;
}
 
// 这里 item 会被推断为 { id: string; name: string }
<List items={users} renderItem={(item) => item.name} />

常用类型速查

想要的东西 类型写法
任意可渲染内容 React.ReactNode
单个 React 元素 React.ReactElement
无返回值的回调 () ⇒ void
点击事件 React.MouseEvent<HTMLButtonElement>
输入框变化事件 React.ChangeEvent<HTMLInputElement>
原生标签的全部属性 React.ComponentProps<“button”>
带 children 的 props PropsWithChildren<MyProps>
内联样式对象 React.CSSProperties
组件本身(可传的组件) React.ComponentType<P>
  • 拆分:一段 UI 重复出现,或者复杂到需要单独理解时,抽成独立组件。
  • 组合:小组件拼成大组件;父组件决定「摆放什么」,子组件决定「怎么渲染」。
  • 插槽思想:容器组件通过 children 或具名 prop 接收内容,而不是把内容写死。
  • 复合组件:把强相关的几个组件挂在同一个名字下,共享内部状态,调用方看到的接口更清晰。
// 复合组件:一组零件共享同一份上下文
<Tabs defaultValue="overview">
  <Tabs.List>
    <Tabs.Tab value="overview">概览</Tabs.Tab>
    <Tabs.Tab value="logs">日志</Tabs.Tab>
  </Tabs.List>
  <Tabs.Panel value="overview">概览内容</Tabs.Panel>
  <Tabs.Panel value="logs">日志内容</Tabs.Panel>
</Tabs>

很多组件库都采用这种「Root + List + Item / Root + Trigger + Content」的拆分方式:外层组件持有状态,内层零件通过 Context 拿到状态,所以零件自己不需要写逻辑。平时使用这类库组件时,只需记住:零件必须放在对应的外层组件内部(例如菜单项必须放在下拉菜单容器里),否则拿不到上下文,行为会异常或直接报错。

受控与非受控

模式 特征 何时用
受控 由外部传 value + onChange 决定 需要外部读写、需要校验或联动时
非受控 由内部 state 自己管,外部只给 defaultValue 简单表单、只用一次的场景
半受控 defaultValue 与 value 按是否传入自动切换 组件库常见的写法,兼容两种用法

状态提升:当两个兄弟组件需要共享同一份数据时,把这份 state 放到它们最近的公共父组件里,再通过 props 往下传、通过回调往上通知。

组件除了接收 props,还可以拥有自己的私有状态。状态变化会触发重新渲染,UI 自动与状态保持一致——这也是「声明式」的含义:你只描述状态和 UI 的对应关系,不用手动增删 DOM。

function Counter({ step = 1 }: { step?: number }) {
  const [count, setCount] = useState(0);
 
  return (
    <button onClick={() => setCount((c) => c + step)}>
      当前:{count}
    </button>
  );
}
  • state 是组件私有的,外部无法直接读取或修改;
  • 外部需要感知变化时,要么走回调,要么把 state 提升出去改成受控组件;
  • 副作用(请求、订阅、定时器)用 useEffect 管理,并且要写清理逻辑。

更完整的用法见 组件基础。

  • 组件名小写:%%<button />%% 是原生标签,%%<Button />%% 才是你自己的组件。
  • 直接改 props:props 只读,想变就让父组件去改它自己的 state。
  • 可选回调当必填调:onClick 声明为可选时,调用要写 onClick?.() 或给个默认空函数。
  • 忘记 key:列表渲染时同级元素要加稳定且唯一的 key,顺序可能变化时不要用数组下标。
  • Hook 写在条件里:Hook 必须在组件顶层、无条件调用,顺序要稳定。
  • 内联对象/函数造成多余渲染:把新对象/新函数当 props 传下去,每次渲染引用都变;确实卡顿时再配合 memo 与 useCallback、useMemo,不要一上来就优化。
  • 展示与取数混在一起:组件里塞满请求与转换逻辑会很难复用,建议把「取数据」抽成 Hook 或父组件,组件只负责渲染。
  • 默认值位置搞错:默认值写在解构参数处,只会对 undefined 生效;null 依然会用 null。

同一个组件,是需要时才创建,还是一直存在、只切换显示,是一个容易忽略但影响不小的选择。下面用「点开回复输入框」这个场景对比两种写法。

写法一:条件渲染——需要时才挂载

function Post({ content }: { content: string }) {
  const [editing, setEditing] = useState(false);
 
  return (
    <article>
      <p>{content}</p>
      {editing ? (
        <ReplyBox onSubmit={(text) => { submit(text); setEditing(false); }} />
      ) : (
        <button onClick={() => setEditing(true)}>回复</button>
      )}
    </article>
  );
}

editing 变成 true 时 ReplyBox 才被创建(挂载),变回 false 时它被销毁(卸载)。带来三个直接结果:

  • 组件内部的状态每次从头开始:上次没提交的草稿、校验错误、展开过的下拉,全部清零;
  • 组件里的 useEffect 每次打开都会重新执行,卸载时自动跑清理函数(订阅、定时器、事件监听随之解除);
  • 没被打开时几乎不产生任何开销。

代价是:状态留不住;带退场动画的组件,可能在动画播完之前就被卸载掉了。

写法二:常驻渲染——一直挂载,只切换显示

function Post({ content }: { content: string }) {
  const [visible, setVisible] = useState(false);
 
  return (
    <article>
      <p>{content}</p>
      <button onClick={() => setVisible(true)}>回复</button>
 
      <ReplyBox
        visible={visible}                 // 显示与否由父组件决定(受控)
        onVisibleChange={setVisible}      // 用户关闭时通知父组件,setter 可直接当回调
        onSubmit={(text) => { submit(text); setVisible(false); }}
      />
    </article>
  );
}

这里有两个值得记住的套路:

  • onVisibleChange={setVisible}:子组件调用 onVisibleChange(false),效果就等于父组件执行 setVisible(false),不必再包一层 (v) ⇒ setVisible(v);
  • 组件自己负责「不可见时少做事」,例如根据 visible 决定要不要请求数据、要不要渲染内容。

好处是内部状态和动画都保得住;代价是它一直留在组件树里,即使从未被打开过。

怎么选

关注点 条件渲染(挂载 / 卸载) 常驻渲染(切换 visible)
内部 state 每次重新开始 保留
副作用 / 请求 每次打开重新执行 只在首次执行,需自己按 visible 变化触发
卸载清理 框架自动完成 需自己判断处理
退场动画 容易被打断 好实现
内存与开销 用时才付出 一直存在
适合场景 较重、一次性、希望每次初始化 较轻、需要保留状态或有动画

判断方法很简单:先问「我希望内部状态和副作用跟着开关重置,还是保留?」,答案基本就决定了写法。

用 && 做条件渲染时的两个坑

  • 左边必须是布尔值:count && <X /> 在 count 为 0 时会把 0 渲染到页面上,应写成 count > 0 ? <X /> : null,或先用布尔变量接住;
  • 需要「否则分支」就用三元表达式,不要并排写两个 &&,否则顺序和漏渲染都很难排查。

还要分清一点:条件渲染控制的是组件存不存在,而不是「显示还是隐藏」。只想切换可见性时,交给组件自己的 visible 或 CSS 更合适。

  • 组件 = 输入 props → 输出 UI 的可复用单元,名字首字母大写。
  • props 是只读的输入契约;children 是特殊 prop,用来接收标签之间的内容。
  • 数据向下(props)、事件向上(回调),单向流动最好推理。
  • 用 TypeScript 把契约写清楚:必填/可选/默认值/回调/children/原生属性透传/泛型组件。
  • 倾向组合而非继承:拆小、拼装、复合组件、受控与非受控各取所需,共享数据就提升状态。
  • 组件「什么时候存在」也是一种设计:按需挂载还是常驻,取决于你希望内部状态与副作用是否重置。

相关:基础概念、组件基础、props-state、usestate、jsx、什么是接口、什么是函数

该主题尚不存在

您访问的页面并不存在。如果允许,您可以使用创建该页面按钮来创建它。

  • typescript/什么是组件.txt
  • 最后更改: 2026/10/15 20:28
  • 由 张叶安