{content}
{editing ? (
props ──▶ [ 组件 ] ──▶ UI(React 元素 / 一段描述)
输入是 **props**(外部传进来的数据与回调),输出是**描述界面该长什么样**的 React 元素。组件本身不直接操作真实 DOM,它只负责「根据当前输入算出 UI」,剩下的交给框架。
// 最小可用组件:不接收任何输入
function Badge() {
return 新;
}
// 接收输入的组件
type AvatarProps = {
src: string;
alt: string;
size?: number; // 可选
};
function Avatar({ src, alt, size = 40 }: AvatarProps) {
return
;
}
使用组件和写 HTML 标签很像,但属性名是 JS 的 camelCase,值用 `{}` 传表达式:
// 字符串可以省略引号写法,其它类型必须用 {}
三条最基本的原则:
* 组件名**首字母必须大写**,否则会被当成原生 HTML 标签;
* 一个组件只负责**一块** UI 及其交互,职责单一才谈得上复用;
* 组件返回的是**描述**(React 元素),不是已经创建好的 DOM 节点。
===== 一、props:组件的输入契约 =====
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 (
);
}
// 使用
**数据向下、事件向上**:父组件通过 props 把数据和「处理函数」传给子组件;子组件只管在合适的时机调用那个函数,并不关心父组件会怎么处理。这样数据流向是单向的,容易推理,也容易调试。
**props 是只读的**:
function Title({ text }: { text: string }) {
text = "改一下"; // ❌ 不要这样:props 属于调用方
return {text}
;
}
// 想「改」,就让父组件通过回调去改它自己的 state
function Title({ text, onRename }: { text: string; onRename: (v: string) => void }) {
return onRename("新标题")}>{text}
;
}
===== 二、children:把内容交给使用者 =====
''children'' 是一个**特殊的 prop**:写在组件标签之间的内容,会自动作为 ''children'' 传进去。它让组件从「内容写死的组件」变成「可装东西的容器」。
type PanelProps = {
title: string;
children: React.ReactNode; // 元素、字符串、数组、null 都可以
};
function Panel({ title, children }: PanelProps) {
return (
{title}
{children}
);
}
// 使用
这里是任意内容
当容器需要**多个插槽**时,就把它们写成普通 prop:
type LayoutProps = {
header: React.ReactNode;
footer?: React.ReactNode;
children: React.ReactNode;
};
function Layout({ header, footer, children }: LayoutProps) {
return (
{header}
{children}
);
}
要点:''children'' 只是「一个位置」;需要几个位置就定义几个 prop,而不要用一堆 ''xxxChildren'' 之类的隐式约定。
===== 三、用 TypeScript 给组件加类型 =====
这是 TS 项目里组件部分最实际的工作:**把 props 的形状写清楚**,编辑器就能在调用处提示参数名、参数类型,并在写错时立刻报错。
**1. 先声明 props 类型,再解构使用**
interface CardProps {
id: string;
subtitle?: string;
onSelect: (id: string) => void;
}
function Card({ id, subtitle, onSelect }: CardProps) {
return (
onSelect(id)}>
{id}
{subtitle ? {subtitle}
: null}
);
}
**2. 组件的返回类型交给推断**
// 推荐:只标注参数类型,返回值由 TS 推断
function Card(props: CardProps) { /* ... */ }
// 需要显式写组件类型时也可以,但注意 React.FC 在 18 之后不再隐含 children
const Card: React.FC = (props) => { /* ... */ };
**3. 回调与事件对象的类型要写对**
type Props = {
// 推荐:定义语义化回调,事件细节留在子组件里
onChange: (value: string) => void;
// 需要用到事件对象时才暴露它,并写清元素类型
onClick: (e: React.MouseEvent) => void;
onInput: (e: React.ChangeEvent) => void;
};
**4. 组合原生属性,避免一个个手写**
type InputProps = React.ComponentPropsWithoutRef<"input"> & {
label: string;
};
function Input({ label, ...rest }: InputProps) {
return (
);
}
// 调用方既能用 label,也能用 type、placeholder、value 等原生属性
**5. 泛型组件:类型跟随数据走**
type ListProps = {
items: T[];
renderItem: (item: T) => React.ReactNode;
};
function List({ items, renderItem }: ListProps) {
return {items.map((it, i) => - {renderItem(it)}
)}
;
}
// 这里 item 会被推断为 { id: string; name: string }
item.name} />
**常用类型速查**
^ 想要的东西 ^ 类型写法 ^
| 任意可渲染内容 | ''React.ReactNode'' |
| 单个 React 元素 | ''React.ReactElement'' |
| 无返回值的回调 | ''() => void'' |
| 点击事件 | ''React.MouseEvent'' |
===== 四、组合:组件之间怎么拼 =====
* **拆分**:一段 UI 重复出现,或者复杂到需要单独理解时,抽成独立组件。
* **组合**:小组件拼成大组件;父组件决定「摆放什么」,子组件决定「怎么渲染」。
* **插槽思想**:容器组件通过 ''children'' 或具名 prop 接收内容,而不是把内容写死。
* **复合组件**:把强相关的几个组件挂在同一个名字下,共享内部状态,调用方看到的接口更清晰。
{content} {content}
// 复合组件:一组零件共享同一份上下文
很多组件库都采用这种「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 (
* state 是**组件私有**的,外部无法直接读取或修改;
* 外部需要感知变化时,要么走**回调**,要么把 state **提升**出去改成受控组件;
* 副作用(请求、订阅、定时器)用 ''useEffect'' 管理,并且要写清理逻辑。
更完整的用法见 [[react:组件基础]]。
===== 六、常见坑 =====
* **组件名小写**:%%
function Post({ content }: { content: string }) {
const [editing, setEditing] = useState(false);
return (
''editing'' 变成 true 时 ''ReplyBox'' 才被创建(挂载),变回 false 时它被销毁(卸载)。带来三个直接结果:
* 组件内部的状态**每次从头开始**:上次没提交的草稿、校验错误、展开过的下拉,全部清零;
* 组件里的 ''useEffect'' 每次打开都会重新执行,卸载时自动跑清理函数(订阅、定时器、事件监听随之解除);
* 没被打开时几乎不产生任何开销。
代价是:状态留不住;带退场动画的组件,可能在动画播完之前就被卸载掉了。
**写法二:常驻渲染——一直挂载,只切换显示**
function Post({ content }: { content: string }) {
const [visible, setVisible] = useState(false);
return (
这里有两个值得记住的套路:
* ''onVisibleChange={setVisible}'':子组件调用 ''onVisibleChange(false)'',效果就等于父组件执行 ''setVisible(false)'',不必再包一层 ''(v) => setVisible(v)'';
* 组件自己负责「不可见时少做事」,例如根据 ''visible'' 决定要不要请求数据、要不要渲染内容。
好处是内部状态和动画都保得住;代价是它一直留在组件树里,即使从未被打开过。
**怎么选**
^ 关注点 ^ 条件渲染(挂载 / 卸载) ^ 常驻渲染(切换 visible) ^
| 内部 state | 每次重新开始 | 保留 |
| 副作用 / 请求 | 每次打开重新执行 | 只在首次执行,需自己按 visible 变化触发 |
| 卸载清理 | 框架自动完成 | 需自己判断处理 |
| 退场动画 | 容易被打断 | 好实现 |
| 内存与开销 | 用时才付出 | 一直存在 |
| 适合场景 | 较重、一次性、希望每次初始化 | 较轻、需要保留状态或有动画 |
判断方法很简单:**先问「我希望内部状态和副作用跟着开关重置,还是保留?」**,答案基本就决定了写法。
**用 ''&&'' 做条件渲染时的两个坑**
* 左边必须是布尔值:''count &&