`)](https://beta.reactjs.org/reference/react-dom/components/common)
->
-> The new docs will soon replace this site, which will be archived. [Provide feedback.](https://github.com/reactjs/reactjs.org/issues/3308)
-
-此参考指南记录了构成 React 事件系统一部分的 `SyntheticEvent` 包装器。请参考有关[事件处理](/docs/handling-events.html)的指南来了解更多。
-
-## 概览 {#overview}
-
-`SyntheticEvent` 实例将被传递给你的事件处理函数,它是浏览器的原生事件的跨浏览器包装器。除兼容所有浏览器外,它还拥有和浏览器原生事件相同的接口,包括 `stopPropagation()` 和 `preventDefault()`。
-
-如果因为某些原因,当你需要使用浏览器的底层事件时,只需要使用 `nativeEvent` 属性来获取即可。合成事件与浏览器的原生事件不同,也不会直接映射到原生事件。例如,在 `onMouseLeave` 事件中 `event.nativeEvent` 将指向 `mouseout` 事件。每个 `SyntheticEvent` 对象都包含以下属性:
-
-```javascript
-boolean bubbles
-boolean cancelable
-DOMEventTarget currentTarget
-boolean defaultPrevented
-number eventPhase
-boolean isTrusted
-DOMEvent nativeEvent
-void preventDefault()
-boolean isDefaultPrevented()
-void stopPropagation()
-boolean isPropagationStopped()
-void persist()
-DOMEventTarget target
-number timeStamp
-string type
-```
-
-> 注意:
->
-> 从 v17 开始,`e.persist()` 将不再生效,因为 `SyntheticEvent` 不再放入[事件池](/docs/legacy-event-pooling.html)中。
-
-> 注意:
->
-> 从 v0.14 开始,事件处理器返回 `false` 时,不再阻止事件传递。你可以酌情手动调用 `e.stopPropagation()` 或 `e.preventDefault()` 作为替代方案。
-
-## 支持的事件 {#supported-events}
-
-React 通过将事件 normalize 以让他们在不同浏览器中拥有一致的属性。
-
-以下的事件处理函数在冒泡阶段被触发。如需注册捕获阶段的事件处理函数,则应为事件名添加 `Capture`。例如,处理捕获阶段的点击事件请使用 `onClickCapture`,而不是 `onClick`。
-
-- [概览 {#overview}](#概览-overview)
-- [支持的事件 {#supported-events}](#支持的事件-supported-events)
-- [参考 {#reference}](#参考-reference)
- - [剪贴板事件 {#clipboard-events}](#剪贴板事件-clipboard-events)
- - [复合事件 {#composition-events}](#复合事件-composition-events)
- - [键盘事件 {#keyboard-events}](#键盘事件-keyboard-events)
- - [焦点事件 {#focus-events}](#焦点事件-focus-events)
- - [onFocus {#onfocus}](#onfocus-onfocus)
- - [onBlur {#onblur}](#onblur-onblur)
- - [监听焦点的进入与离开 {#detecting-focus-entering-and-leaving}](#监听焦点的进入与离开-detecting-focus-entering-and-leaving)
- - [表单事件 {#form-events}](#表单事件-form-events)
- - [通用事件 {#generic-events}](#通用事件-generic-events)
- - [鼠标事件 {#mouse-events}](#鼠标事件-mouse-events)
- - [指针事件 {#pointer-events}](#指针事件-pointer-events)
- - [选择事件 {#selection-events}](#选择事件-selection-events)
- - [触摸事件 {#touch-events}](#触摸事件-touch-events)
- - [UI 事件 {#ui-events}](#ui-事件-ui-events)
- - [滚轮事件 {#wheel-events}](#滚轮事件-wheel-events)
- - [媒体事件 {#media-events}](#媒体事件-media-events)
- - [图像事件 {#image-events}](#图像事件-image-events)
- - [动画事件 {#animation-events}](#动画事件-animation-events)
- - [过渡事件 {#transition-events}](#过渡事件-transition-events)
- - [其他事件 {#other-events}](#其他事件-other-events)
-
-* * *
-
-## 参考 {#reference}
-
-### 剪贴板事件 {#clipboard-events}
-
-事件名:
-
-```
-onCopy onCut onPaste
-```
-
-属性:
-
-```javascript
-DOMDataTransfer clipboardData
-```
-
-* * *
-
-### 复合事件 {#composition-events}
-
-事件名:
-
-```
-onCompositionEnd onCompositionStart onCompositionUpdate
-```
-
-属性:
-
-```javascript
-string data
-
-```
-
-* * *
-
-### 键盘事件 {#keyboard-events}
-
-事件名:
-
-```
-onKeyDown onKeyPress onKeyUp
-```
-
-属性:
-
-```javascript
-boolean altKey
-number charCode
-boolean ctrlKey
-boolean getModifierState(key)
-string key
-number keyCode
-string locale
-number location
-boolean metaKey
-boolean repeat
-boolean shiftKey
-number which
-```
-
-`key` 属性可以是 [DOM Level 3 Events spec](https://www.w3.org/TR/uievents-key/#named-key-attribute-values) 里记录的任意值。
-
-* * *
-
-### 焦点事件 {#focus-events}
-
-事件名:
-
-```
-onFocus onBlur
-```
-
-这些焦点事件在 React DOM 上的所有元素都有效,不只是表单元素。
-
-属性:
-
-```js
-DOMEventTarget relatedTarget
-```
-
-#### onFocus {#onfocus}
-
-`onFocus` 事件在元素(或其内部某些元素)聚焦时被调用。例如,当用户点击文本输入框时,就会调用该事件。
-
-```javascript
-function Example() {
- return (
-
{
- console.log('Focused on input');
- }}
- placeholder="onFocus is triggered when you click this input."
- />
- )
-}
-```
-
-#### onBlur {#onblur}
-
-`onBlur` 事件处理程序在元素(或元素内某些元素)失去焦点时被调用。例如,当用户在已聚焦的文本输入框外点击时,就会被调用。
-
-```javascript
-function Example() {
- return (
-
{
- console.log('Triggered because this input lost focus');
- }}
- placeholder="onBlur is triggered when you click this input and then you click outside of it."
- />
- )
-}
-```
-
-#### 监听焦点的进入与离开 {#detecting-focus-entering-and-leaving}
-
-你可以使用 `currentTarget` 和 `relatedTarget` 来区分聚焦和失去焦点是否来自父元素_外部_。这里有个 DEMO,你可以复制并在本地运行,它展示了如何监听一个子元素的聚焦,元素本身的聚焦,以及整个子树进入焦点或离开焦点。
-
-```javascript
-function Example() {
- return (
-
{
- if (e.currentTarget === e.target) {
- console.log('focused self');
- } else {
- console.log('focused child', e.target);
- }
- if (!e.currentTarget.contains(e.relatedTarget)) {
- // Not triggered when swapping focus between children
- console.log('focus entered self');
- }
- }}
- onBlur={(e) => {
- if (e.currentTarget === e.target) {
- console.log('unfocused self');
- } else {
- console.log('unfocused child', e.target);
- }
- if (!e.currentTarget.contains(e.relatedTarget)) {
- // Not triggered when swapping focus between children
- console.log('focus left self');
- }
- }}
- >
-
-
-
- );
-}
-```
-
-* * *
-
-### 表单事件 {#form-events}
-
-事件名:
-
-```
-onChange onInput onInvalid onReset onSubmit
-```
-
-想了解 onChange 事件的更多信息,查看 [Forms](/docs/forms.html) 。
-
-* * *
-
-### 通用事件 {#generic-events}
-
-事件名:
-
-```
-onError onLoad
-```
-
-* * *
-
-### 鼠标事件 {#mouse-events}
-
-事件名:
-
-```
-onClick onContextMenu onDoubleClick onDrag onDragEnd onDragEnter onDragExit
-onDragLeave onDragOver onDragStart onDrop onMouseDown onMouseEnter onMouseLeave
-onMouseMove onMouseOut onMouseOver onMouseUp
-```
-
-`onMouseEnter` 和 `onMouseLeave` 事件从离开的元素向进入的元素传播,不是正常的冒泡,也没有捕获阶段。
-
-属性:
-
-```javascript
-boolean altKey
-number button
-number buttons
-number clientX
-number clientY
-boolean ctrlKey
-boolean getModifierState(key)
-boolean metaKey
-number pageX
-number pageY
-DOMEventTarget relatedTarget
-number screenX
-number screenY
-boolean shiftKey
-```
-
-* * *
-
-### 指针事件 {#pointer-events}
-
-事件名:
-
-```
-onPointerDown onPointerMove onPointerUp onPointerCancel onGotPointerCapture
-onLostPointerCapture onPointerEnter onPointerLeave onPointerOver onPointerOut
-```
-
-`onPointerEnter` 和 `onPointerLeave` 事件从离开的元素向进入的元素传播,不是正常的冒泡,也没有捕获阶段。
-
-属性:
-
-如 [W3 spec](https://www.w3.org/TR/pointerevents/) 中定义的,指针事件通过以下属性扩展了[鼠标事件](#mouse-events):
-
-```javascript
-number pointerId
-number width
-number height
-number pressure
-number tangentialPressure
-number tiltX
-number tiltY
-number twist
-string pointerType
-boolean isPrimary
-```
-
-关于跨浏览器支持的说明:
-
-并非每个浏览器都支持指针事件(在写这篇文章时,已支持的浏览器有:Chrome,Firefox,Edge 和 Internet Explorer)。React 故意不通过 polyfill 的方式适配其他浏览器,主要是符合标准的 polyfill 会显著增加 react-dom 的 bundle 大小。
-
-如果你的应用要求指针事件,我们推荐添加第三方的指针事件 polyfill。
-
-* * *
-
-### 选择事件 {#selection-events}
-
-事件名:
-
-```
-onSelect
-```
-
-* * *
-
-### 触摸事件 {#touch-events}
-
-事件名:
-
-```
-onTouchCancel onTouchEnd onTouchMove onTouchStart
-```
-
-属性:
-
-```javascript
-boolean altKey
-DOMTouchList changedTouches
-boolean ctrlKey
-boolean getModifierState(key)
-boolean metaKey
-boolean shiftKey
-DOMTouchList targetTouches
-DOMTouchList touches
-```
-
-* * *
-
-### UI 事件 {#ui-events}
-
-事件名:
-
-```
-onScroll
-```
-
->注意
->
->从 React 17 开始,`onScroll` 事件在 React 中**不再冒泡**。这与浏览器的行为一致,并且避免了当一个嵌套且可滚动的元素在其父元素触发事件时造成混乱。
-
-属性:
-
-```javascript
-number detail
-DOMAbstractView view
-```
-
-* * *
-
-### 滚轮事件 {#wheel-events}
-
-事件名:
-
-```
-onWheel
-```
-
-属性:
-
-```javascript
-number deltaMode
-number deltaX
-number deltaY
-number deltaZ
-```
-
-* * *
-
-### 媒体事件 {#media-events}
-
-事件名:
-
-```
-onAbort onCanPlay onCanPlayThrough onDurationChange onEmptied onEncrypted
-onEnded onError onLoadedData onLoadedMetadata onLoadStart onPause onPlay
-onPlaying onProgress onRateChange onSeeked onSeeking onStalled onSuspend
-onTimeUpdate onVolumeChange onWaiting
-```
-
-* * *
-
-### 图像事件 {#image-events}
-
-事件名:
-
-```
-onLoad onError
-```
-
-* * *
-
-### 动画事件 {#animation-events}
-
-事件名:
-
-```
-onAnimationStart onAnimationEnd onAnimationIteration
-```
-
-属性:
-
-```javascript
-string animationName
-string pseudoElement
-float elapsedTime
-```
-
-* * *
-
-### 过渡事件 {#transition-events}
-
-事件名:
-
-```
-onTransitionEnd
-```
-
-属性:
-
-```javascript
-string propertyName
-string pseudoElement
-float elapsedTime
-```
-
-* * *
-
-### 其他事件 {#other-events}
-
-事件名:
-
-```
-onToggle
-```
diff --git a/content/docs/reference-glossary.md b/content/docs/reference-glossary.md
deleted file mode 100644
index f6b0c352c0..0000000000
--- a/content/docs/reference-glossary.md
+++ /dev/null
@@ -1,162 +0,0 @@
----
-id: glossary
-title: React 术语词汇表
-layout: docs
-category: Reference
-permalink: docs/glossary.html
-
----
-
-## 单页面应用 {#single-page-application}
-
-单页面应用(single-page application),是一个应用程序,它可以加载单个 HTML 页面,以及运行应用程序所需的所有必要资源(例如 JavaScript 和 CSS)。与页面或后续页面的任何交互,都不再需要往返 server 加载资源,即页面不会重新加载。
-
-你可以使用 React 来构建单页应用程序,但不是必须如此。React 还可用于增强现有网站的小部分,使其增加额外交互。用 React 编写的代码,可以与服务器端渲染的标记(例如 PHP)或其他客户端库和平共处。实际上,这也正是 Facebook 内部使用 React 的方式。
-
-## ES6, ES2015, ES2016 等 {#es6-es2015-es2016-etc}
-
-这些首字母缩写都是指 ECMAScript 语言规范标准的最新版本,JavaScript 语言是此标准的一个实现。其中 ES6 版本(也称为 ES2015)包括对前面版本的许多补充,例如:箭头函数、class、模板字面量、`let` 和 `const` 语句。可以在[这里](https://en.wikipedia.org/wiki/ECMAScript#Versions)了解此规范特定版本的详细信息。
-
-## Compiler(编译器) {#compilers}
-
-JavaScript compiler 接收 JavaScript 代码,然后对其进行转换,最终返回不同格式的 JavaScript 代码。最为常见的使用示例是,接收 ES6 语法,然后将其转换为旧版本浏览器能够解释执行的语法。[Babel](https://babeljs.io/) 是 React 最常用的 compiler。
-
-## Bundler(打包工具) {#bundlers}
-
-bundler 会接收写成单独模块(通常有数百个)的 JavaScript 和 CSS 代码,然后将它们组合在一起,最终生成出一些为浏览器优化的文件。常用的打包 React 应用的工具有 [webpack](https://webpack.js.org/) 和 [Browserify](http://browserify.org/)。
-
-## Package 管理工具 {#package-managers}
-
-package 管理工具,是帮助你管理项目依赖的工具。[npm](https://www.npmjs.com/) 和 [Yarn](https://yarnpkg.com/) 是两个常用的管理 React 应用依赖的 package 管理工具。它们都是使用了相同 npm package registry 的客户端。
-
-## CDN {#cdn}
-
-CDN 代表内容分发网络(Content Delivery Network)。CDN 会通过一个遍布全球的服务器网络来分发缓存的静态内容。
-
-## JSX {#jsx}
-
-JSX 是一个 JavaScript 语法扩展。它类似于模板语言,但它具有 JavaScript 的全部能力。JSX 最终会被编译为 `React.createElement()` 函数调用,返回称为 “React 元素” 的普通 JavaScript 对象。通过[查看这篇文档](/docs/introducing-jsx.html)获取 JSX 语法的基本介绍,在[这篇文档](/docs/jsx-in-depth.html)中可以找到 JSX 语法的更多深入教程。
-
-React DOM 使用 camelCase(驼峰式命名)来定义属性的名称,而不使用 HTML 属性名称的命名约定。例如,HTML 的 `tabindex` 属性变成了 JSX 的 `tabIndex`。而 `class` 属性则变为 `className`,这是因为 `class` 是 JavaScript 中的保留字:
-
-```jsx
-
My name is Clementine!
-```
-
-## [元素](/docs/rendering-elements.html) {#elements}
-
-React 元素是构成 React 应用的基础砖块。人们可能会把元素与广为人知的“组件”概念相互混淆。元素描述了你在屏幕上想看到的内容。React 元素是不可变对象。
-
-```js
-const element =
Hello, world
;
-```
-
-通常我们不会直接使用元素,而是从组件中返回元素。
-
-## [组件](/docs/components-and-props.html) {#components}
-
-React 组件是可复用的小的代码片段,它们返回要在页面中渲染的 React 元素。React 组件的最简版本是,一个返回 React 元素的普通 JavaScript 函数:
-
-```js
-function Welcome(props) {
- return
Hello, {props.name}
;
-}
-```
-
-组件也可以使用 ES6 的 class 编写:
-
-```js
-class Welcome extends React.Component {
- render() {
- return
Hello, {this.props.name}
;
- }
-}
-```
-
-组件可被拆分为不同的功能片段,这些片段可以在其他组件中使用。组件可以返回其他组件、数组、字符串和数字。根据经验来看,如果 UI 中有一部分被多次使用(Button,Panel,Avatar),或者组件本身就足够复杂(App,FeedStory,Comment),那么它就是一个可复用组件的候选项。组件名称应该始终以大写字母开头(`
` **而不是** `
`)。有关渲染组件的更多信息,请参阅[这篇文档](/docs/components-and-props.html#rendering-a-component)。
-
-### [`props`](/docs/components-and-props.html) {#props}
-
-`props` 是 React 组件的输入。它们是从父组件向下传递给子组件的数据。
-
-记住,`props` 是只读的。不应以任何方式修改它们:
-
-```js
-// 错误做法!
-props.number = 42;
-```
-
-如果你想要修改某些值,以响应用户输入或网络响应,请使用 `state` 来作为替代。
-
-### `props.children` {#propschildren}
-
-每个组件都可以获取到 `props.children`。它包含组件的开始标签和结束标签之间的内容。例如:
-
-```js
-
Hello world!
-```
-
-在 `Welcome` 组件中获取 `props.children`,就可以得到字符串 `Hello world!`:
-
-```js
-function Welcome(props) {
- return
{props.children}
;
-}
-```
-
-对于 class 组件,请使用 `this.props.children` 来获取:
-
-```js
-class Welcome extends React.Component {
- render() {
- return
{this.props.children}
;
- }
-}
-```
-
-### [`state`](/docs/state-and-lifecycle.html#adding-local-state-to-a-class) {#state}
-
-当组件中的一些数据在某些时刻发生变化时,这时就需要使用 `state` 来跟踪状态。例如,`Checkbox` 组件可能需要 `isChecked` 状态,而 `NewsFeed` 组件可能需要跟踪 `fetchedPosts` 状态。
-
-`state` 和 `props` 之间最重要的区别是:`props` 由父组件传入,而 `state` 由组件本身管理。组件不能修改 `props`,但它可以修改 `state`。
-
-对于所有变化数据中的每个特定部分,只应该由一个组件在其 state 中“持有”它。不要试图同步来自于两个不同组件的 state。相反,应当将其[提升](/docs/lifting-state-up.html)到最近的共同祖先组件中,并将这个 state 作为 props 传递到两个子组件。
-
-## [生命周期方法](/docs/state-and-lifecycle.html#adding-lifecycle-methods-to-a-class) {#lifecycle-methods}
-
-生命周期方法,用于在组件不同阶段执行自定义功能。在组件被创建并插入到 DOM 时(即[挂载中阶段(mounting)](/docs/react-component.html#mounting)),组件更新时,组件取消挂载或从 DOM 中删除时,都有可以使用的生命周期方法。
-
-## [受控组件](/docs/forms.html#controlled-components) vs [非受控组件](/docs/uncontrolled-components.html) {#controlled-vs-uncontrolled-components}
-
-React 有两种不同的方式来处理表单输入。
-
-如果一个 input 表单元素的值是由 React 控制,就其称为*受控组件*。当用户将数据输入到受控组件时,会触发修改状态的事件处理器,这时由你的代码来决定此输入是否有效(如果有效就使用更新后的值重新渲染)。如果不重新渲染,则表单元素将保持不变。
-
-一个*非受控组件*,就像是运行在 React 体系之外的表单元素。当用户将数据输入到表单字段(例如 input,dropdown 等)时,React 不需要做任何事情就可以映射更新后的信息。然而,这也意味着,你无法强制给这个表单字段设置一个特定值。
-
-在大多数情况下,你应该使用受控组件。
-
-## [key](/docs/lists-and-keys.html) {#keys}
-
-“key” 是在创建元素数组时,需要用到的一个特殊字符串属性。key 帮助 React 识别出被修改、添加或删除的 item。应当给数组内的每个元素都设定 key,以使元素具有固定身份标识。
-
-只需要保证,在同一个数组中的兄弟元素之间的 key 是唯一的。而不需要在整个应用程序甚至单个组件中保持唯一。
-
-不要将 `Math.random()` 之类的值传递给 key。重要的是,在前后两次渲染之间的 key 要具有“固定身份标识”的特点,以便 React 可以在添加、删除或重新排序 item 时,前后对应起来。理想情况下,key 应该从数据中获取,对应着唯一且固定的标识符,例如 `post.id`。
-
-## [Ref](/docs/refs-and-the-dom.html) {#refs}
-
-React 支持一个特殊的、可以附加到任何组件上的 `ref` 属性。此属性可以是一个由 [`React.createRef()` 函数](/docs/react-api.html#reactcreateref)创建的对象、或者一个回调函数、或者一个字符串(遗留 API)。当 `ref` 属性是一个回调函数时,此函数会(根据元素的类型)接收底层 DOM 元素或 class 实例作为其参数。这能够让你直接访问 DOM 元素或组件实例。
-
-谨慎使用 ref。如果你发现自己经常使用 ref 来在应用中“实现想要的功能”,你可以考虑去了解一下[自上而下的数据流](/docs/lifting-state-up.html)。
-
-## [事件](/docs/handling-events.html) {#events}
-
-使用 React 元素处理事件时,有一些语法上差异:
-
-* React 事件处理器使用 camelCase(驼峰式命名)而不使用小写命名。
-* 通过 JSX,你可以直接传入一个函数,而不是传入一个字符串,来作为事件处理器。
-
-## [协调](/docs/reconciliation.html) {#reconciliation}
-
-当组件的 props 或 state 发生变化时,React 通过将最新返回的元素与原先渲染的元素进行比较,来决定是否有必要进行一次实际的 DOM 更新。当它们不相等时,React 才会更新 DOM。这个过程被称为“协调”。
diff --git a/content/docs/reference-javascript-environment-requirements.md b/content/docs/reference-javascript-environment-requirements.md
deleted file mode 100644
index 6e1eca0d4a..0000000000
--- a/content/docs/reference-javascript-environment-requirements.md
+++ /dev/null
@@ -1,18 +0,0 @@
----
-id: javascript-environment-requirements
-title: JavaScript 环境要求
-layout: docs
-category: Reference
-permalink: docs/javascript-environment-requirements.html
----
-
-React 18 支持所有现代浏览器(Edge, Firefox, Chrome, Safari 等)。
-
-如果你支持旧的浏览器和设备,如 Internet Explorer,它们没有提供原生的现代浏览器特性,或有些不符合标准的实现,你可以考虑在应用程序中引入一个全局的 polyfill。
-
-以下是 React 18 使用的现代浏览器特性的列表:
-- [`Promise`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise)
-- [`Symbol`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Symbol)
-- [`Object.assign`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/assign)
-
-这些特性的 polyfill 取决于你的环境,对于大部分用户来说,你可以配置你的 [Browserlist](https://github.com/browserslist/browserslist)。对于其他用户,你可能需要直接引入类似于 [`core-js`](https://github.com/zloirock/core-js) 这样的 polyfills。
diff --git a/content/docs/reference-profiler.md b/content/docs/reference-profiler.md
deleted file mode 100644
index 324f948b55..0000000000
--- a/content/docs/reference-profiler.md
+++ /dev/null
@@ -1,120 +0,0 @@
----
-id: profiler
-title: Profiler API
-layout: docs
-category: Reference
-permalink: docs/profiler.html
----
-
-`Profiler` 测量一个 React 应用多久渲染一次以及渲染一次的“代价”。
-它的目的是识别出应用中渲染较慢的部分,或是可以使用[类似 memoization 优化](/docs/hooks-faq.html#how-to-memoize-calculations)的部分,并从相关优化中获益。
-
-> 注意:
->
-> Profiling 增加了额外的开支,所以**它在[生产构建](/docs/optimizing-performance.html#use-the-production-build)中会被禁用**。
->
-> 为了将 profiling 功能加入生产环境中,React 提供了使 profiling 可用的特殊的生产构建环境。
-> 从 [fb.me/react-profiling](https://fb.me/react-profiling)了解更多关于如何使用这个构建环境的信息。
-
-## 用法 {#usage}
-
-`Profiler` 能添加在 React 树中的任何地方来测量树中这部分渲染所带来的开销。
-它需要两个 prop :一个是 `id`(string),一个是当组件树中的组件“提交”更新的时候被React调用的回调函数 `onRender`(function)。
-
-例如,为了分析 `Navigation` 组件和它的子代:
-
-```js{3}
-render(
-
-
-
-
-
-
-);
-```
-
-多个 `Profiler` 组件能测量应用中的不同部分:
-```js{3,6}
-render(
-
-
-
-
-
-
-
-
-);
-```
-
-嵌套使用 `Profiler` 组件来测量相同一个子树下的不同组件:
-
-```js{3,5,8}
-render(
-
-
-
-
-
-
-
-
-
-
-
-
-);
-```
-
-> 注意
->
-> 尽管 `Profiler` 是一个轻量级组件,我们依然应该在需要时才去使用它。对一个应用来说,每添加一些都会给 CPU 和内存带来一些负担。
-
-## `onRender` 回调 {#onrender-callback}
-
-`Profiler` 需要一个 `onRender` 函数作为参数。
-React 会在 profile 包含的组件树中任何组件 “提交” 一个更新的时候调用这个函数。
-它的参数描述了渲染了什么和花费了多久。
-
-```js
-function onRenderCallback(
- id, // 发生提交的 Profiler 树的 “id”
- phase, // "mount" (如果组件树刚加载) 或者 "update" (如果它重渲染了)之一
- actualDuration, // 本次更新 committed 花费的渲染时间
- baseDuration, // 估计不使用 memoization 的情况下渲染整棵子树需要的时间
- startTime, // 本次更新中 React 开始渲染的时间
- commitTime, // 本次更新中 React committed 的时间
- interactions // 属于本次更新的 interactions 的集合
-) {
- // 合计或记录渲染时间。。。
-}
-```
-
-让我们来仔细研究一下各个 prop:
-
-* **`id: string`** -
-发生提交的 `Profiler` 树的 `id`。
-如果有多个 profiler,它能用来分辨树的哪一部分发生了“提交”。
-* **`phase: "mount" | "update"`** -
-判断是组件树的第一次装载引起的重渲染,还是由 props、state 或是 hooks 改变引起的重渲染。
-* **`actualDuration: number`** -
-本次更新在渲染 `Profiler` 和它的子代上花费的时间。
-这个数值表明使用 memoization 之后能表现得多好。(例如 [`React.memo`](/docs/react-api.html#reactmemo),[`useMemo`](/docs/hooks-reference.html#usememo),[`shouldComponentUpdate`](/docs/hooks-faq.html#how-do-i-implement-shouldcomponentupdate))。
-理想情况下,由于子代只会因特定的 prop 改变而重渲染,因此这个值应该在第一次装载之后显著下降。
-* **`baseDuration: number`** -
-在 `Profiler` 树中最近一次每一个组件 `render` 的持续时间。
-这个值估计了最差的渲染时间。(例如当它是第一次加载或者组件树没有使用 memoization)。
-* **`startTime: number`** -
-本次更新中 React 开始渲染的时间戳。
-* **`commitTime: number`** -
-本次更新中 React commit 阶段结束的时间戳。
-在一次 commit 中这个值在所有的 profiler 之间是共享的,可以将它们按需分组。
-* **`interactions: Set`** -
-当更新被制定时,["interactions"](https://fb.me/react-interaction-tracing) 的集合会被追踪。(例如当 `render` 或者 `setState` 被调用时)。
-
-> 注意
->
-> Interactions 能用来识别更新是由什么引起的,尽管这个追踪更新的 API 依然是实验性质的。
->
-> 从 [fb.me/react-interaction-tracing](https://fb.me/react-interaction-tracing) 了解更多
diff --git a/content/docs/reference-react-component.md b/content/docs/reference-react-component.md
deleted file mode 100644
index 4f8ec634ea..0000000000
--- a/content/docs/reference-react-component.md
+++ /dev/null
@@ -1,652 +0,0 @@
----
-id: react-component
-title: React.Component
-layout: docs
-category: Reference
-permalink: docs/react-component.html
-redirect_from:
- - "docs/component-api.html"
- - "docs/component-specs.html"
- - "docs/component-specs-ko-KR.html"
- - "docs/component-specs-zh-CN.html"
- - "tips/UNSAFE_componentWillReceiveProps-not-triggered-after-mounting.html"
- - "tips/dom-event-listeners.html"
- - "tips/initial-ajax.html"
- - "tips/use-react-with-other-libraries.html"
----
-
-> Try the new React documentation for [`Component`](https://beta.reactjs.org/reference/react/Component).
->
-> The new docs will soon replace this site, which will be archived. [Provide feedback.](https://github.com/reactjs/reactjs.org/issues/3308)
-
-本章节提供了 React class 组件的详细 API 参考。本章节默认你已熟悉基本的 React 概念,例如 [组件 & Props](/docs/components-and-props.html),以及 [State & 生命周期](/docs/state-and-lifecycle.html)等。如果你还未熟悉,请先阅读之前章节进行学习。
-
-## 概览 {#overview}
-
-React 的组件可以定义为 class 或函数的形式。class 组件目前提供了更多的功能,这些功能将在此章节中详细介绍。如需定义 class 组件,需要继承 `React.Component`:
-
-```js
-class Welcome extends React.Component {
- render() {
- return
Hello, {this.props.name}
;
- }
-}
-```
-
-在 `React.Component` 的子类中有个必须定义的 [`render()`](#render) 函数。本章节介绍其他方法均为可选。
-
-**我们强烈建议你不要创建自己的组件基类。** 在 React 组件中,[代码重用的主要方式是组合而不是继承](/docs/composition-vs-inheritance.html)。
-
->注意:
->
->React 并不会强制你使用 ES6 的 class 语法。如果你倾向于不使用它,你可以使用 `create-react-class` 模块或类似的自定义抽象来代替。请查阅[不使用 ES6](/docs/react-without-es6.html) 了解更多。
-
-### 组件的生命周期 {#the-component-lifecycle}
-
-每个组件都包含 “生命周期方法”,你可以重写这些方法,以便于在运行过程中特定的阶段执行这些方法。**你可以使用此[生命周期图谱](https://projects.wojtekmaj.pl/react-lifecycle-methods-diagram/)作为速查表**。在下述列表中,常用的生命周期方法会被加粗。其余生命周期函数的使用则相对罕见。
-
-#### 挂载 {#mounting}
-
-当组件实例被创建并插入 DOM 中时,其生命周期调用顺序如下:
-
-- [**`constructor()`**](#constructor)
-- [`static getDerivedStateFromProps()`](#static-getderivedstatefromprops)
-- [**`render()`**](#render)
-- [**`componentDidMount()`**](#componentdidmount)
-
->注意:
->
->下述生命周期方法即将过时,在新代码中应该[避免使用它们](/blog/2018/03/27/update-on-async-rendering.html):
->
->- [`UNSAFE_componentWillMount()`](#unsafe_componentwillmount)
-
-#### 更新 {#updating}
-
-当组件的 props 或 state 发生变化时会触发更新。组件更新的生命周期调用顺序如下:
-
-- [`static getDerivedStateFromProps()`](#static-getderivedstatefromprops)
-- [`shouldComponentUpdate()`](#shouldcomponentupdate)
-- [**`render()`**](#render)
-- [`getSnapshotBeforeUpdate()`](#getsnapshotbeforeupdate)
-- [**`componentDidUpdate()`**](#componentdidupdate)
-
->注意:
->
->下述方法即将过时,在新代码中应该[避免使用它们](/blog/2018/03/27/update-on-async-rendering.html):
->
->- [`UNSAFE_componentWillUpdate()`](#unsafe_componentwillupdate)
->- [`UNSAFE_componentWillReceiveProps()`](#unsafe_componentwillreceiveprops)
-
-#### 卸载 {#unmounting}
-
-当组件从 DOM 中移除时会调用如下方法:
-
-- [**`componentWillUnmount()`**](#componentwillunmount)
-
-#### 错误处理 {#error-handling}
-
-当渲染过程,生命周期,或子组件的构造函数中抛出错误时,会调用如下方法:
-
-- [`static getDerivedStateFromError()`](#static-getderivedstatefromerror)
-- [`componentDidCatch()`](#componentdidcatch)
-
-### 其他 APIs {#other-apis}
-
-组件还提供了一些额外的 API:
-
- - [`setState()`](#setstate)
- - [`forceUpdate()`](#forceupdate)
-
-### class 属性 {#class-properties}
-
- - [`defaultProps`](#defaultprops)
- - [`displayName`](#displayname)
-
-### 实例属性 {#instance-properties}
-
- - [`props`](#props)
- - [`state`](#state)
-
-* * *
-
-## 参考 {#reference}
-
-### 常用的生命周期方法 {#commonly-used-lifecycle-methods}
-
-本节中的方法涵盖了创建 React 组件时能遇到的绝大多数用例。**想要更好了解这些方法,可以参考[生命周期图谱](https://projects.wojtekmaj.pl/react-lifecycle-methods-diagram/)。**
-
-### `render()` {#render}
-
-```javascript
-render()
-```
-
-`render()` 方法是 class 组件中唯一必须实现的方法。
-
-当 `render` 被调用时,它会检查 `this.props` 和 `this.state` 的变化并返回以下类型之一:
-
-- **React 元素**。通常通过 [JSX](/docs/introducing-jsx.html) 创建。例如,`
` 会被 React 渲染为 DOM 节点,`
` 会被 React 渲染为自定义组件,无论是 `
` 还是 `
` 均为 React 元素。
-- **数组或 fragments**。 使得 render 方法可以返回多个元素。欲了解更多详细信息,请参阅 [fragments](/docs/fragments.html) 文档。
-- **Portals**。可以渲染子节点到不同的 DOM 子树中。欲了解更多详细信息,请参阅有关 [portals](/docs/portals.html) 的文档。
-- **字符串或数值类型**。它们在 DOM 中会被渲染为文本节点。
-- **布尔类型或 `null` 或者 `undefined`**。什么都不渲染。(主要用于支持 `return test &&
` 的模式,其中 test 为布尔类型。)
-
-`render()` 函数应该为纯函数,这意味着在不修改组件 state 的情况下,每次调用时都返回相同的结果,并且它不会直接与浏览器交互。
-
-如需与浏览器进行交互,请在 `componentDidMount()` 或其他生命周期方法中执行你的操作。保持 `render()` 为纯函数,可以使组件更容易思考。
-
-> 注意
->
-> 如果 `shouldComponentUpdate()` 返回 false,则不会调用 `render()`。
-
-* * *
-
-### `constructor()` {#constructor}
-
-```javascript
-constructor(props)
-```
-
-**如果不初始化 state 或不进行方法绑定,则不需要为 React 组件实现构造函数。**
-
-在 React 组件挂载之前,会调用它的构造函数。在为 React.Component 子类实现构造函数时,应在其他语句之前调用 `super(props)`。否则,`this.props` 在构造函数中可能会出现未定义的 bug。
-
-通常,在 React 中,构造函数仅用于以下两种情况:
-
-* 通过给 `this.state` 赋值对象来初始化[内部 state](/docs/state-and-lifecycle.html)。
-* 为[事件处理函数](/docs/handling-events.html)绑定实例
-
-在 `constructor()` 函数中**不要调用 `setState()` 方法**。如果你的组件需要使用内部 state,请直接在构造函数中为 **`this.state` 赋值初始 state**:
-
-```js
-constructor(props) {
- super(props);
- // 不要在这里调用 this.setState()
- this.state = { counter: 0 };
- this.handleClick = this.handleClick.bind(this);
-}
-```
-
-只能在构造函数中直接为 `this.state` 赋值。如需在其他方法中赋值,你应使用 `this.setState()` 替代。
-
-要避免在构造函数中引入任何副作用或订阅。如遇到此场景,请将对应的操作放置在 `componentDidMount` 中。
-
->注意
->
->**避免将 props 的值复制给 state!这是一个常见的错误:**
->
->```js
->constructor(props) {
-> super(props);
-> // 不要这样做
-> this.state = { color: props.color };
->}
->```
->
->如此做毫无必要(你可以直接使用 `this.props.color`),同时还产生了 bug(更新 prop 中的 `color` 时,并不会影响 state)。
->
->**只有在你刻意忽略 prop 更新的情况下使用。**此时,应将 prop 重命名为 `initialColor` 或 `defaultColor`。必要时,你可以[修改它的 `key`](/blog/2018/06/07/you-probably-dont-need-derived-state.html#recommendation-fully-uncontrolled-component-with-a-key),以强制“重置”其内部 state。
->
->请参阅关于[避免派生状态的博文](/blog/2018/06/07/you-probably-dont-need-derived-state.html),以了解出现 state 依赖 props 的情况该如何处理。
-
-
-* * *
-
-### `componentDidMount()` {#componentdidmount}
-
-```javascript
-componentDidMount()
-```
-
-`componentDidMount()` 会在组件挂载后(插入 DOM 树中)立即调用。依赖于 DOM 节点的初始化应该放在这里。如需通过网络请求获取数据,此处是实例化请求的好地方。
-
-这个方法是比较适合添加订阅的地方。如果添加了订阅,请不要忘记在 `componentWillUnmount()` 里取消订阅
-
-你可以在 `componentDidMount()` 里**直接调用 `setState()`**。它将触发额外渲染,但此渲染会发生在浏览器更新屏幕之前。如此保证了即使在 `render()` 两次调用的情况下,用户也不会看到中间状态。请谨慎使用该模式,因为它会导致性能问题。通常,你应该在 `constructor()` 中初始化 state。如果你的渲染依赖于 DOM 节点的大小或位置,比如实现 modals 和 tooltips 等情况下,你可以使用此方式处理
-
-* * *
-
-### `componentDidUpdate()` {#componentdidupdate}
-
-```javascript
-componentDidUpdate(prevProps, prevState, snapshot)
-```
-
-`componentDidUpdate()` 会在更新后会被立即调用。首次渲染不会执行此方法。
-
-当组件更新后,可以在此处对 DOM 进行操作。如果你对更新前后的 props 进行了比较,也可以选择在此处进行网络请求。(例如,当 props 未发生变化时,则不会执行网络请求)。
-
-```js
-componentDidUpdate(prevProps) {
- // 典型用法(不要忘记比较 props):
- if (this.props.userID !== prevProps.userID) {
- this.fetchData(this.props.userID);
- }
-}
-```
-
-你也可以在 `componentDidUpdate()` 中**直接调用 `setState()`**,但请注意**它必须被包裹在一个条件语句里**,正如上述的例子那样进行处理,否则会导致死循环。它还会导致额外的重新渲染,虽然用户不可见,但会影响组件性能。不要将 props “镜像”给 state,请考虑直接使用 props。 欲了解更多有关内容,请参阅[为什么 props 复制给 state 会产生 bug](/blog/2018/06/07/you-probably-dont-need-derived-state.html)。
-
-如果组件实现了 `getSnapshotBeforeUpdate()` 生命周期(不常用),则它的返回值将作为 `componentDidUpdate()` 的第三个参数 “snapshot” 参数传递。否则此参数将为 undefined。
-
-> 注意
->
-> 如果 [`shouldComponentUpdate()`](#shouldcomponentupdate) 返回值为 false,则不会调用 `componentDidUpdate()`。
-
-* * *
-
-### `componentWillUnmount()` {#componentwillunmount}
-
-```javascript
-componentWillUnmount()
-```
-
-`componentWillUnmount()` 会在组件卸载及销毁之前直接调用。在此方法中执行必要的清理操作,例如,清除 timer,取消网络请求或清除在 `componentDidMount()` 中创建的订阅等。
-
-`componentWillUnmount()` 中**不应调用 `setState()`**,因为该组件将永远不会重新渲染。组件实例卸载后,将永远不会再挂载它。
-
-* * *
-
-### 不常用的生命周期方法 {#rarely-used-lifecycle-methods}
-
-本节中的生命周期方法并不太常用。它们偶尔会很方便,但是大部分情况下组件可能都不需要它们。你可以在[生命周期图谱](https://projects.wojtekmaj.pl/react-lifecycle-methods-diagram/)中,选择“显示不常用的生命周期”复选框,即可看到下述相关方法。
-
-
-### `shouldComponentUpdate()` {#shouldcomponentupdate}
-
-```javascript
-shouldComponentUpdate(nextProps, nextState)
-```
-
-根据 `shouldComponentUpdate()` 的返回值,判断 React 组件的输出是否受当前 state 或 props 更改的影响。默认行为是 state 每次发生变化组件都会重新渲染。大部分情况下,你应该遵循默认行为。
-
-当 props 或 state 发生变化时,`shouldComponentUpdate()` 会在渲染执行之前被调用。返回值默认为 true。首次渲染或使用 `forceUpdate()` 时不会调用该方法。
-
-此方法仅作为**[性能优化的方式](/docs/optimizing-performance.html)**而存在。不要企图依靠此方法来“阻止”渲染,因为这可能会产生 bug。你应该**考虑使用内置的 [`PureComponent`](/docs/react-api.html#reactpurecomponent) 组件**,而不是手动编写 `shouldComponentUpdate()`。`PureComponent` 会对 props 和 state 进行浅层比较,并减少了跳过必要更新的可能性。
-
-如果你一定要手动编写此函数,可以将 `this.props` 与 `nextProps ` 以及 `this.state` 与`nextState` 进行比较,并返回 `false` 以告知 React 可以跳过更新。请注意,返回 `false` 并不会阻止子组件在 state 更改时重新渲染。
-
-我们不建议在 `shouldComponentUpdate()` 中进行深层比较或使用 `JSON.stringify()`。这样非常影响效率,且会损害性能。
-
-目前,如果 `shouldComponentUpdate()` 返回 `false`,则不会调用 [`UNSAFE_componentWillUpdate()`](#unsafe_componentwillupdate),[`render()`](#render) 和 [`componentDidUpdate()`](#componentdidupdate)。后续版本,React 可能会将 `shouldComponentUpdate` 视为提示而不是严格的指令,并且,当返回 `false` 时,仍可能导致组件重新渲染。
-
-* * *
-
-### `static getDerivedStateFromProps()` {#static-getderivedstatefromprops}
-
-```js
-static getDerivedStateFromProps(props, state)
-```
-
-`getDerivedStateFromProps` 会在调用 render 方法之前调用,并且在初始挂载及后续更新时都会被调用。它应返回一个对象来更新 state,如果返回 `null` 则不更新任何内容。
-
-此方法适用于[罕见的用例](/blog/2018/06/07/you-probably-dont-need-derived-state.html#when-to-use-derived-state),即 state 的值在任何时候都取决于 props。例如,实现 `
` 组件可能很方便,该组件会比较当前组件与下一组件,以决定针对哪些组件进行转场动画。
-
-派生状态会导致代码冗余,并使组件难以维护。
-[确保你已熟悉这些简单的替代方案:](/blog/2018/06/07/you-probably-dont-need-derived-state.html)
-
-* 如果你需要**执行副作用**(例如,数据提取或动画)以响应 props 中的更改,请改用 [`componentDidUpdate`](#componentdidupdate)。
-
-* 如果只想在 **prop 更改时重新计算某些数据**,[请使用 memoization helper 代替](/blog/2018/06/07/you-probably-dont-need-derived-state.html#what-about-memoization)。
-
-* 如果你想**在 prop 更改时“重置”某些 state**,请考虑使组件[完全受控](/blog/2018/06/07/you-probably-dont-need-derived-state.html#recommendation-fully-controlled-component)或[使用 `key` 使组件完全不受控](/blog/2018/06/07/you-probably-dont-need-derived-state.html#recommendation-fully-uncontrolled-component-with-a-key) 代替。
-
-此方法无权访问组件实例。如果你需要,可以通过提取组件 props 的纯函数及 class 之外的状态,在`getDerivedStateFromProps()`和其他 class 方法之间重用代码。
-
-请注意,不管原因是什么,都会在*每次*渲染前触发此方法。这与 `UNSAFE_componentWillReceiveProps` 形成对比,后者仅在父组件重新渲染时触发,而不是在内部调用 `setState` 时。
-
-* * *
-
-### `getSnapshotBeforeUpdate()` {#getsnapshotbeforeupdate}
-
-```javascript
-getSnapshotBeforeUpdate(prevProps, prevState)
-```
-
-`getSnapshotBeforeUpdate()` 在最近一次渲染输出(提交到 DOM 节点)之前调用。它使得组件能在发生更改之前从 DOM 中捕获一些信息(例如,滚动位置)。此生命周期方法的任何返回值将作为参数传递给 `componentDidUpdate()`。
-
-此用法并不常见,但它可能出现在 UI 处理中,如需要以特殊方式处理滚动位置的聊天线程等。
-
-应返回 snapshot 的值(或 `null`)。
-
-例如:
-
-`embed:react-component-reference/get-snapshot-before-update.js`
-
-在上述示例中,重点是从 `getSnapshotBeforeUpdate` 读取 `scrollHeight` 属性,因为 “render” 阶段生命周期(如 `render`)和 “commit” 阶段生命周期(如 `getSnapshotBeforeUpdate` 和 `componentDidUpdate`)之间可能存在延迟。
-
-* * *
-
-### Error boundaries {#error-boundaries}
-
-[Error boundaries](/docs/error-boundaries.html) 是 React 组件,它会在其子组件树中的任何位置捕获 JavaScript 错误,并记录这些错误,展示降级 UI 而不是崩溃的组件树。Error boundaries 组件会捕获在渲染期间,在生命周期方法以及其整个树的构造函数中发生的错误。
-
-如果 class 组件定义了生命周期方法 `static getDerivedStateFromError()` 或 `componentDidCatch()` 中的任何一个(或两者),它就成为了 Error boundaries。通过生命周期更新 state 可让组件捕获树中未处理的 JavaScript 错误并展示降级 UI。
-
-仅使用 Error boundaries 组件来从意外异常中恢复的情况;**不要将它们用于流程控制。**
-
-欲了解更多详细信息,请参阅 [*React 16 中的错误处理*](/blog/2017/07/26/error-handling-in-react-16.html)。
-
-> 注意
->
-> Error boundaries 仅捕获组件树中**以下**组件中的错误。但它本身的错误无法捕获。
-
-### `static getDerivedStateFromError()` {#static-getderivedstatefromerror}
-```javascript
-static getDerivedStateFromError(error)
-```
-
-此生命周期会在后代组件抛出错误后被调用。
-它将抛出的错误作为参数,并返回一个值以更新 state
-
-```js{7-10,13-16}
-class ErrorBoundary extends React.Component {
- constructor(props) {
- super(props);
- this.state = { hasError: false };
- }
-
- static getDerivedStateFromError(error) {
- // 更新 state 使下一次渲染可以显降级 UI
- return { hasError: true };
- }
-
- render() {
- if (this.state.hasError) {
- // 你可以渲染任何自定义的降级 UI
- return Something went wrong.
;
- }
-
- return this.props.children;
- }
-}
-```
-
-> 注意
->
-> `getDerivedStateFromError()` 会在`渲染`阶段调用,因此不允许出现副作用。
-如遇此类情况,请改用 `componentDidCatch()`。
-
-* * *
-
-### `componentDidCatch()` {#componentdidcatch}
-
-```javascript
-componentDidCatch(error, info)
-```
-
-此生命周期在后代组件抛出错误后被调用。
-它接收两个参数:
-
-1. `error` —— 抛出的错误。
-2. `info` —— 带有 `componentStack` key 的对象,其中包含[有关组件引发错误的栈信息](/docs/error-boundaries.html#component-stack-traces)。
-
-
-`componentDidCatch()` 会在“提交”阶段被调用,因此允许执行副作用。
-它应该用于记录错误之类的情况:
-
-```js{12-19}
-class ErrorBoundary extends React.Component {
- constructor(props) {
- super(props);
- this.state = { hasError: false };
- }
-
- static getDerivedStateFromError(error) {
- // 更新 state 使下一次渲染可以显示降级 UI
- return { hasError: true };
- }
-
- componentDidCatch(error, info) {
- // "组件堆栈" 例子:
- // in ComponentThatThrows (created by App)
- // in ErrorBoundary (created by App)
- // in div (created by App)
- // in App
- logComponentStackToMyService(info.componentStack);
- }
-
- render() {
- if (this.state.hasError) {
- // 你可以渲染任何自定义的降级 UI
- return Something went wrong.
;
- }
-
- return this.props.children;
- }
-}
-```
-
-React 的开发和生产构建版本在 `componentDidCatch()` 的方式上有轻微差别。
-
-在开发模式下,错误会冒泡至 `window`,这意味着任何 `window.onerror` 或 `window.addEventListener('error', callback)` 会中断这些已经被 `componentDidCatch()` 捕获的错误。
-
-相反,在生产模式下,错误不会冒泡,这意味着任何根错误处理器只会接受那些没有显式地被 `componentDidCatch()` 捕获的错误。
-
-> 注意
->
-> 如果发生错误,你可以通过调用 `setState` 使用 `componentDidCatch()` 渲染降级 UI,但在未来的版本中将不推荐这样做。
-> 可以使用静态 `getDerivedStateFromError()` 来处理降级渲染。
-
-* * *
-
-### 过时的生命周期方法 {#legacy-lifecycle-methods}
-
-以下生命周期方法标记为“过时”。这些方法仍然有效,但不建议在新代码中使用它们。参阅此[博客文章](/blog/2018/03/27/update-on-async-rendering.html)以了解更多有关迁移旧版生命周期方法的信息。
-
-### `UNSAFE_componentWillMount()` {#unsafe_componentwillmount}
-
-```javascript
-UNSAFE_componentWillMount()
-```
-
-> 注意
->
-> 此生命周期之前名为 `componentWillMount`。该名称将继续使用至 React 17。可以使用 [`rename-unsafe-lifecycles` codemod](https://github.com/reactjs/react-codemod#rename-unsafe-lifecycles) 自动更新你的组件。
-
-`UNSAFE_componentWillMount()` 在挂载之前被调用。它在 `render()` 之前调用,因此在此方法中同步调用 `setState()` 不会触发额外渲染。通常,我们建议使用 `constructor()` 来初始化 state。
-
-避免在此方法中引入任何副作用或订阅。如遇此种情况,请改用 `componentDidMount()`。
-
-此方法是服务端渲染唯一会调用的生命周期函数。
-
-* * *
-
-### `UNSAFE_componentWillReceiveProps()` {#unsafe_componentwillreceiveprops}
-
-```javascript
-UNSAFE_componentWillReceiveProps(nextProps)
-```
-
-> 注意
->
-> 此生命周期之前名为 `componentWillReceiveProps`。该名称将继续使用至 React 17。可以使用 [`rename-unsafe-lifecycles` codemod](https://github.com/reactjs/react-codemod#rename-unsafe-lifecycles) 自动更新你的组件。
-
-> 注意:
->
-> 使用此生命周期方法通常会出现 bug 和不一致性:
->
-> * 如果你需要**执行副作用**(例如,数据提取或动画)以响应 props 中的更改,请改用 [`componentDidUpdate`](#componentdidupdate) 生命周期。
-> * 如果你使用 `componentWillReceiveProps` **仅在 prop 更改时重新计算某些数据**,请[使用 memoization helper 代替](/blog/2018/06/07/you-probably-dont-need-derived-state.html#what-about-memoization)。
-> * 如果你使用 `componentWillReceiveProps` 是为了**在 prop 更改时“重置”某些 state**,请考虑使组件[完全受控](/blog/2018/06/07/you-probably-dont-need-derived-state.html#recommendation-fully-controlled-component)或[使用 `key` 使组件完全不受控](/blog/2018/06/07/you-probably-dont-need-derived-state.html#recommendation-fully-uncontrolled-component-with-a-key) 代替。
->
-> 对于其他使用场景,[请遵循此博客文章中有关派生状态的建议](/blog/2018/06/07/you-probably-dont-need-derived-state.html)。
-
-`UNSAFE_componentWillReceiveProps()` 会在已挂载的组件接收新的 props 之前被调用。如果你需要更新状态以响应 prop 更改(例如,重置它),你可以比较 `this.props` 和 `nextProps` 并在此方法中使用 `this.setState()` 执行 state 转换。
-
-请注意,如果父组件导致组件重新渲染,即使 props 没有更改,也会调用此方法。如果只想处理更改,请确保进行当前值与变更值的比较。
-
-在[挂载](#mounting)过程中,React 不会针对初始 props 调用 `UNSAFE_componentWillReceiveProps()`。组件只会在组件的 props 更新时调用此方法。调用 `this.setState()` 通常不会触发 `UNSAFE_componentWillReceiveProps()`。
-
-* * *
-
-### `UNSAFE_componentWillUpdate()` {#unsafe_componentwillupdate}
-
-```javascript
-UNSAFE_componentWillUpdate(nextProps, nextState)
-```
-
-> 注意
->
-> 此生命周期之前名为 `componentWillUpdate`。该名称将继续使用至 React 17。可以使用 [`rename-unsafe-lifecycles` codemod](https://github.com/reactjs/react-codemod#rename-unsafe-lifecycles) 自动更新你的组件。
-
-当组件收到新的 props 或 state 时,会在渲染之前调用 `UNSAFE_componentWillUpdate()`。使用此作为在更新发生之前执行准备更新的机会。初始渲染不会调用此方法。
-
-注意,你不能此方法中调用 `this.setState()`;在 `UNSAFE_componentWillUpdate()` 返回之前,你也不应该执行任何其他操作(例如,dispatch Redux 的 action)触发对 React 组件的更新
-
-通常,此方法可以替换为 `componentDidUpdate()`。如果你在此方法中读取 DOM 信息(例如,为了保存滚动位置),则可以将此逻辑移至 `getSnapshotBeforeUpdate()` 中。
-
-> 注意
->
-> 如果 `shouldComponentUpdate()` 返回 false,则不会调用 `UNSAFE_componentWillUpdate()`。
-
-* * *
-
-## 其他 API {#other-apis-1}
-
-不同于上述生命周期方法(React 主动调用),以下方法是你可以在组件中调用的方法。
-
-只有两个方法:`setState()` 和 `forceUpdate()`。
-
-### `setState()` {#setstate}
-
-```javascript
-setState(updater[, callback])
-```
-
-`setState()` 将对组件 state 的更改排入队列,并通知 React 需要使用更新后的 state 重新渲染此组件及其子组件。这是用于更新用户界面以响应事件处理器和处理服务器数据的主要方式
-
-将 `setState()` 视为*请求*而不是立即更新组件的命令。为了更好的感知性能,React 会延迟调用它,然后通过一次传递更新多个组件。在罕见的情况下,你需要强制 DOM 更新同步应用,你可以使用 [`flushSync`](/docs/react-dom.html#flushsync) 来包装它,但这可能会损害性能。
-
-`setState()` 并不总是立即更新组件。它会批量推迟更新。这使得在调用 `setState()` 后立即读取 `this.state` 成为了隐患。为了消除隐患,请使用 `componentDidUpdate` 或者 `setState` 的回调函数(`setState(updater, callback)`),这两种方式都可以保证在应用更新后触发。如需基于之前的 state 来设置当前的 state,请阅读下述关于参数 `updater` 的内容。
-
-除非 `shouldComponentUpdate()` 返回 `false`,否则 `setState()` 将始终执行重新渲染操作。如果可变对象被使用,且无法在 `shouldComponentUpdate()` 中实现条件渲染,那么仅在新旧状态不一时调用 `setState()`可以避免不必要的重新渲染
-
-参数一为带有形式参数的 `updater` 函数:
-
-```javascript
-(state, props) => stateChange
-```
-
-`state` 是对应用变化时组件状态的引用。当然,它不应直接被修改。你应该使用基于 `state` 和 `props` 构建的新对象来表示变化。例如,假设我们想根据 `props.step` 来增加 state:
-
-```javascript
-this.setState((state, props) => {
- return {counter: state.counter + props.step};
-});
-```
-
-updater 函数中接收的 `state` 和 `props` 都保证为最新。updater 的返回值会与 `state` 进行浅合并。
-
-`setState()` 的第二个参数为可选的回调函数,它将在 `setState` 完成合并并重新渲染组件后执行。通常,我们建议使用 `componentDidUpdate()` 来代替此方式。
-
-`setState()` 的第一个参数除了接受函数外,还可以接受对象类型:
-
-```javascript
-setState(stateChange[, callback])
-```
-
-`stateChange` 会将传入的对象浅层合并到新的 state 中,例如,调整购物车商品数:
-
-```javascript
-this.setState({quantity: 2})
-```
-
-这种形式的 `setState()` 也是异步的,并且在同一周期内会对多个 `setState` 进行批处理。例如,如果在同一周期内多次设置商品数量增加,则相当于:
-
-```javaScript
-Object.assign(
- previousState,
- {quantity: state.quantity + 1},
- {quantity: state.quantity + 1},
- ...
-)
-```
-
-后调用的 `setState()` 将覆盖同一周期内先调用 `setState` 的值,因此商品数仅增加一次。如果后续状态取决于当前状态,我们建议使用 updater 函数的形式代替:
-
-```js
-this.setState((state) => {
- return {quantity: state.quantity + 1};
-});
-```
-
-有关更多详细信息,请参阅:
-
-* [State 和生命周期指南](/docs/state-and-lifecycle.html)
-* [深入学习:何时以及为什么 `setState()` 会批量执行?](https://stackoverflow.com/a/48610973/458193)
-* [深入:为什么不直接更新 `this.state`?](https://github.com/facebook/react/issues/11527#issuecomment-360199710)
-
-* * *
-
-### `forceUpdate()` {#forceupdate}
-
-```javascript
-component.forceUpdate(callback)
-```
-
-默认情况下,当组件的 state 或 props 发生变化时,组件将重新渲染。如果 `render()` 方法依赖于其他数据,则可以调用 `forceUpdate()` 强制让组件重新渲染。
-
-调用 `forceUpdate()` 将致使组件调用 `render()` 方法,此操作会跳过该组件的 `shouldComponentUpdate()`。但其子组件会触发正常的生命周期方法,包括 `shouldComponentUpdate()` 方法。如果标记发生变化,React 仍将只更新 DOM。
-
-通常你应该避免使用 `forceUpdate()`,尽量在 `render()` 中使用 `this.props` 和 `this.state`。
-
-* * *
-
-## Class 属性 {#class-properties-1}
-
-### `defaultProps` {#defaultprops}
-
-`defaultProps` 可以为 Class 组件添加默认 props。这一般用于 props 未赋值,但又不能为 `null` 的情况。例如:
-
-```js
-class CustomButton extends React.Component {
- // ...
-}
-
-CustomButton.defaultProps = {
- color: 'blue'
-};
-```
-
-如果未提供 `props.color`,则默认设置为 `'blue'`
-
-```js
- render() {
- return ; // props.color 将设置为 'blue'
- }
-```
-
-如果 `props.color` 被设置为 `null`,则它将保持为 `null`
-
-```js
- render() {
- return ; // props.color 将保持是 null
- }
-```
-
-* * *
-
-### `displayName` {#displayname}
-
-`displayName` 字符串多用于调试消息。通常,你不需要设置它,因为它可以根据函数组件或 class 组件的名称推断出来。如果调试时需要显示不同的名称或创建高阶组件,请参阅[使用 displayname 轻松进行调试](/docs/higher-order-components.html#convention-wrap-the-display-name-for-easy-debugging)了解更多。
-
-* * *
-
-## 实例属性 {#instance-properties-1}
-
-### `props` {#props}
-
-`this.props` 包括被该组件调用者定义的 props。欲了解 props 的详细介绍,请参阅[组件 & Props](/docs/components-and-props.html)。
-
-需特别注意,`this.props.children` 是一个特殊的 prop,通常由 JSX 表达式中的子组件组成,而非组件本身定义。
-
-### `state` {#state}
-
-组件中的 state 包含了随时可能发生变化的数据。state 由用户自定义,它是一个普通 JavaScript 对象。
-
-如果某些值未用于渲染或数据流(例如,计时器 ID),则不必将其设置为 state。此类值可以在组件实例上定义。
-
-欲了解关于 state 的更多信息,请参阅 [State & 生命周期](/docs/state-and-lifecycle.html)。
-
-永远不要直接改变 `this.state`,因为后续调用的 `setState()` 可能会替换掉你的改变。请把 `this.state` 看作是不可变的。
diff --git a/content/docs/reference-react-dom-server.md b/content/docs/reference-react-dom-server.md
deleted file mode 100644
index d14f9c069d..0000000000
--- a/content/docs/reference-react-dom-server.md
+++ /dev/null
@@ -1,237 +0,0 @@
----
-id: react-dom-server
-title: ReactDOMServer
-layout: docs
-category: Reference
-permalink: docs/react-dom-server.html
----
-
-`ReactDOMServer` 对象允许你将组件渲染成静态标记。通常,它被使用在 Node 服务端上:
-
-```js
-// ES modules
-import * as ReactDOMServer from 'react-dom/server';
-// CommonJS
-var ReactDOMServer = require('react-dom/server');
-```
-
-## 概览 {#overview}
-
-These methods are only available in the **environments with [Node.js Streams](https://nodejs.org/api/stream.html):**
-
-- [`renderToPipeableStream()`](#rendertopipeablestream)
-- [`renderToNodeStream()`](#rendertonodestream) (Deprecated)
-- [`renderToStaticNodeStream()`](#rendertostaticnodestream)
-
-这些方法只在支持 **[Web Streams](https://developer.mozilla.org/en-US/docs/Web/API/Streams_API) 的环境中可用**(这包含浏览器,Deno 和一些现代边缘 runtime):
-
-- [`renderToReadableStream()`](#rendertoreadablestream)
-
-以下方法可以在不支持 Steam 的环境中使用:
-
-- [`renderToString()`](#rendertostring)
-- [`renderToStaticMarkup()`](#rendertostaticmarkup)
-
-## 参考 {#reference}
-
-### `renderToPipeableStream()` {#rendertopipeablestream}
-
-> Try the new React documentation for [`renderToPipeableStream`](https://beta.reactjs.org/reference/react-dom/server/renderToPipeableStream).
->
-> The new docs will soon replace this site, which will be archived. [Provide feedback.](https://github.com/reactjs/reactjs.org/issues/3308)
-
-```javascript
-ReactDOMServer.renderToPipeableStream(element, options)
-```
-
-将一个 React 元素渲染为初始 HTML。返回一个带有 `pipe(res)` 方法的流,用于管道输出。`abort()` 用于中止请求。完美支持了 suspense 和 HTML 流,"延迟" 的内容块会通过内联的 `'
- );
- },
- onAllReady() {
- // If you don't want streaming, use this instead of onShellReady.
- // This will fire after the entire page content is ready.
- // You can use this for crawlers or static generation.
-
- // res.statusCode = didError ? 500 : 200;
- // res.setHeader('Content-type', 'text/html');
- // stream.pipe(res);
- },
- onError(err) {
- didError = true;
- console.error(err);
- },
- }
-);
-```
-
-具体参见 [完整的选项列表](https://github.com/facebook/react/blob/14c2be8dac2d5482fda8a0906a31d239df8551fc/packages/react-dom/src/server/ReactDOMFizzServerNode.js#L36-L46).
-
-> 注意:
->
-> 这是一个针对 Node.js 的 API。只在支持 [Web Streams](https://developer.mozilla.org/en-US/docs/Web/API/Streams_API) 的环境下可用,如 Deno 以及现代边缘 runtimes,应使用 [`renderToReadableStream`](#rendertoreadablestream) 代替。
->
-
-* * *
-
-### `renderToReadableStream()` {#rendertoreadablestream}
-
-> Try the new React documentation for [`renderToReadableStream`](https://beta.reactjs.org/reference/react-dom/server/renderToReadableStream).
->
-> The new docs will soon replace this site, which will be archived. [Provide feedback.](https://github.com/reactjs/reactjs.org/issues/3308)
-
-```javascript
-ReactDOMServer.renderToReadableStream(element, options);
-```
-
-将一个 React 元素通过流的形式注入初始的 HTML 中。返回值为 Promise, resolve 一个 [可读 Stream](https://developer.mozilla.org/en-US/docs/Web/API/ReadableStream)。完美支持了 suspense 和 HTML 流。[了解更多](https://github.com/reactwg/react-18/discussions/127)
-
-如果你在一个已经被服务端渲染标记的节点上调用 [`ReactDOM.hydrateRoot()`](/docs/react-dom-client.html#hydrateroot),React 会保留它,只为其附加事件处理程序。让你拥有一个非常良好的首次加载体验。
-
-```javascript
-let controller = new AbortController();
-let didError = false;
-try {
- let stream = await renderToReadableStream(
-
- Success
- ,
- {
- signal: controller.signal,
- onError(error) {
- didError = true;
- console.error(error);
- }
- }
- );
-
- // This is to wait for all Suspense boundaries to be ready. You can uncomment
- // this line if you want to buffer the entire HTML instead of streaming it.
- // You can use this for crawlers or static generation:
-
- // await stream.allReady;
-
- return new Response(stream, {
- status: didError ? 500 : 200,
- headers: {'Content-Type': 'text/html'},
- });
-} catch (error) {
- return new Response(
- 'Loading...
',
- {
- status: 500,
- headers: {'Content-Type': 'text/html'},
- }
- );
-}
-```
-
-具体参见 [完整的选项列表](https://github.com/facebook/react/blob/14c2be8dac2d5482fda8a0906a31d239df8551fc/packages/react-dom/src/server/ReactDOMFizzServerBrowser.js#L27-L35)。
-
-> 注意:
->
-> 该 API 依赖 [Web Streams](https://developer.mozilla.org/en-US/docs/Web/API/Streams_API)。对于,请使用 [`renderToPipeableStream`](#rendertopipeablestream) 代替。
->
-
-* * *
-
-### `renderToNodeStream()` (Deprecated) {#rendertonodestream}
-
-> Try the new React documentation for [`renderToNodeStream`](https://beta.reactjs.org/reference/react-dom/server/renderToNodeStream).
->
-> The new docs will soon replace this site, which will be archived. [Provide feedback.](https://github.com/reactjs/reactjs.org/issues/3308)
-
-```javascript
-ReactDOMServer.renderToNodeStream(element)
-```
-
-将一个 React 元素渲染成其初始 HTML。返回一个可输出 HTML 字符串的 [Node.js 可读流](https://nodejs.org/api/stream.html#stream_readable_streams)。通过可读流输出的 HTML 完全等同于 [`ReactDOMServer.renderToString`](#rendertostring) 返回的 HTML。你可以使用本方法在服务器上生成 HTML,并在初始请求时将标记下发,以加快页面加载速度,并允许搜索引擎抓取你的页面以达到 SEO 优化的目的。
-
-如果你在已有服务端渲染标记的节点上调用 [`ReactDOM.hydrateRoot()`](/docs/react-dom-client.html#hydrateroot) 方法,React 将会保留该节点且只进行事件处理绑定,从而让你有一个非常高性能的首次加载体验。
-
-> 注意:
->
-> 这个 API 仅允许在服务端使用。不允许在浏览器使用。
->
-> 通过本方法返回的流会返回一个由 utf-8 编码的字节流。如果你需要另一种编码的流,请查看像 [iconv-lite](https://www.npmjs.com/package/iconv-lite) 这样的项目,它为转换文本提供了转换流。
-
-* * *
-
-### `renderToStaticNodeStream()` {#rendertostaticnodestream}
-
-> Try the new React documentation for [`renderToStaticNodeStream`](https://beta.reactjs.org/reference/react-dom/server/renderToStaticNodeStream).
->
-> The new docs will soon replace this site, which will be archived. [Provide feedback.](https://github.com/reactjs/reactjs.org/issues/3308)
-
-```javascript
-ReactDOMServer.renderToStaticNodeStream(element)
-```
-
-此方法与 [`renderToNodeStream`](#rendertonodestream) 相似,但此方法不会在 React 内部创建的额外 DOM 属性,例如 `data-reactroot`。如果你希望把 React 当作静态页面生成器来使用,此方法会非常有用,因为去除额外的属性可以节省一些字节。
-
-通过可读流输出的 HTML,完全等同于 [`ReactDOMServer.renderToStaticMarkup`](#rendertostaticmarkup) 返回的 HTML。
-
-如果你计划在前端使用 React 以使得标记可交互,请不要使用此方法。你可以在服务端上使用 [`renderToNodeStream`](#rendertonodestream) 或在前端上使用 [`ReactDOM.hydrateRoot()`](/docs/react-dom-client.html#hydrateroot) 来代替此方法。
-
-> 注意:
->
-> 此 API 仅限于服务端使用,在浏览器中是不可用的。
->
-> 通过本方法返回的流会返回一个由 utf-8 编码的字节流。如果你需要另一种编码的流,请查看像 [iconv-lite](https://www.npmjs.com/package/iconv-lite) 这样的项目,它为转换文本提供了转换流。
-
-* * *
-
-### `renderToString()` {#rendertostring}
-
-> Try the new React documentation for [`renderToString`](https://beta.reactjs.org/reference/react-dom/server/renderToString).
->
-> The new docs will soon replace this site, which will be archived. [Provide feedback.](https://github.com/reactjs/reactjs.org/issues/3308)
-
-```javascript
-ReactDOMServer.renderToString(element)
-```
-
-将一个 React 元素渲染成其初始的 HTML。React 将返回一个 HTML 字符串。你可以使用这种方法在服务器上生产 HTML,并在初始请求中发送标记。以加快页面加载速度,并允许搜索引擎以 SEO 为目的抓取你的页面。
-
-如果你在一个已被服务端渲染标记的节点上调用 [`ReactDOM.hydrateRoot()`](/docs/react-dom-client.html#hydrateroot),React 会保留它,只附加事件处理程序,让你有一个非常良好的首次加载体验。
-
-> 注意:
->
-> 此 API 对 Suspense 支持有限,并且不支持流。
->
-> 在服务端,建议使用 [`renderToPipeableStream`](#rendertopipeablestream) (Node.js) 或者 [`renderToReadableStream`](#rendertoreadablestream) (for Web Streams) 代替。
-
-* * *
-
-### `renderToStaticMarkup()` {#rendertostaticmarkup}
-
-> Try the new React documentation for [`renderToStaticMarkup`](https://beta.reactjs.org/reference/react-dom/server/renderToStaticMarkup).
->
-> The new docs will soon replace this site, which will be archived. [Provide feedback.](https://github.com/reactjs/reactjs.org/issues/3308)
-
-```javascript
-ReactDOMServer.renderToStaticMarkup(element)
-```
-
-与 [`renderToString`](#rendertostring) 相似,只是该方法不会创建 React 内部使用的额外 DOM 属性,如 `data-reactroot`。如果你只想把 React 作为简单的静态页面生成器使用,此方法会非常实用。因为剥离多余的属性可以节省一些字节占用。
-
-如果你打算在客户端使用 React 进行交互标记,那请不要使用这个方法。作为替代,你可以在服务器使用 [`renderToString`](#rendertostring),同时在客户端使用 [`ReactDOM.hydrateRoot()`](/docs/react-dom-client.html#hydrateroot)。
diff --git a/content/docs/reference-react-dom.md b/content/docs/reference-react-dom.md
deleted file mode 100644
index 2ea19330ac..0000000000
--- a/content/docs/reference-react-dom.md
+++ /dev/null
@@ -1,195 +0,0 @@
----
-id: react-dom
-title: ReactDOM
-layout: docs
-category: Reference
-permalink: docs/react-dom.html
----
-
-`react-dom` 包提供了用户 DOM 的特定方法,可以在你应用程序的顶层进行使用,如果你有需要的话,还可以作为应急方案,在 React 模型以外的地方使用。
-
-```js
-import * as ReactDOM from 'react-dom';
-```
-
-如果你使用 npm 和 ES5,你可以用:
-
-```js
-var ReactDOM = require('react-dom');
-```
-
-`react-dom` 包还提供了客户端和服务器应用程序的特定模块:
-- [`react-dom/client`](/docs/react-dom-client.html)
-- [`react-dom/server`](/docs/react-dom-server.html)
-
-## 概览 {#overview}
-
-`react-dom` 包导出了如下这些方法:
-- [`createPortal()`](#createportal)
-- [`flushSync()`](#flushsync)
-
-如下这些方法也会被 `react-dom` 导出,但会被认为是遗弃:
-- [`render()`](#render)
-- [`hydrate()`](#hydrate)
-- [`findDOMNode()`](#finddomnode)
-- [`unmountComponentAtNode()`](#unmountcomponentatnode)
-
-> 注意:
->
-> 在 React 18,`render` 和 `hydrate` 都被新的 [客户端方法](/docs/react-dom-client.html) 所取代。这些方法将警告你的应用程序将表现得像运行 React 17 一样(欲了解更多请参阅 [此处](https://reactjs.org/link/switch-to-createroot))。
-
-### 浏览器支持 {#browser-support}
-
-React 支持所有的现代浏览器,不过对于旧版本来说,可能需要引入 [相关的 polyfills 依赖](/docs/javascript-environment-requirements.html)。
-
-> 注意:
->
->我们不支持那些不兼容 ES5 方法的旧版浏览器,但如果你的应用包含了 polyfill,例如 [es5-shim 和 es5-sham](https://github.com/es-shims/es5-shim) 你可能会发现你的应用仍然可以在这些浏览器中正常运行。但是如果你选择这种方法,你便需要孤军奋战了。
-
-## 参考 {#reference}
-
-### `createPortal()` {#createportal}
-
-> Try the new React documentation for [`createPortal`](https://beta.reactjs.org/reference/react-dom/createPortal).
->
-> The new docs will soon replace this site, which will be archived. [Provide feedback.](https://github.com/reactjs/reactjs.org/issues/3308)
-
-```javascript
-createPortal(child, container)
-```
-
-创建 portal。[Portal](/docs/portals.html) 提供了一种将子节点渲染到 DOM 节点中的方式,该节点存在于 DOM 组件的层次结构之外。
-
-### `flushSync()` {#flushsync}
-
-> Try the new React documentation for [`flushSync`](https://beta.reactjs.org/reference/react-dom/flushSync).
->
-> The new docs will soon replace this site, which will be archived. [Provide feedback.](https://github.com/reactjs/reactjs.org/issues/3308)
-
-```javascript
-flushSync(callback)
-```
-
-强制 React 同步刷新提供的回调函数中的任何更新。这确保了 DOM 会被立即更新。
-
-```javascript
-// Force this state update to be synchronous.
-flushSync(() => {
- setCount(count + 1);
-});
-// By this point, DOM is updated.
-```
-
-> 注意:
->
-> `flushSync` 会对性能产生很大影响。尽量少用。
->
-> `flushSync` 可能会迫使悬而未决的 Suspense 边界显示其 `fallback` 的状态。
->
-> `flushSync` 也可以运行待定副作用,并在返回之前同步应用它们所包含的任何更新。
->
-> 当需要刷新内部的更新时,`flushSync` 也可以在回调外部刷新更新。例如,如果有来自点击的未决更新。React 可能会在刷新回调之前刷新这些更新。
-
-## 遗留方法参考 {#legacy-reference}
-### `render()` {#render}
-
-> Try the new React documentation for [`render`](https://beta.reactjs.org/reference/react-dom/render).
->
-> The new docs will soon replace this site, which will be archived. [Provide feedback.](https://github.com/reactjs/reactjs.org/issues/3308)
-
-```javascript
-render(element, container[, callback])
-```
-
-> 注意:
->
-> 在 React 18 中,`render` 函数已被 `createRoot` 函数所取代。具体请参阅 [createRoot](/docs/react-dom-client.html#createroot) 以了解更多。
-
-在提供的 `container` 里渲染一个 React 元素,并返回对该组件的[引用](/docs/more-about-refs.html)(或者针对[无状态组件](/docs/components-and-props.html#function-and-class-components)返回 `null`)。
-
-如果 React 元素之前已经在 `container` 里渲染过,这将会对其执行更新操作,并仅会在必要时改变 DOM 以映射最新的 React 元素。
-
-如果提供了可选的回调函数,该回调将在组件被渲染或更新之后被执行。
-
-> 注意:
->
-> `render()` 会控制你传入容器节点里的内容。当首次调用时,容器节点里的所有 DOM 元素都会被替换,后续的调用则会使用 React 的 DOM 差分算法(DOM diffing algorithm)进行高效的更新。
->
-> `render()` 不会修改容器节点(只会修改容器的子节点)。可以在不覆盖现有子节点的情况下,将组件插入已有的 DOM 节点中。
->
-> `render()` 目前会返回对根组件 `ReactComponent` 实例的引用。
-> 但是,目前应该避免使用返回的引用,因为它是历史遗留下来的内容,而且在未来版本的 React 中,组件渲染在某些情况下可能会是异步的。
-> 如果你真的需要获得对根组件 `ReactComponent` 实例的引用,那么推荐为根元素添加 [callback ref](/docs/refs-and-the-dom.html#callback-refs)。
->
-> 使用 `render()` 对服务端渲染容器进行 hydrate 操作的方式已经被废弃,并且会在 React 17 被移除。作为替代,请使用 [`hydrateRoot()`](/docs/react-dom-client.html#hydrateroot)。
-
-* * *
-
-### `hydrate()` {#hydrate}
-
-> Try the new React documentation for [`hydrate`](https://beta.reactjs.org/reference/react-dom/hydrate).
->
-> The new docs will soon replace this site, which will be archived. [Provide feedback.](https://github.com/reactjs/reactjs.org/issues/3308)
-
-```javascript
-hydrate(element, container[, callback])
-```
-
-> 注意:
->
-> 在 React 18 中,请使用 `hydrateRoot` 来替代 `hydrate`。请参阅 [hydrateRoot](/docs/react-dom-client.html#hydrateroot) 以了解更多。
-
-与 [`render()`](#render) 相同,但它用于在 [`ReactDOMServer`](/docs/react-dom-server.html) 渲染的容器中对 HTML 的内容进行 hydrate 操作。React 会尝试在已有标记上绑定事件监听器。
-
-React 希望服务端与客户端渲染的内容完全一致。React 可以弥补文本内容的差异,但是你需要将不匹配的地方作为 bug 进行修复。在开发者模式下,React 会对 hydration 操作过程中的不匹配进行警告。但并不能保证在不匹配的情况下,修补属性的差异。由于性能的关系,这一点非常重要,因为大多数应用中不匹配的情况很少见,并且验证所有标记的成本非常昂贵。
-
-如果单个元素的属性或者文本内容,在服务端和客户端之间有无法避免差异(比如:时间戳),则可以为元素添加 `suppressHydrationWarning={true}` 来消除警告。这种方式只在一级深度上有效,应只作为一种应急方案(escape hatch)。请不要过度使用!除非它是文本内容,否则 React 仍不会尝试修补差异,因此在未来的更新之前,仍会保持不一致。
-
-如果你执意要在服务端与客户端渲染不同内容,你可以采用双重(two-pass)渲染。在客户端渲染不同内容的组件可以读取类似于 `this.state.isClient` 的 state 变量,你可以在 `componentDidMount()` 里将它设置为 `true`。这种方式在初始渲染过程中会与服务端渲染相同的内容,从而避免不匹配的情况出现,但在 hydration 操作之后,会同步进行额外的渲染操作。注意,因为进行了两次渲染,这种方式会使得组件渲染变慢,请小心使用。
-
-记得保证弱网环境下的用户体验。JavaScript 代码的加载要比最初的 HTML 渲染晚的多。因此如果你只在客户端渲染不同的内容,其转换可能会不稳定。但是,如果执行顺利,那么在服务端负责渲染的 shell 会对渲染提供帮助,并且只显示客户端上额外的小组件。欲了解如何在不出现标记不匹配的情况下执行此操作,请参考上一段的解释。
-
-* * *
-
-### `unmountComponentAtNode()` {#unmountcomponentatnode}
-
-> Try the new React documentation for [`unmountComponentAtNode`](https://beta.reactjs.org/reference/react-dom/unmountComponentAtNode).
->
-> The new docs will soon replace this site, which will be archived. [Provide feedback.](https://github.com/reactjs/reactjs.org/issues/3308)
-
-```javascript
-unmountComponentAtNode(container)
-```
-
-> 注意:
->
-> 在 React 18 中,`unmountComponentAtNode` 已被 `root.unmount()` 取代。具体请参阅 [createRoot](/docs/react-dom-client.html#createroot) 以了解更多。
-
-从 DOM 中卸载组件,会将其事件处理器(event handlers)和 state 一并清除。如果指定容器上没有对应已挂载的组件,这个函数什么也不会做。如果组件被移除将会返回 `true`,如果没有组件可被移除将会返回 `false`。
-
-* * *
-
-### `findDOMNode()` {#finddomnode}
-
-> Try the new React documentation for [`findDOMNode`](https://beta.reactjs.org/reference/react-dom/findDOMNode).
->
-> The new docs will soon replace this site, which will be archived. [Provide feedback.](https://github.com/reactjs/reactjs.org/issues/3308)
-
-> 注意:
->
-> `findDOMNode` 是一个访问底层 DOM 节点的应急方案(escape hatch)。在大多数情况下,不推荐使用该方法,因为它会破坏组件的抽象结构。[严格模式下该方法已弃用。](/docs/strict-mode.html#warning-about-deprecated-finddomnode-usage)
-
-```javascript
-findDOMNode(component)
-```
-如果组件已经被挂载到 DOM 上,此方法会返回浏览器中相应的原生 DOM 元素。此方法对于从 DOM 中读取值很有用,例如获取表单字段的值或者执行 DOM 检测(performing DOM measurements)。**大多数情况下,你可以绑定一个 ref 到 DOM 节点上,可以完全避免使用 findDOMNode。**
-
-当组件渲染的内容为 `null` 或 `false` 时,`findDOMNode` 也会返回 `null`。当组件渲染的是字符串时,`findDOMNode` 返回的是字符串对应的 DOM 节点。从 React 16 开始,组件可能会返回有多个子节点的 fragment,在这种情况下,`findDOMNode` 会返回第一个非空子节点对应的 DOM 节点。
-
-> 注意:
->
-> `findDOMNode` 只在已挂载的组件上可用(即,已经放置在 DOM 中的组件)。如果你尝试调用未挂载的组件(例如在一个还未创建的组件上调用 `render()` 中的 `findDOMNode()`)将会引发异常。
->
-> `findDOMNode` 不能用于函数组件。
-
-* * *
diff --git a/content/docs/reference-react.md b/content/docs/reference-react.md
deleted file mode 100644
index 916d1fad75..0000000000
--- a/content/docs/reference-react.md
+++ /dev/null
@@ -1,453 +0,0 @@
----
-id: react-api
-title: React 顶层 API
-layout: docs
-category: Reference
-permalink: docs/react-api.html
-redirect_from:
- - "docs/reference.html"
- - "docs/clone-with-props.html"
- - "docs/top-level-api.html"
- - "docs/top-level-api-ja-JP.html"
- - "docs/top-level-api-ko-KR.html"
- - "docs/top-level-api-zh-CN.html"
----
-
-`React` 是 React 库的入口。如果你通过使用 `
-
-现在我们已经确定了组件层级,可以编写对应的应用了。最容易的方式,是先用已有的数据模型渲染一个不包含交互功能的 UI。最好将渲染 UI 和添加交互这两个过程分开。这是因为,编写一个应用的静态版本时,往往要编写大量代码,而不需要考虑太多交互细节;添加交互功能时则要考虑大量细节,而不需要编写太多代码。所以,将这两个过程分开进行更为合适。我们会在接下来的代码中体会到其中的区别。
-
-在构建应用的静态版本时,我们需要创建一些会重用其他组件的组件,然后通过 *props* 传入所需的数据。*props* 是父组件向子组件传递数据的方式。即使你已经熟悉了 *state* 的概念,也**完全不应该使用 state** 构建静态版本。state 代表了随时间会产生变化的数据,应当仅在实现交互时使用。所以构建应用的静态版本时,你不会用到它。
-
-你可以自上而下或者自下而上构建应用:自上而下意味着首先编写层级较高的组件(比如 `FilterableProductTable`),自下而上意味着从最基本的组件开始编写(比如 `ProductRow`)。当你的应用比较简单时,使用自上而下的方式更方便;对于较为大型的项目来说,自下而上地构建,并同时为低层组件编写测试是更加简单的方式。
-
-到此为止,你应该已经有了一个可重用的组件库来渲染你的数据模型。由于我们构建的是静态版本,所以这些组件目前只需提供 `render()` 方法用于渲染。最顶层的组件 `FilterableProductTable` 通过 props 接受你的数据模型。如果你的数据模型发生了改变,再次调用 `root.render()`,UI 就会相应地被更新。数据模型变化、调用 `render()` 方法、UI 相应变化,这个过程并不复杂,因此很容易看清楚 UI 是如何被更新的,以及是在哪里被更新的。React **单向数据流**(也叫*单向绑定*)的思想使得组件模块化,易于快速开发。
-
-如果你在完成这一步骤时遇到了困难,可以参阅 [React 文档](/docs/getting-started.html)。
-
-### 补充说明: 有关 props 和 state {#a-brief-interlude-props-vs-state}
-
-在 React 中,有两类“模型”数据:props 和 state。清楚地理解两者的区别是十分重要的;如果你不太有把握,可以参阅 [React 官方文档](/docs/state-and-lifecycle.html)。你也可以查看 [FAQ: state 与 props 的区别是什么?](/docs/faq-state.html#what-is-the-difference-between-state-and-props)
-
-## 第三步:确定 UI state 的最小(且完整)表示 {#step-3-identify-the-minimal-but-complete-representation-of-ui-state}
-
-想要使你的 UI 具备交互功能,需要有触发基础数据模型改变的能力。React 通过实现 **state** 来完成这个任务。
-
-为了正确地构建应用,你首先需要找出应用所需的 state 的最小表示,并根据需要计算出其他所有数据。其中的关键正是 [DRY: *Don't Repeat Yourself*](https://en.wikipedia.org/wiki/Don%27t_repeat_yourself)。只保留应用所需的可变 state 的最小集合,其他数据均由它们计算产生。比如,你要编写一个任务清单应用,你只需要保存一个包含所有事项的数组,而无需额外保存一个单独的 state 变量(用于存储任务个数)。当你需要展示任务个数时,只需要利用该数组的 length 属性即可。
-
-我们的示例应用拥有如下数据:
-
- * 包含所有产品的原始列表
- * 用户输入的搜索词
- * 复选框是否选中的值
- * 经过搜索筛选的产品列表
-
-通过问自己以下三个问题,你可以逐个检查相应数据是否属于 state:
-
- 1. 该数据是否是由父组件通过 props 传递而来的?如果是,那它应该不是 state。
- 2. 该数据是否随时间的推移而保持不变?如果是,那它应该也不是 state。
- 3. 你能否根据其他 state 或 props 计算出该数据的值?如果是,那它也不是 state。
-
-包含所有产品的原始列表是经由 props 传入的,所以它不是 state;搜索词和复选框的值应该是 state,因为它们随时间会发生改变且无法由其他数据计算而来;经过搜索筛选的产品列表不是 state,因为它的结果可以由产品的原始列表根据搜索词和复选框的选择计算出来。
-
-综上所述,属于 state 的有:
-
- * 用户输入的搜索词
- * 复选框是否选中的值
-
-## 第四步:确定 state 放置的位置 {#step-4-identify-where-your-state-should-live}
-
-参阅 CodePen 上的 React 哲学:第四步。
-
-我们已经确定了应用所需的 state 的最小集合。接下来,我们需要确定哪个组件能够改变这些 state,或者说*拥有*这些 state。
-
-注意:React 中的数据流是单向的,并顺着组件层级从上往下传递。哪个组件应该拥有某个 state 这件事,**对初学者来说往往是最难理解的部分**。尽管这可能在一开始不是那么清晰,但你可以尝试通过以下步骤来判断:
-
-对于应用中的每一个 state:
-
- * 找到根据这个 state 进行渲染的所有组件。
- * 找到他们的共同所有者(common owner)组件(在组件层级上高于所有需要该 state 的组件)。
- * 该共同所有者组件或者比它层级更高的组件应该拥有该 state。
- * 如果你找不到一个合适的位置来存放该 state,就可以直接创建一个新的组件来存放该 state,并将这一新组件置于高于共同所有者组件层级的位置。
-
-根据以上策略重新考虑我们的示例应用:
-
- * `ProductTable` 需要根据 state 筛选产品列表。`SearchBar` 需要展示搜索词和复选框的状态。
- * 他们的共同所有者是 `FilterableProductTable`。
- * 因此,搜索词和复选框的值应该很自然地存放在 `FilterableProductTable` 组件中。
-
-很好,我们已经决定把这些 state 存放在 `FilterableProductTable` 组件中。首先,将实例属性 `this.state = {filterText: '', inStockOnly: false}` 添加到 `FilterableProductTable` 的 `constructor` 中,设置应用的初始 state;接着,将 `filterText` 和 `inStockOnly` 作为 props 传入 `ProductTable` 和 `SearchBar`;最后,用这些 props 筛选 `ProductTable` 中的产品信息,并设置 `SearchBar` 的表单值。
-
-你现在可以看到应用的变化了:将 `filterText` 设置为 `"ball"` 并刷新应用,你能发现表格中的数据已经更新了。
-
-## 第五步:添加反向数据流 {#step-5-add-inverse-data-flow}
-
-参阅 CodePen 上的 React 哲学:第五步。
-
-到目前为止,我们已经借助自上而下传递的 props 和 state 渲染了一个应用。现在,我们将尝试让数据反向传递:处于较低层级的表单组件更新较高层级的 `FilterableProductTable` 中的 state。
-
-React 通过一种比传统的双向绑定略微繁琐的方法来实现反向数据传递。尽管如此,但这种需要显式声明的方法更有助于人们理解程序的运作方式。
-
-如果你尝试在上一个示例的搜索框中输入或勾选复选框(步骤 4),React 不会产生任何响应。这是正常的,因为我们之前已经将 `input` 的值设置为了从 `FilterableProductTable` 的 `state` 传递而来的固定值。
-
-让我们重新梳理一下需要实现的功能:每当用户改变表单的值,我们需要改变 state 来反映用户的当前输入。由于 state 只能由拥有它们的组件进行更改,`FilterableProductTable` 必须将一个能够触发 state 改变的回调函数(callback)传递给 `SearchBar`。我们可以使用输入框的 `onChange` 事件来监视用户输入的变化,并通知 `FilterableProductTable` 传递给 `SearchBar` 的回调函数。然后该回调函数将调用 `setState()`,从而更新应用。
-
-## 这就是全部了 {#and-thats-it}
-
-希望这篇文档能够帮助你建立起构建 React 组件和应用的一般概念。尽管你可能需要编写更多的代码,但是别忘了:比起写,代码更多地是给人看的。我们一起构建的这个模块化示例应用的代码就很易于阅读。当你开始构建更大的组件库时,你会意识到这种代码模块化和清晰度的重要性。并且随着代码重用程度的加深,你的代码行数也会显著地减少。:)
diff --git a/content/docs/typechecking-with-proptypes.md b/content/docs/typechecking-with-proptypes.md
deleted file mode 100644
index 9b581f8dd9..0000000000
--- a/content/docs/typechecking-with-proptypes.md
+++ /dev/null
@@ -1,239 +0,0 @@
----
-id: typechecking-with-proptypes
-title: 使用 PropTypes 进行类型检查
-permalink: docs/typechecking-with-proptypes.html
-redirect_from:
- - "docs/react-api.html#typechecking-with-proptypes"
----
-
-> 注意:
->
-> 自 React v15.5 起,`React.PropTypes` 已移入另一个包中。请使用 [`prop-types` 库](https://www.npmjs.com/package/prop-types) 代替。
->
->我们提供了一个 [codemod 脚本](/blog/2017/04/07/react-v15.5.0.html#migrating-from-reactproptypes)来做自动转换。
-
-随着你的应用程序不断增长,你可以通过类型检查捕获大量错误。对于某些应用程序来说,你可以使用 [Flow](https://flow.org/) 或 [TypeScript](https://www.typescriptlang.org/) 等 JavaScript 扩展来对整个应用程序做类型检查。但即使你不使用这些扩展,React 也内置了一些类型检查的功能。要在组件的 props 上进行类型检查,你只需配置特定的 `propTypes` 属性:
-
-```javascript
-import PropTypes from 'prop-types';
-
-class Greeting extends React.Component {
- render() {
- return (
- Hello, {this.props.name}
- );
- }
-}
-
-Greeting.propTypes = {
- name: PropTypes.string
-};
-```
-
-在此示例中,我们使用的是 class 组件,但是同样的功能也可用于函数组件,或者是由 [`React.memo`](/docs/react-api.html#reactmemo)/[`React.forwardRef`](/docs/react-api.html#reactforwardref) 创建的组件。
-
-`PropTypes` 提供一系列验证器,可用于确保组件接收到的数据类型是有效的。在本例中, 我们使用了 `PropTypes.string`。当传入的 `prop` 值类型不正确时,JavaScript 控制台将会显示警告。出于性能方面的考虑,`propTypes` 仅在开发模式下进行检查。
-
-### PropTypes {#proptypes}
-
-以下提供了使用不同验证器的例子:
-
-```javascript
-import PropTypes from 'prop-types';
-
-MyComponent.propTypes = {
- // 你可以将属性声明为 JS 原生类型,默认情况下
- // 这些属性都是可选的。
- optionalArray: PropTypes.array,
- optionalBool: PropTypes.bool,
- optionalFunc: PropTypes.func,
- optionalNumber: PropTypes.number,
- optionalObject: PropTypes.object,
- optionalString: PropTypes.string,
- optionalSymbol: PropTypes.symbol,
-
- // 任何可被渲染的元素(包括数字、字符串、元素或数组)
- // (或 Fragment) 也包含这些类型。
- optionalNode: PropTypes.node,
-
- // 一个 React 元素。
- optionalElement: PropTypes.element,
-
- // 一个 React 元素类型(即,MyComponent)。
- optionalElementType: PropTypes.elementType,
-
- // 你也可以声明 prop 为类的实例,这里使用
- // JS 的 instanceof 操作符。
- optionalMessage: PropTypes.instanceOf(Message),
-
- // 你可以让你的 prop 只能是特定的值,指定它为
- // 枚举类型。
- optionalEnum: PropTypes.oneOf(['News', 'Photos']),
-
- // 一个对象可以是几种类型中的任意一个类型
- optionalUnion: PropTypes.oneOfType([
- PropTypes.string,
- PropTypes.number,
- PropTypes.instanceOf(Message)
- ]),
-
- // 可以指定一个数组由某一类型的元素组成
- optionalArrayOf: PropTypes.arrayOf(PropTypes.number),
-
- // 可以指定一个对象由某一类型的值组成
- optionalObjectOf: PropTypes.objectOf(PropTypes.number),
-
- // 可以指定一个对象由特定的类型值组成
- optionalObjectWithShape: PropTypes.shape({
- color: PropTypes.string,
- fontSize: PropTypes.number
- }),
-
- // An object with warnings on extra properties
- optionalObjectWithStrictShape: PropTypes.exact({
- name: PropTypes.string,
- quantity: PropTypes.number
- }),
-
- // 你可以在任何 PropTypes 属性后面加上 `isRequired` ,确保
- // 这个 prop 没有被提供时,会打印警告信息。
- requiredFunc: PropTypes.func.isRequired,
-
- // 任意类型的必需数据
- requiredAny: PropTypes.any.isRequired,
-
- // 你可以指定一个自定义验证器。它在验证失败时应返回一个 Error 对象。
- // 请不要使用 `console.warn` 或抛出异常,因为这在 `oneOfType` 中不会起作用。
- customProp: function(props, propName, componentName) {
- if (!/matchme/.test(props[propName])) {
- return new Error(
- 'Invalid prop `' + propName + '` supplied to' +
- ' `' + componentName + '`. Validation failed.'
- );
- }
- },
-
- // 你也可以提供一个自定义的 `arrayOf` 或 `objectOf` 验证器。
- // 它应该在验证失败时返回一个 Error 对象。
- // 验证器将验证数组或对象中的每个值。验证器的前两个参数
- // 第一个是数组或对象本身
- // 第二个是他们当前的键。
- customArrayProp: PropTypes.arrayOf(function(propValue, key, componentName, location, propFullName) {
- if (!/matchme/.test(propValue[key])) {
- return new Error(
- 'Invalid prop `' + propFullName + '` supplied to' +
- ' `' + componentName + '`. Validation failed.'
- );
- }
- })
-};
-```
-
-### 限制单个元素 {#requiring-single-child}
-
-你可以通过 `PropTypes.element` 来确保传递给组件的 children 中只包含一个元素。
-
-```javascript
-import PropTypes from 'prop-types';
-
-class MyComponent extends React.Component {
- render() {
- // 这必须只有一个元素,否则控制台会打印警告。
- const children = this.props.children;
- return (
-
- {children}
-
- );
- }
-}
-
-MyComponent.propTypes = {
- children: PropTypes.element.isRequired
-};
-```
-
-### 默认 Prop 值 {#default-prop-values}
-
-您可以通过配置特定的 `defaultProps` 属性来定义 `props` 的默认值:
-
-```javascript
-class Greeting extends React.Component {
- render() {
- return (
- Hello, {this.props.name}
- );
- }
-}
-
-// 指定 props 的默认值:
-Greeting.defaultProps = {
- name: 'Stranger'
-};
-
-// 渲染出 "Hello, Stranger":
-const root = ReactDOM.createRoot(document.getElementById('example'));
-root.render();
-```
-
-从 ES2022 开始,你也可以在 React 类组件中将 `defaultProps` 声明为静态属性。欲了解更多信息,请参阅 [class public static fields](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Classes/Public_class_fields#public_static_fields)。这种现代语法需要添加额外的编译步骤才能在老版浏览器中工作。
-
-```javascript
-class Greeting extends React.Component {
- static defaultProps = {
- name: 'stranger'
- }
-
- render() {
- return (
- Hello, {this.props.name}
- )
- }
-}
-```
-
-`defaultProps` 用于确保 `this.props.name` 在父组件没有指定其值时,有一个默认值。`propTypes` 类型检查发生在 `defaultProps` 赋值后,所以类型检查也适用于 `defaultProps`。
-
-### 函数组件 {#function-components}
-
-如果你在常规开发中使用函数组件,那你可能需要做一些适当的改动,以保证 PropsTypes 应用正常。
-
-假设你有如下组件:
-
-```javascript
-export default function HelloWorldComponent({ name }) {
- return (
- Hello, {name}
- )
-}
-```
-
-如果要添加 PropTypes,你可能需要在导出之前以单独声明的一个函数的形式,声明该组件,具体代码如下:
-
-```javascript
-function HelloWorldComponent({ name }) {
- return (
- Hello, {name}
- )
-}
-
-export default HelloWorldComponent
-```
-
-接着,可以直接在 `HelloWorldComponent` 上添加 PropTypes:
-
-```javascript
-import PropTypes from 'prop-types'
-
-function HelloWorldComponent({ name }) {
- return (
- Hello, {name}
- )
-}
-
-HelloWorldComponent.propTypes = {
- name: PropTypes.string
-}
-
-export default HelloWorldComponent
-```
diff --git a/content/docs/uncontrolled-components.md b/content/docs/uncontrolled-components.md
deleted file mode 100644
index 9f7dc04e9f..0000000000
--- a/content/docs/uncontrolled-components.md
+++ /dev/null
@@ -1,93 +0,0 @@
----
-id: uncontrolled-components
-title: 非受控组件
-permalink: docs/uncontrolled-components.html
----
-
-> Try the new React documentation.
->
-> These new documentation pages teach modern React and include live examples:
->
-> - [``](https://beta.reactjs.org/reference/react-dom/components/input)
-> - [`