React 是一个由 Facebook 开发的流行的 JavaScript 库，用于构建交互式用户界面。它采用了一种基于组件化的开发模式，使得开发人员可以将 UI 拆分为独立的、可复用的组件，并由这些组件构建复杂的用户界面。

React 的主要特点包括：

组件化开发：React 将 UI 拆分为独立的、可复用的组件，开发人员可以将这些组件组合在一起构建复杂的用户界面；
虚拟 DOM：React 采用虚拟 DOM 技术来优化 UI 更新性能，通过比较前后状态的差异来最小化 DOM 操作；
单向数据流：React 中的数据流是单向的，数据由父组件传递给子组件，子组件不能直接修改父组件的数据；
JSX：React 支持使用 JSX 语法，将组件的结构和样式与 JavaScript 代码结合在一起，使得代码更加简洁和易于理解。
React 生态系统非常丰富，包括许多与 React 相关的库和工具，如 Redux、React Router、Webpack 等，可帮助开发人员更好地使用 React 构建应用程序。

React 在 Web 开发、移动应用开发和桌面应用开发等领域得到了广泛应用，并且在社区中有着非常活跃的开发者和贡献者。如果您想要学习构建交互式用户界面的技术，React 是一个非常不错的选择。

React

React 函数组件（Function Components）通常是通过函数名称自动获得它们的 `displayName`。但是在某些情况下，你可能需要手动设置或修改这个值，特别是在使用高阶组件（HOC）或类似情况下，这有助于更好地在开发者工具中识别组件。

为了在函数组件中手动设置 `displayName`，你可以如下操作：

```jsx
// 定义你的函数组件
const MyComponent = () => {
  // 组件逻辑
  return <div>Some content</div>;
};

// 手动设置 displayName
MyComponent.displayName = 'CustomDisplayName';

export default MyComponent;
```

在上面的示例中，即使组件的名字是 `MyComponent`，在 React 开发者工具中显示的名字将会是 `CustomDisplayName`。

当你使用组件表达式或者是将组件导出为其他组件的属性时，设置 `displayName` 尤其有用。例如：

```jsx
const SomeLibrary = {
  // ...
};

SomeLibrary.MyComponent = () => {
  return <div>Library content</div>;
};

SomeLibrary.MyComponent.displayName = 'SomeLibrary.MyComponent';

export { SomeLibrary };
```

在这个示例中，我们给 `SomeLibrary` 对象的 `MyComponent` 属性设置了一个 `displayName`，它可以帮助开发者在使用该库的组件时更清晰地识别组件层级关系。

Rreact 如何在 Function 组件中设置 displayName

在React中预加载图表资源是一个重要的优化策略，特别是在处理大型图表或在需要快速加载和渲染的应用程序中。这里有几种方法可以实现预加载图表资源：

### 1. 图片资源的预加载

对于图表依赖的外部图片资源，可以在React组件加载前就开始加载这些资源。这样可以确保当组件渲染时，相关的图表图片已经加载完毕。

**例子：**

假设我们有一个图表组件，它需要一张背景图：

```javascript
import React from 'react';

class ChartComponent extends React.Component {
  constructor(props) {
    super(props);
    this.state = {
      backgroundImageLoaded: false
    };
  }

  componentDidMount() {
    const image = new Image();
    image.src = 'path/to/your/image.jpg';
    image.onload = () => {
      this.setState({ backgroundImageLoaded: true });
    };
  }

  render() {
    if (!this.state.backgroundImageLoaded) {
      return <div>Loading...</div>;
    }

    return (
      <div style={{ backgroundImage: `url('path/to/your/image.jpg')` }}>
        {/* Chart rendering logic here */}
      </div>
    );
  }
}
```

### 2. 数据资源的预加载

如果图表依赖于异步获取的数据，可以在组件挂载前或挂载初期就开始抓取数据。

**例子：**

```javascript
import React, { useEffect, useState } from 'react';

function ChartComponent() {
  const [chartData, setChartData] = useState(null);

  useEffect(() => {
    async function fetchData() {
      const response = await fetch('path/to/your/data/api');
      const data = await response.json();
      setChartData(data);
    }

    fetchData();
  }, []);

  if (!chartData) {
    return <div>Loading data...</div>;
  }

  return (
    <div>
      {/* Render your chart with chartData */}
    </div>
  );
}
```

### 3. 懒加载（Lazy Loading）

对于非初次加载的关键视图，可以使用React的 `React.lazy` 和 `Suspense` 来实现组件的懒加载。这样可以加速应用的首屏加载速度，而将非关键资源的加载推迟到后面。

**例子：**

```javascript
import React, { Suspense } from 'react';
const LazyChartComponent = React.lazy(() => import('./ChartComponent'));

function App() {
  return (
    <div>
      <Suspense fallback={<div>Loading chart...</div>}>
        <LazyChartComponent />
      </Suspense>
    </div>
  );
}
```

通过这些策略，React应用能更有效地管理资源，提升用户体验。这在数据密集或需要高性能的图表显示场景中特别有用。

React 如何预加载图表资源？

在React中，有多种方法可以呈现多行文本字符串。以下是几种常见的方法：

### 1. 使用字符串模板（Template literals）

在JSX中，你可以使用ES6的字符串模板（也称为模板字符串）来嵌入变量或表达式。当你需要展示多行文本时，可以利用模板字符串内自然的换行功能。例如：

```jsx
const multiLineText = `第一行文本
第二行文本
第三行文本`;

function App() {
  return <div>{multiLineText}</div>;
}
```

这种方式非常直观，代码也易于理解，非常适合不包含复杂逻辑或标签的简单多行文本。

### 2. 使用数组

如果每一行都需要特定的样式或处理，可以将每行作为数组的一个元素，然后在JSX中遍历这个数组。每个元素都可以用 `<div>` 或 `<p>` 标签包围，这样每行都会自然地显示在新的一行。例如：

```jsx
const lines = [
  "第一行文本",
  "第二行文本",
  "第三行文本"
];

function App() {
  return (
    <div>
      {lines.map((line, index) => (
        <div key={index}>{line}</div>
      ))}
    </div>
  );
}
```

这种方法的好处是可以轻松地对每一行文本应用样式或执行其他JS逻辑。

### 3. 使用CSS样式

可以通过CSS来控制文本的显示方式。在JSX中，可以将整个文本作为一个字符串传递，然后使用CSS的 `white-space` 属性来保持文本的换行。你可以设置 `white-space: pre-wrap;` 来保持源文本中的所有空白和换行。例如：

```jsx
const multiLineText = "第一行文本\n第二行文本\n第三行文本";

function App() {
  return (
    <div style={{ whiteSpace: "pre-wrap" }}>
      {multiLineText}
    </div>
  );
}
```

`pre-wrap` 会保留换行符和空白符，同时也会自动换行长文本。

### 总结

选择哪种方法取决于具体的需求。如果你只是需要简单地显示多行文本，使用模板字符串可能是最简单的方法。如果需要对每行进行更复杂的处理或样式应用，使用数组的方法会更合适。而CSS的方法则适合于控制长文本的断行和空白的展示。每种方法都有其适用场景，可以根据实际情况灵活选择。

React 如何呈现多行文本字符串

在使用React开发应用时，默认情况下，开发服务器会运行在端口3000上。但如果这个端口已经被其他服务占用，或者你出于其他原因需要更改端口，可以很容易地将其更改为其他端口。

更改React应用的默认端口可以通过修改启动脚本来实现。这主要是通过设置环境变量`PORT`来完成的。这里有几种方法来设置这个环境变量：

### 方法一：直接在命令行中设置

你可以在启动应用时直接在命令行中指定`PORT`环境变量。例如，如果你使用的是npm作为你的包管理器，你可以这样做：

```bash
PORT=5000 npm start
```

这条命令会将React应用的端口设置为5000。如果你使用的是Yarn，相应的命令将是：

```bash
PORT=5000 yarn start
```

### 方法二：修改`package.json`

另一个常见的方法是在`package.json`中修改`scripts`段。这样每次启动时都会自动使用新的端口，而无需每次都手动设置。你可以这样修改：

```json
{
  "scripts": {
    "start": "PORT=5000 react-scripts start",
    "build": "react-scripts build",
    "test": "react-scripts test",
    "eject": "react-scripts eject"
  }
}
```

这里，我们修改了`start`脚本，将PORT环境变量设置为5000。

### 方法三：使用.env文件

对于更持久的环境变量设置，可以使用`.env`文件。创建一个名为`.env`的文件在项目根目录中，并添加以下内容：

```
PORT=5000
```

这样，每次启动项目时，`create-react-app`都会自动读取`.env`文件中的设置。

### 示例用例

假设你正在开发一个项目，其中包含了一个后端API和一个前端React应用。后端API占用了端口3000，因此你需要将React应用的端口更改为5000。使用上述任何一种方法更改端口后，你就可以同时运行这两个服务，而不会发生端口冲突。

总的来说，更改端口是一个简单的过程，可以通过多种方式完成，根据你的项目需求和偏好选择最合适的方法。

如何将 react 中的默认端口从 3000 更改为另一个端口？

在ReactJS中，子组件可以通过props调用父组件的方法。父组件可以将一个方法作为prop传递给子组件，然后子组件可以在适当的时候调用这个方法。这是React中实现组件间通信的常见方式之一。

以下是一个简单的例子来说明这个过程：

首先，我们有一个父组件，它有一个方法 `handleParentMethod`，我们想从子组件中调用这个方法。

```jsx
class ParentComponent extends React.Component {
  handleParentMethod = () => {
    console.log('父组件的方法被调用！');
  };

  render() {
    return (
      <div>
        <ChildComponent callParentMethod={this.handleParentMethod} />
      </div>
    );
  }
}
```

在上面的代码中，`ParentComponent` 有一个方法 `handleParentMethod`，并将其作为prop `callParentMethod` 传递给 `ChildComponent`。

接下来是子组件，它接收 `callParentMethod` 作为prop，并在需要的时候调用它，比如在按钮点击事件中。

```jsx
class ChildComponent extends React.Component {
  render() {
    // 从props中解构出来父组件传递的方法
    const { callParentMethod } = this.props;

    return (
      <button onClick={callParentMethod}>
        调用父组件方法
      </button>
    );
  }
}
```

在这个例子中，当用户点击按钮时，`ChildComponent` 将调用 `callParentMethod`，实际上这个方法是在 `ParentComponent` 中定义的 `handleParentMethod`。这样我们就能看到控制台打印出 "父组件的方法被调用！"。

这种模式很有用，尤其是在将状态管理保留在父组件中，而需要子组件来触发更新这种状态时。这是React中提倡的自顶向下数据流的典型应用。

ReactJS 如何在子组件中调用父组件的方法？

在TypeScript中，`.tsx`扩展名是专门用于支持JSX语法的文件，这通常用于React项目中。使用`.tsx`扩展名而不是`.ts`主要的缺点是以下几点：

1. **性能问题**：当你不需要使用JSX语法时，依然使用`.tsx`可能会导致编译器无谓的解析JSX，这可能会轻微增加编译时间。

2. **项目清晰性**：在项目中混用`.tsx`和`.ts`可以帮助开发者快速识别哪些文件是涉及UI的React组件，哪些是纯TypeScript代码。如果全部使用`.tsx`，这种区分就不明显了，可能会使得项目结构和文件的意图不够清晰。

3. **工具和环境支持**：虽然大多数现代开发环境和工具都支持`.tsx`，但在某些情况下，特定的工具或旧版本的编辑器可能对`.tsx`支持不如对`.ts`那样成熟。这可能导致语法高亮、代码提示等功能出现问题。

4. **学习曲线**：对于新加入项目的开发者，如果项目中所有的文件都是`.tsx`，即使很多中并不包含JSX，这可能会增加他们的学习曲线，因为他们需要理解为什么非组件代码也使用了`.tsx`扩展名。

总结来说，虽然在技术上可以在不使用JSX的情况下使用`.tsx`扩展名，但为了保持代码的清晰性、最优的工具支持和编译性能，建议只在确实包含JSX的React组件中使用`.tsx`，其他纯TypeScript代码使用`.ts`扩展名。这样做可以帮助提高项目的可维护性和降低新成员的入门难度。

在typescript中一直使用.tsx而不是.ts有什么缺点吗？

在React Native中，要获取`ScrollView`的当前滚动位置，我们可以使用`onScroll`事件来监听滚动，并结合`scrollEventThrottle`属性来控制事件触发的频率。此外，我们还需要使用一个引用（`ref`）来确保我们可以访问到`ScrollView`组件的实例。

下面是一个具体的例子来说明如何实现：

首先，我们需要在`ScrollView`组件中设置`onScroll`事件处理器，并通过`event`参数获取滚动位置信息。我们还需要设置`scrollEventThrottle`属性，这个属性决定了滚动事件处理函数被调用的频率，单位是毫秒。

```javascript
import React, { useRef } from 'react';
import { ScrollView, Text, View, StyleSheet } from 'react-native';

const ScrollExample = () => {
    const scrollViewRef = useRef(null);

    const handleScroll = (event) => {
        const scrollPosition = event.nativeEvent.contentOffset.y;
        console.log('当前滚动位置:', scrollPosition);
    };

    return (
        <View style={styles.container}>
            <ScrollView
                ref={scrollViewRef}
                onScroll={handleScroll}
                scrollEventThrottle={16} // 这里设置为16毫秒，意味着每秒最多处理60次滚动事件（1000ms/16ms ≈ 60）
                style={styles.scrollViewStyle}
            >
                {Array.from({ length: 50 }, (_, index) => (
                    <Text style={styles.textStyle} key={index}>
                        Item {index + 1}
                    </Text>
                ))}
            </ScrollView>
        </View>
    );
};

const styles = StyleSheet.create({
    container: {
        flex: 1,
        paddingTop: 50,
    },
    scrollViewStyle: {
        marginHorizontal: 20,
    },
    textStyle: {
        marginVertical: 20,
        fontSize: 20,
        textAlign: 'center',
    },
});

export default ScrollExample;
```

在这个例子中，当用户滚动屏幕时，`handleScroll`函数会被调用，我们可以通过`event.nativeEvent.contentOffset.y`属性来访问垂直方向上的滚动位置。我们设置了`scrollEventThrottle`为16，这意味着函数调用的频率为大约每秒60次，这个设置旨在平衡性能和响应速度。

通过这种方式，我们可以实时获取`ScrollView`中的当前滚动位置，并进行相应的处理，例如触发特定的动画或者更新状态。

获取React Native中ScrollView的当前滚动位置

在ReactJS中，通常我们不直接从HTML字符串转换到JSX，因为这样做可能会引入安全风险，例如跨站脚本（XSS）攻击。然而，有时候，特别是在从外部API获取数据时，我们可能需要将HTML字符串渲染到React组件中。这种情况下，我们可以使用`dangerouslySetInnerHTML`属性来实现。

### 使用 `dangerouslySetInnerHTML`

`dangerouslySetInnerHTML` 是React的一个属性，允许你设置组件的innerHTML。它被命名为 "dangerously" 是因为使用它可能会让你的应用容易受到XSS攻击。因此，如果你决定使用这个属性，你需要确保你加载的HTML是安全的。

**示例代码**：

```jsx
function HtmlComponent({ htmlString }) {
  return <div dangerouslySetInnerHTML={{ __html: htmlString }} />;
}

const htmlString = '<p>Hello, <strong>world</strong>!</p>';
const App = () => {
  return <HtmlComponent htmlString={htmlString} />;
};

export default App;
```

在这个例子中，`HtmlComponent`接收一个名为`htmlString`的prop，这个prop包含了要渲染的HTML字符串。通过将这个字符串作为`__html`键的值传递给`dangerouslySetInnerHTML`，React会将这个字符串解析为HTML而不是文本，从而渲染格式化的HTML内容。

### 安全考虑

如果你从不可信的源接收HTML内容，你应该在将其传递给`dangerouslySetInnerHTML`之前对其进行清理，以确保没有恶意脚本。可以使用如`dompurify`等库来消毒HTML内容。

**示例使用dompurify**：

```jsx
import DOMPurify from 'dompurify';

function SafeHtmlComponent({ htmlString }) {
  const safeHtml = DOMPurify.sanitize(htmlString);
  return <div dangerouslySetInnerHTML={{ __html: safeHtml }} />;
}

const unsafeHtmlString = '<p>Hello, <script>alert("Hacked!")</script><strong>world</strong>!</p>';
const App = () => {
  return <SafeHtmlComponent htmlString={unsafeHtmlString} />;
};

export default App;
```

在这个例子中，我们使用`DOMPurify.sanitize`来清洗HTML字符串，确保它不包含任何恶意脚本，然后再使用`dangerouslySetInnerHTML`进行渲染。

### 结论

虽然直接从HTML字符串到JSX的转换不是React推荐的做法，但通过使用`dangerouslySetInnerHTML`和适当的安全措施，我们可以安全地将HTML内容集成到React应用中。总是确保对任何从外部来源获取的HTML进行清洁处理，以保护你的应用免受XSS攻击。

ReactJS 如何将 HTML 字符串转换为 JSX ？

在React Router v6中，重定向的方式与之前的版本略有不同。v6版本中移除了`<Redirect>`组件，取而代之的是`<Navigate>`组件。这里我会先说明如何使用`<Navigate>`组件来实现重定向，然后提供一个具体的例子。

### 使用`<Navigate>`组件实现重定向

在React Router v6中，如果你想在组件中进行重定向，可以使用`<Navigate>`组件。这个组件接受一个`to`属性，该属性指定了重定向的目标地址。

#### 基本用法

```jsx
import { Navigate } from 'react-router-dom';

function MyComponent() {
  const loggedIn = false; // 假设这是根据应用状态得到的登录状态

  if (!loggedIn) {
    return <Navigate to="/login" />;
  }

  return <div>欢迎回来!</div>;
}
```

在上面的例子中，如果用户没有登录（`loggedIn`为`false`），则会自动将用户重定向到`/login`路径。

### 条件重定向

假设你有一个只有管理员权限的用户才能访问的页面，你可以在渲染组件前检查用户的权限，然后决定是否重定向。

```jsx
function AdminPage() {
  const isAdmin = userHasAdminRole(); // 你需要实现这个函数来判断用户是否为管理员

  if (!isAdmin) {
    return <Navigate to="/home" replace />;
  }

  return <div>管理员页面</div>;
}
```

在这个例子中，如果用户不是管理员，他们将被重定向到首页(`/home`)。这里的`replace`属性是可选的，它决定浏览器历史记录中的当前页面是否被替换掉，而不是添加一个新的记录。

### 总结

使用`<Navigate>`组件进行重定向是React Router v6推荐的方式。它简单直接，通过`to`属性指定重定向的路径，可以灵活地应用在组件的任何地方，以满足不同的业务逻辑需求。

如何在 React Router v6 中重定向？

在使用 `create-react-app` 构建React应用程序时，您可以通过在项目的根目录下创建一个 `.env` 文件来设置环境变量。环境变量在 `.env` 文件中是以 `REACT_APP_` 的前缀开始的。这是 `create-react-app` 的约定，用以确保只有以 `REACT_APP_` 开头的环境变量才会被嵌入到构建中的应用程序里。

如果您想在构建时添加特定的变量，您可以按照以下步骤操作：

1. 在项目的根目录下创建一个新的文件，命名为 `.env`。
2. 在 `.env` 文件中添加环境变量，确保以 `REACT_APP_` 开头，例如：
   ```
   REACT_APP_API_URL=https://myapi.com
   REACT_APP_FEATURE_FLAG=true
   ```
3. 在您的React代码中，您可以通过 `process.env.REACT_APP_API_URL` 和 `process.env.REACT_APP_FEATURE_FLAG` 来访问这些变量。

如果您需要为不同的环境（开发、测试、生产）设置不同的变量，您也可以创建特定环境的 `.env` 文件，例如：

- `.env.local`：本地开发环境变量。
- `.env.development`：开发环境变量。
- `.env.test`：测试环境变量。
- `.env.production`：生产环境变量。

当您运行 `npm run build` 或 `yarn build` 时，`create-react-app` 构建脚本将会默认使用 `.env.production` 中的变量。

例如，如果您想在生产环境中设置一个API URL，您可以这样做：

1. 在项目根目录下创建 `.env.production` 文件。
2. 添加如下内容：
   ```
   REACT_APP_API_URL=https://production.api.com
   ```
3. 当您运行构建脚本时，`REACT_APP_API_URL` 将被设置为 "https://production.api.com"。

确保在将代码推送到版本控制系统（如Git）之前，不要在 `.env` 文件中包含敏感信息（如密码或API密钥）。通常这些敏感信息应该通过安全的方式提供，比如通过CI/CD管道中的环境变量配置。

在运行create-react-app构建脚本时，如何设置build.env变量？

在使用Jest进行异步代码的单元测试时，确保所有的异步操作都完成后再进行`expect`断言是非常重要的。这可以通过几种方法实现：

### 1. 使用`done`回调

Jest提供了一个`done`回调参数，可以用于测试函数。当你在异步测试中调用了`done()`函数，Jest就会知道你的异步操作已经完成，接下来可以安全地执行断言。

**示例代码：**

```javascript
test('异步测试示例 with done', done => {
  setTimeout(() => {
    expect(true).toBe(true);
    done();
  }, 1000);
});
```

在这个例子中，我们在`setTimeout`的回调函数中调用了`done()`来告诉Jest异步代码执行完毕。

### 2. 返回Promise

如果你的函数返回一个Promise，Jest会等待这个Promise解决(resolve)后再继续执行测试。这在处理Promise-based的异步代码时非常方便。

**示例代码：**

```javascript
function fetchData() {
  return new Promise(resolve => resolve("data"));
}

test('异步测试示例 with Promise', () => {
  return fetchData().then(data => {
    expect(data).toBe("data");
  });
});
```

在这个例子中，`fetchData`返回一个解决为"data"的Promise，Jest会等待这个Promise解决后再执行断言。

### 3. 使用Async/Await

`async/await`是处理异步JavaScript代码的一种现代且清晰的方式。在你的测试函数前加上`async`关键字，并在调用返回Promise的函数时使用`await`。

**示例代码：**

```javascript
async function fetchData() {
  return "data";
}

test('异步测试示例 with async/await', async () => {
  const data = await fetchData();
  expect(data).toBe("data");
});
```

在这个例子中，通过`await fetchData()`，Jest会等待`fetchData`的Promise解决，并将解决的值赋给`data`，然后执行断言。

### 总结

选择哪种方法取决于你的具体需求和你的代码风格。如果你的异步逻辑使用了`callback`，可能`done`方法是一个好选择；如果你的代码库广泛使用`Promise`或`async/await`，那么后两种方法可能更适合你。使用这些方法可以确保在执行断言之前，所有的异步代码都已经正确完成。

如何让 Jest 等待所有异步代码完成执行后再 expect

在React的JSX语法中，双大括号`{{}}`通常有两个主要的用途：

1. **表示对象字面量**：当你需要传递一个对象作为属性（props）给一个React组件时，你会使用双花括号。第一对花括号`{}`是JSX语法表示我们要写JavaScript表达式，第二对花括号`{}`实际上是JavaScript对象字面量的标记。

   例如，假设我们有一个`style`对象，我们想要将它作为属性传递给一个div元素：

   ```jsx
   const divStyle = {
     color: 'blue',
     backgroundColor: 'lightgray',
   };

   function App() {
     return <div style={{ color: 'blue', backgroundColor: 'lightgray' }}>Hello, world!</div>;
   }
   ```

   在这个例子中，`style`属性接收一个对象，对象中定义了CSS样式。这里的`{{ color: 'blue', backgroundColor: 'lightgray' }}`就是双大括号的用法，第一对大括号告诉JSX我们要写JavaScript代码，第二对大括号创建了一个对象。

2. **绑定行内样式**：当你需要为React元素直接应用行内样式时，你会用到双大括号。第一对大括号表示我们正在插入一个JavaScript表达式，而内部的大括号表示一个样式对象。

   例如，如果你想给一个元素直接设置样式：

   ```jsx
   function App() {
     return <div style={{ fontSize: '16px', fontWeight: 'bold' }}>Hello, style!</div>;
   }
   ```

   这里，`fontSize`和`fontWeight`是CSS属性的JavaScript表示（驼峰命名法），而`'16px'`和`'bold'`是这些属性的值。使用双大括号可以让我们将这个对象直接作为`style`属性的值传递给元素。

总之，双大括号在React的JSX中被用来内嵌JavaScript表达式，并创建对象字面量，尤其在传递props和绑定行内样式时。这是JSX的一种语法糖，让我们能够在声明式的UI代码中更为紧密地集成JavaScript逻辑。

React 的 JSX 语法中使用双大括号的作用是什么？

`withRouter` 是 `react-router-dom` 库中的一个高阶组件（Higher-Order Component，简称 HOC），它的功能是向组件提供路由相关的 `props`（如 `history`, `location`, `match` 等），即使这些组件不是路由组件（即直接由 `<Route>` 渲染的组件）。

使用 `withRouter` 可以使得那些深层嵌套的组件也能够访问到路由信息，这在很多情况下非常有用，尤其是当一个组件需要知道当前的路由状态但又不在路由树中直接被 `<Route>` 包裹时。

### 使用例子：

假设我们有一个 `UserProfile` 组件，它显示用户的详情，但位于应用的深层次结构中，而非直接由 `<Route>` 渲染。为了在 `UserProfile` 中获取当前的路由信息（比如 URL 中的用户ID），我们可以使用 `withRouter` 来增强它：

```javascript
import React from 'react';
import { withRouter } from 'react-router-dom';

class UserProfile extends React.Component {
    componentDidMount() {
        // 访问路由参数
        let userId = this.props.match.params.userId;
        this.fetchUserData(userId);
    }

    fetchUserData(userId) {
        fetch(`/api/users/${userId}`)
            .then(response => response.json())
            .then(data => {
                // 处理用户数据
                console.log(data);
            });
    }

    render() {
        return (
            <div>
                <h1>User Profile</h1>
                {/* 显示用户信息 */}
            </div>
        );
    }
}

// 使用 withRouter 高阶组件包裹 UserProfile 组件
export default withRouter(UserProfile);
```

在这个例子中，`UserProfile` 组件本身并不直接接收路由的 props，但通过使用 `withRouter`，它能够访问 `this.props.match.params.userId` 来获取 URL 中的用户ID，然后根据用户ID获取并显示用户的数据。

这样，`UserProfile` 就能够灵活地被放置在应用的任何位置，而无需担心如何接收到路由信息。

在 react - router - dom 中，什么是 withRouter ？

在ReactJS中，将文本复制到剪贴板通常可以通过使用原生的JavaScript API来实现，比如`document.execCommand`或更现代的`navigator.clipboard.writeText`。以下是两种常见的方法：

### 方法一：使用 `document.execCommand`

这是较老的方法，但支持较广，包括一些老版本的浏览器：

```jsx
class CopyToClipboard extends React.Component {
  copyText = () => {
    // 选择你要复制的文本
    this.textArea.select();
    // 执行复制命令
    document.execCommand('copy');
  };

  render() {
    return (
      <div>
        <textarea
          ref={(textarea) => this.textArea = textarea}
          value="我是要被复制的文本！"
        />
        <button onClick={this.copyText}>复制文本</button>
      </div>
    );
  }
}
```

在这个例子中，我们创建了一个文本框和一个按钮，点击按钮时会触发`copyText`方法，该方法通过选择文本框中的文本并使用`document.execCommand('copy')`来实现复制功能。

### 方法二：使用 `navigator.clipboard.writeText`

这是一种更现代的方法，推荐使用，因为它更为简洁和安全：

```jsx
const CopyToClipboard = () => {
  const textToCopy = "我是要被复制的文本！";

  const copyText = async () => {
    try {
      // 使用navigator.clipboard API复制文本
      await navigator.clipboard.writeText(textToCopy);
      console.log('文本复制成功！');
    } catch (err) {
      console.error('复制失败: ', err);
    }
  };

  return (
    <div>
      <button onClick={copyText}>复制文本</button>
    </div>
  );
}
```

在这个例子中，我们使用了`navigator.clipboard.writeText`来复制文本。这个方法返回一个promise，所以我们可以通过`async`和`await`处理它，并在复制成功或失败时得到通知。

在实际应用中，推荐使用`navigator.clipboard`的方法，因为它较为现代且更安全（例如，它需要HTTPS连接），而且提供了更好的错误处理机制。不过，需要注意的是，老版本的浏览器可能不支持这个API。

在reactJS中，如何将文本复制到剪贴板？

在React Native中隐藏键盘是一个常见的需求，特别是在处理表单输入时。React Native提供了几种方法来实现键盘的隐藏，以下是几种常用的方法：

### 1. 使用`Keyboard`模块的`dismiss`方法

React Native的`Keyboard`模块提供了一个非常直接的方法来隐藏键盘，即使用`dismiss`方法。这是一个很简单而直接的解决方案，适用于大多数情况。这里是一个使用的例子：

```javascript
import React from 'react';
import { View, TextInput, Button, Keyboard } from 'react-native';

const App = () => {
  return (
    <View>
      <TextInput placeholder="在这里输入内容" />
      <Button title="隐藏键盘" onPress={() => Keyboard.dismiss()} />
    </View>
  );
};

export default App;
```

在这个例子中，当用户点击按钮时，`Keyboard.dismiss()`方法会被调用来隐藏键盘。

### 2. 点击背景隐藏键盘

有时候，我们希望用户点击输入框以外的区域时，能自动隐藏键盘。这可以通过在背景视图上添加一个触摸事件来实现。例如：

```javascript
import React from 'react';
import { View, TextInput, TouchableWithoutFeedback, Keyboard } from 'react-native';

const DismissKeyboardView = ({ children }) => (
  <TouchableWithoutFeedback onPress={() => Keyboard.dismiss()}>
    <View style={{ flex: 1 }}>{children}</View>
  </TouchableWithoutFeedback>
);

const App = () => {
  return (
    <DismissKeyboardView>
      <TextInput placeholder="在这里输入内容" />
    </DismissKeyboardView>
  );
};

export default App;
```

在这个例子中，`TouchableWithoutFeedback`组件被用来包裹整个视图，当用户点击输入框以外的任何地方时，触发`onPress`回调，从而调用`Keyboard.dismiss()`隐藏键盘。

### 3. 使用第三方库

除了React Native自带的方法外，还有一些第三方库提供了更加高级的功能来管理键盘，例如`react-native-keyboard-aware-scroll-view`。这个库可以帮助自动管理键盘与输入框之间的间距、自动滚动等功能，也支持通过点击背景来隐藏键盘。

使用这些方法可以有效地在React Native应用中管理键盘的显示与隐藏，根据不同场景选择最适合的方法，可以提升应用的用户体验。

如何在 react native 中隐藏键盘？

当在React组件中设置初始状态时，`构造函数（constructor）`和`getInitialState`是两种不同的方法，它们存在于React组件的不同类型以及不同的React版本中。

首先，`getInitialState`方法是React早期版本中创建类组件的方法之一。在使用`React.createClass`方式创建组件时，`getInitialState`被用于返回组件的初始状态对象。这是一个无需使用`this`关键字的普通方法，因为`React.createClass`自动绑定了所有方法到其实例上。下面是一个使用`getInitialState`的例子：

```javascript
const MyComponent = React.createClass({
  getInitialState: function() {
    return {
      count: 0
    };
  },
  render: function() {
    return <div>{this.state.count}</div>;
  }
});
```

然而，当React引入了ES6类语法后，`getInitialState`方法就被淘汰了，取而代之的是在类的`构造函数（constructor）`中初始化状态。在ES6类组件中，你需要显式调用`super(props)`来继承React.Component的构造函数，并通过`this.state`来设置初始状态。以下是一个使用构造函数设置初始状态的例子：

```javascript
class MyComponent extends React.Component {
  constructor(props) {
    super(props);
    this.state = {
      count: 0
    };
  }

  render() {
    return <div>{this.state.count}</div>;
  }
}
```

总结一下区别：

- `getInitialState`是React早期版本中`React.createClass`的方法，而构造函数是ES6类组件中设置初始状态的方式。
- 在构造函数中，你需要调用`super(props)`并使用`this.state`直接赋值状态对象，而在`getInitialState`中则直接返回状态对象，无需用到`this`。
- React官方推荐使用ES6类组件，因此在新的React代码中，你更可能会见到构造函数而不是`getInitialState`。

React Native中的组件也遵循这些规则，因为React Native是基于React的，所以在设置初始状态时，它们之间的行为是一致的。在React中，构造函数（`constructor`）和`getInitialState`是用来初始化组件状态的两种不同方法，但它们适用于不同的React版本和不同的组件类型。

### `constructor`方法：

在React ES6类组件中，我们使用`constructor`方法来初始化状态。`constructor`是在组件的生命周期中非常早期被调用的方法，它是ES6类的一部分，这意味着它不是React特有的，而是JavaScript语言的一部分。在这个方法中，你可以设置组件的初始状态，也可以为事件处理函数绑定`this`上下文。

```jsx
class MyComponent extends React.Component {
  constructor(props) {
    super(props); // 这一步是必须的，它调用了父类（React.Component）的constructor
    this.state = { /* 初始状态 */ };
  }

  render() {
    // ...
  }
}
```

在这个例子中，`this.state`是在构造函数内初始化的，这是ES6类组件设置初始状态的推荐方式。

### `getInitialState`方法：

`getInitialState`是React早期版本中创建组件的方法，它用于`React.createClass`方式定义的组件中。`React.createClass`是React提供的一种创建组件的辅助方法，它不是JavaScript语言的一部分。在用`React.createClass`创建组件时，您会使用`getInitialState`方法返回组件的初始状态对象。

```jsx
var MyComponent = React.createClass({
  getInitialState: function() {
    return { /* 初始状态 */ };
  },

  render: function() {
    // ...
  }
});
```

从React 16.0版本开始，`React.createClass`方法已经被废弃，并且`getInitialState`不再是初始化状态的推荐方式。因此，如果你正在使用较新版本的React，应当使用ES6类和构造函数来定义组件和初始化状态。

总结来说，React ES6类组件中使用`constructor`方法来初始化状态，而在老式的`React.createClass`定义的组件中使用`getInitialState`方法。自从React 16.0版本以后，`React.createClass`已经被废弃，因此在现代React代码中应当使用`constructor`方法。React Native也遵循这些规则，因为它使用相同的组件模型。

当在React组件中设置初始状态时，`构造函数（constructor）`和`getInitialState`是两种不同的方法，它们存在于React组件的不同类型以及不同的React版本中。

首先，`getInitialState`方法是React早期版本中创建类组件的方法之一。在使用`React.createClass`方式创建组件时，`getInitialState`被用于返回组件的初始状态对象。这是一个无需使用`this`关键字的普通方法，因为`React.createClass`自动绑定了所有方法到其实例上。下面是一个使用`getInitialState`的例子：

```javascript
const MyComponent = React.createClass({
  getInitialState: function() {
    return {
      count: 0
    };
  },
  render: function() {
    return <div>{this.state.count}</div>;
  }
});
```

然而，当React引入了ES6类语法后，`getInitialState`方法就被淘汰了，取而代之的是在类的`构造函数（constructor）`中初始化状态。在ES6类组件中，你需要显式调用`super(props)`来继承React.Component的构造函数，并通过`this.state`来设置初始状态。以下是一个使用构造函数设置初始状态的例子：

```javascript
class MyComponent extends React.Component {
  constructor(props) {
    super(props);
    this.state = {
      count: 0
    };
  }

  render() {
    return <div>{this.state.count}</div>;
  }
}
```

总结一下区别：

- `getInitialState`是React早期版本中`React.createClass`的方法，而构造函数是ES6类组件中设置初始状态的方式。
- 在构造函数中，你需要调用`super(props)`并使用`this.state`直接赋值状态对象，而在`getInitialState`中则直接返回状态对象，无需用到`this`。
- React官方推荐使用ES6类组件，因此在新的React代码中，你更可能会见到构造函数而不是`getInitialState`。

React Native中的组件也遵循这些规则，因为React Native是基于React的，所以在设置初始状态时，它们之间的行为是一致的。

当在React组件中设置初始状态时，`构造函数（constructor）`和`getInitialState`是两种不同的方法，它们存在于React组件的不同类型以及不同的React版本中。

首先，`getInitialState`方法是React早期版本中创建类组件的方法之一。在使用`React.createClass`方式创建组件时，`getInitialState`被用于返回组件的初始状态对象。这是一个无需使用`this`关键字的普通方法，因为`React.createClass`自动绑定了所有方法到其实例上。下面是一个使用`getInitialState`的例子：

```javascript
const MyComponent = React.createClass({
  getInitialState: function() {
    return {
      count: 0
    };
  },
  render: function() {
    return <div>{this.state.count}</div>;
  }
});
```

然而，当React引入了ES6类语法后，`getInitialState`方法就被淘汰了，取而代之的是在类的`构造函数（constructor）`中初始化状态。在ES6类组件中，你需要显式调用`super(props)`来继承React.Component的构造函数，并通过`this.state`来设置初始状态。以下是一个使用构造函数设置初始状态的例子：

```javascript
class MyComponent extends React.Component {
  constructor(props) {
    super(props);
    this.state = {
      count: 0
    };
  }

  render() {
    return <div>{this.state.count}</div>;
  }
}
```

总结一下区别：

- `getInitialState`是React早期版本中`React.createClass`的方法，而构造函数是ES6类组件中设置初始状态的方式。
- 在构造函数中，你需要调用`super(props)`并使用`this.state`直接赋值状态对象，而在`getInitialState`中则直接返回状态对象，无需用到`this`。
- React官方推荐使用ES6类组件，因此在新的React代码中，你更可能会见到构造函数而不是`getInitialState`。

React Native中的组件也遵循这些规则，因为React Native是基于React的，所以在设置初始状态时，它们之间的行为是一致的。
在React中，构造函数（`constructor`）和`getInitialState`是用来初始化组件状态的两种不同方法，但它们适用于不同的React版本和不同的组件类型。

### `constructor`方法：

在React ES6类组件中，我们使用`constructor`方法来初始化状态。`constructor`是在组件的生命周期中非常早期被调用的方法，它是ES6类的一部分，这意味着它不是React特有的，而是JavaScript语言的一部分。在这个方法中，你可以设置组件的初始状态，也可以为事件处理函数绑定`this`上下文。

```jsx
class MyComponent extends React.Component {
  constructor(props) {
    super(props); // 这一步是必须的，它调用了父类（React.Component）的constructor
    this.state = { /* 初始状态 */ };
  }

  render() {
    // ...
  }
}
```

在这个例子中，`this.state`是在构造函数内初始化的，这是ES6类组件设置初始状态的推荐方式。

### `getInitialState`方法：

`getInitialState`是React早期版本中创建组件的方法，它用于`React.createClass`方式定义的组件中。`React.createClass`是React提供的一种创建组件的辅助方法，它不是JavaScript语言的一部分。在用`React.createClass`创建组件时，您会使用`getInitialState`方法返回组件的初始状态对象。

```jsx
var MyComponent = React.createClass({
  getInitialState: function() {
    return { /* 初始状态 */ };
  },

  render: function() {
    // ...
  }
});
```

从React 16.0版本开始，`React.createClass`方法已经被废弃，并且`getInitialState`不再是初始化状态的推荐方式。因此，如果你正在使用较新版本的React，应当使用ES6类和构造函数来定义组件和初始化状态。

总结来说，React ES6类组件中使用`constructor`方法来初始化状态，而在老式的`React.createClass`定义的组件中使用`getInitialState`方法。自从React 16.0版本以后，`React.createClass`已经被废弃，因此在现代React代码中应当使用`constructor`方法。React Native也遵循这些规则，因为它使用相同的组件模型。

在React/Rect Native中使用构造函数与getInitialState有什么区别？

在 Recoil 中，`atomFamily` 是一个工具函数，它允许我们创建一组相关的 atoms，每一个 atom 都有一个独特的参数作为标识。然而，Recoil 原生并没有直接提供一个函数可以一次性获取 `atomFamily` 中所有的元素。但是，我们可以通过跟踪使用过的参数来间接获取所有的元素。

要追踪一个 `atomFamily` 中所有的元素，你可以创建一个 Recoil selector，这个 selector 会追踪每个被创建和使用过的 atom。每次使用 `atomFamily` 的时候，你可以将其参数添加到一个全局的集合中，并通过这个集合来知道哪些 `atomFamily` 的成员是被访问过的。

例如，以下是如何实现这个功能的一个简单例子：

```javascript
import { atomFamily, selector, useRecoilValue } from 'recoil';

// 定义一个用于追踪访问过的 atomFamily 成员的集合
const atomFamilyParametersSet = new Set();

// 一个示例 atomFamily
const myAtomFamily = atomFamily({
  key: 'MyAtomFamily',
  default: param => {
    // 这里添加逻辑来确定你的默认值
    return defaultValueBasedOnParam(param);
  },
  effects_UNSTABLE: param => [
    ({setSelf, onSet}) => {
      // 当atomFamily的成员被创建时，将其参数添加到集合中
      atomFamilyParametersSet.add(param);
      onSet((newValue, oldValue, isReset) => {
        // 如果有必要，也可以在这里处理值的变化
      });
    },
  ],
});

// 定义一个 selector 来追踪和获取所有已访问的 atomFamily 成员
const allMyAtomFamilyMembers = selector({
  key: 'AllMyAtomFamilyMembers',
  get: ({ get }) => {
    // 将所有追踪过的参数转换成对应的 atomFamily 成员的值
    const allAtoms = Array.from(atomFamilyParametersSet).map(param =>
      get(myAtomFamily(param))
    );
    return allAtoms;
  },
});

// 使用 React 组件时，可以这样获取所有 atomFamily 成员的状态
const MyComponent = () => {
  const allMembers = useRecoilValue(allMyAtomFamilyMembers);
  // 渲染所有 atomFamily 成员的信息...
};
```

在这个例子中，我们创建了一个 `atomFamily`，并使用 `effects_UNSTABLE` 进行了一个效果的设置，在每次这个 atom 被创建时，我们会将其参数添加到 `atomFamilyParametersSet` 集合中。然后，我们定义了一个 `selector` 来获取和追踪所有已经访问过的 `atomFamily` 成员，我们利用这个 `selector` 来得到这些成员的状态。最后，在组件中使用 `useRecoilValue` 来获取所有成员的状态并进行渲染。请注意，这个方法只能跟踪到被实际使用过（即被 `get` 或 `set`）的 atomFamily 成员。未被使用的成员不会被添加到集合中。

Instead of using `useRecoilCallback` you can abstract it with `selectorFamily`.

    // atomFamily
    const mealsAtom = atomFamily({
      key: "meals",
      default: {}
    });
    
    const mealIds = atom({
      key: "mealsIds",
      default: []
    });
    
    // abstraction
    const meals = selectorFamily({
      key: "meals-access",
      get:  (id) => ({ get }) => {
          const atom = get(mealsAtom(id));
          return atom;
      },
      set: (id) => ({set}, meal) => {
          set(mealsAtom(id), meal);
          set(mealIds (id), prev => [...prev, meal.id)]);
      }
    });
    

Further more, in case you would like to support reset you can use the following code:

    // atomFamily
    const mealsAtom = atomFamily({
      key: "meals",
      default: {}
    });
    
    const mealIds = atom({
      key: "mealsIds",
      default: []
    });
    
    // abstraction
    const meals = selectorFamily({
      key: "meals-access",
      get:  (id) => ({ get }) => {
          const atom = get(mealsAtom(id));
          return atom;
      },
      set: (id) => ({set, reset}, meal) => {
          if(meal instanceof DefaultValue) {
            // DefaultValue means reset context
            reset(mealsAtom(id));
            reset(mealIds (id));
            return;
          }
          set(mealsAtom(id), meal);
          set(mealIds (id), prev => [...prev, meal.id)]);
      }
    });
    

If you're using Typescript you can make it more elegant by using the following [guard](https://www.typescriptlang.org/docs/handbook/advanced-types.html).

    import { DefaultValue } from 'recoil';
    
    export const guardRecoilDefaultValue = (
      candidate: unknown
    ): candidate is DefaultValue => {
      if (candidate instanceof DefaultValue) return true;
      return false;
    };
    

Using this guard with Typescript will look something like:

    // atomFamily
    const mealsAtom = atomFamily<IMeal, number>({
      key: "meals",
      default: {}
    });
    
    const mealIds = atom<number[]>({
      key: "mealsIds",
      default: []
    });
    
    // abstraction
    const meals = selectorFamily<IMeal, number>({
      key: "meals-access",
      get:  (id) => ({ get }) => {
          const atom = get(mealsAtom(id));
          return atom;
      },
      set: (id) => ({set, reset}, meal) => {
          if (guardRecoilDefaultValue(meal)) {
            // DefaultValue means reset context
            reset(mealsAtom(id));
            reset(mealIds (id));
            return;
          }
          // from this line you got IMeal (not IMeal | DefaultValue)
          set(mealsAtom(id), meal);
          set(mealIds (id), prev => [...prev, meal.id)]);
      }
    });

You have to track all ids of the `atomFamily` to get all members of the family. Keep in mind that this is not really a list, more like a map.

Something like this should get you going.

    // atomFamily
    const meals = atomFamily({
      key: "meals",
      default: {}
    });
    
    const mealIds = atom({
      key: "mealsIds",
      default: []
    });
    

When creating a new objects inside the family you also have to update the `mealIds` atom.

I usually use a `useRecoilCallback` hook to sync this together

      const createMeal = useRecoilCallback(({ set }) => (mealId, price) => {
        set(mealIds, currVal => [...currVal, mealId]);
        set(meals(mealId), {name: mealId, price});
      }, []);
    

This way you can create a meal by calling:

    createMeal("bananas", 5);
    

And get all ids via:

    const ids = useRecoilValue(mealIds);

You can use an `atom` to track the ids of each atom in the `atomFamily`. Then use a `selectorFamily` or a custom function to update the atom with the list of ids when a new atom is added or deleted from the `atomFamily`. Then, the atom with the list of ids can be used to extract each of the atoms by their id from the `selectorFamily`.

    // File for managing state
    
    
    //Atom Family
    export const mealsAtom = atomFamily({
      key: "meals",
      default: {},
    });
    //Atom ids list
    export const mealsIds = atom({
      key: "mealsIds",
      default: [],
    });
    

This is how the `selectorFamily` looks like:

    // File for managing state
    
    export const mealsSelector = selectorFamily({
      key: "mealsSelector",
      get: (mealId) => ({get}) => {
        return get(meals(mealId));
      },
      set: (mealId) => ({set, reset}, newMeal) => {
        // if 'newMeal' is an instance of Default value, 
        // the 'set' method will delete the atom from the atomFamily.
        if (newMeal instanceof DefaultValue) {
          // reset method deletes the atom from atomFamily. Then update ids list.
          reset(mealsAtom(mealId));
          set(mealsIds, (prevValue) => prevValue.filter((id) => id !== mealId));
        } else {
          // creates the atom and update the ids list
          set(mealsAtom(mealId), newMeal);
          set(mealsIds, (prev) => [...prev, mealId]);
        }
      },
    });
    

**Now, how do you use all this?**

*   Create a meal:

In this case i'm using current timestamp as the atom id with `Math.random()`

    // Component to consume state
    
    import {mealsSelector} from "your/path";
    import {useSetRecoilState} from "recoil";
    const setMeal = useSetRecoilState(mealsSelector(Math.random()));
    
    setMeal({
        name: "banana",
        price: 5,
    });
    
    

*   Delete a meal:

    // Component to consume state
    
    import {mealsSelector} from "your/path";
    import {DefaultValue, useSetRecoilState} from "recoil";
    
    const setMeal = useSetRecoilState(mealsSelector(mealId));
    setMeal(new DefaultValue());
    

*   Get all atoms from atomFamily:

Loop the list of ids and render Meals components that receive the id as props and use it to get the state for each atom.

    // Component to consume state, parent of Meals component
    
    import {mealsIds} from "your/path";
    import {useRecoilValue} from "recoil";
    
    const mealIdsList = useRecoilValue(mealsIds);
    
        //Inside the return function:
        return(
          {mealIdsList.slice()
              .map((mealId) => (
                <MealComponent
                  key={mealId}
                  id={mealId}
                />
              ))}
        );
    

    // Meal component to consume state
    
    import {mealsSelector} from "your/path";
    import {useRecoilValue} from "recoil";
    
    const meal = useRecoilValue(mealsSelector(props.id));
    

Then, you have a list of components for Meals, each with their own state from the `atomFamily`.

Here is how I have it working on my current project:

(For context this is a dynamic form created from an array of field option objects. The form values are submitted via a graphql mutation so we only want the minimal set of changes made. The form is therefore built up as the user edits fields)

    import { atom, atomFamily, DefaultValue, selectorFamily } from 'recoil';
    
    type PossibleFormValue = string | null | undefined;
    
    export const fieldStateAtom = atomFamily<PossibleFormValue, string>({
      key: 'fieldState',
      default: undefined,
    });
    
    export const fieldIdsAtom = atom<string[]>({
      key: 'fieldIds',
      default: [],
    });
    
    export const fieldStateSelector = selectorFamily<PossibleFormValue, string>({
      key: 'fieldStateSelector',
      get: (fieldId) => ({ get }) => get(fieldStateAtom(fieldId)),
      set: (fieldId) => ({ set, get }, fieldValue) => {
        set(fieldStateAtom(fieldId), fieldValue);
        const fieldIds = get(fieldIdsAtom);
        if (!fieldIds.includes(fieldId)) {
          set(fieldIdsAtom, (prev) => [...prev, fieldId]);
        }
      },
    });
    
    export const formStateSelector = selectorFamily<
      Record<string, PossibleFormValue>,
      string[]
    >({
      key: 'formStateSelector',
      get: (fieldIds) => ({ get }) => {
        return fieldIds.reduce<Record<string, PossibleFormValue>>(
          (result, fieldId) => {
            const fieldValue = get(fieldStateAtom(fieldId));
            return {
              ...result,
              [fieldId]: fieldValue,
            };
          },
          {},
        );
      },
      set: (fieldIds) => ({ get, set, reset }, newValue) => {
        if (newValue instanceof DefaultValue) {
          reset(fieldIdsAtom);
          const fieldIds = get(fieldIdsAtom);
          fieldIds.forEach((fieldId) => reset(fieldStateAtom(fieldId)));
        } else {
          set(fieldIdsAtom, Object.keys(newValue));
          fieldIds.forEach((fieldId) => {
            set(fieldStateAtom(fieldId), newValue[fieldId]);
          });
        }
      },
    });
    

The atoms are selectors are used in 3 places in the app:

In the field component:

    ...
    const localValue = useRecoilValue(fieldStateAtom(fieldId));
    const setFieldValue = useSetRecoilState(fieldStateSelector(fieldId));
    ...
    

In the save-handling component (although this could be simpler in a form with an explicit submit button):

    ...
    const fieldIds = useRecoilValue(fieldIdsAtom);
    const formState = useRecoilValue(formStateSelector(fieldIds));
    ...
    

And in another component that handles form actions, including form reset:

    ...
    const resetFormState = useResetRecoilState(formStateSelector([]));
    ...
    const handleDiscard = React.useCallback(() => {
      ...
      resetFormState();
      ...
    }, [..., resetFormState]);

Recoil 如何获得原子族 atomfamily 的所有元素?

在 React Recoil 中，通常我们会在组件内部使用 Recoil 的 `useRecoilState` 或 `useSetRecoilState` 钩子来更新 atom 原子状态。但是，在某些场景下，我们可能需要在组件外部，例如在一个异步函数或者一个普通的 JavaScript 模块中更新 Recoil 的状态。为了实现这一点，我们可以使用 Recoil 的 `RecoilRoot` 和 `atom` API 来创建全局状态，并使用 `useRecoilCallback` 钩子来创建一个可以在组件外部调用的更新函数。

下面是在组件外部更新 atom 状态的步骤：

1. **定义一个 atom：**

```jsx
import { atom } from 'recoil';

export const myAtom = atom({
  key: 'myAtom',
  default: 0, // 初始值
});
```

2. **在组件树中提供一个 RecoilRoot：**

```jsx
import React from 'react';
import { RecoilRoot } from 'recoil';
import App from './App';

function RootComponent() {
  return (
    <RecoilRoot>
      <App />
    </RecoilRoot>
  );
}
```

3. **使用 `useRecoilCallback` 创建可以从组件外部调用的回调函数：**

```jsx
import { useRecoilCallback } from 'recoil';
import { myAtom } from './store';

function useUpdateAtom() {
  const updateAtom = useRecoilCallback(({ set }) => (newValue) => {
    set(myAtom, newValue);
  }, []);

  return updateAtom;
}
```

4. **在组件内部调用 `useUpdateAtom` 并将返回的函数暴露给外部：**

```jsx
import React from 'react';
import { useUpdateAtom } from './useUpdateAtom';

function MyComponent() {
  const updateAtomFromOutside = useUpdateAtom();
  
  // 你现在可以将 updateAtomFromOutside 函数传递给外部或者注册为全局方法
  // 例如绑定到 window 对象，或者传递给需要调用更新操作的外部模块

  return (
    <div>
      <button onClick={() => updateAtomFromOutside(10)}>Update Atom</button>
    </div>
  );
}
```

5. **在组件外部使用该函数更新 atom 状态：**

```javascript
// 假设你已经在合适的地方获取到了 updateAtomFromOutside 函数
updateAtomFromOutside(20); // 这将会更新 myAtom 的值为 20
```

通过这种方式，我们可以轻松地在组件外部更新 Recoil 的状态，同时还能保持与 Recoil 状态管理库的整体架构兼容。这对于处理那些不直接绑定在 React 组件生命周期上的逻辑，如定时器、网络请求回调等情况特别有用。

As I pointed out in [another answer](https://stackoverflow.com/a/65198580/11783958), you generally don't want to run into this, but if you eventually really need to **update atoms outside of React** Components you might give a try to [**Recoil Nexus**](https://www.npmjs.com/package/recoil-nexus).

In the same file where you have your RecoilRoot you'll have something like:

    import React from 'react';
    import { RecoilRoot } from "recoil"
    import RecoilNexus from 'recoil-nexus'
    
    export default function App() {
      return (
        <RecoilRoot>
          <RecoilNexus/>
          
          {/* ... */}
          
        </RecoilRoot>
      );
    };
    
    
    export default App;
    

Then, wherever you need to read/update the values:

    import yourAtom from './yourAtom'
    import { getRecoil, setRecoil } from 'recoil-nexus'
    

Eventually you can get and set the values like this:

    
    const loading = getRecoil(loadingState)
    
    setRecoil(loadingState, !loading)
    
    

That's it!

_Disclaimer: I am the author of the library._

* * *

**Check this [CodeSandbox](https://githubbox.com/luisanton-io/simple-loader-with-nexus) for a live example.**

I think the only way (at least as of a few months ago) is a sort of hack where you include a non-rendering component that uses the recoil hooks and exports the provided functions from them.

See: [https://github.com/facebookexperimental/Recoil/issues/289#issuecomment-777249693](https://github.com/facebookexperimental/Recoil/issues/289#issuecomment-777249693)

Below is the file from my own project that achieves this, heavily based on that link above. All you need to do is put `<RecoilExternalStatePortal />` anywhere in your application tree that is guaranteed to _always_ render.

This seems like an omission in the Recoil API, IMHO.

    import React from 'react'
    import { Loadable, RecoilState, RecoilValue, useRecoilCallback, useRecoilTransactionObserver_UNSTABLE } from 'recoil'
    
    /**
     * Returns a Recoil state value, from anywhere in the app.
     *
     * Can be used outside of the React tree (outside a React component), such as in utility scripts, etc.
    
     * <RecoilExternalStatePortal> must have been previously loaded in the React tree, or it won't work.
     * Initialized as a dummy function "() => null", it's reference is updated to a proper Recoil state mutator when RecoilExternalStatePortal is loaded.
     *
     * @example const lastCreatedUser = getRecoilExternal(lastCreatedUserState);
     */
    export function getRecoilState<T>(recoilValue: RecoilValue<T>): T {
      return getRecoilLoadable(recoilValue).getValue()
    }
    
    /** The `getLoadable` function from recoil. This shouldn't be used directly. */
    let getRecoilLoadable: <T>(recoilValue: RecoilValue<T>) => Loadable<T> = () => null as any
    
    /**
     * Sets a Recoil state value, from anywhere in the app.
     *
     * Can be used outside of the React tree (outside a React component), such as in utility scripts, etc.
     *
     * <RecoilExternalStatePortal> must have been previously loaded in the React tree, or it won't work.
     * Initialized as a dummy function "() => null", it's reference is updated to a proper Recoil state mutator when RecoilExternalStatePortal is loaded.
     *
     * @example setRecoilExternalState(lastCreatedUserState, newUser)
     */
    export let setRecoilState: <T>(recoilState: RecoilState<T>, valOrUpdater: ((currVal: T) => T) | T) => void = () =>
      null as any
    
    /**
     * Utility component allowing to use the Recoil state outside of a React component.
     *
     * It must be loaded in the _app file, inside the <RecoilRoot> component.
     * Once it's been loaded in the React tree, it allows using setRecoilExternalState and getRecoilExternalLoadable from anywhere in the app.
     *
     * @see https://github.com/facebookexperimental/Recoil/issues/289#issuecomment-777300212
     * @see https://github.com/facebookexperimental/Recoil/issues/289#issuecomment-777305884
     * @see https://recoiljs.org/docs/api-reference/core/Loadable/
     */
    export function RecoilExternalStatePortal() {
      // We need to update the getRecoilExternalLoadable every time there's a new snapshot
      // Otherwise we will load old values from when the component was mounted
      useRecoilTransactionObserver_UNSTABLE(({ snapshot }) => {
        getRecoilLoadable = snapshot.getLoadable
      })
    
      // We only need to assign setRecoilExternalState once because it's not temporally dependent like "get" is
      useRecoilCallback(({ set }) => {
        setRecoilState = set
    
        return async () => {
          // no-op
        }
      })()
    
      return <></>
    }

I think the right way to handle this in react is with a custom hook/facade. That way you can keep code centralized, but share it with the components that need it, and in this case, include code that relies on hooks/being in a component. This article explains it fairly well:

[https://wanago.io/2019/12/09/javascript-design-patterns-facade-react-hooks/](https://wanago.io/2019/12/09/javascript-design-patterns-facade-react-hooks/)

But the basic idea is that you would create an custom `useAuth` hook, that would expose what you need:

    export function useAuth() {
      const [auth, setAuth] = useRecoilState(authAtom);
      const resetAuth = useResetRecoilState(authAtom);
      const authState = useMemo(() => {
        return {
          isAuthenticated: () => {
            return !!auth.accessToken && auth.expiresAt > new Date();
          },
        };
      }, [auth]);
      ...
      return { auth, authState, logout: resetAuth, /* and maybe more, error, login, etc */ };
    

and then use it in components that need auth:

    const AuthorizedComponent: FC<Props> = (props) => {
      const { auth, authState } = useAuth();

React Recoil 如何在组件外部更新的 atom 原子状态？

在 React 或 JavaScript 的上下文中，这三个点被称作扩展运算符（spread operator）。扩展运算符有几种不同的用途：

1. **复制对象或数组**：
   扩展运算符可以用来创建对象或数组的浅拷贝。比如，如果我们有一个数组 `arr = [1, 2, 3]`，使用扩展运算符可以创建一个新的数组 `newArr = [...arr]`，这里 `newArr` 将是 `arr` 的一个拷贝，但是是一个新的实例。

   示例代码如下：
   ```javascript
   const originalArray = [1, 2, 3];
   const newArray = [...originalArray]; // newArray: [1, 2, 3]
   ```

2. **合并对象或数组**：
   扩展运算符可以用来合并两个或多个对象（或数组）。这在 React 的状态管理中特别有用，因为经常需要创建新的状态对象，而不是修改现有的状态。

   示例代码如下：
   ```javascript
   const obj1 = { a: 1, b: 2 };
   const obj2 = { b: 3, c: 4 };
   const mergedObject = { ...obj1, ...obj2 }; // mergedObject: { a: 1, b: 3, c: 4 }
   ```

   可以看到，如果有重复的键，后面的对象会覆盖前面的。

3. **函数参数展开**：
   当一个函数期望收到多个参数，而不是一个数组时，扩展运算符可以用来将一个数组'展开'为单独的参数。

   示例代码如下：
   ```javascript
   function sum(a, b, c) {
     return a + b + c;
   }
   const numbers = [1, 2, 3];
   const result = sum(...numbers); // 等同于 sum(1, 2, 3)
   ```

在 React 组件中，扩展运算符经常用来传递 `props`。例如，如果你有一个 `props` 对象，你想将它传递给子组件，你可以使用扩展运算符来传递整个 `props` 对象。

示例代码如下：
```javascript
const MyComponent = (props) => {
  return <ChildComponent {...props} />;
};
```

通过上述方法，`ChildComponent` 将接收到 `MyComponent` 中所有的 `props`，而无需逐一列出它们。这使得组件间的 `props` 传递更加灵活和简洁。

That's [_property spread notation_](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Spread_syntax). It was added in ES2018 (spread for arrays/iterables was earlier, ES2015), but it's been supported in React projects for a long time via transpilation (as "[JSX spread attributes](https://reactjs.org/docs/jsx-in-depth.html#spread-attributes)" even though you could do it elsewhere, too, not just attributes).

`{...this.props}` _spreads out_ the "own" enumerable properties in `props` as discrete properties on the `Modal` element you're creating. For instance, if `this.props` contained `a: 1` and `b: 2`, then

    <Modal {...this.props} title='Modal heading' animation={false}>
    

would be the same as

    <Modal a={this.props.a} b={this.props.b} title='Modal heading' animation={false}>
    

But it's dynamic, so whatever "own" properties are in `props` are included.

Since `children` is an "own" property in `props`, spread will include it. So if the component where this appears had child elements, they'll be passed on to `Modal`. Putting child elements between the opening tag and closing tags is just syntactic sugar — the good kind — for putting a `children` property in the opening tag. Example:

Show code snippet

    class Example extends React.Component {
      render() {
        const { className, children } = this.props;
        return (
          <div className={className}>
          {children}
          </div>
        );
      }
    }
    ReactDOM.render(
      [
        <Example className="first">
          <span>Child in first</span>
        </Example>,
        <Example className="second" children={<span>Child in second</span>} />
      ],
      document.getElementById("root")
    );

    .first {
      color: green;
    }
    .second {
      color: blue;
    }

    <div id="root"></div>
    
    <script src="https://cdnjs.cloudflare.com/ajax/libs/react/16.6.3/umd/react.production.min.js"></script>
    <script src="https://cdnjs.cloudflare.com/ajax/libs/react-dom/16.6.3/umd/react-dom.production.min.js"></script>

Run code snippetHide results

Expand snippet

Spread notation is handy not only for that use case, but for creating a new object with most (or all) of the properties of an existing object — which comes up a lot when you're updating state, since you can't modify state directly:

    this.setState(prevState => {
        return {foo: {...prevState.foo, a: "updated"}};
    });
    

That replaces `this.state.foo` with a new object with all the same properties as `foo` except the `a` property, which becomes `"updated"`:

Show code snippet

    const obj = {
      foo: {
        a: 1,
        b: 2,
        c: 3
      }
    };
    console.log("original", obj.foo);
    // Creates a NEW object and assigns it to `obj.foo`
    obj.foo = {...obj.foo, a: "updated"};
    console.log("updated", obj.foo);

    .as-console-wrapper {
      max-height: 100% !important;
    }

Run code snippetHide results

Expand snippet

`...` are called **spread attributes** which, as the name represents, it allows an expression to be expanded.

    var parts = ['two', 'three'];
    var numbers = ['one', ...parts, 'four', 'five']; // ["one", "two", "three", "four", "five"]
    

And in this case (I'm going to simplify it).

    // Just assume we have an object like this:
    var person= {
        name: 'Alex',
        age: 35 
    }
    

This:

    <Modal {...person} title='Modal heading' animation={false} />
    

is equal to

    <Modal name={person.name} age={person.age} title='Modal heading' animation={false} />
    

So in short, it's a **neat** short-cut, _we can say_.

The three dots represent the **spread operator** in [ES6](https://en.wikipedia.org/wiki/ECMAScript#6th_Edition_%E2%80%93_ECMAScript_2015). It allows us to do quite a few things in JavaScript:

1.  **Concatenate arrays**
    
         var shooterGames = ['Call of Duty', 'Far Cry', 'Resident Evil'];
         var racingGames = ['Need For Speed', 'Gran Turismo', 'Burnout'];
         var games = [...shooterGames, ...racingGames];
        
         console.log(games)  // ['Call of Duty', 'Far Cry', 'Resident Evil',  'Need For Speed', 'Gran Turismo', 'Burnout']
        
    
2.  **Destructuring an array**
    
           var shooterGames = ['Call of Duty', 'Far Cry', 'Resident Evil'];
           var [first, ...remaining] = shooterGames;
           console.log(first); //Call of Duty
           console.log(remaining); //['Far Cry', 'Resident Evil']
        
    
3.  **Combining two objects**
    
         var myCrush = {
           firstname: 'Selena',
           middlename: 'Marie'
         };
        
         var lastname = 'my last name';
        
         var myWife = {
           ...myCrush,
           lastname
         }
        
         console.log(myWife); // {firstname: 'Selena',
                              //   middlename: 'Marie',
                              //   lastname: 'my last name'}
        
    

There's another use for the three dots which is known as **Rest Parameters** and it makes it possible to take all of the arguments to a function in as one array.

4.  **Function arguments as array**
    
          function fun1(...params) {
        
          }

`...` (three dots in JavaScript) is called the Spread Syntax or Spread Operator. This allows an iterable such as an **array** expression or **string** to be expanded or an **object** expression to be expanded wherever placed. This is not specific to React. It is a JavaScript operator.

All these answers here are helpful, but I want to list down the mostly used practical Use Cases of the [Spread Syntax](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Spread_syntax) (Spread Operator).

**1\. Combine Arrays (Concatenate Arrays)**

There are a [variety of ways to combine arrays](https://davidwalsh.name/combining-js-arrays), but the spread operator allows you to place this at any place in an array. If you'd like to combine two arrays and place elements at any point within the array, you can do as follows:

    var arr1 = ['two', 'three'];
    var arr2 = ['one', ...arr1, 'four', 'five'];
    
    // arr2 = ["one", "two", "three", "four", "five"]
    

**2\. Copying Arrays**

When we wanted a copy of an array, we used to have the [`Array.prototype.slice()`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/slice) method. But, you can do the same with the spread operator.

    var arr = [1,2,3];
    var arr2 = [...arr];
    // arr2 = [1,2,3]
    

**3\. Calling Functions without Apply**

In ES5, to pass an array of two numbers to the `doStuff()` function, you often use the [`Function.prototype.apply()`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function/apply) method as follows:

    function doStuff (x, y, z) {}
    var args = [0, 1, 2];
    
    // Call the function, passing args
    doStuff.apply(null, args);
    

However, by using the spread operator, you can pass an array into the function.

    doStuff(...args);
    

**4\. Destructuring Arrays**

You can use destructuring and the rest operator together to extract the information into variables as you'd like them:

    let { x, y, ...z } = { x: 1, y: 2, a: 3, b: 4 };
    console.log(x); // 1
    console.log(y); // 2
    console.log(z); // { a: 3, b: 4 }
    

**5\. Function Arguments as Rest Parameters**

ES6 also has three dots (`...`) which indicates a rest parameter that collects all remaining arguments of a function into an array.

    function f(a, b, ...args) {
      console.log(args);
    }
    
    f(1, 2, 3, 4, 5); // [3, 4, 5]
    

**6\. Using Math Functions**

Any function where spread is used as the argument can be used by functions that can accept any number of arguments.

    let numbers = [9, 4, 7, 1];
    Math.min(...numbers); // 1
    

**7\. Combining Two Objects**

You can use the spread operator to combine two objects. This is an easy and cleaner way to do it.

    var carType = {
      model: 'Toyota',
      yom: '1995'
    };
    
    var carFuel = 'Petrol';
    
    var carData = {
      ...carType,
      carFuel
    }
    
    console.log(carData);
    // {
    //  model: 'Toyota',
    //  yom: '1995',
    //  carFuel = 'Petrol'
    // }
    

**8\. Separate a String into Separate Characters**

You can use the spread operator to spread a string into separate characters.

    let chars = ['A', ...'BC', 'D'];
    console.log(chars); // ["A", "B", "C", "D"]
    

You can think of more ways to use the Spread Operator. What I have listed here are the popular use cases of it.

The three dots in JavaScript are the **spread / rest operator**.

**Spread operator**

The [spread syntax](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Spread_operator) allows an expression to be expanded in places where multiple arguments are expected.

    myFunction(...iterableObj);
    
    [...iterableObj, 4, 5, 6]
    
    [...Array(10)]
    

**Rest parameters**

The [rest](https://developer.mozilla.org/en/docs/Web/JavaScript/Reference/Functions/rest_parameters) parameter syntax is used for functions with a variable number of arguments.

    function(a, b, ...theArgs) {
      // ...
    }
    

The spread / rest operator for arrays was introduced in [ES6](https://en.wikipedia.org/wiki/ECMAScript#6th_Edition_%E2%80%93_ECMAScript_2015). There's a State 2 [proposal](https://github.com/sebmarkbage/ecmascript-rest-spread) for object spread / rest properties.

TypeScript also supports the spread syntax and can transpile that into older versions of ECMAScript with minor [issues](https://github.com/Microsoft/TypeScript/issues/8856).

React 中的这三个点的作用是什么？

在React中，如果您想要在某些情况下（例如，当内容更新时）将`div`滚动到底部，可以通过编程方式操作DOM来实现。以下是几种可以实现这个需求的方法：

### 使用`ref`和DOM方法

您可以通过React的`ref`属性获得DOM元素的直接引用，并使用原生的DOM方法来滚动到底部。这可以通过设置`scrollTop`来实现，`scrollTop`应该等于`scrollHeight`减去`clientHeight`。

```jsx
import React, { useRef, useEffect } from 'react';

function ChatComponent() {
  const messagesEndRef = useRef(null);

  const scrollToBottom = () => {
    messagesEndRef.current.scrollIntoView({ behavior: "smooth" });
  };

  useEffect(scrollToBottom, []); // 如果希望在组件首次渲染时滚动到底部，可以添加空数组作为依赖项

  return (
    <div style={{ overflowY: 'auto', height: '500px' }}>
      {/* 消息内容 */}
      <div>{/* ... */}</div>
      {/* 用于滚动的元素 */}
      <div ref={messagesEndRef} />
    </div>
  );
}
```

这里，`useEffect`用于在组件的生命周期内在适当的时刻触发滚动行为。

### 使用`scrollTop`和`scrollHeight`

如果您想要更直接控制滚动位置，可以直接设置`scrollTop`属性：

```jsx
import React, { useRef, useEffect } from 'react';

function ScrollToBottomComponent() {
  const divRef = useRef(null);

  const scrollToBottom = () => {
    const scrollHeight = divRef.current.scrollHeight;
    const height = divRef.current.clientHeight;
    const maxScrollTop = scrollHeight - height;
    divRef.current.scrollTop = maxScrollTop > 0 ? maxScrollTop : 0;
  };

  useEffect(scrollToBottom, []); // 依据实际情况，可能需要添加其他依赖项，如消息数组

  return (
    <div ref={divRef} style={{ overflowY: 'auto', height: '500px' }}>
      {/* 消息内容 */}
      {/* ... */}
    </div>
  );
}
```

在这个例子中，我们在`useEffect`中调用`scrollToBottom`函数，这会在组件渲染后立即将`div`滚动到底部。

### 自动滚动处理新消息

如果您的`div`包含一个聊天界面，您可能希望在新消息到来时自动滚动到底部。这可以通过在`useEffect`中跟踪消息数组的变化来实现：

```jsx
import React, { useRef, useEffect } from 'react';

function AutoScrollToBottomComponent({ messages }) {
  const divRef = useRef(null);

  useEffect(() => {
    if (divRef.current) {
      const { scrollHeight, clientHeight } = divRef.current;
      divRef.current.scrollTop = scrollHeight - clientHeight;
    }
  }, [messages]); // 当消息数组改变时触发滚动

  return (
    <div ref={divRef} style={{ overflowY: 'auto', height: '300px' }}>
      {messages.map((message, index) => (
        <div key={index}>{message}</div>
      ))}
    </div>
  );
}
```

在这个例子中，每当传入组件的`messages`数组发生变化时，`useEffect`钩子就会执行，导致`div`自动滚动到底部。

以上就是在React中将`div`滚动到底部的几种方法。您可以根据您应用的具体需求选择适合的实现方式。

As Tushar mentioned, you can keep a dummy div at the bottom of your chat:

    render () {
      return (
        <div>
          <div className="MessageContainer" >
            <div className="MessagesList">
              {this.renderMessages()}
            </div>
            <div style={{ float:"left", clear: "both" }}
                 ref={(el) => { this.messagesEnd = el; }}>
            </div>
          </div>
        </div>
      );
    }
    

and then scroll to it whenever your component is updated (i.e. state updated as new messages are added):

    scrollToBottom = () => {
      this.messagesEnd.scrollIntoView({ behavior: "smooth" });
    }
    
    componentDidMount() {
      this.scrollToBottom();
    }
    
    componentDidUpdate() {
      this.scrollToBottom();
    }
    

I'm using the standard [Element.scrollIntoView](https://developer.mozilla.org/en-US/docs/Web/API/Element/scrollIntoView) method here.

I just want to update the answer to match the new `React.createRef()` [method](https://reactjs.org/docs/refs-and-the-dom.html), but it's basically the same, just have in mind the `current` property in the created ref:

    class Messages extends React.Component {
    
      const messagesEndRef = React.createRef()
    
      componentDidMount () {
        this.scrollToBottom()
      }
      componentDidUpdate () {
        this.scrollToBottom()
      }
      scrollToBottom = () => {
        this.messagesEndRef.current?.scrollIntoView({ behavior: 'smooth' })
      }
      render () {
        const { messages } = this.props
        return (
          <div>
            {messages.map(message => <Message key={message.id} {...message} />)}
            <div ref={this.messagesEndRef} />
          </div>
        )
      }
    }
    

UPDATE:

Now that hooks are available, I'm updating the answer to add the use of the `useRef` and `useEffect` hooks, the real thing doing the magic (React refs and `scrollIntoView` DOM method) remains the same:

    import React, { useEffect, useRef } from 'react'
    
    const Messages = ({ messages }) => {
    
      const messagesEndRef = useRef(null)
    
      const scrollToBottom = () => {
        messagesEndRef.current?.scrollIntoView({ behavior: "smooth" })
      }
    
      useEffect(() => {
        scrollToBottom()
      }, [messages]);
    
      return (
        <div>
          {messages.map(message => <Message key={message.id} {...message} />)}
          <div ref={messagesEndRef} />
        </div>
      )
    }
    

Also made a (very basic) codesandbox if you wanna check the behaviour [https://codesandbox.io/s/scrolltobottomexample-f90lz](https://codesandbox.io/s/scrolltobottomexample-f90lz)

Do not use [`findDOMNode`](https://github.com/yannickcr/eslint-plugin-react/issues/678) ["because it blocks certain improvements in React in the future"](https://github.com/jsx-eslint/eslint-plugin-react/issues/678#issue-165177220)

Class components with ref
=========================

    class MyComponent extends Component {
      componentDidMount() {
        this.scrollToBottom();
      }
    
      componentDidUpdate() {
        this.scrollToBottom();
      }
    
      scrollToBottom() {
        this.el.scrollIntoView({ behavior: 'smooth' });
      }
    
      render() {
        return <div ref={el => { this.el = el; }} />
      }
    }
    

Function components with hooks:
===============================

    import React, { useRef, useEffect } from 'react';
    
    const MyComponent = () => {
      const divRef = useRef(null);
    
      useEffect(() => {
        divRef.current.scrollIntoView({ behavior: 'smooth' });
      });
    
      return <div ref={divRef} />;
    }

Thanks to @enlitement

we should avoid using `findDOMNode`, we can use `refs` to keep track of the components

    render() {
      ...
    
      return (
        <div>
          <div
            className="MessageList"
            ref={(div) => {
              this.messageList = div;
            }}
          >
            { messageListContent }
          </div>
        </div>
      );
    }
    
    
    
    scrollToBottom() {
      const scrollHeight = this.messageList.scrollHeight;
      const height = this.messageList.clientHeight;
      const maxScrollTop = scrollHeight - height;
      this.messageList.scrollTop = maxScrollTop > 0 ? maxScrollTop : 0;
    }
    
    componentDidUpdate() {
      this.scrollToBottom();
    }
    

reference:

*   [https://facebook.github.io/react/docs/react-dom.html#finddomnode](https://facebook.github.io/react/docs/react-dom.html#finddomnode)
*   [https://www.pubnub.com/blog/2016-06-28-reactjs-chat-app-infinite-scroll-history-using-redux/](https://www.pubnub.com/blog/2016-06-28-reactjs-chat-app-infinite-scroll-history-using-redux/)

The easiest and best way I would recommend is.
----------------------------------------------

_My ReactJS version: 16.12.0_

* * *

> For Class Components
> --------------------

**HTML structure** inside `render()` function

        render()
            return(
                <body>
                    <div ref="messageList">
                        <div>Message 1</div>
                        <div>Message 2</div>
                        <div>Message 3</div>
                    </div>
                </body>
            )
        )
    

`scrollToBottom()` function which will get reference of the element. and scroll according to `scrollIntoView()` function.

      scrollToBottom = () => {
        const { messageList } = this.refs;
        messageList.scrollIntoView({behavior: "smooth", block: "end", inline: "nearest"});
      }
    

and call the above function inside `componentDidMount()` and `componentDidUpdate()`

* * *

> For Functional Components (Hooks)
> ---------------------------------

Import `useRef()` and `useEffect()`

    import { useEffect, useRef } from 'react'
    

Inside your export function, (same as calling a `useState()`)

    const messageRef = useRef();
    

And let's assume you have to scroll when page load,

    useEffect(() => {
        if (messageRef.current) {
          messageRef.current.scrollIntoView(
            {
              behavior: 'smooth',
              block: 'end',
              inline: 'nearest'
            })
        }
      })
    

OR if you want it to trigger once an action performed,

    useEffect(() => {
      if (messageRef.current) {
        messageRef.current.scrollIntoView(
          {
            behavior: 'smooth',
            block: 'end',
            inline: 'nearest'
          })
      }
    },
    [stateVariable])
    

And Finally, to your **HTML structure**

    return(
        <body>
            <div ref={messageRef}> // <= The only different is we are calling a variable here
                <div>Message 1</div>
                <div>Message 2</div>
                <div>Message 3</div>
            </div>
        </body>
    )
    

for more explanation about `Element.scrollIntoView()` visit [developer.mozilla.org](https://developer.mozilla.org/en-US/docs/Web/API/Element/scrollIntoView)

More detailed explanation in Callback refs visit [reactjs.org](https://reactjs.org/docs/refs-and-the-dom.html#callback-refs)

React相关问题