Skip to content

5. 第 4 章 - [React] 简介

5.1. 资料来源

本章基于 [React] 的官方文档:react.dev。

5.2. 从 AngularJS 1.x 到 [React]

原文档(2014)使用 AngularJS 1.x:这是一个 JavaScript 框架(当时还没有 TypeScript),围绕 $scope、控制器、指令(ng-repeat、ng-if……)以及基于“摘要循环”($digest)和变量监视($watch)的变更检测机制组织。

[React] (由 Meta 于 2013 年创建)不是像 AngularJS 1.x 或 [Angular] 那样的完整框架:它是一个 库 ,专注于一项任务:用 组件构建界面。就其本身而言,它既不提供 HTTP 客户端,也不提供路由器,更没有依赖注入机制——因此本章的 [RdvMedecins] 客户端在这些方面依赖浏览器的原生 API(fetch(),见下文)和 [React] 特有的机制——上下文(Context),而不是依赖 [HttpClient] 或 [Angular] 路由器之类的专用模块。本章逐一介绍这些概念,并配以独立于案例研究的简短示例——下一章将在完整的 [RdvMedecins] 客户端中,在 [React] 19 里展示它们的实际运用。

5.3. [React] 应用的概念:“单页应用”

[React] 应用与 [Angular] 应用一样,是单页应用(SPA):服务器只向浏览器提供一个页面(HTML),其中包含一个封装了应用全部逻辑的文件(JavaScript)。该页面加载之后,就不会再有完整的页面重新加载:每次用户交互(切换视图、提交表单等)都由浏览器中已有的 JavaScript 代码处理,它更新显示,并通过异步 HTTP 请求(最常用的是 JSON)在后台与服务器通信。这已经是使用 AngularJS 1.x 的原文档的原则,也是本课程 [Angular] 变体的原则——它没有改变:不同变体之间只有管理显示的库不同。

5.4. 组件:函数与 [JSX]

与 [Angular] 中一样,组件 是 [React] 应用的基本单元:它根据当前的状态和接收到的属性,生成要显示在屏幕上的内容。区别在于形式:[Angular] 组件是一个带装饰器的 类,与单独的(或内联的)HTML 模板相关联;[React] 组件则只是一个返回 JavaScript (或 TypeScript)函数 ,返回的是 [JSX]——一种类似 HTML 的语法,但实际上会被编译器转换为普通的 JavaScript 函数调用。

下面是一个非常小的组件,独立于案例研究,等价于本课程 [CounterComponent] 在 [Angular] 变体中给出的示例:

// Counter.tsx

import { useState } from 'react';

export function Counter() {
  const [value, setValue] = useState(0);

  function increment(): void {
    setValue((v) => v + 1);
  }

  return (
    <>
      <p>Value: {value}</p>
      <button onClick={increment}>+1</button>
    </>
  );
}

我们来解读这段代码:

  • 第 3 行:import { useState } from 'react'; ——[useState] 是一个 Hook [React]:一种特殊函数(可通过其“use”前缀识别),它使组件函数能够维护在多次渲染之间保持不变的状态——其作用可与 [Angular] 方面的信号或 $scope/AngularJS 控制器相比;
  • 第 5 行:export function Counter() { ——[React] 组件是一个被导出的普通函数:既没有装饰器,也不需要声明自定义选择器(HTML)(不同于 [@Component]({ selector: … }) 在 [Angular] 中的做法)——它直接以自己的名称作为标签 <Counter /> 在父组件的 [JSX] 中使用;
  • 第 6 行:const [value, setValue] = useState(0); ——[useState](0) 创建一个初始化为 0 的状态值,并返回一个 数对:当前值(value)和替换它的函数(setValue)。数组解构([value, setValue])只是一种命名约定——完全可以用不同的名称来命名这两个元素;
  • 第 8–10 行:setValue((v) => v + 1); ——调用 setValue 不会就地修改 `value`([React] 的状态值是不可变的):它指示 [React] 用根据旧值计算出的新值重新绘制组件,与 [Angular] 方面的 mySignal.update(v => …) 完全一样;
  • 第 13–16 行:<p>Value: {value}</p> ——函数返回的 [JSX] 就是模板:花括号 { } 插入一个 JavaScript 表达式(这里是当前值)——作用与 [Angular] 模板中的双花括号 {{ value() }} 相同,只是没有调用括号:`value` 就是数据本身,而不是调用时才会被解释的信号。

<> … </> 标签(“片段”)把多个元素组合在一起,而不会在它们外面添加多余的 HTML 节点——这是 [JSX] 的一个技术细节,它要求组件函数只返回一个根元素。

5.5. 本地状态:[useState] 和 props

在 AngularJS 1.x 中,[Angular] 通过系统性的检查循环($digest)来检测数据值是否发生变化,在本课程的 [Angular] 变体中,它被 信号 (signal()、computed())取代。[React] 采用第三种看起来更简单的方式:组件会完整地重新执行其函数(从而重新计算其整个 [JSX]),每当它的某个 [useState] 值发生变化时——[React] 随后将结果与上一次渲染进行比较,只修改浏览器真实 DOM 中确实发生变化的部分(这种技术称为协调,或“虚拟 DOM”)。与信号不同,[useState] 状态本身并不“知道”什么依赖于它:由整个组件的重新渲染机制来处理,这在推理上更简单,但在非常大的应用中理论上开销略高,这是 [React] 有意做出的权衡。

函数
作用
useState(initialValue)
创建本地状态并返回数对 [value, setValue];setValue 用新值重新绘制组件
setValue(newValue)
用预先计算好的值替换状态值
setValue(v => ...)
根据旧值计算新值(见上面的 increment())
useMemo(() => ..., [deps])
仅当 [deps] 中的某个元素发生变化时,才重新计算派生值——在概念上等价于 [Angular] 方面的 computed()

有两种机制与 [useState] 互补,使组件能够与其父组件通信——我们会在 [RdvMedecins] 客户端(下一章)中不断遇到它们,它们恰好位于 [Angular] 方面 input()/output() 所在的位置:

  • props:[React] 组件以简单的函数参数(一个解构的对象,{ doctors, onSearch })接收其输入——直接对应 input.required<Doctor[]>()(在 [Angular] 方面),在概念上也对应 AngularJS 1.x 指令的属性;
  • 回调 props:由父组件提供的函数(onSearch: (criteria) => void),作为 prop 传入,然后由子组件在适当的时候调用——直接对应 [Angular] 方面的 output<...>()(及其 .emit(value) 方法),以及 AngularJS 1.x 的自定义事件($emit)。

5.6. 没有模块:每个文件本身就是自包含的

AngularJS 1.x 应用是围绕模块(angular.module(...))组织的。[Angular] 最初以更僵硬的形式(NgModule)采纳了这一思想,随后才提出把独立组件作为默认模式——本课程的 [Angular] 变体已经采用了这一简化。[React] 从来不需要这个概念:.tsx 文件用 JavaScript 语言本身的 export 关键字导出组件,另一个文件用简单的 import 使用它——这就是标准的 ECMAScript 模块,没有任何界面库特有的额外层次:

// Parent.tsx

import { Counter } from './Counter';

export function Parent() {
  return (
    <div>
      <Counter />
    </div>
  );
}

本课程在整个 [RdvMedecins] 客户端(下一章)中都采用这种风格:没有 *.module.ts 文件,没有需要随时保持更新的 imports: 装饰器 [...] ——相比 AngularJS 1.x、带 NgModule 的 [Angular],甚至 [Angular] 的独立组件(它们仍然要在 imports 中列出其依赖:[...] 来自装饰器 [@Component]),这又是进一步的简化。

5.7. 共享逻辑:自定义 Hook 和 [Context]

与 [NestJS] (第 2 章)中一样,客户端 [RdvMedecins] 需要在多个组件之间共享逻辑:与服务器通信、识别已登录的用户,以及切换语言。[Angular] 用可注入的 服务 ([@Injectable]({ providedIn: 'root' }) + inject(...))来满足这一需求——它是 AngularJS 1.x 的 .service()/.factory() 的直接继承者。[React] 没有内置的依赖注入机制;现代用法结合了上面已经讨论过的两种工具:

  • 一个 自定义 Hook——名称以 `use` 开头的函数,它本身可以调用其他 Hook([useState]、[useContext]……)——封装可复用的逻辑,就像 [Angular] 方面的服务方法一样;
  • 上下文(Context)([React.createContext])把一个值(状态 + 函数)共享给整个组件子树,而无需逐级、逐个 prop 地手动向下传递——这相当于 [Angular] 方面 providedIn: 'root' 所起的作用:单个实例,在任何需要的地方都可用。

下面是一个简短的示例,独立于案例研究,在概念上等价于本课程 [MyService] 在 [Angular] 变体中给出的示例:

// my-context.tsx
import { createContext, useContext, type ReactNode } from 'react';

interface MyContextValue {
  greet: () => string;
}

const MyContext = createContext<MyContextValue | null>(null);

export function MyProvider({ children }: { children: ReactNode }) {
  const value: MyContextValue = { greet: () => 'Hello' };
  return <MyContext.Provider value={value}>{children}</MyContext.Provider>;
}

export function useMyContext(): MyContextValue {
  const context = useContext(MyContext);
  if (context === null) {
    throw new Error('useMyContext() must be called under a <MyProvider>');
  }
  return context;
}

我们来解读这段代码:

  • 第 8 行:const MyContext = createContext<MyContextValue | null>(null); ——创建 Context 本身;`null` 是默认值,仅当树中其上方没有 `<MyProvider>` 时才会使用——这是一个在第 17 行检测到的编程错误;
  • 第 10–13 行:<MyContext.Provider value={value}>{children}</MyContext.Provider> ——Provider 组件使该值对其所有后代({children})可用;它只需在应用根部附近放置一次(见 [RdvMedecins] 客户端的 main.tsx,下一章)——相当于 [Angular] 方面 providedIn: 'root' 所执行的隐式“注册”;
  • 第 15–21 行:export function useMyContext(): MyContextValue { ——提供对 Context 值访问的自定义 Hook;组件调用的就是它(const my = useMyContext();),就像它们在 [Angular] 方面调用 inject(MyService) 一样。

5.8. 与服务器通信:[fetch]

[HttpClient] ([Angular])是原文档所用的 AngularJS 1.x 的 $http 服务的直接继承者。由于 [React] 只是一个界面库,它不提供任何 HTTP 客户端:客户端 [RdvMedecins] 直接使用 [fetch],即浏览器的标准 API(无需任何额外依赖即可使用):

1
2
3
const httpResponse = await fetch('http://localhost:8080/hello');
const response = (await httpResponse.json()) as { message: string };
console.log(response.message);

与 $http 和 [HttpClient] 的一个重要区别:[fetch] 直接返回 Promise(JavaScript 的标准异步机制),而不是 Observable——没有 RxJS 库,没有 .subscribe({ next, error }),也没有 .pipe(map(...))。可以配合 .then(...) 使用,或者为了更好的可读性,配合 async/await 使用(如上所示,它会挂起函数的执行,直到 Promise 完成,而不会阻塞应用的其余部分)。网络错误或错误响应随后用简单的 try/catch 块处理,而不是用 RxJS 订阅的错误分支。

[RdvMedecins] 客户端(下一章)的 useAppointmentService() Hook 系统地封装了 [fetch] 调用及随后的 .json(),原因届时会具体说明(所有服务器响应共有的 [ServerResponse]<T> 包装)。

5.9. 条件渲染和列表:纯 [JSX]

AngularJS 1.x 使用结构型指令(ng-if、ng-repeat)来有条件地显示元素,或为列表中的每个元素重复一个模板块。本课程的 [Angular] 变体使用内置语法 [@if]/[@for]。[React] 没有需要另学的单独模板语法:组件返回的 [JSX] 就是 JavaScript,流程控制用普通的 JavaScript 运算符来表达:

{loggedInUser ? (
  <p>Welcome!</p>
) : (
  <p>Please log in.</p>
)}

<ul>
  {itemList.map((item) => (
    <li key={item.id}>{item.name}</li>
  ))}
</ul>

我们来解读这段代码:

  • 第 1–5 行:loggedInUser ? (...) : (...) ——JavaScript 的三元运算符取代了 [@if]/[@else]([Angular])和 ng-if(AngularJS 1.x):由条件决定返回两个 [JSX] 表达式中的哪一个。对于没有备选分支的条件,只需用 && 运算符:{condition && <p>...</p>} 在条件为 false 时完全不显示任何内容(例如,下一章讨论的 [RdvMedecins] 客户端的 App 组件中的 ADMIN/USER 横幅就采用这种风格);
  • 第 8 行:itemList.map((item) => (...)) ——.map()(JavaScript 的标准数组方法)取代了 [@for]([Angular])和 ng-repeat(AngularJS 1.x):它把数组的每个元素转换为一个 [JSX] 元素;
  • 第 9 行:key={item.id} (在 [JSX] 列表中是必需的)——告诉 [React] 在重新绘制列表时如何识别已经显示过的元素;这与 [@for] 之后的 track item.id 在 [Angular] 方面所起的作用完全相同。

5.10. 小结:[Angular] -> [React] 的对应关系

[Angular] (本课程的上一版本)
[React] (2026)
Standalone components ([@Component])
函数组件
Signals (signal(), input(), output(), computed())
[useState]()、props、回调 props、[useMemo]()
effect()
[useEffect]()
Separate template (.html) + decorator (.ts)
[JSX] 嵌入在组件中(.tsx)
[@if], [@for]
三元运算符 / &&、.map()
Injectable services ([@Injectable]({ providedIn: 'root' })) + inject()
自定义 Hook + [Context]
[HttpClient] (RxJS Observables)
[fetch] (原生 Promise)
[@angular/router] (empty routing table)
没有路由器(结论相同,且更进一步)
Angular CLI / [@angular/build]
[Vite]

有了这些概念,就足以着手学习下一章的 [RdvMedecins] 客户端:不过,每种新用法都会随着代码的推进,在其出现的确切位置重新加以解释。