From 5f84f020b5d144e1f41e3104bea0fa0bc0553d17 Mon Sep 17 00:00:00 2001
From: Yucohny <79147654+Yucohny@users.noreply.github.com>
Date: Mon, 30 Oct 2023 11:13:19 +0800
Subject: [PATCH] docs(cn): standardize the translations of the word fallback
 (#1360)

Co-authored-by: Xavi Lee <awxiaoxian2020@163.com>
---
 .../blog/2022/03/08/react-18-upgrade-guide.md |  6 +--
 src/content/blog/2022/03/29/react-v18.md      |  4 +-
 ...what-we-have-been-working-on-march-2023.md |  2 +-
 src/content/reference/react-dom/flushSync.md  |  4 +-
 .../server/renderToPipeableStream.md          | 18 ++++----
 .../server/renderToReadableStream.md          | 16 +++----
 .../react-dom/server/renderToStaticMarkup.md  |  2 +-
 .../react-dom/server/renderToString.md        |  4 +-
 src/content/reference/react/Component.md      |  4 +-
 src/content/reference/react/Suspense.md       | 42 +++++++++----------
 src/content/reference/react/components.md     |  2 +-
 src/content/reference/react/createContext.md  |  4 +-
 src/content/reference/react/use.md            |  6 +--
 src/content/reference/react/useContext.md     |  2 +-
 .../reference/react/useDeferredValue.md       |  6 +--
 .../reference/react/useLayoutEffect.md        |  2 +-
 src/content/reference/react/useTransition.md  |  2 +-
 17 files changed, 63 insertions(+), 63 deletions(-)

diff --git a/src/content/blog/2022/03/08/react-18-upgrade-guide.md b/src/content/blog/2022/03/08/react-18-upgrade-guide.md
index ca50fe441f..765459c30e 100644
--- a/src/content/blog/2022/03/08/react-18-upgrade-guide.md
+++ b/src/content/blog/2022/03/08/react-18-upgrade-guide.md
@@ -305,7 +305,7 @@ globalThis.IS_REACT_ACT_ENVIRONMENT = true;
 * **一致的 useEffect 时间**：现在，如果更新是在类似点击或者敲击键盘事件这样的离散用户输入事件期间触发，React 总是同步刷新 effect 函数。而之前的行为不是一直可预测或者一致的。
 * **更严格的 hydrate 报错**：由于缺失或者额外的文本而导致的 hydrate 不匹配现在会作为错误而不是告警对待。React 将不再试图通过在客户端增加或删除节点来“修补”单个节点来匹配服务端标记，并且将会回退客户端渲染到树中最近的 `<Suspense>` 边界。这可以保证 hydrate 树保持一致并且避免可能由 hydrate 不匹配导致的隐私和安全漏洞。
 * **Suspense 树一直保持一致**：如果一个组件在它完全被添加到树上之前挂起，React 将不会把它以不完整的状态添加到树或者触发它的 effect。React 会完全扔掉新树，等待异步操作结束，然后重新尝试从头开始再次渲染。React 会同时渲染重试尝试，并且不会阻塞浏览器。
-* **使用 Suspense 的 Layout Effect**：当一个树重新挂起并恢复为回退时，现在的 React 会清理 layout effect，然后在边界内的内容再次显示时重新创建它们。这修复了一个在与 Suspense 一起使用时的问题：阻止组件库正确测量布局。
+* **使用 Suspense 的 Layout Effect**：当一个树重新挂起并恢复为后备方案时，现在的 React 会清理 layout effect，然后在边界内的内容再次显示时重新创建它们。这修复了一个在与 Suspense 一起使用时的问题：阻止组件库正确测量布局。
 * **新的 JavaScript 环境要求**：React 现在依赖于现代浏览器特性，包括 `Promise`、`Symbol` 和 `Object.assign`。如果你需要支持像 Internet Explorer 这样较老版本的浏览器和设备，它们本身不提供现代浏览器特性或者有不兼容的实现，可以考虑在打包后的应用中包含全局的 polyfill。
 
 ## 其他值得注意的变化 {/*other-notable-changes*/}
@@ -320,8 +320,8 @@ globalThis.IS_REACT_ACT_ENVIRONMENT = true;
 
 ### React DOM Server {/*react-dom-server*/}
 
-* **`renderToString`**：当在服务端挂起时，它不再会报错。而是会为最接近的 `<Suspense>` 边界发射 fallback HTML，然后在客户端尝试渲染同样的内容。我们仍然推荐你切换到像 `renderToPipeableStream` 或者 `renderToReadableStream` 这样的流式 API。
-* **`renderToStaticMarkup`**：当在服务端挂起时，它不再会报错。而是会为最接近的 `<Suspense>` 边界发射 fallback HTML。
+* **`renderToString`**：当在服务端挂起时，它不再会报错。而是会为最接近的 `<Suspense>` 边界发射后备 HTML，然后在客户端尝试渲染同样的内容。我们仍然推荐你切换到像 `renderToPipeableStream` 或者 `renderToReadableStream` 这样的流式 API。
+* **`renderToStaticMarkup`**：当在服务端挂起时，它不再会报错。而是会为最接近的 `<Suspense>` 边界发射后备 HTML。
 
 ## 更新日志 {/*changelog*/}
 
diff --git a/src/content/blog/2022/03/29/react-v18.md b/src/content/blog/2022/03/29/react-v18.md
index a8ebd43e17..98fe646405 100644
--- a/src/content/blog/2022/03/29/react-v18.md
+++ b/src/content/blog/2022/03/29/react-v18.md
@@ -74,7 +74,7 @@ React 18 中最重要的更新内容是我们希望你永远不会考虑的：
 
 在未来，我们可能会暴露更多原语，使你能用 `Suspense` 更容易地获取数据，那时也就不一定必须要使用某个的框架。不过，Suspense 被深度整合到你的应用结构中时能产生最好的效果：你的路由，你的数据层，你的服务端渲染环境。因此我们预计，即使在未来相当长一段时间里，库和框架也还会在 React 生态中发挥关键作用。
 
-就像在过去的 React 的版本中，你总是可以使用 Suspense 与客户端侧的 `React.lazy` 配合进行代码分割。但是我们的对 Suspense 的期望并不仅仅是加载代码——最终的目标是扩展对 Suspense 的支持，以至于相同的声明式 Suspense fallback 能够处理任何异步操作（加载代码，数据，图片等）。
+就像在过去的 React 的版本中，你总是可以使用 Suspense 与客户端侧的 `React.lazy` 配合进行代码分割。但是我们的对 Suspense 的期望并不仅仅是加载代码——最终的目标是扩展对 Suspense 的支持，以至于相同的声明式 Suspense 后备方案能够处理任何异步操作（加载代码，数据，图片等）。
 
 ## 服务器组件仍在开发中 {/*server-components-is-still-in-development*/}
 
@@ -162,7 +162,7 @@ Suspense 使得“UI 加载状态”成为了 React 编程模型中最高级的
 
 在 React 18 中，我们已经支持了服务端 Suspense，并且使用并发渲染特性扩展了其功能。
 
-React 18 中的 Suspense 在与 transition API 结合时效果最好。如果你在 transition 期间挂起，React 不会让已显示的内容被之前的内容取代。相反，React 会延迟渲染，直到有足够的数据，以防止出现加载状态错误。
+React 18 中的 Suspense 在与 transition API 结合时效果最好。如果你在 transition 期间挂起，React 不会让已显示的内容被后备方案取代。相反，React 会延迟渲染，直到有足够的数据，以防止出现加载状态错误。
 
 更多内容参见 [React 18 中的 Suspense](https://github.com/reactjs/rfcs/blob/main/text/0213-suspense-in-react-18.md) 的意见征求。
 
diff --git a/src/content/blog/2023/03/22/react-labs-what-we-have-been-working-on-march-2023.md b/src/content/blog/2023/03/22/react-labs-what-we-have-been-working-on-march-2023.md
index 0885d8bff4..59248b63b9 100644
--- a/src/content/blog/2023/03/22/react-labs-what-we-have-been-working-on-march-2023.md
+++ b/src/content/blog/2023/03/22/react-labs-what-we-have-been-working-on-march-2023.md
@@ -85,7 +85,7 @@ React 的核心思想是开发人员将其 UI 定义为当前状态的函数。
 
 我们的想法是，开发者应该能够在不更改组件编写方式的情况下，将任何 React 树渲染到屏幕外。当组件被离屏渲染时，它实际上并没有 **挂载**，直到组件变为可见状态——其效果不会被触发。例如，如果组件使用 `useEffect` 在首次出现时记录分析数据，预渲染不会影响数据的准确性。同样，当组件离开屏幕时，其效果也会被卸载。离屏渲染的一个关键特性是，可以切换组件的可见性，而不会失去其状态。
 
-自上次更新以来，我们在 Meta 的 React Native 应用程序上测试了一个实验性的预渲染版本，包括 Android 和 iOS，性能表现良好。我们还改进了离屏渲染与 Suspense 的配合方式——在离屏树中挂起（suspend）但不会触发 suspense fallback。我们剩下的工作是完成向库开发人员公开的基本组件。我们预计将于今年晚些时候发布一个 RFC，同时发布一个实验性的 API 用于测试和反馈。
+自上次更新以来，我们在 Meta 的 React Native 应用程序上测试了一个实验性的预渲染版本，包括 Android 和 iOS，性能表现良好。我们还改进了离屏渲染与 Suspense 的配合方式——在离屏树中挂起（suspend）但不会触发 Suspense 后备方案。我们剩下的工作是完成向库开发人员公开的基本组件。我们预计将于今年晚些时候发布一个 RFC，同时发布一个实验性的 API 用于测试和反馈。
 
 ## 追踪 transition {/*transition-tracing*/}
 
diff --git a/src/content/reference/react-dom/flushSync.md b/src/content/reference/react-dom/flushSync.md
index 878dc1f3fa..fccd214bc2 100644
--- a/src/content/reference/react-dom/flushSync.md
+++ b/src/content/reference/react-dom/flushSync.md
@@ -43,7 +43,7 @@ flushSync(() => {
 #### 参数 {/*parameters*/}
 
 
-* `callback`：一个函数。React 会立即调用这个回调函数，并同步刷新其中包含的任何更新。它也可能会刷新任何挂起的更新、Effect 或 Effect 内部的更新。如果因为调用 `flushSync` 而导致更新挂起（suspend），则可能会重新显示 fallback。
+* `callback`：一个函数。React 会立即调用这个回调函数，并同步刷新其中包含的任何更新。它也可能会刷新任何挂起的更新、Effect 或 Effect 内部的更新。如果因为调用 `flushSync` 而导致更新挂起（suspend），则可能会重新显示后备方案。
 
 #### 返回值 {/*returns*/}
 
@@ -126,7 +126,7 @@ export default function PrintApp() {
 
 <Pitfall>
 
-`flushSync` 可能会严重影响性能，并且可能会意外地强制挂起的 Suspense 边界显示其 fallback 状态。
+`flushSync` 可能会严重影响性能，并且可能会意外地强制挂起的 Suspense 边界显示其后备状态。
 
 大多数时候都不需要使用 `flushSync`，请将其作为最后的手段使用。
 
diff --git a/src/content/reference/react-dom/server/renderToPipeableStream.md b/src/content/reference/react-dom/server/renderToPipeableStream.md
index 77d2d3926d..dac5dc6145 100644
--- a/src/content/reference/react-dom/server/renderToPipeableStream.md
+++ b/src/content/reference/react-dom/server/renderToPipeableStream.md
@@ -57,8 +57,8 @@ const { pipe } = renderToPipeableStream(<App />, {
   * **可选** `nonce`：[`nonce`](http://developer.mozilla.org/zh-CN/docs/Web/HTML/Element/script#nonce) 一个字符串，能为脚本设置跨域限制，即 [`script-src` 浏览器内容安全策略](https://developer.mozilla.org/zh-CN/docs/Web/HTTP/Headers/Content-Security-Policy/script-src)。
   * **可选** `onAllReady`：一个回调函数，将会在所有渲染完成时触发，包括 [shell](#specifying-what-goes-into-the-shell) 和所有额外的 [content](#streaming-more-content-as-it-loads)。你可以用这个替代 `onShellReady` [用于爬虫和静态内容生成](#waiting-for-all-content-to-load-for-crawlers-and-static-generation)。如果在此处开启了流式传输，所有的 HTML 都会被包含在流中直接返回，而不会有任何渐进的加载。
   * **可选** `onError`：一个回调函数，只要是出现了异常错误，无论这是 [可恢复的](#recovering-from-errors-outside-the-shell) 还是 [不可恢复的](#recovering-from-errors-inside-the-shell)，它都会触发。默认情况下，它只会调用 `console.error`。如果你想要将它重写为 [日志崩溃报告](#logging-crashes-on-the-server)，记得仍然要使用 `console.error` 为可能不兼容的场景兜底。你也可以在 shell 发送之前使用它来 [修改状态码](#setting-the-status-code)。
-  * **可选** `onShellReady`：一个回调函数，在 [shell 初始化](#specifying-what-goes-into-the-shell) 渲染后立即调用。你可以 [设置状态码](#setting-the-status-code) 然后在这里调用 `pipe` 方法启用流式传输。这样一来，React 将会初始化 shell 渲染完毕后，通过上面提到的 `<script>` 进行 [流式传输更多内容](#streaming-more-content-as-it-loads)，用这些内容替换掉 HTML 的加载动画部分。
-  * **可选** `onShellError`：一个回调函数，在初始化 shell 发生错误渲染时调用。它的第一个参数将自动接收捕获到的异常错误。此时，这个流中的任何内容都不会被发送，并且 `onShellReady` 和 `onAllReady` 都不会被调用，所以你还可以 [输出一段备用的 HTML shell](#recovering-from-errors-inside-the-shell) 作为兜底。
+  * **可选** `onShellReady`：一个回调函数，在 [shell 初始化](#specifying-what-goes-into-the-shell) 渲染后立即调用。你可以 [设置状态码](#setting-the-status-code) 然后在这里调用 `pipe` 方法启用流式传输。这样一来，React 将会初始化 shell 渲染完毕后，通过上面提到的 `<script>` 进行 [流式传输更多内容](#streaming-more-content-as-it-loads)，用这些内容替换掉 HTML 的加载中的后备方案。
+  * **可选** `onShellError`：一个回调函数，在初始化 shell 发生错误渲染时调用。它的第一个参数将自动接收捕获到的异常错误。此时，这个流中的任何内容都不会被发送，并且 `onShellReady` 和 `onAllReady` 都不会被调用，所以你还可以 [输出一段后备 HTML shell](#recovering-from-errors-inside-the-shell) 作为兜底。
   * **可选** `progressiveChunkSize`：一个块中的字节数。[查阅更多关于该参数默认值的信息](https://github.com/facebook/react/blob/14c2be8dac2d5482fda8a0906a31d239df8551fc/packages/react-server/src/ReactFizzServer.js#L210-L225)。
 
 
@@ -253,7 +253,7 @@ function ProfilePage() {
 }
 ```
 
-这样做将通知 React 在 `Posts` 加载数据之前就开始流式传输 HTML。React 首先会发送加载动画（`PostsGlimmer`）对应的 HTML，然后当 `Posts` 的数据加载完成时，React 会将剩下的 HTML 带上一个 `<script>` 标签一并发送，这个 `<script>` 的作用是将加载动画替换为这段 HTML。从用户的角度上看，页面上首先出现的是 `PostsGlimmer`，稍后被替换为 `Posts`。
+这样做将通知 React 在 `Posts` 加载数据之前就开始流式传输 HTML。React 首先会发送加载中的后备方案（`PostsGlimmer`）对应的 HTML，然后当 `Posts` 的数据加载完成时，React 会将剩下的 HTML 带上一个 `<script>` 标签一并发送，这个 `<script>` 的作用是将加载中的后备方案替换为这段 HTML。从用户的角度上看，页面上首先出现的是 `PostsGlimmer`，稍后被替换为 `Posts`。
 
 你可以进一步地 [嵌套 `<Suspense>`](/reference/react/Suspense#revealing-nested-content-as-it-loads) 来创建一个更加细致的加载序列：
 
@@ -276,7 +276,7 @@ function ProfilePage() {
 }
 ```
 
-在这个例子中，React 甚至能够更早地启用流式传输。因为 `ProfileLayout` 和 `ProfileCover` 没有被包裹在 `<Suspense>` 中，所以它们必须先完成渲染。然而，如果 `Sidebar`、`Friend` 或者 `Photos` 需要加载更多数据，React 将会发送加载动画 `BigSpinner` 对应的 HTML 暂时替代有效内容。然后，当这些数据加载完成时，有效内容将渐进地显示直至全部可见。
+在这个例子中，React 甚至能够更早地启用流式传输。因为 `ProfileLayout` 和 `ProfileCover` 没有被包裹在 `<Suspense>` 中，所以它们必须先完成渲染。然而，如果 `Sidebar`、`Friend` 或者 `Photos` 需要加载更多数据，React 将会发送后备方案 `BigSpinner` 所对应的 HTML 暂时替代有效内容。然后，当这些数据加载完成时，有效内容将渐进地显示直至全部可见。
 
 流式传输不需要等待 React 本身在浏览器中的加载，也不需要等待你的应用程序变得可交互。在任何 `<script>` 标签加载之前，服务端发送的 HTML 内容就会开始渐进式地显示。
 
@@ -389,7 +389,7 @@ function ProfilePage() {
 }
 ```
 
-在这些组件渲染的过程中，如果发生了异常错误，React 就不会发送任何有效的 HTML 到客户端。重载 `onShellError` ，发送一个不依赖服务端渲染的 HTML 作为兜底处理方案：
+在这些组件渲染的过程中，如果发生了异常错误，React 就不会发送任何有效的 HTML 到客户端。重载 `onShellError`，发送一个不依赖服务端渲染的 HTML 作为后备方案：
 
 ```js {7-11}
 const { pipe } = renderToPipeableStream(<App />, {
@@ -410,7 +410,7 @@ const { pipe } = renderToPipeableStream(<App />, {
 });
 ```
 
-如果在生成 shell 的过程中出现异常错误，`onError` 和 `onShellError` 都会触发。使用 `onError` 来做错误上报，并且使用 `onShellError` 发送一个兜底的 HTML 文档。你的兜底 HTML 不一定要是一个错误提示页面。你还可以引入一个可交互的、并且只在客户端渲染你的应用程序的 shell。
+如果在生成 shell 的过程中出现异常错误，`onError` 和 `onShellError` 都会触发。使用 `onError` 来做错误上报，并且使用 `onShellError` 发送一个后备 HTML 文档。你的后备 HTML 不一定要是一个错误提示页面。你还可以引入一个可交互的、并且只在客户端渲染你的应用程序的 shell。
 
 ---
 
@@ -433,13 +433,13 @@ function ProfilePage() {
 
 如果 `Post` 组件本身或者其内部的某处发生异常报错，React 将会 [试图将它恢复](/reference/react/Suspense#providing-a-fallback-for-server-errors-and-server-only-content)：
 
-1. 它将用在结构上和异常发生的位置最近的一个父级 `<Suspense>` 的加载动画（`PostsGlimmer`）替代这段 HTML。
+1. 它将用在结构上和异常发生的位置最近的一个父级 `<Suspense>` 的加载中的后备方案（`PostsGlimmer`）替代这段 HTML。
 2. 它将会“放弃”尝试在服务端渲染 `Posts` 组件的内容。
 3. 当 JavaScript 在客户端代码加载时，React 将会在客户端 **重试** 渲染 `Posts` 组件。
 
 如果在客户端重试渲染 `Posts` **也** 失败了，React 将会在客户端抛出一个异常错误。当渲染过程中的所有异常错误都被抛出时，距离它们[最近的父级异常错误边界](/reference/react/Component#static-getderivedstatefromerror) 会定义这个异常错误将如何呈现给用户。实际上，这意味着用户将看到一个加载指示器，直到这个异常错误被判定为是不可恢复的。
 
-如果在客户端重试渲染 `Posts` 成功了，加载动画将被替换为客户端渲染的内容。这样一来用户感知到服务端出现了异常错误。不过，服务端的 `onError` 回调函数和客户端的 [`onRecoverableError`](/reference/react-dom/client/hydrateRoot#hydrateroot) 回调函数仍然会触发，所以你也可以获取到一些关于这个异常错误的提示信息。
+如果在客户端重试渲染 `Posts` 成功了，加载中的后备方案将被替换为客户端渲染的内容。这样一来用户感知到服务端出现了异常错误。不过，服务端的 `onError` 回调函数和客户端的 [`onRecoverableError`](/reference/react-dom/client/hydrateRoot#hydrateroot) 回调函数仍然会触发，所以你也可以获取到一些关于这个异常错误的提示信息。
 
 ---
 
@@ -605,4 +605,4 @@ setTimeout(() => {
 }, 10000);
 ```
 
-React 将会刷新内容，把剩余的加载动画转为 HTML，然后尝试在客户端渲染剩下的内容。
+React 将会刷新内容，把剩余的加载中的后备方案转为 HTML，然后尝试在客户端渲染剩下的内容。
diff --git a/src/content/reference/react-dom/server/renderToReadableStream.md b/src/content/reference/react-dom/server/renderToReadableStream.md
index 900564fb70..46dd53de6c 100644
--- a/src/content/reference/react-dom/server/renderToReadableStream.md
+++ b/src/content/reference/react-dom/server/renderToReadableStream.md
@@ -66,7 +66,7 @@ async function handler(request) {
 `renderToReadableStream` 返回一个 Promise：
 
 - 如果渲染 [shell](#specifying-what-goes-into-the-shell) 成功，那么 Promise 将 resolve [Web 可读流](https://developer.mozilla.org/zh-CN/docs/Web/API/ReadableStream)。
-- 如果渲染 shell 失败，Promise 将 reject。[使用这个输出回滚 shell ](#recovering-from-errors-inside-the-shell)。
+- 如果渲染 shell 失败，Promise 将 reject。[使用这个输出后备 shell ](#recovering-from-errors-inside-the-shell)。
 
 返回的流具有附加属性：
 
@@ -251,7 +251,7 @@ function ProfilePage() {
 }
 ```
 
-告诉 React 在 `Posts` 加载数据之前开始流式传输 HTML。React 将首先发送加载回滚的 HTML（`PostsGlimmer`），然后，当 `Posts` 完成数据加载后，React 将发送剩余的 HTML，并用该 HTML 替换加载回滚的内联 `<script>` 标签。从用户视角看，该页面会首先显示 `PostsGlimmer` 的内容，然后被替换为 `Posts` 的内容。
+告诉 React 在 `Posts` 加载数据之前开始流式传输 HTML。React 将首先发送加载后备 HTML（`PostsGlimmer`），然后，当 `Posts` 完成数据加载后，React 将发送剩余的 HTML，并用该 HTML 替换之前替代内联 `<script>` 标签的后备方案。从用户视角看，该页面会首先显示 `PostsGlimmer` 的内容，然后被替换为 `Posts` 的内容。
 
 你可以进一步 [嵌套 `<Suspense>` 边界](/reference/react/Suspense#revealing-nested-content-as-it-loads) 来创建更细粒度的加载序列：
 
@@ -275,7 +275,7 @@ function ProfilePage() {
 ```
 
 
-在本例中，React 可以更早地开始对页面进行流式传输。只有 `ProfileLayout` 和 `ProfileCover` 是必须先完成渲染的，因为它们没有封装进任何 `<Suspense>` 边界中。但是，如果 `Sidebar`、`Friends` 或 `Photos` 需要加载一些数据，React 将发送 HTML 以供 `BigSpinner` 回滚。然后，随着更多的数据变得可用，更多的内容将会被显示，直到所有的内容都可见。
+在本例中，React 可以更早地开始对页面进行流式传输。只有 `ProfileLayout` 和 `ProfileCover` 是必须先完成渲染的，因为它们没有封装进任何 `<Suspense>` 边界中。但是，如果 `Sidebar`、`Friends` 或 `Photos` 需要加载一些数据，React 将发送 HTML 以供回退 `BigSpinner`。然后，随着更多的数据变得可用，更多的内容将会被显示，直到所有的内容都可见。
 
 在浏览器中，流不需要等待 React 自身的加载，也不需等待应用变得可交互。在任何 `<script>` 标签加载之前，来自服务器中的 HTML 内容将会逐步的显示出来。
 
@@ -390,7 +390,7 @@ function ProfilePage() {
 }
 ```
 
-如果在渲染这些组件时发生错误，React 将不会向客户端发送任何有意义的 HTML。将 `renderToReadableStream` 的调用放到 `try...catch` 里，发送一个不依赖服务端渲染的回滚 HTML 作为最后的备用方案：
+如果在渲染这些组件时发生错误，React 将不会向客户端发送任何有意义的 HTML。将 `renderToReadableStream` 的调用放到 `try...catch` 里，发送一个不依赖服务端渲染的回滚 HTML 作为最后的后备方案：
 
 ```js {2,13-18}
 async function handler(request) {
@@ -414,7 +414,7 @@ async function handler(request) {
 }
 ```
 
-如果在生成 shell 时出错，`onError` 和 `catch` 都会被触发。用 `onError` 报告错误，并用 `catch` 发送回滚 HTML。你的回滚 HTML 不一定必须是个错误页面。相反，你可以返回一个替代的 shell，这个 shell 只在客户端上渲染你的应用。
+如果在生成 shell 时出错，`onError` 和 `catch` 都会被触发。用 `onError` 报告错误，并用 `catch` 发送后备 HTML。你的后备 HTML 不一定必须是个错误页面。相反，你可以返回一个替代的 shell，这个 shell 只在客户端上渲染你的应用。
 
 ---
 
@@ -437,13 +437,13 @@ function ProfilePage() {
 
 如果 `Posts` 组件或其内部发生错误，React 将 [尝试从中恢复](/reference/react/Suspense#providing-a-fallback-for-server-errors-and-server-only-content)：
 
-1. 它将为最近的 `<Suspense>` 边界（`PostsGlimmer`）触发加载回滚到 HTML。
+1. 它将为最近的 `<Suspense>` 边界（`PostsGlimmer`）触发加载中的后备方案到 HTML。
 2. 它将 **放弃** 再尝试在服务器上渲染 `Posts`。
 3. 当 JavaScript 代码加载到客户端上时，React **重新尝试** 在客户端上渲染 `Posts`。
 
 如果在客户端上重新尝试渲染 `Posts` **也** 失败，React 将在客户端上抛出错误。与渲染过程中抛出的所有错误一样，[最近的父级错误边界](/reference/reflect/Component#staticgetderivedstatefromwerror) 决定如何向用户展示错误。在实践中，这意味着用户将看到加载指示符，直到确定错误不可恢复为止。
 
-如果在客户端上重新尝试渲染 `Posts` 成功，则从服务器加载回滚将被客户端渲染的输出所取代。用户不会知道有服务器错误。但是，服务器的 `onError` 回调和客户端的 [`onRecoverableError`](/reference/react-dom/client/hydrateRoot#hydrateroot) 回调将被触发，以便你可以收到有关错误通知。
+如果在客户端上重新尝试渲染 `Posts` 成功，则从服务器加载中的后备方案将被客户端渲染的输出所取代。用户不会知道有服务器错误。但是，服务器的 `onError` 回调和客户端的 [`onRecoverableError`](/reference/react-dom/client/hydrateRoot#hydrateroot) 回调将被触发，以便你可以收到有关错误通知。
 
 ---
 
@@ -622,4 +622,4 @@ async function handler(request) {
     // ...
 ```
 
-React 会把剩余的加载回滚刷新成 HTML，并尝试在客户端上渲染其余部分。
+React 会把剩余的加载中的后备方案刷新为 HTML，并尝试在客户端上渲染其余部分。
diff --git a/src/content/reference/react-dom/server/renderToStaticMarkup.md b/src/content/reference/react-dom/server/renderToStaticMarkup.md
index 187eccb998..094dd545b6 100644
--- a/src/content/reference/react-dom/server/renderToStaticMarkup.md
+++ b/src/content/reference/react-dom/server/renderToStaticMarkup.md
@@ -44,7 +44,7 @@ const html = renderToStaticMarkup(<Page />);
 
 * `renderToStaticMarkup` 的输出无法进行二次渲染。
 
-* `renderToStaticMarkup` 对 Suspense 的支持有限。如果一个组件触发了 Suspense，`renderToStaticMarkup` 立即将它的 fallback 作为 HTML 输出。
+* `renderToStaticMarkup` 对 Suspense 的支持有限。如果一个组件触发了 Suspense，`renderToStaticMarkup` 立即将它的后备方案作为 HTML 输出。
 
 * `renderToStaticMarkup` 在浏览器中可以使用，但不建议在客户端代码中使用它。如果你需要在浏览器中将组件渲染成 HTML，[请把它渲染到 DOM 节点中以获取 HTML](/reference/react-dom/server/renderToString#removing-rendertostring-from-the-client-code)。
 
diff --git a/src/content/reference/react-dom/server/renderToString.md b/src/content/reference/react-dom/server/renderToString.md
index 6029b31f08..3062695d91 100644
--- a/src/content/reference/react-dom/server/renderToString.md
+++ b/src/content/reference/react-dom/server/renderToString.md
@@ -48,7 +48,7 @@ const html = renderToString(<App />);
 
 #### 注意事项 {/*caveats*/}
 
-* `renderToString` 对 Suspense 的支持有限。如果一个组件挂起（suspend），`renderToString` 会立即将其 fallback 作为 HTML 发送。
+* `renderToString` 对 Suspense 的支持有限。如果一个组件挂起（suspend），`renderToString` 会立即将其后备方案作为 HTML 发送。
 
 * `renderToString` 可以在浏览器中工作，但 [不推荐](#removing-rendertostring-from-the-client-code) 在客户端代码中使用它。
 
@@ -128,7 +128,7 @@ console.log(div.innerHTML); // 例如，"<svg>...</svg>"
 
 ## 故障排除 {/*troubleshooting*/}
 
-### 当组件暂停时，HTML 中始终包含一个 fallback {/*when-a-component-suspends-the-html-always-contains-a-fallback*/}
+### 当组件暂停时，HTML 中始终包含一个后备方案 {/*when-a-component-suspends-the-html-always-contains-a-fallback*/}
 
 `renderToString` 不完全支持 Suspense。
 
diff --git a/src/content/reference/react/Component.md b/src/content/reference/react/Component.md
index d241f243d7..0c978f8253 100644
--- a/src/content/reference/react/Component.md
+++ b/src/content/reference/react/Component.md
@@ -234,7 +234,7 @@ class Counter extends Component {
 
 #### 注意 {/*componentdidcatch-caveats*/}
 
-* 在以前经常会在 `componentDidCatch` 中使用 `setState` 来更新 UI 以及显示回退错误消息。我们反对这种方法，更赞同定义 [`static getDerivedStateFromError`](#static-getderivedstatefromerror)。
+* 在以前经常会在 `componentDidCatch` 中使用 `setState` 来更新 UI 以及显示后备错误消息。我们反对这种方法，更赞同定义 [`static getDerivedStateFromError`](#static-getderivedstatefromerror)。
 
 * `componentDidCatch` 在 React 生产环境和开发环境中处理错误的方式有所不同，在开发环境下，错误将冒泡至 `window`，这意味着任何 `window.onerror` 或者 `window.addEventListener('error', callback)` 事件都将中断被 `componentDidCatch` 所捕获到的错误。而在生产环境下则相反，错误并不会冒泡，这意味着任何父级的错误处理器都只会接收到被 `componentDidCatch` 捕获的非显式错误。
 
@@ -1345,7 +1345,7 @@ button { margin-left: 10px; }
 
 ### 使用错误边界捕获渲染错误 {/*catching-rendering-errors-with-an-error-boundary*/}
 
-默认情况下，如果你的应用程序在渲染过程中抛出错误，React 将从屏幕上删除其 UI。为了防止这种情况，你可以将 UI 的一部分包装到 **错误边界** 中。错误边界是一个特殊的组件，可让你显示一些备用 UI，而不是显示例如错误消息这样崩溃的部分。
+默认情况下，如果你的应用程序在渲染过程中抛出错误，React 将从屏幕上删除其 UI。为了防止这种情况，你可以将 UI 的一部分包装到 **错误边界** 中。错误边界是一个特殊的组件，可让你显示一些后备 UI，而不是显示例如错误消息这样崩溃的部分。
 
 要实现错误边界组件，你需要提供 [`static getDerivedStateFromError`](#static-getderivedstatefromerror)，它允许你更新状态以响应错误并向用户显示错误消息。你还可以选择实现 [`componentDidCatch`](#componentdidcatch) 来添加一些额外的逻辑，例如将错误添加到分析服务。
 
diff --git a/src/content/reference/react/Suspense.md b/src/content/reference/react/Suspense.md
index 1d66fe9e2b..2a291c545d 100644
--- a/src/content/reference/react/Suspense.md
+++ b/src/content/reference/react/Suspense.md
@@ -4,7 +4,7 @@ title: <Suspense>
 
 <Intro>
 
-`<Suspense>` 允许在子组件完成加载前展示一个 fallback。
+`<Suspense>` 允许在子组件完成加载前展示后备方案。
 
 
 ```js
@@ -25,7 +25,7 @@ title: <Suspense>
 
 #### 参数 {/*props*/}
 * `children`：真正的 UI 渲染内容。如果 `children` 在渲染中被挂起，Suspense 边界将会渲染 `fallback`。
-* `fallback`：真正的 UI 未渲染完成时代替其渲染的备用 UI，它可以是任何有效的 React 节点。fallback 通常是一个轻量的占位符，例如表示加载中的图标或者骨架屏。当 `children` 被挂起时，Suspense 将自动切换至渲染 `fallback`；当数据准备好时，又会自动切换至渲染 `children`。如果 `fallback` 在渲染中被挂起，那么将自动激活最近的 Suspense 边界。
+* `fallback`：真正的 UI 未渲染完成时代替其渲染的备用 UI，它可以是任何有效的 React 节点。后备方案通常是一个轻量的占位符，例如表示加载中的图标或者骨架屏。当 `children` 被挂起时，Suspense 将自动切换至渲染 `fallback`；当数据准备好时，又会自动切换至渲染 `children`。如果 `fallback` 在渲染中被挂起，那么将自动激活最近的 Suspense 边界。
 
 #### 注意 {/*caveats*/}
 
@@ -38,7 +38,7 @@ title: <Suspense>
 
 ## 用法 {/*usage*/}
 
-### 当内容正在加载时显示 fallback {/*displaying-a-fallback-while-content-is-loading*/}
+### 当内容正在加载时显示后备方案 {/*displaying-a-fallback-while-content-is-loading*/}
 
 你可以使用 Suspense 边界包裹你应用的任何部分：
 
@@ -48,9 +48,9 @@ title: <Suspense>
 </Suspense>
 ```
 
-React 将展示 <CodeStep step={1}> fallback </CodeStep> 直到 <CodeStep step={2}> children </CodeStep> 需要的所有代码和数据都加载完成。
+React 将展示 <CodeStep step={1}>后备方案</CodeStep> 直到 <CodeStep step={2}> children </CodeStep> 需要的所有代码和数据都加载完成。
 
-在下面的例子中，`Albums` 组件在获取专辑列表时被 **挂起**。在它准备好渲染前，`Albums` 祖先组件中距离其最近的 Suspense 将展示 fallback —— 即 `Loading` 组件。当数据加载完成时，React 会隐藏 `Loading` fallback 并渲染带有数据的 `Albums` 组件。
+在下面的例子中，`Albums` 组件在获取专辑列表时被 **挂起**。在它准备好渲染前，`Albums` 祖先组件中距离其最近的 Suspense 将展示后备方案 —— 即 `Loading` 组件。当数据加载完成时，React 会隐藏 `Loading` 后备方案并渲染带有数据的 `Albums` 组件。
 
 <Sandpack>
 
@@ -586,7 +586,7 @@ function Details({ artistId }) {
 
 ### 逐步加载内容 {/*revealing-nested-content-as-it-loads*/}
 
-当一个组件被挂起时，最近的父级 `Suspense` 组件会展示 fallback。这允许你嵌套多个 `Suspense` 组件创建一个加载序列。每个 `Suspense` 边界的 fallback 都会在下一级内容可用时填充。例如，你可以给专辑列表设置自己的 fallback：
+当一个组件被挂起时，最近的父级 `Suspense` 组件会展示后备方案。这允许你嵌套多个 `Suspense` 组件创建一个加载序列。每个 `Suspense` 边界的后备方案都会在下一级内容可用时填充。例如，你可以给专辑列表设置自己的后备方案
 
 ```js {3,7}
 <Suspense fallback={<BigSpinner />}>
@@ -925,7 +925,7 @@ Suspense 边界允许协调 UI 的哪些部分应该总是一起“浮现”，
 
 ### 在新内容加载时展示过时内容 {/*showing-stale-content-while-fresh-content-is-loading*/}
 
-在这个例子中，`SearchResults` 组件在获取搜索结果时被挂起。输入 `"a"`，等待结果，然后将其编辑为 `"ab"`。`"a"` 的结果将被加载中 fallback 替换。
+在这个例子中，`SearchResults` 组件在获取搜索结果时被挂起。输入 `"a"`，等待结果，然后将其编辑为 `"ab"`。`"a"` 的结果将被加载中的后备方案替换。
 
 <Sandpack>
 
@@ -1149,7 +1149,7 @@ export default function App() {
 </div>
 ```
 
-在下面的例子中，输入 `"a"`，等待结果加载，然后编辑输入为 `"ab"`。注意，你现在看到的不是 Suspense 的 fallback，而是暗淡的过时结果列表，直到新的结果加载完成：
+在下面的例子中，输入 `"a"`，等待结果加载，然后编辑输入为 `"ab"`。注意，你现在看到的不是 Suspense 的后备方案，而是暗淡的过时结果列表，直到新的结果加载完成：
 
 
 <Sandpack>
@@ -1348,7 +1348,7 @@ input { margin: 10px; }
 
 <Note>
 
-延迟值和 [transition](#preventing-already-revealed-content-from-hiding) 都可以让你避免显示 Suspense fallback，而是使用内联指示器。transition 将整个更新标记为非紧急的，因此它们通常由框架和路由库用于导航。另一方面，延迟值在你希望将 UI 的一部分标记为非紧急，并让它“落后于” UI 的其余部分时非常有用。
+延迟值和 [transition](#preventing-already-revealed-content-from-hiding) 都可以让你避免显示 Suspense 后备方案，而是使用内联指示器。transition 将整个更新标记为非紧急的，因此它们通常由框架和路由库用于导航。另一方面，延迟值在你希望将 UI 的一部分标记为非紧急，并让它“落后于” UI 的其余部分时非常有用。
 
 </Note>
 
@@ -1356,7 +1356,7 @@ input { margin: 10px; }
 
 ### 阻止隐藏已经显示的内容 {/*preventing-already-revealed-content-from-hiding*/}
 
-当一个组件被挂起时，最近的 Suspense 边界会切换到显示 fallback。如果它已经显示了一些内容，这可能会导致令人不快的用户体验。试着按下这个按钮：
+当一个组件被挂起时，最近的 Suspense 边界会切换到显示后备方案。如果它已经显示了一些内容，这可能会导致令人不快的用户体验。试着按下这个按钮：
 
 <Sandpack>
 
@@ -1725,7 +1725,7 @@ main {
 
 </Sandpack>
 
-当你按下按钮时，`Router` 组件渲染了 `ArtistPage` 而不是 `IndexPage`。因为 `ArtistPage` 内部的一个组件被挂起，所以最近的 Suspense 边界开始显示 fallback。最近的 Suspense 边界在根附近，所以整个站点布局被 `BigSpinner` 替换了。
+当你按下按钮时，`Router` 组件渲染了 `ArtistPage` 而不是 `IndexPage`。因为 `ArtistPage` 内部的一个组件被挂起，所以最近的 Suspense 边界开始显示后备方案。最近的 Suspense 边界在根附近，所以整个站点布局被 `BigSpinner` 替换了。
 
 为了阻止这种情况，你可以使用 [`startTransition`](/reference/react/startTransition) 将导航状态更新标记为 **transition**：
 
@@ -2508,19 +2508,19 @@ main {
 <ProfilePage key={queryParams.id} />
 ```
 
-想想在用户的个人资料页面中导航，然后暂停了。如果更新被包装在 transition 中，它将不会触发已经可见内容的 fallback。这是预期的行为。
+想想在用户的个人资料页面中导航，然后暂停了。如果更新被包装在 transition 中，它将不会触发已经可见内容的后备方案。这是预期的行为。
 
-然而，现在想象一下你在两个不同的用户资料之间导航。在这种情况下，显示 fallback 是有意义的。例如，一个用户的时间线是与另一个用户的时间线是 **不同的内容**。通过指定一个 `key`，你可以确保 React 将不同用户的个人资料视为不同的组件，并在导航期间重置 Suspense 边界。集成 Suspense 的路由应该自动执行此操作。
+然而，现在想象一下你在两个不同的用户资料之间导航。在这种情况下，显示后备方案是有意义的。例如，一个用户的时间线是与另一个用户的时间线是 **不同的内容**。通过指定一个 `key`，你可以确保 React 将不同用户的个人资料视为不同的组件，并在导航期间重置 Suspense 边界。集成 Suspense 的路由应该自动执行此操作。
 
 ---
 
-### 为服务器错误和客户端内容提供 fallback {/*providing-a-fallback-for-server-errors-and-client-only-content*/}
+### 为服务器错误和客户端内容提供后备方案 {/*providing-a-fallback-for-server-errors-and-client-only-content*/}
 
-如果你使用过 [流式服务器渲染 API](/reference/react-dom/server)（或依赖它们的框架），React 也会使用你的 `<Suspense>` 边界来处理服务器上的错误。如果组件在服务器上抛出错误，React 将不会中止服务器渲染。相反，它将找到最接近的 `<Suspense>` 组件并将其退路方案（fallback）（例如一个加载中指示器）包含到生成的服务端 HTML 中。用户将首先看到一个加载中指示器。
+如果你使用过 [流式服务器渲染 API](/reference/react-dom/server)（或依赖它们的框架），React 也会使用你的 `<Suspense>` 边界来处理服务器上的错误。如果组件在服务器上抛出错误，React 将不会中止服务器渲染。相反，它将找到最接近的 `<Suspense>` 组件并将其后备方案（例如一个加载中指示器）包含到生成的服务端 HTML 中。用户将首先看到一个加载中指示器。
 
 在客户端，React 将尝试再次渲染相同的组件。如果它在客户端也出错，React 将抛出错误并显示最接近的 [错误边界](/reference/react/Component#static-getderivedstatefromerror)。然而，如果它在客户端没有错误，React 将不会向用户显示错误，因为内容最终成功显示了。
 
-你可以使用这个来防止一些组件在服务端渲染。为此，你应该在服务器环境中抛出一个错误，然后将其包装在一个 `<Suspense>` 边界中，从而使用 fallback 替换它们的 HTML：
+你可以使用这个来防止一些组件在服务端渲染。为此，你应该在服务器环境中抛出一个错误，然后将其包装在一个 `<Suspense>` 边界中，从而使用后备方案替换它们的 HTML：
 
 ```js
 <Suspense fallback={<Loading />}>
@@ -2541,11 +2541,11 @@ function Chat() {
 
 ## 故障排除 {/*troubleshooting*/}
 
-### 如何阻止 UI 在更新期间被 fallback 替换 {/*preventing-unwanted-fallbacks*/}
+### 如何阻止 UI 在更新期间被后备方案替换 {/*preventing-unwanted-fallbacks*/}
 
-使用 fallback 替换一个可见的 UI 会带来令人不快的用户体验。当一个更新导致一个组件被挂起时，而最近的 Suspense 边界已经向用户显示了内容时，这种情况可能发生。
+使用后备方案替换一个可见的 UI 会带来令人不快的用户体验。当一个更新导致一个组件被挂起时，而最近的 Suspense 边界已经向用户显示了内容时，这种情况可能发生。
 
-为了防止这种情况发生，[使用 `startTransition` 将更新标记为非紧急的](#preventing-already-revealed-content-from-hiding)。在 transition 期间，React 将等待足够的数据加载，以防止不需要的 fallback 出现：
+为了防止这种情况发生，[使用 `startTransition` 将更新标记为非紧急的](#preventing-already-revealed-content-from-hiding)。在 transition 期间，React 将等待足够的数据加载，以防止不需要的后备方案出现：
 
 ```js {2-3,5}
 function handleNextPageClick() {
@@ -2556,8 +2556,8 @@ function handleNextPageClick() {
 }
 ```
 
-这将避免隐藏现有内容。然而，任何新渲染的 `Suspense` 边界仍然会立即显示 fallback，以避免阻塞 UI 并让用户在内容可用时看到内容。
+这将避免隐藏现有内容。然而，任何新渲染的 `Suspense` 边界仍然会立即显示后备方案，以避免阻塞 UI 并让用户在内容可用时看到内容。
 
-**React 只会在非紧急更新期间阻止不必要的 fallback**。这意味着它不会阻止紧急更新的 fallback。你必须使用 [`startTransition`](/reference/react/startTransition) 或 [`useDeferredValue`](/reference/react/useDeferredValue) 这样的 API 来选择性的优化。
+**React 只会在非紧急更新期间阻止不必要的后备方案**。这意味着它不会阻止紧急更新的 fallback。你必须使用 [`startTransition`](/reference/react/startTransition) 或 [`useDeferredValue`](/reference/react/useDeferredValue) 这样的 API 来选择性的优化。
 
 如果你的路由集成了 Suspense，它将会自动将更新包装到 [`startTransition`](/reference/react/startTransition) 中。
diff --git a/src/content/reference/react/components.md b/src/content/reference/react/components.md
index f5e09d0721..8f72bd9ab5 100644
--- a/src/content/reference/react/components.md
+++ b/src/content/reference/react/components.md
@@ -14,7 +14,7 @@ React 提供了一些内置的组件，你可以在 JSX 中使用它们。
 
 * [`<Fragment>`](/reference/react/Fragment)，也可以写作 `<>...</>`，让你可以将多个 JSX 节点组合在一起。
 * [`<Profiler>`](/reference/react/Profiler) 让你可以以编程方式衡量 React 树的渲染性能。
-* [`<Suspense>`](/reference/react/Suspense) 让你可以在子组件加载时显示一个 fallback。
+* [`<Suspense>`](/reference/react/Suspense) 让你可以在子组件加载时显示后备方案。
 * [`<StrictMode>`](/reference/react/StrictMode) 可以开启一些额外的，仅用于开发环境的检测，帮助你更早地发现 bug。
 
 ---
diff --git a/src/content/reference/react/createContext.md b/src/content/reference/react/createContext.md
index 78d50e4cde..b16c4c7ef0 100644
--- a/src/content/reference/react/createContext.md
+++ b/src/content/reference/react/createContext.md
@@ -32,7 +32,7 @@ const ThemeContext = createContext('light');
 
 #### 参数 {/*parameters*/}
 
-* `defaultValue`：当包裹需要读取上下文的组件树中没有匹配的上下文时，你可以用该值作上下文的。倘若你没有任何有意义的默认值，可指定其为 `null`。该默认值是用于作为”最后的手段“的备选值。它是静态的，永远不会随时间改变。
+* `defaultValue`：当包裹需要读取上下文的组件树中没有匹配的上下文时，你可以用该值作上下文的。倘若你没有任何有意义的默认值，可指定其为 `null`。该默认值是用于作为“最后的手段”的后备方案。它是静态的，永远不会随时间改变。
 
 #### 返回值 {/*returns*/}
 
@@ -211,7 +211,7 @@ function App() {
 const ThemeContext = createContext('light');
 ```
 
-该值永远不会发生改变。当 React 无法找到匹配的 provider 时，该值会被作为备选值。
+该值永远不会发生改变。当 React 无法找到匹配的 provider 时，该值会被作为后备方案。
 
 要想使上下文的值随时间变化，[添加状态并用一个 context provider 包裹组件](/reference/react/useContext#updating-data-passed-via-context)。
 
diff --git a/src/content/reference/react/use.md b/src/content/reference/react/use.md
index 8c521d6331..77e27c9c90 100644
--- a/src/content/reference/react/use.md
+++ b/src/content/reference/react/use.md
@@ -40,7 +40,7 @@ function MessageComponent({ messagePromise }) {
 
 与其他 React Hook 不同的是，可以在循环和条件语句（如 `if`）中调用 `use`。但需要注意的是，调用 `use` 的函数仍然必须是一个组件或 Hook。
 
-当使用 Promise 调用 `use` Hook 时，它会与 [`Suspense`](/reference/react/Suspense) 和 [错误边界](/reference/react/Component#catching-rendering-errors-with-an-error-boundary) 集成。当传递给 `use` 的 Promise 处于 pending 时，调用 `use` 的组件也会 **挂起**。如果调用 `use` 的组件被包装在 Suspense 边界内，将显示 fallback UI。一旦 Promise 被解决，Suspense fallback 将被使用 `use` Hook 返回的数据替换。如果传递给 `use` 的 Promise 被拒绝，将显示最近错误边界的 fallback UI。
+当使用 Promise 调用 `use` Hook 时，它会与 [`Suspense`](/reference/react/Suspense) 和 [错误边界](/reference/react/Component#catching-rendering-errors-with-an-error-boundary) 集成。当传递给 `use` 的 Promise 处于 pending 时，调用 `use` 的组件也会 **挂起**。如果调用 `use` 的组件被包装在 Suspense 边界内，将显示后备 UI。一旦 Promise 被解决，Suspense 后备方案将被使用 `use` Hook 返回的数据替换。如果传递给 `use` 的 Promise 被拒绝，将显示最近错误边界的后备 UI。
 
 [参见下方更多示例)(#usage)。
 
@@ -243,7 +243,7 @@ export function Message({ messagePromise }) {
   return <p>Here is the message: {messageContent}</p>;
 }
 ```
-由于 <CodeStep step={2}>`Message`</CodeStep> 被包裹在 <CodeStep step={3}>[`Suspense`](/reference/react/Suspense)</CodeStep> 中，所以在 Promise 解决之前将显示 fallback。当 Promise 被解决后，<CodeStep step={5}>`use`</CodeStep> Hook 将读取值，然后 <CodeStep step={2}>`Message`</CodeStep> 组件将替换 Suspense fallback。
+由于 <CodeStep step={2}>`Message`</CodeStep> 被包裹在 <CodeStep step={3}>[`Suspense`](/reference/react/Suspense)</CodeStep> 中，所以在 Promise 解决之前将显示后备方案。当 Promise 被解决后，<CodeStep step={5}>`use`</CodeStep> Hook 将读取值，然后 <CodeStep step={2}>`Message`</CodeStep> 组件将替换 Suspense 后备方案。
 
 <Sandpack>
 
@@ -360,7 +360,7 @@ export default function App() {
 
 #### 使用错误边界将错误展示给用户 {/*displaying-an-error-to-users-with-error-boundary*/}
 
-如果希望在 Promise 被拒绝（rejected）时向用户显示错误信息，可以使用 [错误边界](/reference/react/Component#catching-rendering-errors-with-an-error-boundary)。如果需要使用错误边界，请将调用 `use` Hook 的组件包装在错误边界中。如果传递给 `use` 的 Promise 被拒绝（rejected），将显示错误边界的 fallback。
+如果希望在 Promise 被拒绝（rejected）时向用户显示错误信息，可以使用 [错误边界](/reference/react/Component#catching-rendering-errors-with-an-error-boundary)。如果需要使用错误边界，请将调用 `use` Hook 的组件包装在错误边界中。如果传递给 `use` 的 Promise 被拒绝（rejected），将显示错误边界的后备方案。
 
 <Sandpack>
 
diff --git a/src/content/reference/react/useContext.md b/src/content/reference/react/useContext.md
index bd58d3742c..1849eeaf9f 100644
--- a/src/content/reference/react/useContext.md
+++ b/src/content/reference/react/useContext.md
@@ -947,7 +947,7 @@ ul, li { margin: 0; padding: 0; }
 
 ---
 
-### 指定回退默认值 {/*specifying-a-fallback-default-value*/}
+### 指定后备方案默认值 {/*specifying-a-fallback-default-value*/}
 
 如果 React 没有在父树中找到该特定 <CodeStep step={1}>context</CodeStep> 的任何 provider，`useContext()` 返回的 context 值将等于你在 [创建 context](/reference/react/createContext) 时指定的 <CodeStep step={3}>默认值</CodeStep>：
 
diff --git a/src/content/reference/react/useDeferredValue.md b/src/content/reference/react/useDeferredValue.md
index 21a385f13e..30ebec018c 100644
--- a/src/content/reference/react/useDeferredValue.md
+++ b/src/content/reference/react/useDeferredValue.md
@@ -48,7 +48,7 @@ function SearchPage() {
 
 - 当 `useDeferredValue` 接收到与之前不同的值（使用 [`Object.is`](https://developer.mozilla.org/zh-CN/docs/Web/JavaScript/Reference/Global_Objects/Object/is) 进行比较）时，除了当前渲染（此时它仍然使用旧值），它还会安排一个后台重新渲染。这个后台重新渲染是可以被中断的，如果 `value` 有新的更新，React 会从头开始重新启动后台渲染。举个例子，如果用户在输入框中的输入速度比接收延迟值的图表重新渲染的速度快，那么图表只会在用户停止输入后重新渲染。
 
-- `useDeferredValue` 与 [`<Suspense>`](/reference/react/Suspense) 集成。如果由于新值引起的后台更新导致 UI 暂停，用户将不会看到 fallback 效果。他们将看到旧的延迟值，直到数据加载完成。
+- `useDeferredValue` 与 [`<Suspense>`](/reference/react/Suspense) 集成。如果由于新值引起的后台更新导致 UI 暂停，用户将不会看到后备方案。他们将看到旧的延迟值，直到数据加载完成。
 
 - `useDeferredValue` 本身并不能阻止额外的网络请求。
 
@@ -93,7 +93,7 @@ function SearchPage() {
 </Note>
 
 
-这个例子中，在获取搜索结果时，`SearchResults` 组件会 [suspend](/reference/react/Suspense#displaying-a-fallback-while-content-is-loading)。尝试输入 `"a"`，等待结果出现后，将其编辑为 `"ab"`。此时 `"a"` 的结果会被加载中的 fallback 替代。
+这个例子中，在获取搜索结果时，`SearchResults` 组件会 [suspend](/reference/react/Suspense#displaying-a-fallback-while-content-is-loading)。尝试输入 `"a"`，等待结果出现后，将其编辑为 `"ab"`。此时 `"a"` 的结果会被加载中的后备方案替代。
 
 <Sandpack>
 
@@ -307,7 +307,7 @@ export default function App() {
 
 `query` 会立即更新，所以输入框将显示新值。然而，`deferredQuery` 在数据加载完成前会保留以前的值，因此 `SearchResults` 将暂时显示旧的结果。
 
-在下面的示例中，输入 `"a"`，等待结果加载完成，然后将输入框编辑为 `"ab"`。注意，现在你看到的不是 suspense fallback，而是旧的结果列表，直到新的结果加载完成：
+在下面的示例中，输入 `"a"`，等待结果加载完成，然后将输入框编辑为 `"ab"`。注意，现在你看到的不是 suspense 后备方案，而是旧的结果列表，直到新的结果加载完成：
 
 <Sandpack>
 
diff --git a/src/content/reference/react/useLayoutEffect.md b/src/content/reference/react/useLayoutEffect.md
index 0371f43b13..60913efe84 100644
--- a/src/content/reference/react/useLayoutEffect.md
+++ b/src/content/reference/react/useLayoutEffect.md
@@ -732,7 +732,7 @@ export default function TooltipContainer({ children, x, y, contentRef }) {
 
 - 用 [`useEffect`](/reference/react/useEffect) 替换 `useLayoutEffect`。React 可以在不阻塞绘制的情况下显示初始的渲染结果（因为初始的 HTML 将在 Effect 运行之前显示出来）。
 
-- 或者，[将组件标记为仅客户端](/reference/react/Suspense#providing-a-fallback-for-server-errors-and-server-only-content)。这告诉 React 在服务端渲染时用一个 loading 降级（例如，一个 spinner 或者 glimmer）替换其内容到上方最近的 [`<Suspense>`](/reference/react/Suspense) 边界。
+- 或者，[将组件标记为仅客户端](/reference/react/Suspense#providing-a-fallback-for-server-errors-and-server-only-content)。这告诉 React 在服务端渲染时用一个加载中的后备方案（例如，一个 spinner 或者 glimmer）替换其内容到上方最近的 [`<Suspense>`](/reference/react/Suspense) 边界。
 
 - 或者，只有在水合之后，使用 `useLayoutEffect` 渲染组件。保留一个初始化为 `false` 的 `isMounted` 布尔状态，并在 `useEffect` 调用中将其设置为 `true`。然后你的渲染逻辑就会像 `return isMounted ? <RealContent /> : <FallbackContent />` 这样。在服务端和水合过程中，用户将看到 `FallbackContent`，它不应该调用 `useLayoutEffect`。然后 React 将用 `RealContent` 替换它，`RealContent` 仅在客户端上运行并且可以包含 `useLayoutEffect` 调用。
 
diff --git a/src/content/reference/react/useTransition.md b/src/content/reference/react/useTransition.md
index cdfa651dba..7154c1a195 100644
--- a/src/content/reference/react/useTransition.md
+++ b/src/content/reference/react/useTransition.md
@@ -710,7 +710,7 @@ b { display: inline-block; margin-right: 10px; }
 
 ### 避免不必要的加载指示器 {/*preventing-unwanted-loading-indicators*/}
 
-在这个例子中，`PostsTab` 组件从启用了 [Suspense](/reference/react/Suspense) 的数据源中获取了一些数据。当你点击“Posts”选项卡时，`PostsTab` 组件将 **挂起**，导致最近的加载占位符出现：
+在这个例子中，`PostsTab` 组件从启用了 [Suspense](/reference/react/Suspense) 的数据源中获取了一些数据。当你点击“Posts”选项卡时，`PostsTab` 组件将 **挂起**，导致最近的加载中的后备方案出现：
 
 <Sandpack>