差别

这里会显示出您选择的修订版和当前版本之间的差别。

到此差别页面的链接

后一修订版
前一修订版
typescript:什么是组件 [2026/10/15 20:20] – 创建 张叶安typescript:什么是组件 [2026/10/15 20:28] (当前版本) – 小结补充「按需挂载 vs 常驻」一条,相关链接加入 react:usestate 张叶安
行 1: 行 1:
-1+====== 什么是组件 ====== 
 + 
 +**组件**是界面上「独立、可复用的一块 UI 及其行为的封装」。从形态上看它就是一个函数: 
 + 
 +<code typescript> 
 +props  ──▶  [ 组件 ]  ──▶  UI(React 元素 / 一段描述) 
 +</code> 
 + 
 +输入是 **props**(外部传进来的数据与回调),输出是**描述界面该长什么样**的 React 元素。组件本身不直接操作真实 DOM,它只负责「根据当前输入算出 UI」,剩下的交给框架。 
 + 
 +<code typescript> 
 +// 最小可用组件:不接收任何输入 
 +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} />; 
 +} 
 +</code> 
 + 
 +使用组件和写 HTML 标签很像,但属性名是 JS 的 camelCase,值用 `{}` 传表达式: 
 + 
 +<code typescript> 
 +<Avatar src="/a.png" alt="头像" /> 
 +<Avatar src="/b.png" alt="头像" size={64} /> 
 + 
 +// 字符串可以省略引号写法,其它类型必须用 {} 
 +<button disabled={isBusy} tabIndex={-1}>提交</button> 
 +</code> 
 + 
 +三条最基本的原则: 
 + 
 +  * 组件名**首字母必须大写**,否则会被当成原生 HTML 标签; 
 +  * 一个组件只负责**一块** UI 及其交互,职责单一才谈得上复用; 
 +  * 组件返回的是**描述**(React 元素),不是已经创建好的 DOM 节点。 
 + 
 +===== 一、props:组件的输入契约 ===== 
 + 
 +props 是组件对外暴露的「接口」。它在组件的整个生命周期里**只读**,组件不能自己修改。 
 + 
 +^ 形态 ^ 写法示例 ^ 说明 ^ 
 +| 必填 | ''name: string'' | 调用方少传就报错 | 
 +| 可选 | ''size?: number'' | 可以省略,读出来可能是 undefined | 
 +| 默认值 | ''size = 40'' | 解构参数时给默认值,只对 undefined 生效 | 
 +| 回调 | ''onClick?: () => void'' | 把「发生了什么」告诉父组件 | 
 +| 内容插槽 | ''children: React.ReactNode'' | 标签之间的内容 | 
 +| 原生属性透传 | ''React.ComponentProps<"button">'' | 一次性拿到某个原生标签的全部属性 | 
 +| 其余属性 | ''...rest'' | 收集未显式声明的属性,再原样透传 | 
 + 
 +<code typescript> 
 +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" /> 
 +</code> 
 + 
 +**数据向下、事件向上**:父组件通过 props 把数据和「处理函数」传给子组件;子组件只管在合适的时机调用那个函数,并不关心父组件会怎么处理。这样数据流向是单向的,容易推理,也容易调试。 
 + 
 +**props 是只读的**: 
 + 
 +<code typescript> 
 +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>; 
 +} 
 +</code> 
 + 
 +===== 二、children:把内容交给使用者 ===== 
 + 
 +''children'' 是一个**特殊的 prop**:写在组件标签之间的内容,会自动作为 ''children'' 传进去。它让组件从「内容写死的组件」变成「可装东西的容器」。 
 + 
 +<code typescript> 
 +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> 
 +</code> 
 + 
 +当容器需要**多个插槽**时,就把它们写成普通 prop: 
 + 
 +<code typescript> 
 +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> 
 +  ); 
 +} 
 +</code> 
 + 
 +要点:''children'' 只是「一个位置」;需要几个位置就定义几个 prop,而不要用一堆 ''xxxChildren'' 之类的隐式约定。 
 + 
 +===== 三、用 TypeScript 给组件加类型 ===== 
 + 
 +这是 TS 项目里组件部分最实际的工作:**把 props 的形状写清楚**,编辑器就能在调用处提示参数名、参数类型,并在写错时立刻报错。 
 + 
 +**1. 先声明 props 类型,再解构使用** 
 + 
 +<code typescript> 
 +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> 
 +  ); 
 +} 
 +</code> 
 + 
 +**2. 组件的返回类型交给推断** 
 + 
 +<code typescript> 
 +// 推荐:只标注参数类型,返回值由 TS 推断 
 +function Card(props: CardProps) { /* ... */ } 
 + 
 +// 需要显式写组件类型时也可以,但注意 React.FC 在 18 之后不再隐含 children 
 +const Card: React.FC<CardProps> = (props) => { /* ... */ }; 
 +</code> 
 + 
 +**3. 回调与事件对象的类型要写对** 
 + 
 +<code typescript> 
 +type Props = { 
 +  // 推荐:定义语义化回调,事件细节留在子组件里 
 +  onChange: (value: string) => void; 
 +  // 需要用到事件对象时才暴露它,并写清元素类型 
 +  onClick: (e: React.MouseEvent<HTMLButtonElement>) => void; 
 +  onInput: (e: React.ChangeEvent<HTMLInputElement>) => void; 
 +}; 
 +</code> 
 + 
 +**4. 组合原生属性,避免一个个手写** 
 + 
 +<code typescript> 
 +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" /> 
 +</code> 
 + 
 +**5. 泛型组件:类型跟随数据走** 
 + 
 +<code typescript> 
 +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} /> 
 +</code> 
 + 
 +**常用类型速查** 
 + 
 +^ 想要的东西 ^ 类型写法 ^ 
 +| 任意可渲染内容 | ''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 接收内容,而不是把内容写死。 
 +  * **复合组件**:把强相关的几个组件挂在同一个名字下,共享内部状态,调用方看到的接口更清晰。 
 + 
 +<code typescript> 
 +// 复合组件:一组零件共享同一份上下文 
 +<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> 
 +</code> 
 + 
 +很多组件库都采用这种「Root + List + Item / Root + Trigger + Content」的拆分方式:外层组件持有状态,内层零件通过 Context 拿到状态,所以零件自己不需要写逻辑。**平时使用这类库组件时,只需记住:零件必须放在对应的外层组件内部**(例如菜单项必须放在下拉菜单容器里),否则拿不到上下文,行为会异常或直接报错。 
 + 
 +**受控与非受控** 
 + 
 +^ 模式 ^ 特征 ^ 何时用 ^ 
 +| 受控 | 由外部传 ''value'' + ''onChange'' 决定 | 需要外部读写、需要校验或联动时 | 
 +| 非受控 | 由内部 state 自己管,外部只给 ''defaultValue'' | 简单表单、只用一次的场景 | 
 +| 半受控 | ''defaultValue'' 与 ''value'' 按是否传入自动切换 | 组件库常见的写法,兼容两种用法 | 
 + 
 +**状态提升**:当两个兄弟组件需要共享同一份数据时,把这份 state 放到它们最近的公共父组件里,再通过 props 往下传、通过回调往上通知。 
 + 
 +===== 五、组件自己的状态 ===== 
 + 
 +组件除了接收 props,还可以拥有**自己的私有状态**。状态变化会触发重新渲染,UI 自动与状态保持一致——这也是「声明式」的含义:你只描述状态和 UI 的对应关系,不用手动增删 DOM。 
 + 
 +<code typescript> 
 +function Counter({ step = 1 }: { step?: number }) { 
 +  const [count, setCount] = useState(0); 
 + 
 +  return ( 
 +    <button onClick={() => setCount((c) => c + step)}> 
 +      当前:{count} 
 +    </button> 
 +  ); 
 +} 
 +</code> 
 + 
 +  * state 是**组件私有**的,外部无法直接读取或修改; 
 +  * 外部需要感知变化时,要么走**回调**,要么把 state **提升**出去改成受控组件; 
 +  * 副作用(请求、订阅、定时器)用 ''useEffect'' 管理,并且要写清理逻辑。 
 + 
 +更完整的用法见 [[react:组件基础]]。 
 + 
 +===== 六、常见坑 ===== 
 + 
 +  * **组件名小写**:%%<button />%% 是原生标签,%%<Button />%% 才是你自己的组件。 
 +  * **直接改 props**:props 只读,想变就让父组件去改它自己的 state。 
 +  * **可选回调当必填调**:''onClick'' 声明为可选时,调用要写 ''onClick?.()'' 或给个默认空函数。 
 +  * **忘记 ''key''**:列表渲染时同级元素要加稳定且唯一的 ''key'',顺序可能变化时不要用数组下标。 
 +  * **Hook 写在条件里**:Hook 必须在组件顶层、无条件调用,顺序要稳定。 
 +  * **内联对象/函数造成多余渲染**:把新对象/新函数当 props 传下去,每次渲染引用都变;确实卡顿时再配合 ''memo'' 与 ''useCallback''、''useMemo'',不要一上来就优化。 
 +  * **展示与取数混在一起**:组件里塞满请求与转换逻辑会很难复用,建议把「取数据」抽成 Hook 或父组件,组件只负责渲染。 
 +  * **默认值位置搞错**:默认值写在**解构参数**处,只会对 ''undefined'' 生效;''null'' 依然会用 null。 
 + 
 +===== 七、附加实战:条件渲染与常驻渲染 ===== 
 + 
 +同一个组件,是**需要时才创建**,还是**一直存在、只切换显示**,是一个容易忽略但影响不小的选择。下面用「点开回复输入框」这个场景对比两种写法。 
 + 
 +**写法一:条件渲染——需要时才挂载** 
 + 
 +<code typescript> 
 +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> 
 +  ); 
 +} 
 +</code> 
 + 
 +''editing'' 变成 true 时 ''ReplyBox'' 才被创建(挂载),变回 false 时它被销毁(卸载)。带来三个直接结果: 
 + 
 +  * 组件内部的状态**每次从头开始**:上次没提交的草稿、校验错误、展开过的下拉,全部清零; 
 +  * 组件里的 ''useEffect'' 每次打开都会重新执行,卸载时自动跑清理函数(订阅、定时器、事件监听随之解除); 
 +  * 没被打开时几乎不产生任何开销。 
 + 
 +代价是:状态留不住;带退场动画的组件,可能在动画播完之前就被卸载掉了。 
 + 
 +**写法二:常驻渲染——一直挂载,只切换显示** 
 + 
 +<code typescript> 
 +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> 
 +  ); 
 +} 
 +</code> 
 + 
 +这里有两个值得记住的套路: 
 + 
 +  * ''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/原生属性透传/泛型组件。 
 +  * 倾向组合而非继承:拆小、拼装、复合组件、受控与非受控各取所需,共享数据就提升状态。 
 +  * 组件「什么时候存在」也是一种设计:按需挂载还是常驻,取决于你希望内部状态与副作用是否重置。 
 + 
 +相关:[[react:基础概念]]、[[react:组件基础]]、[[react:props-state]]、[[react:usestate]]、[[react:jsx]]、[[typescript:什么是接口]]、[[typescript:什么是函数]] 

该主题尚不存在

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

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