K
经验分享2026-10-16

React学习笔记

16 分钟阅读5 次浏览
#学习笔记#React

我以前虽然用AI写过前端基于React的项目,但是其实自己是没有系统学习和使用过React的,这段时间公司新开发项目的前端正是React,于是借这个机会我也来好好的学习一番,顺便记录笔记~。

事先说明,博主本人还是有一定的编程基础,因此学习时主要专注框架本身的特点,而不会详细解释一些基本的编程概念。

组件

何为React的组件

首先来看看官方文档对React的定义:React是一个用于构建用户界面(UI)的 JavaScript 库,用户界面由按钮、文本和图像等小单元内容构建而成。React 帮助你把它们组合成可重用、可嵌套的 组件。从 web 端网站到移动端应用,屏幕上的所有内容都可以被分解成组件。

React 应用是由被称为 组件 的独立 UI 片段构建而成。React 组件本质上是可以任意添加标签的 JavaScript 函数。组件可以小到一个按钮,也可以大到是整个页面。这是一个 Gallery 组件,用于渲染三个 Profile 组件:

//Gallery.js
function Profile() {
  return (
    <img
      src="https://react.dev/images/docs/scientists/MK3eW3As.jpg"
      alt="Katherine Johnson"
    />
  );
}

export default function Gallery() {
  return (
    <section>
      <h1>Amazing scientists</h1>
      <Profile />
      <Profile />
      <Profile />
    </section>
  );
}

可以看到,React 允许你将标签、CSS 和 JavaScript 组合成自定义“组件”,即程序中可复用的 UI 元素。

采用组件的形式在各个语言和框架中其实很常见,标准的面向对象思想,但是看示例代码还是有其特色的,每个function就代表一个组件,而返回值就直接是一段html代码,非常直观易懂。

不过虽然看起来写得像 HTML,但实际上还是 JavaScript。这种语法被称为 JSX,它允许你在 JavaScript 中嵌入标签。

React 组件是常规的 JavaScript 函数,但 组件的名称必须以大写字母开头,否则无法运行!

React是根据标签名的大小写来区分HTML标签和组件的,例如<section> 是小写的,所以 React 才知道是 HTML 标签。而<Profile/> 以大写 P 开头,所以是名为 Profile 的组件。

组件的导入导出

就像编程时的import、use、include一样,你不可能将所有的组件存放在一个文件夹内,你必然需要引用其他文件中定义好的组件,因此你也必然需要导出组件以便在其他文件夹中引用。

来看下面这个示例代码,它导入了上一小节中的Gallery组件。

//App.js
import Gallery from './Gallery.js';

export default function App() {
  return (
    <Gallery />
  );
}

可以看到,React中组件的导出就是使用了Javascript语法中的导出功能(非 React 的特性),并且同样支持 默认导出 或 具名导出。

导入时也是一样,通过Js语法直接导入即可。

一个模块最多只能有一个默认导出,对于默认导出,导入时可以赋予任意名称,且不需要使用花括号

import AnyName from './Gallery.js';

而命名导出和导入就必须完全匹配名称,且必须使用花括号:

import { Gallery } from './Gallery.js'; 

React组件间通信

React 组件使用 props 来互相通信。每个父组件都可以提供 props 给它的子组件,从而将一些信息传递给它。Props 的作用基本上与函数的参数相同,而且看上去使用方法也差不多,但你可以通过它们传递任何 JavaScript 值,包括对象、数组和函数。

以下是官方文档的一个示例,我将使用它来解释组件间如何使用props进行通信。

//app.js
import { getImageUrl } from './utils.js';

function Avatar({ person, size }) {
  return (
    <img
      className="avatar"
      src={getImageUrl(person)}
      alt={person.name}
      width={size}
      height={size}
    />
  );
}

export default function Profile() {
  return (
    <div>
      <Avatar
        size={100}
        person={{
          name: 'Katsuko Saruhashi',
          imageId: 'YfeOqp2'
        }}
      />
      <Avatar
        size={80}
        person={{
          name: 'Aklilu Lemma',
          imageId: 'OKS67lh'
        }}
      />
    </div>
  );
}
//utils.js
export function getImageUrl(person, size = 's') {
  return (
    'https://react.dev/images/docs/scientists/' +
    person.imageId +
    size +
    '.jpg'
  );
}

可以看到,我们首先定义了一个组件getImageUrl,但它不返回任何UI元素,仅组装并返回一个地址字符串,显然是单纯当作函数来使用。

然后,在app.js文件中,定义了组件Avatar,并且接受两个参数,也就是props,这样就可以在 Avatar 的代码中直接使用它们,就像使用变量一样。如此,在导出组件profile时,为两个不同的Avatar传入不同的props,从而实现多种不同方式的渲染,而不需要实现两次Avatar。

注意这段代码使用了大量的花括号来包裹各种元素,请记住,在 JSX 中的花括号,具有非常多独特的意义。

在 JSX 中,只能在以下两种场景中使用大括号:

  1. 用作 JSX 标签内的文本:<h1>{name}'s To Do List</h1> 是有效的,但是 <{tag}>Gregorio Y. Zara's To Do List</{tag}> 无效。
  2. 用作紧跟在 = 符号后的 属性:src={avatar} 会读取 avatar 变量,但是 src="{avatar}" 只会传一个字符串 {avatar}。

本小节开头就提到,除了字符串、数字和其它 JavaScript 表达式,你还可以在 JSX 中传递对象。在JSX中对象也用大括号表示,例如 { name: "Hedy Lamarr", inventions: 5 }。因此,结合上面的第2点,为了能在 JSX 中传递变量,你必须用另一对额外的大括号包裹对象:person={{ name: "Hedy Lamarr", inventions: 5 }}。

JSX标签语言

在 React 中,渲染逻辑和标签共同存在于同一个地方——组件。这样做的目的是确保它们在每次编辑时都能保持互相同步,各个组件间天然就互相隔离,修改其中任意一个组件时会更安全。

JSX 看起来和 HTML 很像,但它的语法更加严格。这里默认读者已经了解HTML语法,主要讲讲JSX与HTML的区别。

1、根元素限制

​ JSX 的组件必须返回一个单一的根元素,而 HTML 没有这样的限制。如果想要在一个组件中包含多个元素,需要用一个父标签把它们包裹起来。为了满足这一要求,通常使用 <div>或 React 的空标签 < >和</> 包裹多个元素:

<div>
  <h1>待办事项</h1>
  <img
    src="https://react.dev/images/docs/scientists/yXOvdOSs.jpg"
    alt="Hedy Lamarr"
    class="photo"
  >
  <ul>
    ...
  </ul>
</div>

或

<>
  <h1>待办事项</h1>
  ...
</>

< >和</> 是React特有的组件<Fragment> 的简写。当你需要单个元素时,你可以使用 <Fragment> 将其他元素组合起来,使用 <Fragment> 组合后的元素不会对 DOM 产生影响,就像元素没有被组合一样。大多数情况下,<Fragment></Fragment> 可以简写为空的 JSX 元素 <></>。

2、标签必须闭合

JSX 要求标签必须正确闭合。像在HTML中 <img> 这样的自闭合标签必须书写成 <img/>,而像 <li>oranges 这样只有开始标签的元素必须带有闭合标签,需要改为 <li>oranges</li>。

3、语法和属性命名,驼峰式命名法

JSX 最终会被转化为 JavaScript,而 JSX 中的属性也会变成 JavaScript 对象中的键值对。

在你自己的组件中,经常会遇到需要用变量的方式读取这些属性的时候。然而 JavaScript 对变量的命名有限制,例如变量名称不能包含 - 符号或者像 class 这样的保留字。

这就是为什么在 React 中,大部分 HTML 和 SVG 的属性都用驼峰式命名法表示。因为,许多HTML中的属性名恰好是JavaScript中的保留关键字。例如,需要用className 来代替class ,用htmlFor 来代替for , strokeWidth 代替 stroke-width。

就像这样:

<img
  src="https://react.dev/images/docs/scientists/yXOvdOSs.jpg"
  alt="Hedy Lamarr"
  className="photo"
/>

4、动态内容的嵌入

JSX 支持直接在花括号 {} 中嵌入 JavaScript 表达式,而 HTML 需要通过 <script> 标签或外部文件来实现动态内容。例如:

const name = "John";
const element = <h1>Hello, {name}!</h1>;

5、注释方式

在 JSX 中,不能直接使用普通的 // 或 /* */ 注释,否则会导致语法错误。JSX 中的注释需要包裹在 { }中,这样 JSX 编译器会将其视为 JavaScript 表达式并忽略渲染。而 HTML 使用 <!-- ... -->。例如:

{/* JSX 注释 */}
<div>{/* This is a comment */}</div>

响应事件

事件处理函数

React 可以在 JSX 中添加 事件处理函数。它将在响应交互(如点击、悬停、表单输入框获得焦点等)时触发。

如需添加一个事件处理函数,你需要先定义一个函数,然后将其作为 prop 传入合适的 JSX 标签。

按照如下三个步骤,我们来实现一个按钮,让它在用户点击时显示消息:

  1. 在 Button 组件 内部 声明一个名为 handleClick 的函数。
  2. 实现函数内部的逻辑(使用 alert 来显示消息)。
  3. 添加 onClick={handleClick} 到 <button> JSX 中。
export default function Button() {
  function handleClick() {
    alert('你点击了我!');
  }

  return (
    <button onClick={handleClick}>
      点我
    </button>
  );
}

可以看到,实现逻辑和常规的JS开发非常相似,其中 handleClick 就是一个 事件处理函数 。事件处理函数有如下特点:

  • 通常在你的组件内部定义。
  • 名称通常以 handle 开头,后跟事件名称。

当然,也可以直接定义一个内联的事件处理函数:

<button onClick={function handleClick() {
  alert('你点击了我!');
}}>

或者,直接使用更为简洁箭头函数:

<button onClick={() => {
  alert('你点击了我!');
}}>

将事件处理函数作为 props 传递

通常,我们会在父组件中定义子组件的事件处理函数。例如位于不同位置的 Button 组件,可能最终执行的功能也不同。

为此,有必要将组件从父组件接收的 prop 作为事件处理函数传递,如下所示:

function Button({ onClick, children }) {
  return (
    <button onClick={onClick}>
      {children}
    </button>
  );
}

function PlayButton({ movieName }) {
  function handlePlayClick() {
    alert('正在播放 {movieName}!');
  }

  return (
    <Button onClick={handlePlayClick}>
      播放 "{movieName}"
    </Button>
  );
}

function UploadButton() {
  return (
    <Button onClick={() => alert('正在上传!')}>
      上传图片
    </Button>
  );
}

export default function Toolbar() {
  return (
    <div>
      <PlayButton movieName="魔女宅急便" />
      <UploadButton />
    </div>
  );
}

在这个示例中,Toolbar 组件渲染了一个 PlayButton 组件和 UploadButton 组件:

  • PlayButton 将 handlePlayClick 作为 onClick prop 传入 Button 组件内部。
  • UploadButton 将 () => alert('正在上传!') 作为 onClick prop 传入 Button 组件内部。

最后,你的 Button 组件接收一个名为 onClick 的 prop。它直接将这个 prop 以 onClick={onClick} 方式传递给浏览器内置的 <button>。当点击按钮时,React 会调用传入的函数。

事件传播

事件处理函数还会捕获任何来自子组件的事件。

export default function Toolbar() {
  return (
    <div className="Toolbar" onClick={() => {
      alert('你点击了 toolbar !');
    }}>
      <button onClick={() => alert('正在播放!')}>
        播放电影
      </button>
      <button onClick={() => alert('正在上传!')}>
        上传图片
      </button>
    </div>
  );
}

在这个简单的例子中,点击任一按钮,它自身的 onClick 将首先执行,然后父级 <div> 的 onClick 会接着执行。因此会出现两条消息。

如果你想阻止一个事件到达父组件,你需要像下面 Button 组件那样调用 e.stopPropagation() :

function Button({ onClick, children }) {
  return (
    <button onClick={e => {
      e.stopPropagation();
      onClick();
    }}>
      {children}
    </button>
  );
}

export default function Toolbar() {
  return (
    <div className="Toolbar" onClick={() => {
      alert('你点击了 toolbar !');
    }}>
      <Button onClick={() => alert('正在播放!')}>
        播放电影
      </Button>
      <Button onClick={() => alert('正在上传!')}>
        上传图片
      </Button>
    </div>
  );
}

并不是每一个传播行为都需要阻止,你有时可以利用事件传播的特性来实现类似接口或继承的效果。

组件的state

如何实时更新屏幕上的数据?

组件通常需要根据交互更改屏幕上显示的内容。例如,在输入表单中应该实时更新输入字段,单击轮播图上的“下一个”应该更改显示的图片。显然,组件是需要记住一些数据的,在 React 中,这种组件特有的记忆被称为 state。

以下是一个轮播图逻辑的代码示例,每次点击button则使index+1,以播放下一张图。

import { imageList } from './data.js';

export default function Gallery() {
  let index = 0;

  function handleClick() {
    index = index + 1;
  }

  let image = imageList[index];
  return (
    <>
      <button onClick={handleClick}>
        Next
      </button>
      <h2>
        <i>{iamge.name} </i>
        by {iamge.artist}
      </h2>
      <img
        src={image.url}
        alt={image.alt}
      />
      <p>
        {iamge.description}
      </p>
    </>
  );
}

当然,这样做是无法按照预期生效的,你会发现无论如何点击按钮,画面都不发生变化。

在React中的渲染逻辑中,存在以下两个特性:

  1. 局部变量无法在多次渲染中持久保存。 当 React 再次渲染这个组件时,它会从头开始渲染——不会考虑之前对局部变量的任何更改。
  2. 更改局部变量不会触发渲染。 React 没有意识到它需要使用新数据再次渲染组件。

因此,要使用新数据更新组件,需要做两件事:

  1. 保留两次渲染之间需要的数据。
  2. 触发 React 使用新数据渲染组件(重新渲染)。

而useState Hook 提供了这两个功能:

  1. State 变量 用于保存渲染间的数据。
  2. State setter 函数 更新变量并触发 React 再次渲染组件。

新增一个State

要添加 state 变量,先从文件顶部的 React 中导入 useState:

import { useState } from 'react';

然后,替换这一行:

let index = 0;

将其修改为

const [index, setIndex] = useState(0);

useState(0)返回一个由两个值组成的数组:分别是 state 变量index ,和对应的 setter 函数 setIndex 。这里的参数0设置了index的初始值。

修改后的轮播图代码应为:

import { useState } from 'react';
import { imageList } from './data.js';

export default function Gallery() {
  const [index, setIndex] = useState(0);

  function handleClick() {
    setIndex(index + 1);
  }

  let image = imageList[index];
  return (
    <>
      <button onClick={handleClick}>
        Next
      </button>
      <h2>
        <i>{iamge.name} </i>
        by {iamge.artist}
      </h2>
      <img
        src={image.url}
        alt={image.alt}
      />
      <p>
        {iamge.description}
      </p>
    </>
  );
}

现在,点击按钮,图片切换就正常生效了。

当你将一个数组或对象传入state时,要注意Java的对象索引逻辑。如果直接修改对象本身,React是无法知道对象被修改过的。你应该把在渲染过程中可以访问到的 state 视为只读的,在每次需要触发重新渲染时,创建一个新对象并把它传递给 state 的设置函数。

Hook——钩子函数

在 React 中,useState 以及任何其他以“use”开头的函数都被称为 Hook。React 中的Hooks 是一种函数式组件的增强机制,它允许你在不编写类组件的情况下使用 React 的特性。

Hook 是特殊的函数,只在 React 渲染时有效。它们能让你 “hook” 到不同的 React 特性中去。使函数组件能够拥有类组件的一些特性,例如状态管理和生命周期方法的使用。

**Hooks只能在组件的最顶层调用,你不能在条件语句、循环语句或其他嵌套函数内调用 Hook。**Hook 是函数,但可以将它们视为关于组件需求的无条件声明。在组件顶部 “use” React 特性,类似于在文件顶部“导入”模块。

React 在内部维护着每个组件实例对应的 Fiber 节点。当你首次渲染一个使用了 Hooks 的组件时,React 会按照 Hooks 的调用顺序,在 Fiber 节点上创建一个链表来存储这些 Hooks 的信息(包括 state、effect 等)。

当组件进行后续渲染时,React 再次按照相同的顺序执行这些 Hooks。通过这个顺序,React 能够准确地从链表中获取到对应 Hook 上一次的状态或信息。这就是为什么必须在组件的顶层调用 Hooks,并且不能在循环、条件或嵌套函数中调用 Hooks,因为这会打乱调用顺序,导致 React 无法正确匹配 Hooks。

Fiber Reconciler(简称Fiber),是React团队在2017年发布的React 16中引入的一项革命性的技术。在Fiber架构中,Fiber节点是React渲染的最小工作单元。每个Fiber节点对应一个组件实例或DOM节点,它不仅存储了组件的类型、属性、状态等信息,还包含了用于调度和协调的元数据。不仅如此,Fiber采用双缓冲(Double Buffering)技术来实现高效的diff比较,避免了频繁的DOM操作,提高了渲染效率。

Fiber架构的核心突破是将原本同步的渲染过程分解为多个可中断的小任务。这些任务可以在浏览器的空闲时间内执行,必要时让出控制权给更高优先级的任务。在整个渲染过程中,React会首先进行协调,遍历组件树,比较新旧Fiber节点,确定需要更新的部分,协调完成后,将所有变更一次性应用到DOM上。

React Fiber巧妙的利用了浏览器的requestAnimationFrame(动画渲染)和requestIdleCallback(空闲时渲染)等API,实现了与浏览器渲染节奏的完美同步,最大限度地提升了应用性能。

渲染和提交

有两种原因会导致组件的渲染:

  • 组件的 初次渲染。

  • 组件(或者其父组件)的 状态发生了改变。

在你触发渲染后,React 会调用你的组件来确定要在屏幕上显示的内容。“渲染中” 即 React 在调用你的组件。

  • 在进行初次渲染时, React 会调用根组件。
  • 对于后续的渲染, React 会调用内部状态更新触发了渲染的函数组件。

这个过程是递归的:如果更新后的组件会返回了另外一个组件,那么 React 接下来就会渲染那个组件,而如果那个组件又返回了某个组件,React 依然会接着渲染,以此类推。

在每次渲染时,React 会为各个标签 创建 DOM 节点。每一次重渲染过程中, React 都会计算哪些属性自上次渲染以来发生了变更。在下一步(提交阶段)之前,它不会对这些信息执行任何操作。

在渲染(调用)你的组件之后,React 将会修改 DOM。

  • 对于初次渲染,React 会使用 appendChild() DOM API 将其创建的所有 DOM 节点放在屏幕上。
  • 对于重渲染,React 将应用最少的必要操作(在渲染时计算),以使得 DOM 与最新的渲染输出相互匹配。

React 仅在渲染之间存在差异时才会更改 DOM 节点。

在渲染完成并且 React 更新 DOM 之后,浏览器就会重新绘制屏幕。

实用示例

使用 filter() 和 map() 方法来渲染组件列表

假设有以下数据:

const people = [
  '凯瑟琳·约翰逊: 数学家',
  '马里奥·莫利纳: 化学家',
  '穆罕默德·阿卜杜勒·萨拉姆: 物理学家',
  '珀西·莱温·朱利亚: 化学家',
  '苏布拉马尼扬·钱德拉塞卡: 天体物理学家',
];

我们试图使用JS的map方法来遍历并返回一个JSX 节点数组 listItems。

export default function List() {
  const listItems = people.map(person =>
    <li>{person}</li>
  );
  return <ul>{listItems}</ul>;
}

理想情况下能够成功渲染,但是会报如下控制台错误信息:

Warning: Each child in a list should have a unique “key” prop.

这是因为在React中,你必须给数组中的每一项都指定一个 key,这是React唯一标识出某一项JSX 节点或文件所必需的——它可以是字符串或数字的形式,只要能唯一标识出各个数组项就行。

因此我们需要将数据变得更加结构化一些:

const people = [{
  id: 0,
  name: '凯瑟琳·约翰逊',
  profession: '数学家',
}, {
  id: 1,
  name: '马里奥·莫利纳',
  profession: '化学家',
}, {
  id: 2,
  name: '穆罕默德·阿卜杜勒·萨拉姆',
  profession: '物理学家',
}, {
  id: 3,
  name: '珀西·莱温·朱利亚',
  profession: '化学家',
}, {
  id: 4,
  name: '苏布拉马尼扬·钱德拉塞卡',
  profession: '天体物理学家',
}];

现在,我想只显示职业为化学家的人,那么我可以使用filter()方法,对数组进行过滤。

export default function List() {
  const chemists = people.filter(person =>
    person.profession === '化学家'
  );
  const listItems = chemists.map(person =>
    <li>
      <p>
        <b>{person.name}:</b>
        {' ' + person.profession + ' '}
      </p>
    </li>
  );
  return <ul>{listItems}</ul>;
}

1、箭头函数会隐式地返回位于 => 之后的表达式,所以你可以省略 return 语句。

2、filter() 和 map() 是JavaScript中的语法,这里不再详细解释使用方法。

相关文章