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 Query 和 Redux 是两个用于在React应用程序中管理状态的库，但它们的关注点和使用场景有一些显著的区别。

1. **设计目的**:
   - **React Query** 是专门为处理异步数据（服务器状态）而设计的，比如从API检索数据、缓存数据以及数据同步。
   - **Redux** 是一个更通用的状态管理库，它为JavaScript应用提供了一个可预测的状态容器，可以用来管理应用的客户端状态（UI状态）。

2. **数据缓存和失效**:
   - **React Query** 内建了数据缓存和自动失效的机制。它能够自动地在后台重新获取数据，以及在数据变得过时时标记它们。
   - **Redux** 本身并不直接提供这些功能。要在Redux中实现数据缓存和失效，通常需要额外的中间件或手动实现相应的逻辑。

3. **数据同步和更新**:
   - **React Query** 提供了一套内置的工具来处理数据的查询、突变（mutations）、更新和同步，这样在使用时只需要少量的样板代码。
   - **Redux** 需要手动管理数据同步和更新，通常涉及到编写action、reducer以及使用中间件来处理异步逻辑，这可能会导致较多的样板代码。

4. **配置和样板代码**:
   - **React Query** 的使用通常更简洁，它提供了hooks，如`useQuery`和`useMutation`，这些API可以让你直接在组件中发起数据请求。
   - **Redux** 的配置和使用相对复杂，特别是在项目初始搭建时。你需要定义actions、reducers、创建store等，虽然Redux Toolkit可以帮助减少一些样板代码。

5. **开发哲学**:
   - **React Query** 倾向于提供一种简化的方式来处理服务器状态，它鼓励你直接从组件内部加载数据，而不需要将所有的数据都放到全局状态管理中。
   - **Redux** 遵循Functional Programming的原则，通过使用纯函数（reducers）和不可变数据来管理和更新状态，这样可以更容易地跟踪状态的变化和进行时间旅行调试。

6. **社区和生态**:
   - **React Query** 在异步数据管理方面很受欢迎，但是它的生态相较于Redux来说较小，因为它比较专注于数据获取和缓存。
   - **Redux** 有一个庞大的社区和生态系统，包括许多中间件和附加库，如redux-thunk, redux-saga, reselect, redux-form等。

### 例子:
假设你的应用需要从一个REST API获取用户列表，并且你希望显示的数据是最新的。使用**React Query**，你可以这样做：

```jsx
import { useQuery } from 'react-query';

function UsersComponent() {
  const { data, error, isLoading } = useQuery('users', fetchUsers);

  // Render your UI based on the data, error, and loading state...
}
```

在这个例子中，`fetchUsers`是一个异步函数，它向API请求数据。`useQuery`会自动处理数据的加载、缓存、重载和更新。

而在**Redux**中，你可能需要创建actions和reducers来处理异步请求，并使用例如`redux-thunk`的中间件来处理异步逻辑：

```jsx
import { useDispatch, useSelector } from 'react-redux';

function UsersComponent() {
  const dispatch = useDispatch();
  const { users, error, isLoading } = useSelector(state => state.users);

  useEffect(() => {
    dispatch(fetchUsers());
  }, [dispatch]);

  // Render your UI based on the users, error, and loading state...
React Query 和 Redux 是两种不同类型的库，它们在React应用程序中承担着不同的角色。

**React Query** 是一个用于数据获取、缓存、同步和更新的库。它专注于处理异步数据操作，如从API检索数据、缓存结果以及自动重新获取数据。以下是React Query的一些关键特点：

- **自动缓存和无效化**：React Query自动缓存每次请求的结果，并在数据变化时提供重新获取数据的机制。
- **后台同步**：支持在数据变化或用户与应用程序互动时，自动在后台更新数据。
- **查询状态**: React Query 提供了丰富的状态信息，包括加载状态、错误状态、数据状态等，方便在UI中展示。
- **最小的全局状态管理**：React Query的目标是用最小的配置管理服务器状态。

**Redux** 是一个为JavaScript应用程序提供可预测状态容器的库，特别适合在React中使用。它主要用于管理和维护应用程序的全局状态，并提供一种模式来更新和访问这个状态。以下是Redux的一些关键特点：

- **全局状态管理**：Redux提供单一的全局状态树，所有状态的变化都通过派发行为(action)和归约器(reducers)的方式来管理。
- **可预测性**：因为所有的状态变化都遵循一个明确的流程，所以应用程序的行为是可预测的。
- **中间件**：Redux 支持使用中间件来扩展其功能，比如异步调用、日志记录等。
- **开发工具**：Redux拥有强大的开发工具，如Redux DevTools，可以帮助开发者追踪状态的变化和行为的派发。

**主要区别**：

1. **用途**：React Query主要用于数据同步，而Redux用于全局状态管理。
2. **数据管理**：React Query内置了数据获取和缓存的机制，而Redux需要开发者手动管理数据请求和响应结果。
3. **状态同步**：React Query提供自动的数据同步机制，Redux则需要结合额外的库（如redux-thunk或redux-saga）来处理异步逻辑。
4. **配置**：React Query减少了配置和样板代码的需要，Redux则需要更多的样板代码和配置步骤。
5. **开发体验**：React Query 的API设计更贴近React的hooks模式，而Redux通常需要遵循特定的设计模式和最佳实践。

例如，如果我们有一个用户列表，并且我们想通过React Query来获取这些用户，我们可能会这样做：

```javascript
import { useQuery } from 'react-query';

function Users() {
  const { isLoading, error, data } = useQuery('fetchUsers', fetchUsersApi);

  if (isLoading) return 'Loading...';
  if (error) return 'An error has occurred: ' + error.message;
  
  return (
    <ul>
      {data.map(user => (
        <li key={user.id}>{user.name}</li>
      ))}
    </ul>
  );
}

async function fetchUsersApi() {
  const response = await fetch('/api/users');
  if (!response.ok) {
    throw new Error('Network response was not ok');
  }
  return response.json();
}
```

使用Redux处理相同的数据获取，我们需要编写action creators、reducers以及相应的async action handlers：

```javascript
import { createStore, applyMiddleware } from 'redux';
import thunk from 'redux-thunk';
import { Provider, useDispatch, useSelector } from 'react-redux';

// Action types
const FETCH_USERS_REQUEST = 'FETCH_USERS_REQUEST';
const FETCH_USERS_SUCCESS = 'FETCH_USERS_SUCCESS';
const FETCH_USERS_FAILURE = 'FETCH_USERS_FAILURE';

// Action creators
const fetchUsersRequest = () => ({ type: FETCH_USERS_REQUEST });
const fetchUsersSuccess = users => ({ type: FETCH_USERS_SUCCESS, payload:

React-query 就是所谓的专用库。它为你保存了一个 api 缓存——没有别的。由于它是专门的，因此它可以很好地完成这项工作并且需要更少的代码。

另一方面，Redux 为您提供了几乎可以存储任何内容的工具 - 但您必须编写逻辑。因此，您可以在 Redux 中做更多事情，但您可能必须编写专用库不需要的代码。

您可以并行使用它们：react 查询中的 api 缓存，Redux 中的其余全局状态。

也就是说，官方 Redux Toolkit 从 1.6 版开始还附带了 api 缓存抽象[RTK Query](https://redux-toolkit.js.org/rtk-query/overview)，其功能集与 React Query 类似，但总体概念有所不同 - 您可能还想检查一下。

`react-query`旨在**处理存储在远程服务器上的数据**。要访问此数据，您的应用程序需要使用异步请求。您可能需要在这里处理缓存、加载状态、网络故障等问题。

这就是react-query 的闪光点。

`Redux`另一端**处理客户端的数据**。例如，文本输入的内容或模态的状态。您不需要处理与网络相关的问题。但您确实需要处理复杂的因果序列。

这就是 redux 的闪光点

`Redux`这`react-query`是两个非常不同的东西：`react-query`用于数据同步，`Redux`是全局状态管理器。`react-query`用于将所有应用程序保持同步到同一个数据库，`Redux`用于将应用程序状态的一部分共享给需要读取该状态的所有组件。

举个例子：我有一个可以与其他用户聊天的应用程序。我使`react-query`所有应用程序与用户收到的所有消息保持同步，然后将消息存储在其中，`Redux`以便在聊天页面和历史聊天页面上显示消息。

React Query 管理服务器状态。它的主要功能是处理Server和Client之间的功能。

Redux 处理客户端状态。Redux 可用于异步存储数据。

因此，它们在不同层面上都有其独特的作用，并且可以同时使用。

我们应该区分两种状态，**客户端状态**和**服务器（或远程）状态**：

*   客户端状态包含：
    *   本地创建的尚未持久化到服务器的数据。
    *   处理活动路由、选定选项卡、微调器、分页控件等的 UI 状态。
*   服务器状态是与以下内容相关的所有内容：
    *   数据远程保存，需要异步 API 来获取和更新

当涉及到客户端状态时，**Redux**是一个用于管理应用程序状态的出色管理工具。

另一方面，为了管理服务器状态，我们可以使用常规状态管理工具，但它们不太擅长处理异步或服务器状态。因此，为了解决这个问题，我们使用**React Query**。正如他们的文档中所述，**React 查询**是一个很棒的工具：

*   缓存...（可能是编程中最难做的事情）
*   将同一数据的多个请求合并为单个请求
*   在后台更新“过时”数据
*   了解数据何时“过时”
*   尽快反映数据更新
*   性能优化，例如分页和延迟加载数据
*   管理服务器状态的内存和垃圾收集
*   通过结构共享来记忆查询结果

React Query 和 Redux 是两个用于在React应用程序中管理状态的库，但它们的关注点和使用场景有一些显著的区别。

1. **设计目的**:
   - **React Query** 是专门为处理异步数据（服务器状态）而设计的，比如从API检索数据、缓存数据以及数据同步。
   - **Redux** 是一个更通用的状态管理库，它为JavaScript应用提供了一个可预测的状态容器，可以用来管理应用的客户端状态（UI状态）。

2. **数据缓存和失效**:
   - **React Query** 内建了数据缓存和自动失效的机制。它能够自动地在后台重新获取数据，以及在数据变得过时时标记它们。
   - **Redux** 本身并不直接提供这些功能。要在Redux中实现数据缓存和失效，通常需要额外的中间件或手动实现相应的逻辑。

3. **数据同步和更新**:
   - **React Query** 提供了一套内置的工具来处理数据的查询、突变（mutations）、更新和同步，这样在使用时只需要少量的样板代码。
   - **Redux** 需要手动管理数据同步和更新，通常涉及到编写action、reducer以及使用中间件来处理异步逻辑，这可能会导致较多的样板代码。

4. **配置和样板代码**:
   - **React Query** 的使用通常更简洁，它提供了hooks，如`useQuery`和`useMutation`，这些API可以让你直接在组件中发起数据请求。
   - **Redux** 的配置和使用相对复杂，特别是在项目初始搭建时。你需要定义actions、reducers、创建store等，虽然Redux Toolkit可以帮助减少一些样板代码。

5. **开发哲学**:
   - **React Query** 倾向于提供一种简化的方式来处理服务器状态，它鼓励你直接从组件内部加载数据，而不需要将所有的数据都放到全局状态管理中。
   - **Redux** 遵循Functional Programming的原则，通过使用纯函数（reducers）和不可变数据来管理和更新状态，这样可以更容易地跟踪状态的变化和进行时间旅行调试。

6. **社区和生态**:
   - **React Query** 在异步数据管理方面很受欢迎，但是它的生态相较于Redux来说较小，因为它比较专注于数据获取和缓存。
   - **Redux** 有一个庞大的社区和生态系统，包括许多中间件和附加库，如redux-thunk, redux-saga, reselect, redux-form等。

### 例子:
假设你的应用需要从一个REST API获取用户列表，并且你希望显示的数据是最新的。使用**React Query**，你可以这样做：

```jsx
import { useQuery } from 'react-query';

function UsersComponent() {
  const { data, error, isLoading } = useQuery('users', fetchUsers);

  // Render your UI based on the data, error, and loading state...
}
```

在这个例子中，`fetchUsers`是一个异步函数，它向API请求数据。`useQuery`会自动处理数据的加载、缓存、重载和更新。

而在**Redux**中，你可能需要创建actions和reducers来处理异步请求，并使用例如`redux-thunk`的中间件来处理异步逻辑：

```jsx
import { useDispatch, useSelector } from 'react-redux';

function UsersComponent() {
  const dispatch = useDispatch();
  const { users, error, isLoading } = useSelector(state => state.users);

  useEffect(() => {
    dispatch(fetchUsers());
  }, [dispatch]);

  // Render your UI based on the users, error, and loading state...

React Query 和 Redux 是两种不同类型的库，它们在React应用程序中承担着不同的角色。

**React Query** 是一个用于数据获取、缓存、同步和更新的库。它专注于处理异步数据操作，如从API检索数据、缓存结果以及自动重新获取数据。以下是React Query的一些关键特点：

- **自动缓存和无效化**：React Query自动缓存每次请求的结果，并在数据变化时提供重新获取数据的机制。
- **后台同步**：支持在数据变化或用户与应用程序互动时，自动在后台更新数据。
- **查询状态**: React Query 提供了丰富的状态信息，包括加载状态、错误状态、数据状态等，方便在UI中展示。
- **最小的全局状态管理**：React Query的目标是用最小的配置管理服务器状态。

**Redux** 是一个为JavaScript应用程序提供可预测状态容器的库，特别适合在React中使用。它主要用于管理和维护应用程序的全局状态，并提供一种模式来更新和访问这个状态。以下是Redux的一些关键特点：

- **全局状态管理**：Redux提供单一的全局状态树，所有状态的变化都通过派发行为(action)和归约器(reducers)的方式来管理。
- **可预测性**：因为所有的状态变化都遵循一个明确的流程，所以应用程序的行为是可预测的。
- **中间件**：Redux 支持使用中间件来扩展其功能，比如异步调用、日志记录等。
- **开发工具**：Redux拥有强大的开发工具，如Redux DevTools，可以帮助开发者追踪状态的变化和行为的派发。

**主要区别**：

1. **用途**：React Query主要用于数据同步，而Redux用于全局状态管理。
2. **数据管理**：React Query内置了数据获取和缓存的机制，而Redux需要开发者手动管理数据请求和响应结果。
3. **状态同步**：React Query提供自动的数据同步机制，Redux则需要结合额外的库（如redux-thunk或redux-saga）来处理异步逻辑。
4. **配置**：React Query减少了配置和样板代码的需要，Redux则需要更多的样板代码和配置步骤。
5. **开发体验**：React Query 的API设计更贴近React的hooks模式，而Redux通常需要遵循特定的设计模式和最佳实践。

例如，如果我们有一个用户列表，并且我们想通过React Query来获取这些用户，我们可能会这样做：

```javascript
import { useQuery } from 'react-query';

function Users() {
  const { isLoading, error, data } = useQuery('fetchUsers', fetchUsersApi);

  if (isLoading) return 'Loading...';
  if (error) return 'An error has occurred: ' + error.message;
  
  return (
    <ul>
      {data.map(user => (
        <li key={user.id}>{user.name}</li>
      ))}
    </ul>
  );
}

async function fetchUsersApi() {
  const response = await fetch('/api/users');
  if (!response.ok) {
    throw new Error('Network response was not ok');
  }
  return response.json();
}
```

使用Redux处理相同的数据获取，我们需要编写action creators、reducers以及相应的async action handlers：

```javascript
import { createStore, applyMiddleware } from 'redux';
import thunk from 'redux-thunk';
import { Provider, useDispatch, useSelector } from 'react-redux';

// Action types
const FETCH_USERS_REQUEST = 'FETCH_USERS_REQUEST';
const FETCH_USERS_SUCCESS = 'FETCH_USERS_SUCCESS';
const FETCH_USERS_FAILURE = 'FETCH_USERS_FAILURE';

// Action creators
const fetchUsersRequest = () => ({ type: FETCH_USERS_REQUEST });
const fetchUsersSuccess = users => ({ type: FETCH_USERS_SUCCESS, payload:

What is the main difference between React Query and Redux?

React 的 `setState` 函数并不保证立即更新组件的状态，这是因为 React 采用了一种名为批处理更新（batched updates）的性能优化策略。当您调用 `setState` 时，React 实际上将这个状态更改排入一个队列中，并非立即执行状态更新。这样做的目的是为了减少不必要的DOM操作和重渲染，从而提高应用程序的性能。

这里有几个关键点解释为什么 `setState` 不立即更新：

1. **异步更新**：`setState` 实际上是一个异步操作。React 会收集多次状态更改，然后一次性进行批量更新，这通常发生在浏览器的每一帧渲染结束之前。

2. **组件生命周期**：React 的设计理念是在组件的生命周期中的特定点上统一进行状态更新和渲染。如果每次调用 `setState` 都会立即触发重渲染，那么在处理复杂组件时会产生性能问题。

3. **避免不必要的渲染**：假设您在一个事件处理函数中连续调用了多次 `setState`。如果每次调用都立即更新，那么浏览器可能会进行多余的渲染操作，这显然是不高效的。通过批量更新，React 可以合并这些状态更改，并只进行一次渲染。

4. **并发模式**：在 React 的未来版本中（如 React 18 引入的并发模式），React 更加智能地调度更新，以便更好地利用浏览器的渲染能力，提供流畅的用户体验。

举个例子，假设在一个组件的事件处理函数中，你连续调用了三次 `setState`，每次都改变了组件状态中的一个值：

```javascript
this.setState({ value: this.state.value + 1 });
this.setState({ value: this.state.value + 1 });
this.setState({ value: this.state.value + 1 });
```

在上述代码中，你可能期望 `value` 的值会增加三次。但由于 React 的批处理和异步更新，这三次调用可能会合并成一次更新，`value` 只增加一次。

了解 `setState` 是异步的，对于编写正确的 React 代码非常重要。如果你需要在状态更新后立即执行某些操作，应该使用 `setState` 的回调函数，或者使用生命周期方法，比如 `componentDidUpdate`。

```javascript
this.setState({ value: this.state.value + 1 }, () => {
  console.log('状态更新完成，新的值为:', this.state.value);
});
```

在这个例子中，打印状态的操作会在状态更新且组件重新渲染后执行。

您应该调用第二个函数作为 setState 的回调，因为 setState 是异步发生的。就像是：

    this.setState({pencil:!this.state.pencil}, myFunction)
    

然而，在您的情况下，由于您希望使用参数调用该函数，因此您必须更具创意，并且也许创建自己的函数来调用道具中的函数：

    myFunction = () => {
      this.props.updateItem(this.state)
    }
    

将它们结合在一起应该可以工作。

`setState()`由于各种原因（主要是性能），React 中的调用是异步的。在幕后，React 会将多个调用批处理`setState()`为一个状态突变，然后重新渲染一次组件，而不是为每个状态更改都重新渲染。

幸运的是，解决方案相当简单 -`setState`接受回调参数：

    checkPencil: () => {
       this.setState(previousState => ({
          pencil: !previousState.pencil,
       }), () => {
          this.props.updateItem(this.state);
       });
    }

关于 Ben Hare 的回答，如果有人想使用 React Hooks 实现相同的目标，我在下面添加了示例代码。

    import React, { useState, useEffect } from "react"
    
    let [myArr, setMyArr] = useState([1, 2, 3, 4]) // the state on update of which we want to call some function
    
    const someAction = () => {
      let arr = [...myArr]
      arr.push(5) // perform State update
      setMyArr(arr) // set new state
    }
    
    useEffect(() => { // this hook will get called every time myArr has changed
       // perform some action every time myArr is updated
       console.log('Updated State', myArr)
    }, [myArr])

当您使用当前状态的属性更新状态时，React 文档建议您使用函数调用版本而`setState`不是对象。

所以`setState((state, props) => {...})`代替`setState(object)`.

原因是这`setState`更多的是要求国家改变而不是立即改变。React 会批量处理这些`setState`提高性能的请求。

这意味着您正在检查的国有财产可能不稳定。这是一个需要注意的潜在陷阱。

有关更多信息，请参阅此处的文档： https: [//facebook.github.io/react/docs/react-component.html#setstate](https://facebook.github.io/react/docs/react-component.html#setstate)

* * *

为了回答你的问题，我会这样做。

    checkPencil(){
        this.setState((prevState) => {
            return {
                pencil: !prevState.pencil
            };
        }, () => {
            this.props.updateItem(this.state)
        });
    }

这是因为它是**异步**发生的，所以意味着那时可能还没有更新......

根据 React v.16 文档，您需要使用第二种形式来`setState()`接受函数而不是对象：

> ### 状态更新可能是异步的
> 
> React 可以将多个 setState() 调用批处理为单个更新以提高性能。
> 
> 由于 this.props 和 this.state 可能会异步更新，因此您不应依赖它们的值来计算下一个状态。
> 
> 例如，以下代码可能无法更新计数器：

    // Wrong
    this.setState({
      counter: this.state.counter + this.props.increment,
    });
    

> 要修复此问题，请使用 setState() 的第二种形式，它接受函数而不是对象。该函数将接收先前的状态作为第一个参数，并将应用更新时的 props 作为第二个参数：

    // Correct
    this.setState((prevState, props) => ({
      counter: prevState.counter + props.increment
    }));

Why react setstate is not updating immediately?

在使用`create-react-app`创建的React项目中，可以通过设置环境变量`PORT`来指定应用的运行端口。这里有几种方式可以设置这个环境变量：

### 使用命令行直接设置

在启动项目时，可以在命令行中直接指定`PORT`环境变量。例如在Unix系统（包括macOS和Linux）上，你可以使用以下命令：

```bash
PORT=3001 npm start
```

而在Windows上，你可以使用`set`命令：

```bash
set PORT=3001 && npm start
```

如果你使用的是Windows PowerShell，命令会有所不同：

```powershell
$env:PORT=3001; npm start
```

### 使用.env文件

`create-react-app`支持加载项目根目录下的`.env`文件中的环境变量。你可以创建一个`.env`文件（如果还没有的话），然后在该文件中添加如下内容来指定端口：

```
PORT=3001
```

每次运行`npm start`时，`create-react-app`都会加载`.env`文件中的环境变量。

### 综合示例

假设你的项目需要在端口`3001`上运行。你可以首先创建一个`.env`文件在你的项目根目录下（如果已经存在，就编辑它），然后添加如下内容：

```
PORT=3001
```

保存文件后，每次你运行`npm start`，React开发服务器就会自动在端口3001上启动。

如果你偶尔需要在不同的端口上运行，你可以临时在命令行中覆盖`.env`文件中的设置，例如：

```bash
PORT=3002 npm start
```

这样，即使`.env`文件中指定的是端口`3001`，应用也会在端口`3002`上启动。

请注意，端口只能指定一个未被使用的端口号。如果指定的端口已经被其他应用占用，React开发服务器会报错，告知该端口已被占用。

If you don't want to set the [environment variable](https://stackoverflow.com/a/40714921/4249707), another option is to modify the `scripts` part of package.json from:

    "start": "react-scripts start"
    

to

**Linux** (tested on Ubuntu 14.04/16.04) and **MacOS** (tested by aswin-s on MacOS Sierra 10.12.4):

    "start": "PORT=3006 react-scripts start"
    

or (may be) more general solution by [IsaacPak](https://stackoverflow.com/users/1991020/isaac-pak)

    "start": "export PORT=3006 react-scripts start"
    

**Windows** [JacobEnsor](https://stackoverflow.com/users/1389990/jacob-ensor)'s solution

    "start": "set PORT=3006 && react-scripts start"
    

**cross-env lib** works everywhere. See Aguinaldo Possatto's [answer](https://stackoverflow.com/a/48669909/4249707) for details

**Update due to the popularity of my answer:** Currently I prefer to use environment variables saved in [`.env`](https://stackoverflow.com/a/42232944/4249707) file(useful to store sets of variables for different `deploy` configurations in a convenient and readable form). Don't forget to add `*.env` into `.gitignore` if you're still storing your secrets in `.env` files. [Here](https://12factor.net/config) is the explanation of why using environment variables is better in the most cases. [Here](https://diogomonica.com/2017/03/27/why-you-shouldnt-use-env-variables-for-secret-data/) is the explanation of why storing secrets in environment is bad idea.

Here is another way to accomplish this task.

Create a `.env` file at your project root and specify port number there. Like:

    PORT=3005

Create a file with name `.env` in the main directory besides`package.json` and set `PORT` variable to desired port number.

For example:

**.env**

    PORT=4200
    

You can find the documentation for this action here: [https://create-react-app.dev/docs/advanced-configuration](https://create-react-app.dev/docs/advanced-configuration)

You could use [**cross-env**](https://github.com/kentcdodds/cross-env) to set the port, and it will work on Windows, Linux and Mac.

    yarn add -D cross-env
    

then in package.json the start link could be like this:

    "start": "cross-env PORT=3006 react-scripts start",

**Method 1**

Create .env File in the root folder of a project

[![enter image description here](https://i.stack.imgur.com/B7E0y.png)](https://i.stack.imgur.com/B7E0y.png)

Set like this

    PORT=3005
    

**Method 2**

[![enter image description here](https://i.stack.imgur.com/4bCsC.png)](https://i.stack.imgur.com/4bCsC.png)

In _package.json_

    set PORT=3006 && react-scripts start

How to specify a port to run a create- react -app based project?

在React中实现防抖函数(debounce function)通常涉及到在组件中使用一个特定的函数，该函数能够延迟执行实际的处理逻辑，直到停止触发一段时间后。这样做可以减少像输入框连续输入这样的事件处理函数的调用次数，从而提高性能。

下面是在React组件中实现防抖功能的步骤：

1. **创建防抖函数：**
   创建一个防抖函数，该函数会接收一个要延迟执行的函数 `func` 和延迟执行的时间 `wait`。

```javascript
const debounce = (func, wait) => {
  let timeout;

  return function executedFunction(...args) {
    const later = () => {
      clearTimeout(timeout);
      func(...args);
    };

    clearTimeout(timeout);
    timeout = setTimeout(later, wait);
  };
};
```

2. **在React组件中使用防抖函数：**
   使用 `useEffect` 钩子配合防抖函数实现防抖效果。

假设我们有一个搜索输入框，我们想要在用户停止输入一段时间后再触发搜索，避免每次键入都进行搜索：

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

const SearchComponent = () => {
  const [inputValue, setInputValue] = useState('');

  // 定义防抖函数
  const debounceSearch = debounce((searchValue) => {
    console.log(`搜索: ${searchValue}`);
    // 在这里执行搜索逻辑，例如 API 调用
  }, 500);

  useEffect(() => {
    if (inputValue) {
      debounceSearch(inputValue);
    }
  }, [inputValue]);

  return (
    <input
      type="text"
      value={inputValue}
      onChange={(e) => setInputValue(e.target.value)}
      placeholder="输入关键词进行搜索"
    />
  );
};

export default SearchComponent;
```

上面的例子中，我们在输入框的 `onChange` 事件中设置了 `inputValue` 的值，然后我们在 `useEffect` 中使用 `inputValue` 作为依赖项，这表示当 `inputValue` 改变时，`useEffect` 的回调会被执行。在 `useEffect` 的回调中，我们调用了 `debounceSearch` 函数，它会延迟执行搜索逻辑，直到用户停止输入500毫秒后。

这样，无论用户输入多快，真正的搜索逻辑只会在用户停止输入一段时间后才会执行，大大减少了不必要的处理和API调用。

### 2019：尝试 hooks + Promise debouncing

这是我解决此问题的最新版本。我会用：

*   [Awesome-debounce-promise](https://github.com/slorber/awesome-debounce-promise)来消除异步函数的抖动
*   [使用常量](https://github.com/Andarist/use-constant)将去抖函数存储到组件中
*   [React-async-hook](https://github.com/slorber/react-async-hook)将结果获取到我的组件中

这是一些初始接线，但是您正在自己编写原始块，并且您可以创建自己的自定义挂钩，这样您只需要做一次。

    // Generic reusable hook
    const useDebouncedSearch = (searchFunction) => {
    
      // Handle the input text state
      const [inputText, setInputText] = useState('');
    
      // Debounce the original search async function
      const debouncedSearchFunction = useConstant(() =>
        AwesomeDebouncePromise(searchFunction, 300)
      );
    
      // The async callback is run each time the text changes,
      // but as the search function is debounced, it does not
      // fire a new request on each keystroke
      const searchResults = useAsync(
        async () => {
          if (inputText.length === 0) {
            return [];
          } else {
            return debouncedSearchFunction(inputText);
          }
        },
        [debouncedSearchFunction, inputText]
      );
    
      // Return everything needed for the hook consumer
      return {
        inputText,
        setInputText,
        searchResults,
      };
    };
    

然后你可以使用你的钩子：

    const useSearchStarwarsHero = () => useDebouncedSearch(text => searchStarwarsHeroAsync(text))
    
    const SearchStarwarsHeroExample = () => {
      const { inputText, setInputText, searchResults } = useSearchStarwarsHero();
      return (
        <div>
          <input value={inputText} onChange={e => setInputText(e.target.value)} />
          <div>
            {searchResults.loading && <div>...</div>}
            {searchResults.error && <div>Error: {search.error.message}</div>}
            {searchResults.result && (
              <div>
                <div>Results: {search.result.length}</div>
                <ul>
                  {searchResults.result.map(hero => (
                    <li key={hero.name}>{hero.name}</li>
                  ))}
                </ul>
              </div>
            )}
          </div>
        </div>
      );
    };
    

您会发现此示例[在此处](https://react-async-hook.netlify.com)运行，您应该阅读[react-async-hook](https://github.com/slorber/react-async-hook)文档以获取更多详细信息。

* * *

### 2018：尝试消除承诺

我们经常希望消除 API 调用的反跳，以避免无用的请求淹没后端。

在 2018 年，使用回调（[Lodash](https://en.wikipedia.org/wiki/Lodash) / [Underscore.js](https://en.wikipedia.org/wiki/Underscore.js)）对我来说感觉很糟糕并且容易出错。由于 API 调用以任意顺序解析，因此很容易遇到样板文件和并发问题。

我创建了一个考虑到 React 的小库来解决你的痛苦：[awesome-debounce-promise](https://github.com/slorber/awesome-debounce-promise)。

这不应该比以下更复杂：

    const searchAPI = text => fetch('/search?text=' + encodeURIComponent(text));
    
    const searchAPIDebounced = AwesomeDebouncePromise(searchAPI, 500);
    
    class SearchInputAndResults extends React.Component {
      state = {
        text: '',
        results: null,
      };
    
      handleTextChange = async text => {
        this.setState({ text, results: null });
        const result = await searchAPIDebounced(text);
        this.setState({ result });
      };
    }
    

去抖功能可确保：

*   API 调用将被反跳
*   去抖函数总是返回一个承诺
*   只有最后一个调用返回的承诺才会解决
*   `this.setState({ result });`每次API 调用都会发生一次

最后，如果您的组件卸载，您可以添加另一个技巧：

    componentWillUnmount() {
      this.setState = () => {};
    }
    

请注意，**Observables**（[RxJS](https://github.com/Reactive-Extensions/RxJS)）也非常适合消除输入的抖动，但它是一个更强大的抽象，可能更难正确学习/使用。

* * *

### < 2017：仍然想使用回调去抖动？

这里重要的部分是**为每个组件实例创建一个去抖动（或节流）函数**。您不想每次都重新创建去抖（或节流）函数，并且不希望多个实例共享相同的去抖函数。

我没有在这个答案中定义去抖动函数，因为它并不真正相关，但是这个答案可以与`_.debounce`Underscore.js 或 Lodash 以及任何用户提供的去抖动函数完美配合。

* * *

#### 好主意：

由于去抖函数是有状态的，因此我们必须**为每个组件实例创建一个去抖函数**。

**[ES6](https://en.wikipedia.org/wiki/ECMAScript#6th_Edition_%E2%80%93_ECMAScript_2015)（类属性）**：推荐

    class SearchBox extends React.Component {
        method = debounce(() => {
          ...
        });
    }
    

**ES6（类构造函数）**

    class SearchBox extends React.Component {
        constructor(props) {
            super(props);
            this.method = debounce(this.method.bind(this),1000);
        }
        method() { ... }
    }
    

**[ES5](https://en.wikipedia.org/wiki/ECMAScript#5th_Edition_%E2%80%93_ECMAScript_2009)**

    var SearchBox = React.createClass({
        method: function() {...},
        componentWillMount: function() {
           this.method = debounce(this.method.bind(this),100);
        },
    });
    

请参阅[JSFiddle](https://jsfiddle.net/0mLb4vnp/)：三个实例每个实例生成一个日志条目（全局为三个）。

* * *

##### _这不是_一个好主意：

    var SearchBox = React.createClass({
      method: function() {...},
      debouncedMethod: debounce(this.method, 100);
    });
    

这是行不通的，因为在类描述对象创建过程中，`this`对象本身并不是创建的。`this.method`不会返回您期望的内容，因为`this`上下文不是对象本身（顺便说一句，它实际上还不存在，因为它刚刚被创建）。

* * *

##### _这不是_一个好主意：

    var SearchBox = React.createClass({
      method: function() {...},
      debouncedMethod: function() {
          var debounced = debounce(this.method,100);
          debounced();
      },
    });
    

这次，您实际上创建了一个去抖函数，该函数调用您的`this.method`. 问题是您在每次`debouncedMethod`调用时都重新创建它，因此新创建的去抖函数对以前的调用一无所知！随着时间的推移，您必须重复使用相同的去抖函数，否则去抖将不会发生。

* * *

##### _这不是_一个好主意：

    var SearchBox = React.createClass({
      debouncedMethod: debounce(function () {...},100),
    });
    

这里有点棘手。

该类的所有已安装实例将共享相同的去抖函数，而大多数情况下这不是您想要的！请参阅[JSFiddle](https://jsfiddle.net/5trmuzau/)：三个实例在全局范围内仅生成一个日志条目。

您必须**为每个组件实例**创建一个去抖函数，而不是在类级别创建由每个组件实例共享的单个去抖函数。

* * *

### 照顾 React 的事件池

这是相关的，因为我们经常想要消除或限制 DOM 事件。

在 React 中，您在回调中收到的事件对象（即`SyntheticEvent`）被池化（现在已[记录](https://facebook.github.io/react/docs/events.html#event-pooling)）。这意味着在调用事件回调后，您收到的 SyntheticEvent 将以空属性放回池中，以减少[GC](https://en.wikipedia.org/wiki/Garbage_collection_%28computer_science%29)压力。

因此，如果您`SyntheticEvent`与原始回调异步访问属性（如果您限制/反跳，可能会出现这种情况），您访问的属性可能会被删除。如果您希望事件永远不会被放回池中，您可以使用该`persist()`方法。

##### 没有持久化（默认行为：池化事件）

    onClick = e => {
      alert(`sync -> hasNativeEvent=${!!e.nativeEvent}`);
      setTimeout(() => {
        alert(`async -> hasNativeEvent=${!!e.nativeEvent}`);
      }, 0);
    };
    

第二个（异步）将打印`hasNativeEvent=false`，因为事件属性已被清理。

##### 凭着坚持

    onClick = e => {
      e.persist();
      alert(`sync -> hasNativeEvent=${!!e.nativeEvent}`);
      setTimeout(() => {
        alert(`async -> hasNativeEvent=${!!e.nativeEvent}`);
      }, 0);
    };
    

第二个（异步）将打印`hasNativeEvent=true`，因为`persist`允许您避免将事件放回池中。

您可以在这里测试这两种行为：[JSFiddle](https://jsfiddle.net/d1mghxm5/)

阅读[Julen 的答案](https://stackoverflow.com/a/24679479/82609)`persist()`，了解使用油门/去抖功能的示例。

### 不受控制的组件

您可以使用该[`event.persist()`方法](https://facebook.github.io/react/docs/events.html#event-pooling)。

[下面是使用Underscore.js](https://en.wikipedia.org/wiki/Underscore.js) '的示例`_.debounce()`：

    var SearchBox = React.createClass({
    
      componentWillMount: function () {
         this.delayedCallback = _.debounce(function (event) {
           // `event.target` is accessible now
         }, 1000);
      },
    
      onChange: function (event) {
        event.persist();
        this.delayedCallback(event);
      },
    
      render: function () {
        return (
          <input type="search" onChange={this.onChange} />
        );
      }
    
    });
    

请参阅[这个 JSFiddle](http://jsfiddle.net/TzLZq/2/)。

* * *

### 受控组件

上面的例子显示了一个[不受控制的组件](http://facebook.github.io/react/docs/forms.html#uncontrolled-components)。我一直使用受控元素，所以这是上面的另一个例子，但没有使用`event.persist()`“欺骗”。

JSFiddle也[可用。](http://jsfiddle.net/87epx3yt/6/)[不带下划线的示例](http://jsfiddle.net/c7a0joha)

    var SearchBox = React.createClass({
        getInitialState: function () {
            return {
                query: this.props.query
            };
        },
    
        componentWillMount: function () {
           this.handleSearchDebounced = _.debounce(function () {
               this.props.handleSearch.apply(this, [this.state.query]);
           }, 500);
        },
    
        onChange: function (event) {
          this.setState({query: event.target.value});
          this.handleSearchDebounced();
        },
    
        render: function () {
          return (
            <input type="search"
                   value={this.state.query}
                   onChange={this.onChange} />
          );
        }
    });
    
    
    var Search = React.createClass({
        getInitialState: function () {
            return {
                result: this.props.query
            };
        },
    
        handleSearch: function (query) {
            this.setState({result: query});
        },
    
        render: function () {
          return (
            <div id="search">
              <SearchBox query={this.state.result}
                         handleSearch={this.handleSearch} />
              <p>You searched for: <strong>{this.state.result}</strong></p>
            </div>
          );
        }
    });
    
    React.render(<Search query="Initial query" />, document.body);

2019：使用“useCallback”反应钩子
------------------------

在尝试了许多不同的方法之后，我发现 using`useCallback`是解决事件`debounce`中使用的多次调用问题的最简单且最有效的方法`onChange`。

根据[Hooks API 文档](https://reactjs.org/docs/hooks-reference.html#usecallback)，

> useCallback 返回回调的记忆版本，仅当依赖项之一发生更改时该版本才会更改。

将空数组作为依赖项传递可确保回调仅被调用一次。这是一个简单的实现：

    import React, { useCallback } from "react";
    import { debounce } from "lodash";
    
    const handler = useCallback(debounce(someFunction, 2000), []);
        
    const onChange = (event) => {
        // perform any event related action here
        
        handler();
     };

在与文本输入斗争了一段时间并且自己没有找到完美的解决方案之后，我在 npm 上找到了这个：[react-debounce-input](https://www.npmjs.com/package/react-debounce-input)。

这是一个简单的例子：

    import React from 'react';
    import ReactDOM from 'react-dom';
    import {DebounceInput} from 'react-debounce-input';
    
    class App extends React.Component {
    state = {
        value: ''
    };
    
    render() {
        return (
        <div>
            <DebounceInput
            minLength={2}
            debounceTimeout={300}
            onChange={event => this.setState({value: event.target.value})} />
    
            <p>Value: {this.state.value}</p>
        </div>
        );
    }
    }
    
    const appRoot = document.createElement('div');
    document.body.appendChild(appRoot);
    ReactDOM.render(<App />, appRoot);
    

DebounceInput 组件接受您可以分配给普通输入元素的所有属性。[在CodePen](http://codepen.io/nkbt/pen/VvmzLQ?editors=0010)上尝试一下。

可以有一种使用[React hooks 的](https://en.wikipedia.org/wiki/React_(web_framework)#React_hooks)简单方法。

第 1 步：定义一个状态来维护搜索到的文本

    const [searchTerm, setSearchTerm] = useState('')
    

步骤 2：使用 useEffect 捕获任何变化`searchTerm`

    useEffect(() => {
      const delayDebounceFn = setTimeout(() => {
        if (searchTerm) {
          // Write your logic here
        }
      }, 400)
    
      return () => clearTimeout(delayDebounceFn)
    }, [searchTerm])
    

第三步：编写一个函数来处理输入变化

    function handleInputChange(value) {
      if (value) {
        setSearchTerm(value)
      }
    }
    

就这样！在需要时调用此方法。

How can I perform a debounce in React ?

当您在React的函数组件中使用`useState`钩子来设置一个状态值时，您可能会注意到，调用设置状态的函数后，状态的值不会立即改变。这是因为React中的状态设置是异步的。具体来说，这意味着React将在稍后某个时间点批量处理状态更新和重新渲染组件，而不是在调用设置状态函数的时候立即更新状态和重新渲染。

这样做有几个好处：
1. **性能优化**：通过合并多个状态更新，React可以减少不必要的渲染次数，从而避免额外的性能开销。
2. **一致性保障**：这样可以确保在一个事件处理函数中，不会因为状态更新导致其他状态的计算出现不一致的情况。

请看以下例子来说明这一点：

```jsx
import React, { useState } from 'react';

function Counter() {
  const [count, setCount] = useState(0);

  const handleClick = () => {
    // 这里尝试连续更新状态，但状态的变化不会立即反映
    setCount(count + 1);
    setCount(count + 1);
    // 在这个函数调用后，你可能会期待count是2，但是实际上它仍然是0
    // 因为这两次更新会被合并，且基于相同的开始状态（0）计算
  };

  return (
    <div>
      <p>Count: {count}</p>
      <button onClick={handleClick}>Increment</button>
    </div>
  );
}
```

在上面的例子中，当`handleClick`函数被调用时，即使我们调用了两次`setCount`来增加`count`，但在这个事件处理函数结束之前，你不会看到`count`的值发生变化。在实践中，如果你希望连续的状态更新彼此依赖，你应该使用函数形式的`setState`来确保每次更新都基于最新的状态：

```jsx
setCount(previousCount => previousCount + 1);
```

使用函数形式的更新可以确保每次更新都基于上一次更新后的状态，而不是基于状态的闭包值。

与通过扩展or创建的[类组件](https://stackoverflow.com/q/30782948/1048572)非常[相似`.setState()`](https://stackoverflow.com/q/30782948/1048572)，使用 hook 提供的更新程序进行的状态更新也是异步的，并且不会立即反映。`React.Component``React.PureComponent``useState`

**此外，这里的主要问题不仅仅是异步性质，而是函数根据当前闭包使用状态值的事实，并且状态更新将反映在下一次重新渲染中，现有闭包不受影响，但新的闭包不会受到影响。那些被创建了**。现在在当前状态下，钩子内的值是通过现有的闭包获取的，当重新渲染发生时，闭包会根据函数是否再次重新创建而更新。

即使您添加了一个`setTimeout`函数，尽管超时将在重新渲染发生一段时间后运行，但该函数`setTimeout`仍将使用其先前闭包中的值，而不是更新后的值。

    setMovies(result);
    console.log(movies) // movies here will not be updated
    

如果要对状态更新执行操作，则需要使用钩子`useEffect`，就像`componentDidUpdate`在类组件中使用一样，因为返回的 setter`useState`没有回调模式

    useEffect(() => {
        // action on update of movies
    }, [movies]);
    

就更新状态的语法而言，将用异步请求中可用的值替换状态中的`setMovies(result)`先前值。`movies`

但是，如果要将响应与先前存在的值合并，则必须使用状态更新的回调语法以及正确使用扩展语法，例如

    setMovies(prevMovies => ([...prevMovies, ...result]));

_[先前答案](https://stackoverflow.com/a/54069332/1176601)的更多详细信息：_

虽然 React`setState` _是_异步的（类和钩子），并且很容易用这个事实来解释观察到的行为，但这并不是它发生的_**原因**_。

TLDR：原因是围绕不可变值的[闭包](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Closures)`const`范围。

* * *

### _解决方案：_

*   读取渲染函数中的值（不在嵌套函数内）：
    
          useEffect(() => { setMovies(result) }, [])
          console.log(movies)
        
    
*   将变量添加到依赖项中（并使用[react-hooks/exhaustive-deps](https://reactjs.org/docs/hooks-rules.html#eslint-plugin) eslint规则）：
    
          useEffect(() => { setMovies(result) }, [])
          useEffect(() => { console.log(movies) }, [movies])
        
    
*   使用临时变量：
    
          useEffect(() => {
            const newMovies = result
            console.log(newMovies)
            setMovies(newMovies)
          }, [])
        
    
*   使用可变引用（如果我们不需要状态而只想记住值 - 更新引用不会触发重新渲染）：
    
          const moviesRef = useRef(initialValue)
          useEffect(() => {
            moviesRef.current = result
            console.log(moviesRef.current)
          }, [])
        
    

* * *

### _解释为什么会发生：_

如果异步是唯一的原因，那么就有可能`await setState()`。

但是，假定`props`和`state`两者[在 1 render 期间保持不变](https://reactjs.org/docs/react-component.html#state)。

> `this.state`就好像它是不可变的一样对待。

对于钩子，通过使用带有关键字的**常量值**来增强这种假设`const`：

    const [state, setState] = useState('initial')
    

两次渲染之间的值可能不同，但在渲染本身和任何[闭包](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Closures)内（即使在渲染完成后存活时间更长的函数，例如`useEffect`，任何 Promise 或 setTimeout 内的事件处理程序）仍然保持不变。

考虑以下假的、但**同步的**、类似 React 的实现：

    // sync implementation:
    
    let internalState
    let renderAgain
    
    const setState = (updateFn) => {
      internalState = updateFn(internalState)
      renderAgain()
    }
    
    const useState = (defaultState) => {
      if (!internalState) {
        internalState = defaultState
      }
      return [internalState, setState]
    }
    
    const render = (component, node) => {
      const {html, handleClick} = component()
      node.innerHTML = html
      renderAgain = () => render(component, node)
      return handleClick
    }
    
    // test:
    
    const MyComponent = () => {
      const [x, setX] = useState(1)
      console.log('in render:', x) // ✅
      
      const handleClick = () => {
        setX(current => current + 1)
        console.log('in handler/effect/Promise/setTimeout:', x) // ❌ NOT updated
      }
      
      return {
        html: `<button>${x}</button>`,
        handleClick
      }
    }
    
    const triggerClick = render(MyComponent, document.getElementById('root'))
    triggerClick()
    triggerClick()
    triggerClick()

    <div id="root"></div>

运行代码片段隐藏结果

展开片段

我知道已经有很好的答案了。但我想给出另一个想法如何解决同样的问题，并使用我的模块[react-useStateRef](https://www.npmjs.com/package/react-usestateref)访问最新的“电影”状态，它每周的下载量超过11,000次。

正如您所理解的，通过使用 React 状态，您可以在每次状态更改时渲染页面。但通过使用 React ref，您始终可以获得最新值。

因此，该模块`react-useStateRef`允许您一起使用状态和引用。它向后兼容`React.useState`，因此您只需替换该`import`语句即可

    const { useEffect } = React
    import { useState } from 'react-usestateref'
    
      const [movies, setMovies] = useState(initialValue);
    
      useEffect(() => {
        (async function() {
          try {
    
            const result = [
              {
                id: "1546514491119",
              },
            ];
            console.log("result =", result);
            setMovies(result);
            console.log("movies =", movies.current); // will give you the latest results
          } catch (e) {
            console.error(e);
          }
        })();
      }, []);
    

更多信息：
-----

*   [反应-usestateref](https://www.npmjs.com/package/react-usestateref)

React 的 useEffect 有自己的状态/生命周期。它与状态的突变有关，直到效果被破坏时才会更新状态。

只需在参数状态中传递一个参数或将其保留为黑色数组即可完美运行。

    React.useEffect(() => {
        console.log("effect");
        (async () => {
            try {
                let result = await fetch("/query/countries");
                const res = await result.json();
                let result1 = await fetch("/query/projects");
                const res1 = await result1.json();
                let result11 = await fetch("/query/regions");
                const res11 = await result11.json();
                setData({
                    countries: res,
                    projects: res1,
                    regions: res11
                });
            } catch {}
        })(data)
    }, [setData])
    # or use this
    useEffect(() => {
        (async () => {
            try {
                await Promise.all([
                    fetch("/query/countries").then((response) => response.json()),
                    fetch("/query/projects").then((response) => response.json()),
                    fetch("/query/regions").then((response) => response.json())
                ]).then(([country, project, region]) => {
                    // console.log(country, project, region);
                    setData({
                        countries: country,
                        projects: project,
                        regions: region
                    });
                })
            } catch {
                console.log("data fetch error")
            }
        })()
    }, [setData]);
    

或者，您可以尝试 React.useRef() 在 React hook 中进行即时更改。

    const movies = React.useRef(null);
    useEffect(() => {
    movies.current='values';
    console.log(movies.current)
    }, [])

这里的大多数答案都是关于如何根据其先前的值更新状态，但我不明白这与问题有何关系

> useState set 方法没有立即反映更改

* * *

反应18
====

useState 是异步的：
--------------

当触发某个代码的事件发生时，代码开始运行，当它完成时，react将检查是否有状态更新，如果是，则**只有**`useState`更新钩子的值，这会导致一个新的渲染，其中新值可用。  

    const [example,setExemple] = useState("")
    //...
    <button
      onClick={() => {
        const newValue = "new";
        setExample(newValue);
        console.log(example); // output "" and this is normal, because the component didn't rerenderd yet so the new value is not availabe yet
      }}
    >
      Update state
    </button>
    

假设我们有一个场景，其中一个状态依赖于另一个状态，例如我们希望根据`example`每次更新时的新值进行 API 调用，然后将响应中的数据存储在另一个状态中`anotherExample`。  
为了实现这样我们有两种方法：

**1\. 使用 的值`newValue`：  
**

    <button
      onClick={async () => {
        const newValue = "new";
        const response = await axios.get(`http://127.0.0.1:5000/${newValue}`);
        setExample(newValue);
        setAnotherExample(response.data);
      }}
    >
      test
    </button>
    

因为您知道`example`将收到该值，所以您可以直接基于它创建逻辑。

**2.每次更新时触发[useEffect](https://reactjs.org/docs/hooks-effect.html)运行，方法是将其包含在其依赖项数组中：`example``example`**  

    <button
      onClick={() => {
        const newValue = "new";
        setExample(newValue);
      }}
    >
      test
    </button>
    

    useEffect(() => {
     async function test(){
      const response = await axios.get(`http://127.0.0.1:5000/${example}`);
      setAnotherExample(response.data);
     } 
     test();
    }, [example])
    

因此，当`example`使用事件函数更新组件重新渲染时，**我们现在处于一个新的不同渲染中**，一旦完成，`useEffect`就会运行**，因为 的值`example`与上次渲染期间的值不同**，并且因为它是一个新的不同渲染， useState 挂钩的新值`example`可在此处获得。

**注意：**`useEffect`在第一次安装期间，钩子无论如何都会运行。

哪种方法更好？
-------

*   而第一种方法将使所有工作在一次渲染中完成**（更好的方法）** “React 将多个状态更新分组到单个重新渲染中以获得更好的性能”，第二种方法将在两次渲染中完成，第一次`example`更新时和第二个`anotherExample`是从内部更新的`useEffect`😕
    
*   由于组件仅在`useState`钩子的新值与旧值不同时才重新渲染，因此当`newValue`等于 时`example`组件不会重新渲染，因此`useEffect`不会运行且`anotherExample`不会更新 🙂 **（更好的方法）**，但是在第一个中无论如何，API 都会被调用，如果没有必要，我们不想这样做，如果发生这种情况，`anotherExample`也会更新（`anotherExample`将收到它已经包含的相同数据，因为它是相同的请求，因为`newValue`等于`example`）但是如果然后，在对象或数组中响应，`Object.is`方法（钩子`useState`使用的）无法检测新值是否等于前一个值，因此，组件将重新渲染😕
    

结论：
---

正如上面提到的，每种都有其优点，所以这取决于用例。

**更推荐使用第二种方法**，但是在某些情况下，第一种方法的性能更高，例如，当您确定代码仅在`newValue`使用 获取新值时才会运行`onChange`，或者当您想使用您将要使用的其他一些局部变量时不再能够从 useEffect 内部访问

The useState set method is not reflecting a change immediately

在React中，我们可以使用不同的方法来从URL字符串中获取参数值，这通常涉及到处理路由。一个流行的库是React Router。以下是使用React Router v5和v6来从URL中获取参数值的几种方法。

### 使用 React Router v5

在React Router v5中，你可以通过`match`对象来访问URL参数。这些参数是通过定义在路由中的`path`属性捕获的。例子如下：

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

const MyComponent = () => {
  // 使用 useParams 钩子来获取参数
  let { param1 } = useParams();

  // 现在你可以使用 param1 作为变量了
  return <div>参数值: {param1}</div>;
};

export default MyComponent;
```

在这个例子中，如果你的应用路由定义如下：

```jsx
<Route path="/somepath/:param1" component={MyComponent} />
```

当用户访问`/somepath/value1`时，`param1`将会是`value1`。

### 使用 React Router v6

在React Router v6中，获取参数的方式类似，但是更倾向于使用钩子而不是组件的props。这是一个例子：

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

const MyComponent = () => {
  // 使用 useParams 钩子来获取参数
  const { param1 } = useParams();

  // 现在你可以使用 param1 作为变量了
  return <div>参数值: {param1}</div>;
};

export default MyComponent;
```

路由定义：

```jsx
import { Route, Routes } from 'react-router-dom';

// ...

<Routes>
  <Route path="/somepath/:param1" element={<MyComponent />} />
</Routes>
```

在这种情况下，`useParams` 钩子同样被用来获取动态路径参数。

### 查询参数

如果你需要获取的是查询参数（query parameters），也就是URL中`?`后面的那部分，则可以使用`useLocation`钩子来获取整个location对象，其中包括查询字符串：

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

const useQuery = () => {
  return new URLSearchParams(useLocation().search);
};

const MyComponent = () => {
  const query = useQuery();
  const paramValue = query.get('param1'); // 假设URL是 /somepath?param1=value1

  return <div>查询参数值: {paramValue}</div>;
};

export default MyComponent;
```

这里，`useQuery`是一个自定义钩子，它封装了创建`URLSearchParams`实例的逻辑，让你可以通过`get`方法来获取特定的查询参数值。在这个例子中，如果URL是`/somepath?param1=value1`，那么`paramValue`变量将会是`value1`。

总的来说，在React中获取URL参数主要通过使用`useParams`来获取动态路由参数，以及通过`useLocation`和`URLSearchParams`来获取查询参数。这些是React Router库提供的工具，但它们实际上都是基于原生的Web API（比如`window.location`）进行封装的。在React中，从URL字符串中获取参数通常涉及到使用React Router库，因为它为路由相关的任务提供了方便的工具和组件。以下是在不同版本的React Router中获取URL参数的方法。

### 如果您使用的是 React Router v5：

您可以通过`useParams`钩子或`withRouter`高阶组件来获取参数值。这里有两个例子：

1. **使用`useParams`钩子** (适用于函数组件):
   ```javascript
   import React from 'react';
   import { useParams } from 'react-router-dom';

   const MyComponent = () => {
     let { myParam } = useParams();
     console.log(myParam); // 打印出URL参数myParam的值

     // 做其他操作...
     
     return <div>URL中的参数值: {myParam}</div>;
   };

   export default MyComponent;
   ```

   在这个例子中，如果您的路由定义是`<Route path="/somepath/:myParam" component={MyComponent} />`，那么当您访问`/somepath/value`时，`myParam`将会是`value`。

2. **使用`withRouter`高阶组件** (适用于类组件):
   ```javascript
   import React, { Component } from 'react';
   import { withRouter } from 'react-router-dom';

   class MyComponent extends Component {
     componentDidMount() {
       let { myParam } = this.props.match.params;
       console.log(myParam); // 打印出URL参数myParam的值
     }

     render() {
       let { myParam } = this.props.match.params;
       return <div>URL中的参数值: {myParam}</div>;
     }
   }

   export default withRouter(MyComponent);
   ```

   `withRouter`会向您的组件提供`match`、`location`和`history`对象，您可以通过这些对象来访问路由的相关信息。

### 如果您使用的是 React Router v6：

在React Router v6中，`useParams`仍然存在，但`withRouter`已经被移除。以下是使用`useParams`钩子的方法：

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

const MyComponent = () => {
  let { myParam } = useParams();
  console.log(myParam); // 打印出URL参数myParam的值

  // 做其他操作...

  return <div>URL中的参数值: {myParam}</div>;
};

export default MyComponent;
```

在v6中，路由API做了许多改动，所以您可能也需要使用`Routes`和`Route`来定义路由，而不是v5的`Switch`和`Route`。

### 从URL查询字符串中获取参数：

除了路由参数之外，有时您可能还需要从URL的查询字符串（`?key=value`部分）中获取参数值。您可以使用`useLocation`钩子结合URLSearchParams API来实现这一点：

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

const MyComponent = () => {
  let location = useLocation();
  let queryParams = new URLSearchParams(location.search);
  let myQueryParam = queryParams.get('key'); // 假设URL是“/myroute?key=value”

  console.log(myQueryParam); // 打印出查询参数key的值

  // 做其他操作...

  return <div>URL查询字符串中的参数值: {myQueryParam}</div>;
};

export default MyComponent;
```

在这个例子中，如果URL是`/myroute?key=value`，那么`myQueryParam`将会是`value`。

这些就是在React中获取URL参数的几种常用方法。如果您需要更多帮助，请告诉我。

**React Router v6，使用钩子**

在react-router-dom v6中，有一个名为[useSearchParams](https://reactrouter.com/en/v6/hooks/use-search-params)的新钩子。所以与

    const [searchParams, setSearchParams] = useSearchParams();
    searchParams.get("__firebase_request_key")
    

你会得到`"blablabla"`。请注意，searchParams 是 URLSearchParams 的一个实例，它还实现了一个迭代器，例如用于使用 Object.fromEntries 等。

**React Router v4/v5，无钩子，通用**

React Router v4 不再为您解析查询，但您只能通过`this.props.location.search`（或 useLocation，见下文）访问它。原因请参见[nbeuchat 的回答](https://stackoverflow.com/a/48256676/969483)。

例如，您可以导入[qs](https://github.com/ljharb/qs)库`qs`

    qs.parse(this.props.location.search, { ignoreQueryPrefix: true }).__firebase_request_key
    

另一个库是[query-string](https://github.com/sindresorhus/query-string)。有关解析搜索字符串的更多想法，请参阅[此答案。](https://stackoverflow.com/a/53079875/969483)如果您不需要[IE 兼容性，](https://developer.mozilla.org/en-US/docs/Web/API/URLSearchParams)也可以使用

    new URLSearchParams(this.props.location.search).get("__firebase_request_key")
    

对于功能组件，您可以`this.props.location`用钩子[useLocation](https://reacttraining.com/react-router/core/api/Hooks/uselocation)替换。请注意，您可以使用`window.location.search`，但这不允许在更改时触发 React 渲染。如果您的（非功能性）组件不是 a 的直接子组件，`Switch`您需要使用[withRouter](https://reacttraining.com/react-router/web/api/withRouter)来访问路由器提供的任何道具。

**反应路由器 v3**

React Router 已经为您解析了位置并将其作为 props传递给您的[RouteComponent 。](https://reacttraining.com/react-router/core/api/Route/Route-props)您可以通过以下方式访问查询（网址中？之后）部分

    this.props.location.query.__firebase_request_key
    

如果您正在查找路由器内用冒号 (:) 分隔的路径参数值，可以通过以下方式访问这些值

    this.props.match.params.redirectParam
    

这适用于最新的 React Router v3 版本（不确定是哪个）。据报道，较旧的路由器版本使用`this.props.params.redirectParam`.

**一般的**

nizam.sp 的建议

    console.log(this.props)
    

无论如何都会有帮助。

反应路由器 v4
--------

**使用`component`**

    <Route path="/users/:id" component={UserPage}/> 
    

    this.props.match.params.id
    

该组件是使用路线道具自动渲染的。

  

**使用`render`**

    <Route path="/users/:id" render={(props) => <UserPage {...props} />}/> 
    

    this.props.match.params.id
    

路线道具被传递给渲染函数。

**反应路由器 v3**

使用 React Router v3，您可以从 (?qs1=naisarg&qs2=parmar) 获取查询字符串`this.props.location.search`。例如，使用`let params = queryString.parse(this.props.location.search)`, 会给出`{ qs1 : 'naisarg', qs2 : 'parmar'}`

**反应路由器 v4**

使用 React Router v4，则`this.props.location.query`不再存在。您需要**`this.props.location.search`**自己使用或使用现有的包（例如[`query-string`](https://github.com/sindresorhus/query-string).

**例子**

这是使用 React Router v4 和库的最小示例`query-string`。

    import { withRouter } from 'react-router-dom';
    import queryString from 'query-string';
        
    class ActivateAccount extends Component{
        someFunction(){
            let params = queryString.parse(this.props.location.search)
            ...
        }
        ...
    }
    export default withRouter(ActivateAccount);
    

**合理的**

React Router 团队删除该`query`属性的理由是：

> 有许多流行的软件包在查询字符串解析/字符串化方面略有不同，并且这些差异中的每一个对于某些用户来说可能是“正确”的方式，而对于其他用户来说可能是“不正确”的方式。如果 React Router 选择了“正确”的一个，那么它只适合某些人。然后，需要添加一种方法供其他用户替换他们首选的查询解析包。React Router 没有内部使用搜索字符串，需要它解析键值对，因此它不需要选择其中哪一个应该是“正确的”。
> 
> \[...\]
> 
> 4.0 采取的方法是去掉所有“包含电池”的功能，并恢复到基本的路由。如果您需要查询字符串解析或异步加载或 Redux 集成或其他非常具体的东西，那么您可以将其添加到专门针对您的用例的库中。减少您不需要的东西，您可以根据您的特定偏好和需求进行自定义。

[您可以在GitHub](https://github.com/ReactTraining/react-router/issues/4410)上找到完整的讨论。

据我所知，可以通过三种方法来做到这一点。

1.使用正则表达式获取查询字符串。

2.您可以使用浏览器api。图片当前的url是这样的：

    http://www.google.com.au?token=123
    

我们只想得到123；

第一的

     const query = new URLSearchParams(this.props.location.search);
    

然后

    const token = query.get('token')
    console.log(token)//123
    

3.  使用名为“query-string”的第三个库。首先安装它
    
    npm i query-string 然后将其导入到当前的javascript文件中：
    
    从“查询字符串”导入查询字符串
    

下一步是获取当前 url 中的“token”，执行以下操作：

    const value=queryString.parse(this.props.location.search);
    const token=value.token;
    console.log('token',token)//123
    

**更新于 25/02/2019**

4\. 如果当前 url 如下所示：

[http://www.google.com.au?app=home&act=article&aid=160990](http://www.google.com.au?app=home&act=article&aid=160990)

我们定义一个函数来获取参数：

    function getQueryVariable(variable)
    {
            var query = window.location.search.substring(1);
            console.log(query)//"app=article&act=news_content&aid=160990"
            var vars = query.split("&");
            console.log(vars) //[ 'app=article', 'act=news_content', 'aid=160990' ]
            for (var i=0;i<vars.length;i++) {
                        var pair = vars[i].split("=");
                        console.log(pair)//[ 'app', 'article' ][ 'act', 'news_content' ][ 'aid', '160990' ] 
            if(pair[0] == variable){return pair[1];}
             }
             return(false);
    }
    

我们可以通过以下方式获得“援助”：

    getQueryVariable('aid') //160990

当使用 React hooks 时，无法访问`this.props.location`. 要捕获 url 参数，请使用`window`object.

    const search = window.location.search;
    const params = new URLSearchParams(search);
    const foo = params.get('bar');

在React中，我们可以使用不同的方法来从URL字符串中获取参数值，这通常涉及到处理路由。一个流行的库是React Router。以下是使用React Router v5和v6来从URL中获取参数值的几种方法。

### 使用 React Router v5

在React Router v5中，你可以通过`match`对象来访问URL参数。这些参数是通过定义在路由中的`path`属性捕获的。例子如下：

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

const MyComponent = () => {
  // 使用 useParams 钩子来获取参数
  let { param1 } = useParams();

  // 现在你可以使用 param1 作为变量了
  return <div>参数值: {param1}</div>;
};

export default MyComponent;
```

在这个例子中，如果你的应用路由定义如下：

```jsx
<Route path="/somepath/:param1" component={MyComponent} />
```

当用户访问`/somepath/value1`时，`param1`将会是`value1`。

### 使用 React Router v6

在React Router v6中，获取参数的方式类似，但是更倾向于使用钩子而不是组件的props。这是一个例子：

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

const MyComponent = () => {
  // 使用 useParams 钩子来获取参数
  const { param1 } = useParams();

  // 现在你可以使用 param1 作为变量了
  return <div>参数值: {param1}</div>;
};

export default MyComponent;
```

路由定义：

```jsx
import { Route, Routes } from 'react-router-dom';

// ...

<Routes>
  <Route path="/somepath/:param1" element={<MyComponent />} />
</Routes>
```

在这种情况下，`useParams` 钩子同样被用来获取动态路径参数。

### 查询参数

如果你需要获取的是查询参数（query parameters），也就是URL中`?`后面的那部分，则可以使用`useLocation`钩子来获取整个location对象，其中包括查询字符串：

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

const useQuery = () => {
  return new URLSearchParams(useLocation().search);
};

const MyComponent = () => {
  const query = useQuery();
  const paramValue = query.get('param1'); // 假设URL是 /somepath?param1=value1

  return <div>查询参数值: {paramValue}</div>;
};

export default MyComponent;
```

这里，`useQuery`是一个自定义钩子，它封装了创建`URLSearchParams`实例的逻辑，让你可以通过`get`方法来获取特定的查询参数值。在这个例子中，如果URL是`/somepath?param1=value1`，那么`paramValue`变量将会是`value1`。

总的来说，在React中获取URL参数主要通过使用`useParams`来获取动态路由参数，以及通过`useLocation`和`URLSearchParams`来获取查询参数。这些是React Router库提供的工具，但它们实际上都是基于原生的Web API（比如`window.location`）进行封装的。

在React中，从URL字符串中获取参数通常涉及到使用React Router库，因为它为路由相关的任务提供了方便的工具和组件。以下是在不同版本的React Router中获取URL参数的方法。

### 如果您使用的是 React Router v5：

您可以通过`useParams`钩子或`withRouter`高阶组件来获取参数值。这里有两个例子：

1. **使用`useParams`钩子** (适用于函数组件):
   ```javascript
   import React from 'react';
   import { useParams } from 'react-router-dom';

   const MyComponent = () => {
     let { myParam } = useParams();
     console.log(myParam); // 打印出URL参数myParam的值

     // 做其他操作...
     
     return <div>URL中的参数值: {myParam}</div>;
   };

   export default MyComponent;
   ```

   在这个例子中，如果您的路由定义是`<Route path="/somepath/:myParam" component={MyComponent} />`，那么当您访问`/somepath/value`时，`myParam`将会是`value`。

2. **使用`withRouter`高阶组件** (适用于类组件):
   ```javascript
   import React, { Component } from 'react';
   import { withRouter } from 'react-router-dom';

   class MyComponent extends Component {
     componentDidMount() {
       let { myParam } = this.props.match.params;
       console.log(myParam); // 打印出URL参数myParam的值
     }

     render() {
       let { myParam } = this.props.match.params;
       return <div>URL中的参数值: {myParam}</div>;
     }
   }

   export default withRouter(MyComponent);
   ```

   `withRouter`会向您的组件提供`match`、`location`和`history`对象，您可以通过这些对象来访问路由的相关信息。

### 如果您使用的是 React Router v6：

在React Router v6中，`useParams`仍然存在，但`withRouter`已经被移除。以下是使用`useParams`钩子的方法：

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

const MyComponent = () => {
  let { myParam } = useParams();
  console.log(myParam); // 打印出URL参数myParam的值

  // 做其他操作...

  return <div>URL中的参数值: {myParam}</div>;
};

export default MyComponent;
```

在v6中，路由API做了许多改动，所以您可能也需要使用`Routes`和`Route`来定义路由，而不是v5的`Switch`和`Route`。

### 从URL查询字符串中获取参数：

除了路由参数之外，有时您可能还需要从URL的查询字符串（`?key=value`部分）中获取参数值。您可以使用`useLocation`钩子结合URLSearchParams API来实现这一点：

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

const MyComponent = () => {
  let location = useLocation();
  let queryParams = new URLSearchParams(location.search);
  let myQueryParam = queryParams.get('key'); // 假设URL是“/myroute?key=value”

  console.log(myQueryParam); // 打印出查询参数key的值

  // 做其他操作...

  return <div>URL查询字符串中的参数值: {myQueryParam}</div>;
};

export default MyComponent;
```

在这个例子中，如果URL是`/myroute?key=value`，那么`myQueryParam`将会是`value`。

这些就是在React中获取URL参数的几种常用方法。如果您需要更多帮助，请告诉我。

How to get parameter value from query string?

Redux 本身是一个同步状态管理库，它专注于以可预测的方式管理和更新应用程序的状态。Redux 的核心概念是纯函数的 reducer 和同步的 action。当应用程序需要处理异步操作，如数据的 API 请求时，Redux 单独并不能有效地处理。

异步中间件，如 Redux Thunk 或 Redux Saga，使得在 Redux 应用程序中处理异步逻辑成为可能。下面是一些为什么需要异步中间件的原因：

### 1. 处理异步操作
Redux 的基本原则是 action 应该是一个具有 `type` 属性的对象，而且 reducer 应该是同步的纯函数。这种模式并不适用于执行异步操作，例如 API 调用。异步中间件允许我们在 dispatching action 之前执行异步代码，然后根据异步操作的结果来 dispatch 实际的 action。

**例子：**
假设我们有一个获取用户信息的异步操作。使用 Redux Thunk，我们可以创建一个 thunk action creator，它返回一个函数而非 action 对象。这个函数能够执行异步请求并且在请求完成后 dispatch 一个 action。

```javascript
const fetchUserData = (userId) => {
    return (dispatch) => {
        dispatch({ type: 'FETCH_USER_REQUEST' });
        fetch(`/api/user/${userId}`)
            .then((response) => response.json())
            .then((user) => dispatch({ type: 'FETCH_USER_SUCCESS', payload: user }))
            .catch((error) => dispatch({ type: 'FETCH_USER_FAILURE', error }));
    };
};
```

### 2. 便于管理复杂的异步逻辑
在大型应用程序中，异步逻辑可能变得非常复杂，包括并发请求、条件请求、请求之间的竞争、错误处理等。异步中间件可以帮助管理这些复杂性，提供更清晰和更可维护的代码结构。

**例子：**
在使用 Redux Saga 的情况下，我们可以使用 ES6 的 generator 函数来更加直观和声明式地处理复杂的异步流。

```javascript
function* fetchUserDataSaga(action) {
    try {
        yield put({ type: 'FETCH_USER_REQUEST' });
        const user = yield call(fetchApi, `/api/user/${action.userId}`);
        yield put({ type: 'FETCH_USER_SUCCESS', payload: user });
    } catch (error) {
        yield put({ type: 'FETCH_USER_FAILURE', error });
    }
}
```

### 3. 更好的测试性
异步中间件使得异步逻辑更加独立于组件，这有助于进行单元测试。我们可以在不进行实际的 API 调用的情况下，测试 action creators 和 reducers 的逻辑。

**例子：**
使用 Redux Thunk，我们可以测试 thunk action creator 是否正确地 dispatch 了相应的 actions。

```javascript
// 使用 Jest 测试框架
it('creates FETCH_USER_SUCCESS when fetching user has been done', () => {
    // 模拟 dispatch 和 getState 函数
    const dispatch = jest.fn();
    const getState = jest.fn();

    // 模拟 fetch API
    global.fetch = jest.fn(() =>
        Promise.resolve({
            json: () => Promise.resolve({ id: 1, name: 'John Doe' }),
        })
    );

    // 执行 thunk action creator
    return fetchUserData(1)(dispatch, getState).then(() => {
        // 检查是否 dispatch 了正确的 action
        expect(dispatch).toHaveBeenCalledWith({ type: 'FETCH_USER_SUCCESS', payload: { id: 1, name: 'John Doe' } });
    });
});
```

### 总结
Redux 需要异步中间件来处理异步操作，帮助维护复杂的异步逻辑，并提高代码的可测试性。这些中间件扩展了 Redux，使其能够以一种既有序又高效的方式处理异步数据流。Redux 作为一个状态管理库，其核心设计是围绕着同步的状态更新。也就是说，在没有任何中间件的情况下，当一个 action 被派发（dispatched）时，它会立即通过同步的 reducers 更新状态。然而，在实际的应用中，我们经常需要处理异步操作，比如从服务器获取数据，这些操作并不能立刻完成并返回数据。

因此，为了在 Redux 架构中处理这些异步操作，我们需要一种方式来扩展 Redux 的功能，使其能够处理异步逻辑。这就是异步中间件的用武之地。以下是几个为什么 Redux 需要异步数据流中间件的理由：

1. **维护纯净的 reducer 函数**：
   Reducer 函数应该是纯函数，这意味着给定相同的输入，总是返回相同的输出，并且不产生任何副作用。异步操作（如 API 调用）会产生副作用，因此不能直接在 reducer 中处理。

2. **扩展 Redux 的功能**：
   异步中间件像是 Redux 生态系统中的插件，它允许开发者在不修改原始 Redux 库代码的情况下增加新的功能。例如，可以增加日志记录、错误报告或异步处理等功能。

3. **异步控制流**：
   异步中间件允许开发者在派发 action 和到达 reducer 之间插入一个异步操作。这意味着可以先发出一个表示“开始异步操作”的 action，然后在操作完成时发出另一个表示“异步操作完成”的 action。

4. **更干净的代码结构**：
   通过将异步逻辑封装在中间件内，我们可以保持组件和 reducer 的简洁。这避免了在组件中混合异步调用和状态管理逻辑，有助于代码分离和维护。

5. **测试和调试的便捷性**：
   中间件提供了一个独立的层，可以在这个层中进行单独的测试和模拟异步行为，而不必担心组件逻辑或者 UI 层的细节。

### 例子

在实际应用中，最常见的异步中间件是 `redux-thunk` 和 `redux-saga`。

- **redux-thunk** 允许 action 创建函数（action creators）返回一个函数而不是一个 action 对象。这个返回的函数接收 `dispatch` 和 `getState` 作为参数，让你可以进行异步操作，并在操作结束后派发一个新的 action。

```javascript
const fetchUserData = (userId) => {
  return (dispatch, getState) => {
    dispatch({ type: 'USER_FETCH_REQUESTED', userId });
    return fetchUserFromApi(userId)
      .then(userData => {
        dispatch({ type: 'USER_FETCH_SUCCEEDED', userData });
      })
      .catch(error => {
        dispatch({ type: 'USER_FETCH_FAILED', error });
      });
  };
};
```

- **redux-saga** 则使用 ES6 的 Generator 函数来使异步流更易于读写。Sagas 可以监听派发到 store 的 actions，并在某个 action 被派发时执行复杂的异步逻辑。

```javascript
import { call, put, takeEvery } from 'redux-saga/effects';

function* fetchUser(action) {
  try {
    const user = yield call(Api.fetchUser, action.payload.userId);
    yield put({type: 'USER_FETCH_SUCCEEDED', user: user});
  } catch (e) {
    yield put({type: 'USER_FETCH_FAILED', message: e.message});
  }
}

function* mySaga() {
  yield takeEvery('USER_FETCH_REQUESTED', fetchUser);
}
```

总的来说，异步中间件在处理复杂的异步数据流时，可以提高 Redux 应用的可扩

> 这种方法有什么问题吗？正如文档所示，为什么我要使用 Redux Thunk 或 Redux Promise？

这种做法并没有什么问题。这在大型应用程序中很不方便，因为您将有不同的组件执行相同的操作，您可能想要对某些操作进行反跳，或者保留一些本地状态，例如自动递增 ID 靠近操作创建者等。因此，从从维护的角度将动作创建者提取到单独的功能中。

**您可以阅读[我对“如何在超时情况下调度 Redux 操作”的回答，](https://stackoverflow.com/questions/35411423/how-to-dispatch-a-redux-action-with-a-timeout/35415559#35415559)以获取更详细的演练。**

像 Redux Thunk 或 Redux Promise 这样的中间件只是为您提供了用于调度 thunk 或 Promise 的“语法糖”，但您不必_使用_它。

因此，如果没有任何中间件，您的动作创建器可能看起来像

    // action creator
    function loadData(dispatch, userId) { // needs to dispatch, so it is first argument
      return fetch(`http://data.com/${userId}`)
        .then(res => res.json())
        .then(
          data => dispatch({ type: 'LOAD_DATA_SUCCESS', data }),
          err => dispatch({ type: 'LOAD_DATA_FAILURE', err })
        );
    }
    
    // component
    componentWillMount() {
      loadData(this.props.dispatch, this.props.userId); // don't forget to pass dispatch
    }
    

但是使用 Thunk Middleware 你可以这样写：

    // action creator
    function loadData(userId) {
      return dispatch => fetch(`http://data.com/${userId}`) // Redux Thunk handles these
        .then(res => res.json())
        .then(
          data => dispatch({ type: 'LOAD_DATA_SUCCESS', data }),
          err => dispatch({ type: 'LOAD_DATA_FAILURE', err })
        );
    }
    
    // component
    componentWillMount() {
      this.props.dispatch(loadData(this.props.userId)); // dispatch like you usually do
    }
    

所以没有太大的区别。我喜欢后一种方法的一件事是该组件不关心动作创建者是否异步。它只是正常调用`dispatch`，它也可以用`mapDispatchToProps`简短的语法来绑定这样的动作创建者等。组件不知道动作创建者是如何实现的，你可以在不同的异步方法之间切换（Redux Thunk，Redux Promise，Redux Saga） ）而不改变组件。另一方面，使用前一种显式方法，您的组件_确切地_知道特定调用是异步的，并且需要`dispatch`通过某种约定传递（例如，作为同步参数）。

还要考虑一下这段代码将如何改变。假设我们想要有第二个数据加载功能，并将它们组合在一个动作创建器中。

使用第一种方法时，我们需要注意我们所调用的动作创建者类型：

    // action creators
    function loadSomeData(dispatch, userId) {
      return fetch(`http://data.com/${userId}`)
        .then(res => res.json())
        .then(
          data => dispatch({ type: 'LOAD_SOME_DATA_SUCCESS', data }),
          err => dispatch({ type: 'LOAD_SOME_DATA_FAILURE', err })
        );
    }
    function loadOtherData(dispatch, userId) {
      return fetch(`http://data.com/${userId}`)
        .then(res => res.json())
        .then(
          data => dispatch({ type: 'LOAD_OTHER_DATA_SUCCESS', data }),
          err => dispatch({ type: 'LOAD_OTHER_DATA_FAILURE', err })
        );
    }
    function loadAllData(dispatch, userId) {
      return Promise.all(
        loadSomeData(dispatch, userId), // pass dispatch first: it's async
        loadOtherData(dispatch, userId) // pass dispatch first: it's async
      );
    }
    
    
    // component
    componentWillMount() {
      loadAllData(this.props.dispatch, this.props.userId); // pass dispatch first
    }
    

使用 Redux Thunk 动作创建者可以`dispatch`得到其他动作创建者的结果，甚至不用考虑它们是同步还是异步：

    // action creators
    function loadSomeData(userId) {
      return dispatch => fetch(`http://data.com/${userId}`)
        .then(res => res.json())
        .then(
          data => dispatch({ type: 'LOAD_SOME_DATA_SUCCESS', data }),
          err => dispatch({ type: 'LOAD_SOME_DATA_FAILURE', err })
        );
    }
    function loadOtherData(userId) {
      return dispatch => fetch(`http://data.com/${userId}`)
        .then(res => res.json())
        .then(
          data => dispatch({ type: 'LOAD_OTHER_DATA_SUCCESS', data }),
          err => dispatch({ type: 'LOAD_OTHER_DATA_FAILURE', err })
        );
    }
    function loadAllData(userId) {
      return dispatch => Promise.all(
        dispatch(loadSomeData(userId)), // just dispatch normally!
        dispatch(loadOtherData(userId)) // just dispatch normally!
      );
    }
    
    
    // component
    componentWillMount() {
      this.props.dispatch(loadAllData(this.props.userId)); // just dispatch normally!
    }
    

通过这种方法，如果您稍后希望操作创建者查看当前的 Redux 状态，您可以只使用`getState`传递给 thunk 的第二个参数，而无需修改调用代码：

    function loadSomeData(userId) {
      // Thanks to Redux Thunk I can use getState() here without changing callers
      return (dispatch, getState) => {
        if (getState().data[userId].isLoaded) {
          return Promise.resolve();
        }
    
        fetch(`http://data.com/${userId}`)
          .then(res => res.json())
          .then(
            data => dispatch({ type: 'LOAD_SOME_DATA_SUCCESS', data }),
            err => dispatch({ type: 'LOAD_SOME_DATA_FAILURE', err })
          );
      }
    }
    

如果需要将其更改为同步，也可以在不更改任何调用代码的情况下执行此操作：

    // I can change it to be a regular action creator without touching callers
    function loadSomeData(userId) {
      return {
        type: 'LOAD_SOME_DATA_SUCCESS',
        data: localStorage.getItem('my-data')
      }
    }
    

因此，使用 Redux Thunk 或 Redux Promise 等中间件的好处是，组件不知道操作创建者是如何实现的，也不知道它们是否关心 Redux 状态，它们是同步还是异步，以及它们是否调用其他操作创建者。缺点是有点间接，但我们相信在实际应用中这是值得的。

最后，Redux Thunk 和朋友只是 Redux 应用程序中异步请求的一种可能方法。另一个有趣的方法是[Redux Saga](https://github.com/yelouafi/redux-saga)，它允许您定义长期运行的守护进程（“saga”），这些守护进程在出现操作时采取操作，并在输出操作之前转换或执行请求。这将逻辑从动作创造者转变为传奇。您可能想检查一下，然后选择最适合您的。

> 我在 Redux 存储库中搜索线索，发现过去 Action Creator 被要求是纯函数。

这是不正确的。文档是这么说的，但文档是错误的。  
动作创建者从来不需要是纯函数。  
我们修复了文档以反映这一点。

你不知道。
=====

但是......你应该使用 redux-saga :)
===========================

Dan Abramov 的答案是正确的`redux-thunk`，但我会更多地谈论[redux-saga](https://github.com/yelouafi/redux-saga)，它非常相似但更强大。

命令式 VS 声明式
==========

*   **DOM**：jQuery 是命令式的 / React 是声明式的
*   **Monads**：IO 是命令式的 / Free 是声明式的
*   **Redux 效果**：`redux-thunk`命令式/`redux-saga`声明式

当你手中有一个 thunk 时，比如 IO monad 或 Promise，你无法轻易知道执行后它会做什么。测试 thunk 的唯一方法是执行它，并模拟调度程序（或整个外部世界，如果它与更多东西交互......）。

如果您使用模拟，那么您就不是在进行函数式编程。

> 从副作用的角度来看，模拟是您的代码不纯的标志，并且在函数式程序员的眼中，是出现问题的证据。我们不应该下载一个库来帮助我们检查冰山是否完好，而应该绕着它航行。一位铁杆 TDD/Java 人员曾经问我如何在 Clojure 中进行模拟。答案是，我们通常不会。我们通常将其视为需要重构代码的标志。

[来源](http://blog.jenkster.com/2015/12/which-programming-languages-are-functional.html)

sagas（正如它们在 中实现的那样`redux-saga`）是声明性的，就像 Free monad 或 React 组件一样，它们更容易在没有任何模拟的情况下进行测试。

另请参阅这篇[文章](http://degoes.net/articles/modern-fp)：

> 在现代函数式编程中，我们不应该编写程序——我们应该编写程序的描述，然后我们可以随意内省、转换和解释。

（实际上，Redux-saga 就像一个混合体：流程是命令式的，但效果是声明性的）

混乱：动作/事件/命令...
==============

在前端世界中，对于 CQRS / EventSourcing 和 Flux / Redux 等一些后端概念如何相关可能存在很多困惑，主要是因为在 Flux 中我们使用术语“操作”，它有时可以表示命令式代码 ( )`LOAD_USER`和事件 ( `USER_LOADED`）。我相信，就像事件溯源一样，您应该只调度事件。

在实践中使用传奇
========

想象一个带有用户个人资料链接的应用程序。使用每个中间件处理这个问题的惯用方法是：

`redux-thunk`
-------------

    <div onClick={e => dispatch(actions.loadUserProfile(123)}>Robert</div>
    
    function loadUserProfile(userId) {
      return dispatch => fetch(`http://data.com/${userId}`)
        .then(res => res.json())
        .then(
          data => dispatch({ type: 'USER_PROFILE_LOADED', data }),
          err => dispatch({ type: 'USER_PROFILE_LOAD_FAILED', err })
        );
    }
    

`redux-saga`
------------

    <div onClick={e => dispatch({ type: 'USER_NAME_CLICKED', payload: 123 })}>Robert</div>
    
    
    function* loadUserProfileOnNameClick() {
      yield* takeLatest("USER_NAME_CLICKED", fetchUser);
    }
    
    function* fetchUser(action) {
      try {
        const userProfile = yield fetch(`http://data.com/${action.payload.userId }`)
        yield put({ type: 'USER_PROFILE_LOADED', userProfile })
      } 
      catch(err) {
        yield put({ type: 'USER_PROFILE_LOAD_FAILED', err })
      }
    }
    

这个传奇翻译过来就是：

> 每次单击用户名时，都会获取用户配置文件，然后使用加载的配置文件调度一个事件。

正如您所看到的，有一些优点`redux-saga`。

使用`takeLatest`许可证来表达您只对获取最后单击的用户名的数据感兴趣（处理并发问题，以防用户快速单击大量用户名）。这种东西很难用 thunks 来完成。`takeEvery`如果您不想要这种行为，您可以使用。

你让动作创造者保持纯粹。请注意，保留 actionCreators （在 sagas`put`和 elements中`dispatch`）仍然很有用，因为它可能会帮助您将来添加操作验证（断言/流程/打字稿）。

由于效果是声明性的，您的代码变得更加可测试

您不再需要触发类似 rpc 的调用，例如`actions.loadUser()`. 你的用户界面只需要发送已经发生的事情。我们只触发**事件**（总是过去时！），不再触发动作。这意味着您可以创建解耦的[“鸭子”](https://github.com/erikras/ducks-modular-redux)或[限界上下文](http://martinfowler.com/bliki/BoundedContext.html)，并且传奇可以充当这些模块化组件之间的耦合点。

这意味着您的视图更易于管理，因为它们不再需要包含已发生的情况和应该发生的效果之间的转换层

例如，想象一个无限滚动视图。`CONTAINER_SCROLLED`可以导致`NEXT_PAGE_LOADED`，但是可滚动容器真的有责任决定我们是否应该加载另一个页面吗？然后他必须了解更复杂的事情，例如最后一个页面是否已成功加载，或者是否已经有一个页面正在尝试加载，或者是否没有更多项目可供加载？我不这么认为：为了获得最大的可重用性，可滚动容器应该只描述它已被滚动。页面的加载是该滚动的“业务效果”

有些人可能会认为生成器本质上可以使用局部变量隐藏 redux 存储之外的状态，但是如果您开始通过启动计时器等在 thunk 内部编排复杂的事情，无论如何您都会遇到同样的问题。现在有一个`select`效果允许从 Redux 存储中获取一些状态。

Sagas 可以进行时间旅行，还可以实现复杂的流日志记录和当前正在开发的开发工具。以下是一些已经实现的简单异步流日志记录：

[![传奇流日志记录](https://i.stack.imgur.com/F9Jsh.png)](https://i.stack.imgur.com/F9Jsh.png)

解耦
==

Sagas 不仅取代了 redux thunk。它们来自后端/分布式系统/事件源。

这是一个非常常见的误解，认为 sagas 只是为了取代 redux thunk 来提供更好的可测试性。实际上这只是 redux-saga 的一个实现细节。对于可测试性而言，使用声明性效果比 thunk 更好，但 saga 模式可以在命令式或声明性代码之上实现。

首先，saga 是一个软件，允许协调长期运行的事务（最终一致性）以及跨不同有界上下文的事务（领域驱动设计术语）。

为了简化前端世界，假设有 widget1 和 widget2。当点击 widget1 上的某个按钮时，它应该会对 widget2 产生影响。widget1 没有将 2 个小部件耦合在一起（即小部件 1 调度针对小部件 2 的操作），而是仅调度其按钮被单击。然后 saga 侦听此按钮单击，然后通过调度 widget2 知道的新事件来更新 widget2。

这增加了简单应用程序不必要的间接级别，但使扩展复杂应用程序变得更容易。现在，您可以将 widget1 和 widget2 发布到不同的 npm 存储库，这样它们就永远不必相互了解，而无需让它们共享全局操作注册表。这两个小部件现在是可以单独存在的有界上下文。它们不需要彼此保持一致，也可以在其他应用程序中重复使用。传奇是两个小部件之间的耦合点，以对您的业务有意义的方式协调它们。

一些关于如何构建 Redux 应用程序的好文章，您可以在其中使用 Redux-saga 来实现解耦：

*   [http://jaysoo.ca/2016/02/28/organizing-redux-application/](http://jaysoo.ca/2016/02/28/organizing-redux-application/)
*   [http://marmelab.com/blog/2015/12/17/react-directory-struct.html](http://marmelab.com/blog/2015/12/17/react-directory-structure.html)
*   [https://github.com/slorber/scalable-frontend-with-elm-or-redux](https://github.com/slorber/scalable-frontend-with-elm-or-redux)

具体用例：通知系统
=========

我希望我的组件能够触发应用内通知的显示。但我不希望我的组件与具有自己的业务规则的通知系统高度耦合（最多同时显示 3 个通知、通知排队、4 秒显示时间等...）。

我不希望我的 JSX 组件决定通知何时显示/隐藏。我只是赋予它请求通知的能力，并将复杂的规则留在传奇中。这种事情很难通过 thunk 或 Promise 来实现。

[![通知](https://i.stack.imgur.com/XQ8lx.png)](https://i.stack.imgur.com/XQ8lx.png)

我[在这里](https://stackoverflow.com/a/38574266/82609)描述了如何使用 saga 来完成此操作

为什么叫传奇呢？
========

saga 这个术语来自后端世界。[我最初在一次长时间的讨论](https://github.com/paldepind/functional-frontend-architecture/issues/20#issuecomment-158694062)中向 Yassine（Redux-saga 的作者）介绍了这个术语。

[最初，该术语是在一篇论文](http://www.cs.cornell.edu/andru/cs711/2002fa/reading/sagas.pdf)中引入的，saga 模式应该用于处理分布式事务中的最终一致性，但后端开发人员已将其用法扩展到更广泛的定义，因此它现在还涵盖“流程管理器”模式（不知何故，原始的 saga 模式是流程管理器的一种特殊形式）。

如今，“传奇”一词很令人困惑，因为它可以描述两种不同的事物。正如它在 redux-saga 中使用的那样，它并不描述一种处理分布式事务的方法，而是一种协调应用程序中操作的方法。`redux-saga`也可以被称为`redux-process-manager`。

也可以看看：

*   [Yassine 关于 Redux-saga 历史的采访](http://survivejs.com/blog/redux-saga-interview/)
*   [Kella Byte：阐释 Saga 模式](http://kellabyte.com/2012/05/30/clarifying-the-saga-pattern/)
*   [Microsoft CQRS 之旅：传奇上的传奇](https://msdn.microsoft.com/en-us/library/jj591569.aspx)
*   [亚辛的中等反应](https://medium.com/@yelouafi/agree-for-the-saga-confusion-3fb2fc375322#.dxe1prl4y)

备择方案
====

如果您不喜欢使用生成器的想法，但对 saga 模式及其解耦属性感兴趣，您也可以使用[redux-observable](https://github.com/redux-observable/redux-observable)实现相同的目的，它使用名称`epic`来描述完全相同的模式，但使用 RxJS。如果您已经熟悉 Rx，您会感到宾至如归。

    const loadUserProfileOnNameClickEpic = action$ =>
      action$.ofType('USER_NAME_CLICKED')
        .switchMap(action =>
          Observable.ajax(`http://data.com/${action.payload.userId}`)
            .map(userProfile => ({
              type: 'USER_PROFILE_LOADED',
              userProfile
            }))
            .catch(err => Observable.of({
              type: 'USER_PROFILE_LOAD_FAILED',
              err
            }))
        );
    

一些 redux-saga 有用的资源
===================

*   [Redux-saga 与带有 async/await 的 Redux-thunk](https://stackoverflow.com/questions/34930735/pros-cons-of-using-redux-saga-with-es6-generators-vs-redux-thunk-with-es7-async/34933395)
*   [管理 Redux Saga 中的流程](http://jaysoo.ca/2016/01/03/managing-processes-in-redux-using-sagas)
*   [从 actionsCreators 到 Sagas](https://riad.blog/2015/12/28/redux-nowadays-from-actions-creators-to-sagas/)
*   [使用 Redux-saga 实现的贪吃蛇游戏](http://codepen.io/CrocoDillon/pen/pgaRwb?editors=0010)

2017年建议
=======

*   不要为了使用 Redux-saga 而过度使用它。仅可测试的 API 调用是不值得的。
*   对于大多数简单的情况，不要从项目中删除 thunk。
*   `yield put(someActionThunk)`如果有意义的话，请毫不犹豫地发出重击。

如果您害怕使用 Redux-saga （或 Redux-observable）但只需要解耦模式，请检查[redux-dispatch-subscribe](https://github.com/slorber/redux-dispatch-subscribe)：它允许侦听调度并在侦听器中触发新调度。

    const unsubscribe = store.addDispatchListener(action => {
      if (action.type === 'ping') {
        store.dispatch({ type: 'pong' });
      }
    });

**简短的回答**：对我来说，这似乎是解决异步问题的完全合理的方法。有一些警告。

在我们刚刚开始工作的新项目中，我也有非常相似的想法。我是 vanilla Redux 优雅系统的忠实粉丝，该系统以一种远离 React 组件树内部的方式更新存储和重新渲染组件。对我来说，使用这种优雅的`dispatch`机制来处理异步似乎很奇怪。

我最终采用了与我从项目中提取的库中的方法非常相似的方法，我们将其称为“ [react-redux-controller”](https://github.com/artsy/react-redux-controller)。

由于以下几个原因，我最终没有采用您上面的确切方法：

1.  按照您的编写方式，这些调度函数无法访问商店。您可以通过让 UI 组件传入调度函数所需的所有信息来解决这个问题。但我认为这不必要地将这些 UI 组件与调度逻辑耦合起来。更成问题的是，调度函数没有明显的方法来访问异步延续中的更新状态。
2.  调度函数可以通过词法作用域访问`dispatch`自身。一旦该语句失控，这就会限制重构的选项`connect`——而且仅使用这种方法看起来相当笨重`update`。因此，如果您将这些调度程序功能分解为单独的模块，您需要一些系统来组合它们。

总而言之，您必须安装一些系统，以允许`dispatch`将存储以及事件的参数注入到您的调度函数中。我知道这种依赖注入的三种合理方法：

*   [redux-thunk](https://github.com/gaearon/redux-thunk)通过将它们传递到你的 thunk 中，以一种函数式的方式做到这一点（根据 dome 的定义，使它们根本不完全是 thunk）。我没有使用过其他`dispatch`中间件方法，但我认为它们基本上是相同的。
*   React-redux-controller 使用协程来完成此操作。作为奖励，它还使您可以访问“选择器”，这些函数是您可能作为第一个参数传递给 的函数`connect`，而不必直接使用原始的标准化存储。
*   `this`您还可以通过各种可能的机制将它们注入上下文中，以面向对象的方式完成此操作。

**更新**

我发现这个难题的一部分是[react-redux](https://github.com/rackt/react-redux)的限制。第一个参数[`connect`](https://github.com/rackt/react-redux/blob/master/docs/api.md#connectmapstatetoprops-mapdispatchtoprops-mergeprops-options)获取状态快照，但不获取调度。第二个参数得到调度，但没有得到状态。这两个参数都没有得到关闭当前状态的 thunk，以便能够在继续/回调时看到更新的状态。

Abramov 的目标（也是每个人的理想目标）只是将_复杂性（和异步调用）封装在最合适和可重用的地方_。

在标准 Redux 数据流中执行此操作的最佳位置在哪里？怎么样：

*   **减速机**？决不。它们应该是没有副作用的纯函数。更新商店是一件严肃而复杂的事情。不要污染它。
*   **愚蠢的视图组件？**绝对不是。他们关心的只有一个：演示和用户交互，并且应该尽可能简单。
*   **容器组件？**可能，但不是最优的。这是有道理的，因为容器是我们封装一些与视图相关的复杂性并与存储交互的地方，但是：
    *   容器确实需要比哑组件更复杂，但它仍然是单一职责：提供视图和状态/存储之间的绑定。您的异步逻辑与此完全不同。
    *   通过将其放置在容器中，您可以将异步逻辑锁定到单个上下文中，并与一个或多个视图/路由耦合。馊主意。理想情况下，它都是可重用的，并且与视图完全分离。
    *   （与所有规则一样，如果您拥有可在多个上下文中重用的有状态绑定逻辑，或者您可以以某种方式将所有状态概括为集成 GraphQL 模式之类的东西，则可能存在例外。好吧，好吧，这可能是很酷。但是......大多数时候，绑定似乎最终都非常特定于上下文/视图。）
*   **其他一些服务模块？**坏主意：您需要注入对商店的访问权限，这是可维护性/可测试性的噩梦。最好遵循 Redux 的原则，仅使用提供的 API/模型访问商店。
*   **操作和解释它们的中间件？**为什么不？！对于初学者来说，这是我们剩下的唯一主要选择。:-) 从逻辑上讲，操作系统是解耦的执行逻辑，您可以在任何地方使用它。它可以访问商店并可以调度更多操作。它有一个单一的职责，那就是围绕应用程序组织控制流和数据流，大多数异步都适合这一点。
    *   那么动作创作者呢？为什么不直接在那里进行异步，而不是在操作本身和中间件中进行异步？
        *   首先也是最重要的是，创建者无法像中间件那样访问商店。这意味着您无法调度新的或有操作，无法从存储中读取数据来编写异步操作等。
        *   因此，将复杂性保留在必要性复杂的地方，并保持其他一切简单。创建者可以是简单、相对纯粹、易于测试的函数。

回答一开始提出的问题：

> 为什么容器组件不能调用异步 API，然后分派操作？

请记住，这些文档适用于 Redux，而不是 Redux 加 React。_连接到 React 组件的_Redux 存储可以完全按照你所说的操作，但是没有中间件的 Plain Jane Redux 存储不接受除`dispatch`普通 ol' 对象之外的参数。

没有中间件，你当然仍然可以这样做

    const store = createStore(reducer);
    MyAPI.doThing().then(resp => store.dispatch(...));
    

但这是一个类似的情况，异步是_围绕_Redux 进行的，而不是_由_Redux 处理。因此，中间件通过修改可以直接传递给`dispatch`.

* * *

也就是说，我认为你的建议的精神是有效的。当然还有其他方法可以在 Redux + React 应用程序中处理异步。

使用中间件的好处之一是您可以继续照常使用动作创建器，而不必担心它们是如何连接的。例如，使用`redux-thunk`，您编写的代码看起来很像

    function updateThing() {
      return dispatch => {
        dispatch({
          type: ActionTypes.STARTED_UPDATING
        });
        AsyncApi.getFieldValue()
          .then(result => dispatch({
            type: ActionTypes.UPDATED,
            payload: result
          }));
      }
    }
    
    const ConnectedApp = connect(
      (state) => { ...state },
      { update: updateThing }
    )(App);
    

它看起来与原始版本没有什么不同——只是稍微打乱了一点——并且`connect`不知道这`updateThing`是（或需要）异步的。

如果您还想支持[Promise](https://github.com/acdlite/redux-promise)、[Observables](https://github.com/acdlite/redux-rx)、[Sagas](https://github.com/yelouafi/redux-saga)或[疯狂的自定义](https://github.com/rackt/redux/blob/b35c1c95432e793df92609938ae79be96788e09e/examples/real-world/middleware/api.js#L76-L123)和[高度声明性的](https://github.com/rackt/redux/blob/b35c1c95432e793df92609938ae79be96788e09e/examples/real-world/actions/index.js#L9-L17)Action Creators，那么 Redux 只需更改您传递给的内容`dispatch`（也就是您从 Action Creators 返回的内容）即可做到这一点。无需对 React 组件（或`connect`调用）进行任何改动。

Redux 本身是一个同步状态管理库，它专注于以可预测的方式管理和更新应用程序的状态。Redux 的核心概念是纯函数的 reducer 和同步的 action。当应用程序需要处理异步操作，如数据的 API 请求时，Redux 单独并不能有效地处理。

异步中间件，如 Redux Thunk 或 Redux Saga，使得在 Redux 应用程序中处理异步逻辑成为可能。下面是一些为什么需要异步中间件的原因：

### 1. 处理异步操作
Redux 的基本原则是 action 应该是一个具有 `type` 属性的对象，而且 reducer 应该是同步的纯函数。这种模式并不适用于执行异步操作，例如 API 调用。异步中间件允许我们在 dispatching action 之前执行异步代码，然后根据异步操作的结果来 dispatch 实际的 action。

**例子：**
假设我们有一个获取用户信息的异步操作。使用 Redux Thunk，我们可以创建一个 thunk action creator，它返回一个函数而非 action 对象。这个函数能够执行异步请求并且在请求完成后 dispatch 一个 action。

```javascript
const fetchUserData = (userId) => {
    return (dispatch) => {
        dispatch({ type: 'FETCH_USER_REQUEST' });
        fetch(`/api/user/${userId}`)
            .then((response) => response.json())
            .then((user) => dispatch({ type: 'FETCH_USER_SUCCESS', payload: user }))
            .catch((error) => dispatch({ type: 'FETCH_USER_FAILURE', error }));
    };
};
```

### 2. 便于管理复杂的异步逻辑
在大型应用程序中，异步逻辑可能变得非常复杂，包括并发请求、条件请求、请求之间的竞争、错误处理等。异步中间件可以帮助管理这些复杂性，提供更清晰和更可维护的代码结构。

**例子：**
在使用 Redux Saga 的情况下，我们可以使用 ES6 的 generator 函数来更加直观和声明式地处理复杂的异步流。

```javascript
function* fetchUserDataSaga(action) {
    try {
        yield put({ type: 'FETCH_USER_REQUEST' });
        const user = yield call(fetchApi, `/api/user/${action.userId}`);
        yield put({ type: 'FETCH_USER_SUCCESS', payload: user });
    } catch (error) {
        yield put({ type: 'FETCH_USER_FAILURE', error });
    }
}
```

### 3. 更好的测试性
异步中间件使得异步逻辑更加独立于组件，这有助于进行单元测试。我们可以在不进行实际的 API 调用的情况下，测试 action creators 和 reducers 的逻辑。

**例子：**
使用 Redux Thunk，我们可以测试 thunk action creator 是否正确地 dispatch 了相应的 actions。

```javascript
// 使用 Jest 测试框架
it('creates FETCH_USER_SUCCESS when fetching user has been done', () => {
    // 模拟 dispatch 和 getState 函数
    const dispatch = jest.fn();
    const getState = jest.fn();

    // 模拟 fetch API
    global.fetch = jest.fn(() =>
        Promise.resolve({
            json: () => Promise.resolve({ id: 1, name: 'John Doe' }),
        })
    );

    // 执行 thunk action creator
    return fetchUserData(1)(dispatch, getState).then(() => {
        // 检查是否 dispatch 了正确的 action
        expect(dispatch).toHaveBeenCalledWith({ type: 'FETCH_USER_SUCCESS', payload: { id: 1, name: 'John Doe' } });
    });
});
```

### 总结
Redux 需要异步中间件来处理异步操作，帮助维护复杂的异步逻辑，并提高代码的可测试性。这些中间件扩展了 Redux，使其能够以一种既有序又高效的方式处理异步数据流。

Redux 本身是一个同步状态管理库，它专注于以可预测的方式管理和更新应用程序的状态。Redux 的核心概念是纯函数的 reducer 和同步的 action。当应用程序需要处理异步操作，如数据的 API 请求时，Redux 单独并不能有效地处理。

异步中间件，如 Redux Thunk 或 Redux Saga，使得在 Redux 应用程序中处理异步逻辑成为可能。下面是一些为什么需要异步中间件的原因：

### 1. 处理异步操作
Redux 的基本原则是 action 应该是一个具有 `type` 属性的对象，而且 reducer 应该是同步的纯函数。这种模式并不适用于执行异步操作，例如 API 调用。异步中间件允许我们在 dispatching action 之前执行异步代码，然后根据异步操作的结果来 dispatch 实际的 action。

**例子：**
假设我们有一个获取用户信息的异步操作。使用 Redux Thunk，我们可以创建一个 thunk action creator，它返回一个函数而非 action 对象。这个函数能够执行异步请求并且在请求完成后 dispatch 一个 action。

```javascript
const fetchUserData = (userId) => {
    return (dispatch) => {
        dispatch({ type: 'FETCH_USER_REQUEST' });
        fetch(`/api/user/${userId}`)
            .then((response) => response.json())
            .then((user) => dispatch({ type: 'FETCH_USER_SUCCESS', payload: user }))
            .catch((error) => dispatch({ type: 'FETCH_USER_FAILURE', error }));
    };
};
```

### 2. 便于管理复杂的异步逻辑
在大型应用程序中，异步逻辑可能变得非常复杂，包括并发请求、条件请求、请求之间的竞争、错误处理等。异步中间件可以帮助管理这些复杂性，提供更清晰和更可维护的代码结构。

**例子：**
在使用 Redux Saga 的情况下，我们可以使用 ES6 的 generator 函数来更加直观和声明式地处理复杂的异步流。

```javascript
function* fetchUserDataSaga(action) {
    try {
        yield put({ type: 'FETCH_USER_REQUEST' });
        const user = yield call(fetchApi, `/api/user/${action.userId}`);
        yield put({ type: 'FETCH_USER_SUCCESS', payload: user });
    } catch (error) {
        yield put({ type: 'FETCH_USER_FAILURE', error });
    }
}
```

### 3. 更好的测试性
异步中间件使得异步逻辑更加独立于组件，这有助于进行单元测试。我们可以在不进行实际的 API 调用的情况下，测试 action creators 和 reducers 的逻辑。

**例子：**
使用 Redux Thunk，我们可以测试 thunk action creator 是否正确地 dispatch 了相应的 actions。

```javascript
// 使用 Jest 测试框架
it('creates FETCH_USER_SUCCESS when fetching user has been done', () => {
    // 模拟 dispatch 和 getState 函数
    const dispatch = jest.fn();
    const getState = jest.fn();

    // 模拟 fetch API
    global.fetch = jest.fn(() =>
        Promise.resolve({
            json: () => Promise.resolve({ id: 1, name: 'John Doe' }),
        })
    );

    // 执行 thunk action creator
    return fetchUserData(1)(dispatch, getState).then(() => {
        // 检查是否 dispatch 了正确的 action
        expect(dispatch).toHaveBeenCalledWith({ type: 'FETCH_USER_SUCCESS', payload: { id: 1, name: 'John Doe' } });
    });
});
```

### 总结
Redux 需要异步中间件来处理异步操作，帮助维护复杂的异步逻辑，并提高代码的可测试性。这些中间件扩展了 Redux，使其能够以一种既有序又高效的方式处理异步数据流。
Redux 作为一个状态管理库，其核心设计是围绕着同步的状态更新。也就是说，在没有任何中间件的情况下，当一个 action 被派发（dispatched）时，它会立即通过同步的 reducers 更新状态。然而，在实际的应用中，我们经常需要处理异步操作，比如从服务器获取数据，这些操作并不能立刻完成并返回数据。

因此，为了在 Redux 架构中处理这些异步操作，我们需要一种方式来扩展 Redux 的功能，使其能够处理异步逻辑。这就是异步中间件的用武之地。以下是几个为什么 Redux 需要异步数据流中间件的理由：

1. **维护纯净的 reducer 函数**：
   Reducer 函数应该是纯函数，这意味着给定相同的输入，总是返回相同的输出，并且不产生任何副作用。异步操作（如 API 调用）会产生副作用，因此不能直接在 reducer 中处理。

2. **扩展 Redux 的功能**：
   异步中间件像是 Redux 生态系统中的插件，它允许开发者在不修改原始 Redux 库代码的情况下增加新的功能。例如，可以增加日志记录、错误报告或异步处理等功能。

3. **异步控制流**：
   异步中间件允许开发者在派发 action 和到达 reducer 之间插入一个异步操作。这意味着可以先发出一个表示“开始异步操作”的 action，然后在操作完成时发出另一个表示“异步操作完成”的 action。

4. **更干净的代码结构**：
   通过将异步逻辑封装在中间件内，我们可以保持组件和 reducer 的简洁。这避免了在组件中混合异步调用和状态管理逻辑，有助于代码分离和维护。

5. **测试和调试的便捷性**：
   中间件提供了一个独立的层，可以在这个层中进行单独的测试和模拟异步行为，而不必担心组件逻辑或者 UI 层的细节。

### 例子

在实际应用中，最常见的异步中间件是 `redux-thunk` 和 `redux-saga`。

- **redux-thunk** 允许 action 创建函数（action creators）返回一个函数而不是一个 action 对象。这个返回的函数接收 `dispatch` 和 `getState` 作为参数，让你可以进行异步操作，并在操作结束后派发一个新的 action。

```javascript
const fetchUserData = (userId) => {
  return (dispatch, getState) => {
    dispatch({ type: 'USER_FETCH_REQUESTED', userId });
    return fetchUserFromApi(userId)
      .then(userData => {
        dispatch({ type: 'USER_FETCH_SUCCEEDED', userData });
      })
      .catch(error => {
        dispatch({ type: 'USER_FETCH_FAILED', error });
      });
  };
};
```

- **redux-saga** 则使用 ES6 的 Generator 函数来使异步流更易于读写。Sagas 可以监听派发到 store 的 actions，并在某个 action 被派发时执行复杂的异步逻辑。

```javascript
import { call, put, takeEvery } from 'redux-saga/effects';

function* fetchUser(action) {
  try {
    const user = yield call(Api.fetchUser, action.payload.userId);
    yield put({type: 'USER_FETCH_SUCCEEDED', user: user});
  } catch (e) {
    yield put({type: 'USER_FETCH_FAILED', message: e.message});
  }
}

function* mySaga() {
  yield takeEvery('USER_FETCH_REQUESTED', fetchUser);
}
```

总的来说，异步中间件在处理复杂的异步数据流时，可以提高 Redux 应用的可扩

Why do we need middleware for async flow in Redux?

在React中，检测组件外部的点击事件通常可以通过以下几个步骤进行：

1. **添加全局事件监听器**：在组件挂载（`componentDidMount` 或者 `useEffect`）后，添加一个点击事件监听器到`document`上，这样可以监听到所有的点击事件。

2. **设置引用（Ref）**：使用`useRef`创建一个引用，并将其附加到你希望检测外部点击的组件上。这允许我们可以访问真实的DOM节点，以判断点击事件是否发生在其内部。

3. **检测点击位置**：当全局点击事件被触发时，可以使用该事件的`target`属性，并与我们的组件的DOM节点进行比较，来确定点击是否在组件外部进行。

4. **清理事件监听器**：在组件卸载（`componentWillUnmount` 或者 `useEffect`的返回函数）时，要移除事件监听器，避免内存泄漏。

下面是一个使用Hooks实现的例子：

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

function OutsideClickExample() {
  const wrapperRef = useRef(null); // Step 2

  useEffect(() => {
    // Step 1
    function handleClickOutside(event) {
      if (wrapperRef.current && !wrapperRef.current.contains(event.target)) {
        // Step 3
        console.log('你点击了组件外部');
      }
    }

    // 在document上添加事件监听器
    document.addEventListener('mousedown', handleClickOutside);

    // Step 4
    return () => {
      // 在组件卸载时移除事件监听器
      document.removeEventListener('mousedown', handleClickOutside);
    };
  }, [wrapperRef]);

  return (
    <div ref={wrapperRef}>
      <p>点击我之外的地方试试看!</p>
    </div>
  );
}

export default OutsideClickExample;
```

在这个例子中，`useEffect`确保了事件监听器仅在组件挂载后添加，并在组件卸载时移除。`ref`的作用是提供了一种方式来引用实际的DOM元素，从而我们可以判断点击事件是否在这个元素之外发生。注意，这个例子使用了`mousedown`事件，它会在点击鼠标按钮时立即触发，而不是在释放按钮时（`click`事件）。根据你的应用场景，你可能需要选择不同的事件类型。

以下解决方案使用 ES6 并遵循绑定的最佳实践以及通过方法设置引用。

要查看它的实际效果：

*   [钩子实现](https://codesandbox.io/s/outside-alerter-hooks-lmr2y?module=%2Fsrc%2FOutsideAlerter.js)
*   [React 16.3 之后的类实现](https://codesandbox.io/s/outside-alerter-react-16-3-0-bn267m?file=/src/OutsideAlerter.js)
*   [React 16.3 之前的类实现](https://codesandbox.io/s/30q3mzjv91?module=%2Fsrc%2FOutsideAlerter.js)

钩子实现：
-----

    import React, { useRef, useEffect } from "react";
    
    /**
     * Hook that alerts clicks outside of the passed ref
     */
    function useOutsideAlerter(ref) {
      useEffect(() => {
        /**
         * Alert if clicked on outside of element
         */
        function handleClickOutside(event) {
          if (ref.current && !ref.current.contains(event.target)) {
            alert("You clicked outside of me!");
          }
        }
        // Bind the event listener
        document.addEventListener("mousedown", handleClickOutside);
        return () => {
          // Unbind the event listener on clean up
          document.removeEventListener("mousedown", handleClickOutside);
        };
      }, [ref]);
    }
    
    /**
     * Component that alerts if you click outside of it
     */
    export default function OutsideAlerter(props) {
      const wrapperRef = useRef(null);
      useOutsideAlerter(wrapperRef);
    
      return <div ref={wrapperRef}>{props.children}</div>;
    }
    

类实现：
----

**16.3之后**

    import React, { Component } from "react";
    
    /**
     * Component that alerts if you click outside of it
     */
    export default class OutsideAlerter extends Component {
      constructor(props) {
        super(props);
    
        this.wrapperRef = React.createRef();
        this.handleClickOutside = this.handleClickOutside.bind(this);
      }
    
      componentDidMount() {
        document.addEventListener("mousedown", this.handleClickOutside);
      }
    
      componentWillUnmount() {
        document.removeEventListener("mousedown", this.handleClickOutside);
      }
    
      /**
       * Alert if clicked on outside of element
       */
      handleClickOutside(event) {
        if (this.wrapperRef && !this.wrapperRef.current.contains(event.target)) {
          alert("You clicked outside of me!");
        }
      }
    
      render() {
        return <div ref={this.wrapperRef}>{this.props.children}</div>;
      }
    }
    

**16.3之前**

    import React, { Component } from "react";
    
    /**
     * Component that alerts if you click outside of it
     */
    export default class OutsideAlerter extends Component {
      constructor(props) {
        super(props);
    
        this.setWrapperRef = this.setWrapperRef.bind(this);
        this.handleClickOutside = this.handleClickOutside.bind(this);
      }
    
      componentDidMount() {
        document.addEventListener("mousedown", this.handleClickOutside);
      }
    
      componentWillUnmount() {
        document.removeEventListener("mousedown", this.handleClickOutside);
      }
    
      /**
       * Set the wrapper ref
       */
      setWrapperRef(node) {
        this.wrapperRef = node;
      }
    
      /**
       * Alert if clicked on outside of element
       */
      handleClickOutside(event) {
        if (this.wrapperRef && !this.wrapperRef.contains(event.target)) {
          alert("You clicked outside of me!");
        }
      }
    
      render() {
        return <div ref={this.setWrapperRef}>{this.props.children}</div>;
      }
    }

我被困在同样的问题上。我参加这里的聚会有点晚了，但对我来说，这是一个非常好的解决方案。希望它对其他人有帮助。您需要`findDOMNode`从以下位置导入`react-dom`

    import ReactDOM from 'react-dom';
    // ... ✂
    
    componentDidMount() {
        document.addEventListener('click', this.handleClickOutside, true);
    }
    
    componentWillUnmount() {
        document.removeEventListener('click', this.handleClickOutside, true);
    }
    
    handleClickOutside = event => {
        const domNode = ReactDOM.findDOMNode(this);
    
        if (!domNode || !domNode.contains(event.target)) {
            this.setState({
                visible: false
            });
        }
    }
    

* * *

React Hooks 方法 (16.8 +)
-----------------------

您可以创建一个名为 的可重用挂钩`useComponentVisible`。

    import { useState, useEffect, useRef } from 'react';
    
    export default function useComponentVisible(initialIsVisible) {
        const [isComponentVisible, setIsComponentVisible] = useState(initialIsVisible);
        const ref = useRef(null);
    
        const handleClickOutside = (event) => {
            if (ref.current && !ref.current.contains(event.target)) {
                setIsComponentVisible(false);
            }
        };
    
        useEffect(() => {
            document.addEventListener('click', handleClickOutside, true);
            return () => {
                document.removeEventListener('click', handleClickOutside, true);
            };
        }, []);
    
        return { ref, isComponentVisible, setIsComponentVisible };
    }
    

然后在您希望添加功能的组件中执行以下操作：

    const DropDown = () => {
        const { ref, isComponentVisible } = useComponentVisible(true);
        return (
           <div ref={ref}>
              {isComponentVisible && (<p>Dropdown Component</p>)}
           </div>
        );
     
    }
    

在这里找到一个[codesandbox](https://codesandbox.io/s/989y0758np)示例。

**2021 年更新：**

自从我添加此响应以来已经有一段时间了，由于它似乎仍然引起了一些兴趣，我想我会将其更新到更新的 React 版本。到 2021 年，我会这样编写这个组件：

    import React, { useState } from "react";
    import "./DropDown.css";
    
    export function DropDown({ options, callback }) {
        const [selected, setSelected] = useState("");
        const [expanded, setExpanded] = useState(false);
    
        function expand() {
            setExpanded(true);
        }
    
        function close() {
            setExpanded(false);
        }
    
        function select(event) {
            const value = event.target.textContent;
            callback(value);
            close();
            setSelected(value);
        }
    
        return (
            <div className="dropdown" tabIndex={0} onFocus={expand} onBlur={close} >
                <div>{selected}</div>
                {expanded ? (
                    <div className={"dropdown-options-list"}>
                        {options.map((O) => (
                            <div className={"dropdown-option"} onClick={select}>
                                {O}
                            </div>
                        ))}
                    </div>
                ) : null}
            </div>
        );
    }
    

* * *

**原答案（2016）：**
--------------

这是最适合我的解决方案，无需将事件附加到容器：

某些 HTML 元素可以具有所谓的“**焦点**”，例如输入元素。当这些元素失去焦点时，它们也会响应_模糊事件。_

要赋予任何元素获得焦点的能力，只需确保其 tabindex 属性设置为除 -1 之外的任何值。在常规 HTML 中，可以通过设置`tabindex`属性来实现，但在 React 中，您必须使用`tabIndex`（注意大写`I`）。

你也可以通过 JavaScript 来完成`element.setAttribute('tabindex',0)`

这就是我用它来制作自定义下拉菜单的目的。

    var DropDownMenu = React.createClass({
        getInitialState: function(){
            return {
                expanded: false
            }
        },
        expand: function(){
            this.setState({expanded: true});
        },
        collapse: function(){
            this.setState({expanded: false});
        },
        render: function(){
            if(this.state.expanded){
                var dropdown = ...; //the dropdown content
            } else {
                var dropdown = undefined;
            }
            
            return (
                <div className="dropDownMenu" tabIndex="0" onBlur={ this.collapse } >
                    <div className="currentValue" onClick={this.expand}>
                        {this.props.displayValue}
                    </div>
                    {dropdown}
                </div>
            );
        }
    });

在尝试了多种方法之后，我决定使用[github.com/Pomax/react-onclickoutside](https://github.com/Pomax/react-onclickoutside)因为它非常完整。

我通过 npm 安装了该模块并将其导入到我的组件中：

    import onClickOutside from 'react-onclickoutside'
    

然后，在我的组件类中我定义了该`handleClickOutside`方法：

    handleClickOutside = () => {
      console.log('onClickOutside() method called')
    }
    

当导出我的组件时，我将其包装在`onClickOutside()`：

    export default onClickOutside(NameOfComponent)
    

就是这样。

Hook 实现基于 Tanner Linsley[在 JSConf Hawaii 2020 上的精彩演讲](https://www.youtube.com/watch?v=J-g9ZJha8FE&feature=youtu.be&t=481)：

### `useOuterClick`应用程序编程接口

    const Client = () => {
      const innerRef = useOuterClick(ev => {/*event handler code on outer click*/});
      return <div ref={innerRef}> Inside </div> 
    };
    

### 执行

    function useOuterClick(callback) {
      const callbackRef = useRef(); // initialize mutable ref, which stores callback
      const innerRef = useRef(); // returned to client, who marks "border" element
    
      // update cb on each render, so second useEffect has access to current value 
      useEffect(() => { callbackRef.current = callback; });
      
      useEffect(() => {
        document.addEventListener("click", handleClick);
        return () => document.removeEventListener("click", handleClick);
        function handleClick(e) {
          if (innerRef.current && callbackRef.current && 
            !innerRef.current.contains(e.target)
          ) callbackRef.current(e);
        }
      }, []); // no dependencies -> stable click listener
          
      return innerRef; // convenience for client (doesn't need to init ref himself) 
    }
    

这是一个工作示例：

显示代码片段

    /*
      Custom Hook
    */
    function useOuterClick(callback) {
      const innerRef = useRef();
      const callbackRef = useRef();
    
      // set current callback in ref, before second useEffect uses it
      useEffect(() => { // useEffect wrapper to be safe for concurrent mode
        callbackRef.current = callback;
      });
    
      useEffect(() => {
        document.addEventListener("click", handleClick);
        return () => document.removeEventListener("click", handleClick);
    
        // read most recent callback and innerRef dom node from refs
        function handleClick(e) {
          if (
            innerRef.current && 
            callbackRef.current &&
            !innerRef.current.contains(e.target)
          ) {
            callbackRef.current(e);
          }
        }
      }, []); // no need for callback + innerRef dep
      
      return innerRef; // return ref; client can omit `useRef`
    }
    
    /*
      Usage 
    */
    const Client = () => {
      const [counter, setCounter] = useState(0);
      const innerRef = useOuterClick(e => {
        // counter state is up-to-date, when handler is called
        alert(`Clicked outside! Increment counter to ${counter + 1}`);
        setCounter(c => c + 1);
      });
      return (
        <div>
          <p>Click outside!</p>
          <div id="container" ref={innerRef}>
            Inside, counter: {counter}
          </div>
        </div>
      );
    };
    
    ReactDOM.render(<Client />, document.getElementById("root"));

    #container { border: 1px solid red; padding: 20px; }

    <script src="https://cdnjs.cloudflare.com/ajax/libs/react/16.12.0/umd/react.production.min.js" integrity="sha256-Ef0vObdWpkMAnxp39TYSLVS/vVUokDE8CDFnx7tjY6U=" crossorigin="anonymous"></script>
    <script src="https://cdnjs.cloudflare.com/ajax/libs/react-dom/16.12.0/umd/react-dom.production.min.js" integrity="sha256-p2yuFdE8hNZsQ31Qk+s8N+Me2fL5cc6NKXOC0U9uGww=" crossorigin="anonymous"></script>
    <script> var {useRef, useEffect, useCallback, useState} = React</script>
    <div id="root"></div>

Run code snippetHide results

Expand snippet

### 关键点

*   `useOuterClick`利用[可变引用](https://reactjs.org/docs/hooks-faq.html#is-there-something-like-instance-variables)来提供精益`Client`API
*   在包含组件 ( `[]`deps)的生命周期内_保持稳定的点击侦听器_
*   `Client`可以设置回调而不需要通过以下方式记住它`useCallback`
*   回调主体可以访问最新的 props 和状态 -[没有过时的闭包值](https://reactjs.org/docs/hooks-faq.html#why-am-i-seeing-stale-props-or-state-inside-my-function)

### （iOS 的旁注）

iOS 通常只将某些元素视为可点击。要使外部点击起作用，请选择不同的点击侦听器`document`\- 没有向上，包括`body`。例如，在 React 根上添加一个侦听器`div`并扩展其高度，例如`height: 100vh`，以捕获所有外部点击。资料来源：[quirksmode.org](https://www.quirksmode.org/blog/archives/2014/02/mouse_event_bub.html)

How to detect click outside on react component

npx 和 npm 之间的区别？`npx` 和 `npm` 都是 Node.js 环境中常用的工具，它们在 Node.js 和 JavaScript 生态系统中扮演着关键的角色。以下是它们之间的一些主要区别：

### npm (Node Package Manager):

- **Package 管理器**：npm 是 Node.js 默认的包管理器，用来安装、更新和管理项目中的依赖包。
- **全局安装**：npm 可以全局安装包，这样你就可以在命令行中任何位置使用这些包。
- **本地安装**：npm 也可用来在特定项目中安装包，通常这些包会被放在项目的 `node_modules` 文件夹中。
- **脚本运行**：npm 还可以运行定义在 `package.json` 文件中的脚本。
- **版本管理**：npm 通过 `package.json` 和 `package-lock.json` 文件帮助管理包的版本。
- **包发布**：npm 可用于发布和更新包到 npm registry。

### npx (Node Package Execute):

- **执行包**：npx 用来执行在 npm registry 中的包，无需手动下载或者安装。
- **一次性命令**：npx 非常适合一次性使用命令，它可以在不全局安装包的情况下执行包的二进制文件。
- **即时安装执行**：npx 会在本地或者全局找不到命令的时候，自动从 npm registry 安装包并立即执行。
- **避免全局污染**：npx 避免了全局安装多个包可能导致的版本冲突或环境污染问题。
- **测试不同版本**：npx 可以用来轻松地测试不同版本的包，而不需要更改项目中的依赖。

简而言之，`npm` 主要用作包的安装和管理工具，而 `npx` 是一个辅助工具，用于执行包中的命令，特别是在不想或不需要永久安装这些包的情况下。这两个工具经常一起使用，以更有效地开发和管理 Node.js 项目。

[Introducing npx: an npm package runner](https://blog.npmjs.org/post/162869356040/introducing-npx-an-npm-package-runner)
------------------------------------------------------------------------------------------------------------------------

### `NPM` - _Manages_ packages _but_ doesn't make life easy _executing_ any.  
`NPX` - A tool for _executing_ Node packages.

> `NPX` comes bundled with `NPM` version `5.2+`  

`NPM` by itself does not simply run any package. It doesn't run any package as a matter of fact. If you want to run a package using NPM, you must specify that package in your `package.json` file.

When executables are installed via NPM packages, NPM links to them:

1.  _local_ installs have "links" created at `./node_modules/.bin/` directory.
2.  _global_ installs have "links" created from the global `bin/` directory (e.g. `/usr/local/bin`) on Linux or at `%AppData%/npm` on Windows.

[**Documentation you should read**](https://docs.npmjs.com/files/folders#executables)

* * *

NPM:
====

One might install a package locally on a certain project:

    npm install some-package
    

Now let's say you want NodeJS to execute that package from the command line:

    $ some-package
    

The above will **fail**. Only **globally installed** packages can be executed by typing their name _only_.

To fix this, and have it run, you must type the local path:

    $ ./node_modules/.bin/some-package
    

You can technically run a locally installed package by editing your `packages.json` file and adding that package in the `scripts` section:

    {
      "name": "whatever",
      "version": "1.0.0",
      "scripts": {
        "some-package": "some-package"
      }
    }
    

Then run the script using [`npm run-script`](https://docs.npmjs.com/cli/run-script) (or `npm run`):

    npm run some-package
    

* * *

NPX:
====

`npx` will check whether `<command>` exists in `$PATH`, or in the local project binaries, and execute it. So, for the above example, if you wish to execute the locally-installed package `some-package` all you need to do is type:

    npx some-package
    

Another **major** advantage of `npx` is the ability to execute a package which wasn't previously installed:

    $ npx create-react-app my-app
    

The above example will generate a `react` app boilerplate _within_ the path the command had run in, and ensures that you always use the latest version of a generator or build tool without having to upgrade each time you’re about to use it.

* * *

### Use-Case Example:

`npx` command may be helpful in the `script` section of a `package.json` file, when it is unwanted to define a dependency which might not be commonly used or any other reason:

    "scripts": {
        "start": "npx gulp@3.9.1",
        "serve": "npx http-server"
    }
    

Call with: `npm run serve`

* * *

### Related questions:

1.  [How to use package installed locally in node\_modules?](https://stackoverflow.com/q/9679932/104380)
2.  [NPM: how to source ./node\_modules/.bin folder?](https://stackoverflow.com/q/18033754/104380)
3.  [How do you run a js file using npm scripts?](https://stackoverflow.com/q/32964900/104380)

_**npx**_ is a npm package runner (x probably stands for eXecute). One common way to use _npx_ is to download and run a package temporarily or for trials.

_**create-react-app**_ is an npm package that is expected to be run only once in a project's lifecycle. Hence, it is preferred to use npx to install and run it in a single step.

As mentioned in the main page [https://www.npmjs.com/package/npx](https://www.npmjs.com/package/npx), _npx_ can run commands in the PATH or from node\_modules/.bin by default.

**Note:** With some digging, we can find that create-react-app points to a Javascript file (possibly to /usr/lib/node\_modules/create-react-app/index.js on Linux systems) that is executed within the node environment. This is simply a global tool that does some checks. The actual setup is done by react-scripts, whose latest version is installed in the project. Refer [https://github.com/facebook/create-react-app](https://github.com/facebook/create-react-app) for more info.

NPM is a package manager, you can install node.js packages using NPM

NPX is a tool to execute node.js packages.

It doesn't matter whether you installed that package globally or locally. NPX will temporarily install it and run it. NPM also can run packages if you configure a package.json file and include it in the script section.

> So remember this, if you want to check/run a node package quickly without installing locally or globally use NPX.

np**M** - Manager

np**X** - Execute - easy to remember

**npm** - Package manager for JavaScript, just like: `pip` (Python), `Maven` (Java), `NuGet` (.NET), `Composer` (PHP), `RubyGems` (Ruby), ...

**npx** - runs a command of a package without installing it explicitly.

Use cases:

*   You don't want to install packages neither globally nor locally.
*   You don't have permission to install it globally.
*   Just want to test some commands.
*   Sometime, you want to have a script command (generate, convert something, ...) in `package.json` to execute something without installing these packages as project's dependencies.

Syntax:

    npx [options] [-p|--package <package>] <command> [command-arg]...
    

Package is optional:

    npx   -p uglify-js         uglifyjs --output app.min.js app.js common.js
          +----------------+   +--------------------------------------------+
          package (optional)   command, followed by arguments
    

For example:

    Start a HTTP Server      : npx http-server
    Lint code                : npx eslint ./src
                             # Run uglifyjs command in the package uglify-js
    Minify JS                : npx -p uglify-js uglifyjs -o app.min.js app.js common.js
    Minify CSS               : npx clean-css-cli -o style.min.css css/bootstrap.css style.css
    Minify HTML              : npx html-minifier index-2.html -o index.html --remove-comments --collapse-whitespace
    Scan for open ports      : npx evilscan 192.168.1.10 --port=10-9999
    Cast video to Chromecast : npx castnow http://commondatastorage.googleapis.com/gtv-videos-bucket/sample/ForBiggerFun.mp4
    

More about `command`:

*   [https://docs.npmjs.com/files/package.json#bin](https://docs.npmjs.com/files/package.json#bin)
*   [https://github.com/mishoo/UglifyJS2/blob/master/package.json#L17](https://github.com/mishoo/UglifyJS2/blob/master/package.json#L17)

NPX:

From [https://www.futurehosting.com/blog/npx-makes-life-easier-for-node-developers-plus-node-vulnerability-news/](https://www.futurehosting.com/blog/npx-makes-life-easier-for-node-developers-plus-node-vulnerability-news/):

> Web developers can have dozens of projects on their development machines, and each project has its own particular set of npm-installed dependencies. A few years back, the usual advice for dealing with CLI applications like Grunt or Gulp was to install them locally in each project and also globally so they could easily be run from the command line.
> 
> But installing globally caused as many problems as it solved. Projects may depend on different versions of command line tools, and polluting the operating system with lots of development-specific CLI tools isn’t great either. Today, most developers prefer to install tools locally and leave it at that.
> 
> Local versions of tools allow developers to pull projects from GitHub without worrying about incompatibilities with globally installed versions of tools. NPM can just install local versions and you’re good to go. But project specific installations aren’t without their problems: how do you run the right version of the tool without specifying its exact location in the project or playing around with aliases?
> 
> That’s the problem npx solves. A new tool included in NPM 5.2, npx is a small utility that’s smart enough to run the right application when it’s called from within a project.
> 
> If you wanted to run the project-local version of mocha, for example, you can run npx mocha inside the project and it will do what you expect.
> 
> A useful side benefit of npx is that it will automatically install npm packages that aren’t already installed. So, as the tool’s creator Kat Marchán points out, you can run npx benny-hill without having to deal with Benny Hill polluting the global environment.
> 
> If you want to take npx for a spin, update to the most recent version of npm.

Difference between npx and npm?

React Native 和 React 在很多方面是相似的，因为 React Native 是基于 React 的，但是它们也有一些关键的区别，主要体现在它们的使用平台和渲染机制上。

### React

React 是一个用于构建用户界面的JavaScript库，它专注于构建Web应用程序的前端。React 使用了一种名为JSX的语法，它允许开发者在JavaScript代码中编写类似HTML的结构。

#### 特点：

- **Virtual DOM**：React 通过使用虚拟DOM来优化DOM操作，提高渲染性能。
- **组件化**：React 强调构建可重用的组件，这有助于代码的维护和管理。
- **单向数据流**：React 通常与如Redux这样的状态管理库一起使用，以提供一个可预测的单向数据流环境。

### React Native

React Native 是一个用于构建原生移动应用的框架，它允许开发者使用JavaScript和React来构建iOS和Android应用程序。

#### 特点：

- **跨平台**：使用React Native，开发者可以用相同的代码库创建在iOS和Android上运行的应用程序。
- **原生组件**：React Native将React的组件转换成对应平台的原生组件，这样可以保证用户获得接近原生应用的体验。
- **动态更新**：React Native支持热更新，允许开发者直接推送更新到用户的设备上，而无需经过应用商店的审核。

### 主要区别

- **平台**：React 通常用于构建Web应用程序，而 React Native 则用于构建移动应用程序。
- **渲染机制**：React 在浏览器中使用虚拟DOM来渲染Web界面，而React Native 使用的是桥接技术（Bridge）来调用原生模块，这样可以使得应用在不同的设备上拥有原生的性能和外观。
- **样式**：React 使用CSS来定义样式，而React Native 则使用JavaScript对象来定义样式，这些样式对象最后会被转换成对应平台的样式规则。
- **导航**：Web应用的导航是建立在URL和浏览器历史上的，而移动应用则通常使用屏幕之间的导航堆栈。

#### 示例：

在React中，你可能会这样创建一个按钮组件：

```jsx
function MyButton() {
  return <button className="my-button">Click me</button>;
}
```

在React Native中，相同的按钮组件会是这样：

```jsx
import { Button } from 'react-native';

function MyButton() {
  return <Button title="Click me" />;
}
```

总结来说，虽然React和React Native在设计理念和开发模式上有着很多共通之处，但它们是为不同平台和不同类型的应用程序设计的。React 更适合Web应用程序的开发，而React Native 则是为了解决移动应用开发中的跨平台问题。

[ReactJS](https://reactjs.org/)是一个 JavaScript 库，支持前端 Web 并在服务器上运行，用于构建用户界面和 Web 应用程序。它遵循可重用组件的概念。

[React Native](https://reactnative.dev/)是一个移动框架，它利用主机上可用的 JavaScript 引擎，允许您使用 JavaScript 为不同平台（iOS、Android 和 Windows Mobile）构建移动应用程序，从而允许您使用 ReactJS 构建可重用组件并进行通信与本机组件[进一步解释](https://stackoverflow.com/questions/41124338/does-react-native-compile-javascript-into-java-for-android)

两者都遵循 JavaScript 的 JSX 语法扩展。它编译为`React.createElement`底层调用。[JSX 深入](https://reactjs.org/docs/jsx-in-depth.html)

两者都是 Facebook 开源的。

这是[**React**项目](https://github.com/facebook/react)。

在 Facebook，他们发明了**React**，这样 JavaScript 就可以使用虚拟 DOM 模型更快地操作网站 DOM。

[与React virtual-dom 模型](https://stackoverflow.com/questions/21109361/why-is-reacts-concept-of-virtual-dom-said-to-be-more-performant-than-dirty-mode)相比，DOM 完全刷新速度较慢，React virtual-dom 模型仅刷新页面的部分内容（读作：部分刷新）。

[从这段视频](https://www.youtube.com/watch?v=oWPoW0gIzvs)中你可能会了解到，Facebook 并没有发明 React，因为他们立即意识到部分刷新会比传统刷新更快。最初他们需要一种方法来减少 Facebook 应用程序重新构建时间，幸运的是，这使部分 DOM 刷新变得栩栩如生。

[**React Native**](https://github.com/facebook/react-native)只是 React 的结果。它是一个使用 JavaScript 构建本机应用程序的平台。

**在使用React Native**之前，您需要了解适用于 Android 的 Java 或 Kotlin 以及适用于 iPhone 和 iPad 的 Swift 或 Objective-C 来创建本机应用程序。

使用 React Native，可以在 JavaScript 中模仿本机应用程序的行为，最终，您将获得特定于平台的代码作为输出。如果您需要进一步优化您的应用程序，您甚至可以将**本机代码与 JavaScript 混合。**

正如 Olivia Bishop 在[视频](https://www.youtube.com/watch?v=oWPoW0gIzvs)中所说，85% 的**React 原生**代码库可以在平台之间共享。这些将是应用程序通常使用的组件和通用逻辑。

15% 的代码是特定于平台的。特定于平台的 JavaScript 赋予了平台风味（并带来了不同的体验）。

最酷的是这个特定于平台的代码 - 已经编写好了，所以您只需要使用它即可。

**反应：**

> React 是一个声明式、高效且灵活的 JavaScript 库，用于构建用户界面。  

**反应本机：**

> React Native 允许您仅使用 JavaScript 构建移动应用程序。它使用与 React 相同的设计，让您可以通过声明性组件构建丰富的移动 UI。  
> 使用 React Native，您不需要构建“移动 Web 应用程序”、“HTML5 应用程序”或“混合应用程序”。您构建的真正的移动应用程序与使用 Objective-C 或 Java 构建的应用程序没有什么区别。React Native 使用与常规 iOS 和 Android 应用程序相同的基本 UI 构建块。您只需使用 JavaScript 和 React 将这些构建块组合在一起即可。  
> React Native 可让您更快地构建应用程序。您可以立即重新加载应用程序，而不用重新编译。通过热重载，您甚至可以在保留应用程序状态的同时运行新代码。尝试一下 - 这是一次神奇的体验。  
> React Native 与 Objective-C、Java 或 Swift 编写的组件顺利结合。如果您需要优化应用程序的某些方面，那么可以简单地使用本机代码。在 React Native 中构建应用程序的一部分，以及直接使用本机代码构建应用程序的一部分也很容易 - 这就是 Facebook 应用程序的工作原理。

所以基本上**React**是用于 Web 应用程序视图的 UI 库，使用**javascript**和**JSX**，**React Native**是 React 之上的一个额外库，用于为`iOS`和`Android`设备制作本机应用程序。  
  

**反应**代码示例：

    import React, { Component } from 'react';
    import ReactDOM from 'react-dom';
    
    class Clock extends React.Component {
      constructor(props) {
        super(props);
        this.state = {date: new Date()};
      }
    
      componentDidMount() {
        this.timerID = setInterval(
          () => this.tick(),
          1000
        );
      }
    
      componentWillUnmount() {
        clearInterval(this.timerID);
      }
    
      tick() {
        this.setState({
          date: new Date()
        });
      }
    
      render() {
        return (
          <div>
            <h1>Hello, world!</h1>
            <h2>It is {this.state.date.toLocaleTimeString()}.</h2>
          </div>
        );
      }
    }
    
    ReactDOM.render(
      <Clock />,
      document.getElementById('root')
    );
    

**React Native**代码示例：

    import React, { Component } from 'react';
    import { Text, View } from 'react-native';
    
    class WhyReactNativeIsSoGreat extends Component {
      render() {
        return (
          <View>
            <Text>
              If you like React on the web, you'll like React Native.
            </Text>
            <Text>
              You just use native components like 'View' and 'Text',
              instead of web components like 'div' and 'span'.
            </Text>
          </View>
        );
      }
    }
    

有关**React**的更多信息，请访问由 facebook 团队创建的官方网站：

[https://reactjs.org/](https://reactjs.org/)

有关**React Native**的更多信息，请访问下面的 React Native 网站：

[https://reactnative.dev/](https://reactnative.dev/)

**首先，相似之处：** React 和 React Native (RN) 都旨在创建灵活的用户界面。这些框架有很多好处，但最基本的要点是它们是为 UI 开发而设计的。Facebook 在 React 几年后开发了 RN。

**React：** Facebook 设计这个框架几乎就像在 HTML/XML 中编写 JavaScript 一样，这就是为什么这些标签被称为“ _JSX_ ”（JavaScript XML）并且类似于熟悉的类似 HTML 的标签，例如`<div>`或`<p>`。React 的一个标志是大写字母标签，它表示自定义组件，例如`<MyFancyNavbar />`，它也存在于 RN 中。然而，React 使用[DOM](https://developer.mozilla.org/en-US/docs/Web/API/Document_Object_Model/Introduction)。DOM 是为 HTML 而存在的，因此 React 用于 Web 开发。

**React Native：** RN不使用HTML，因此不用于Web开发。它用于……几乎所有其他用途！移动开发（iOS 和 Android）、智能设备（例如手表、电视）、增强现实等。由于 RN 没有可交互的 DOM，因此它没有使用 React 中使用的同类 HTML 标签，而是使用其标签然后被编译成其他语言。例如，`<div>`RN 开发人员使用 RN 的内置标签代替`<View>`标签，该标签在底层编译成其他本机代码（例如`android.view`在 Android 上；`UIView`在 iOS 上）。

_简而言之：它们非常相似（对于 UI 开发），但用于不同的媒介。_

ReactJS 是一个用于构建 UI 组件层次结构的框架。每个组件都有状态和道具。数据通过 props 从顶层组件流向底层组件。使用事件处理程序在顶级组件中更新状态。

React Native 使用 React 框架来构建移动应用程序的组件。React Native 为 iOS 和 Android 平台提供了一组基本组件。React Native 中的一些组件包括 Navigator、TabBar、Text、TextInput、View、ScrollView。这些组件在内部使用原生 iOS UIKit 和 Android UI 组件。React Native 还允许使用 NativeModules，其中 iOS 的 Objective-C 和 Android 的 Java 编写的代码可以在 JavaScript 中使用。

注意：React Native 作为一个框架，允许使用与 HTML 和 CSS 类似的语法来开发移动应用程序。React Native 组件有效地取代了原生开发中的 HTML。

What is the difference between React Native and React?

在React中，通常我们通过调用`setState`来通知组件需要更新其状态，并触发重新渲染。不过，如果需要在不直接调用`setState`的情况下强制组件重新渲染，可以使用下面几种方法：

1. 使用`forceUpdate()`方法
   React类组件中的`forceUpdate()`方法会使组件跳过`shouldComponentUpdate`，直接触发一个重新渲染。

   ```jsx
   class MyComponent extends React.Component {
     someMethod() {
       // ... 执行某些操作后，需要强制重新渲染
       this.forceUpdate();
     }

     render() {
       // render logic
     }
   }
   ```

   这种方式不推荐频繁使用，因为它绕过了React的正常更新流程（如`shouldComponentUpdate`生命周期方法），可能导致性能问题。

2. 使用Hooks中的一个小技巧
   在函数组件中，我们可以使用`useState`和一个更新函数来强制重新渲染。

   ```jsx
   import { useState, useCallback } from 'react';

   function MyComponent() {
     const [, updateState] = useState();
     const forceUpdate = useCallback(() => updateState({}), []);

     function handleSomeAction() {
       // ... 执行某些操作后，需要强制重新渲染
       forceUpdate();
     }

     return (
       // render logic
     );
   }
   ```

   通过更改状态来触发重新渲染，即使状态值没有实际改变。

3. 使用Key改变
   通过改变组件的`key`属性，可以让React卸载当前组件并且装载一个新的组件实例。

   ```jsx
   function MyParentComponent() {
     const [key, setKey] = useState(0);

     function forceRender() {
       setKey(prevKey => prevKey + 1);
     }

     return <MyComponent key={key} />;
   }
   ```

   当`key`发生变化时，React将会认为是不同的组件，并且进行重新装载。这会导致组件的状态被重置，因此该方法适用于没有状态或者可以丢弃状态的组件。

需要注意的是，不推荐在常规开发中绕过React的正常更新流程来强制渲染，这样做通常会违背React声明式编程的理念，可能造成不可预见的问题。在大部分情况下，合理使用state和props来控制组件的渲染会更加符合React的设计哲学。强制更新通常用于与外部库交互或者处理一些特殊的副作用。

In class components, you can call `this.forceUpdate()` to force a rerender.

Documentation: [https://facebook.github.io/react/docs/component-api.html](https://facebook.github.io/react/docs/react-component.html#forceupdate)

In function components, there's no equivalent of `forceUpdate`, but you can [contrive a way to force updates with the `useState` hook](https://stackoverflow.com/a/53837442/200224).

`forceUpdate` should be avoided because it deviates from a React mindset. The React docs cite an example of when `forceUpdate` might be used:

> By default, when your component's state or props change, your component will re-render. However, if these change implicitly (eg: data deep within an object changes without changing the object itself) or if your render() method depends on some other data, you can tell React that it needs to re-run render() by calling forceUpdate().

However, I'd like to propose the idea that even with deeply nested objects, `forceUpdate` is unnecessary. By using an immutable data source tracking changes becomes cheap; a change will always result in a new object so we only need to check if the reference to the object has changed. You can use the library [Immutable JS](http://facebook.github.io/immutable-js/) to implement immutable data objects into your app.

> Normally you should try to avoid all uses of forceUpdate() and only read from this.props and this.state in render(). This makes your component "pure" and your application much simpler and more efficient.[forceUpdate()](https://facebook.github.io/react/docs/component-api.html#forceupdate)

Changing the key of the element you want re-rendered will work. Set the key prop on your element via state and then when you want to update set state to have a new key.

    <Element key={this.state.key} /> 
    

Then a change occurs and you reset the key

    this.setState({ key: Math.random() });
    

I want to note that this will replace the element that the key is changing on. An example of where this could be useful is when you have a file input field that you would like to reset after an image upload.

While the true answer to the OP's question would be `forceUpdate()` I have found this solution helpful in different situations. I also want to note that if you find yourself using `forceUpdate` you may want to review your code and see if there is another way to do things.

**NOTE 1-9-2019:**

The above (changing the key) will completely replace the element. If you find yourself updating the key to make changes happen you probably have an issue somewhere else in your code. Using `Math.random()` in key will re-create the element with each render. I would NOT recommend updating the key like this as react uses the key to determine the best way to re-render things.

In 2021 and 2022, this is [the official way](https://reactjs.org/docs/hooks-faq.html#is-there-something-like-forceupdate) to forceUpdate a React Functional Component.

    const [, forceUpdate] = useReducer(x => x + 1, 0);
    
      function handleClick() {
        forceUpdate();
      }
    

I know the OP is for a class component. But the question was asked in 2015 and now that hooks are available, many may search for `forceUpdate` in functional components. This little bit is for them.

**Edit 18th Apr 2022**

It's usually bad practice to force update your components.

A few reasons that can cause the need to use force updates.

*   Not using state variables where you have to - local, redux, context.
*   The field from the state object you are trying to access and expecting to update/change is too deeply nested in objects or arrays. Even Redux advises to maintain flat objects or arrays. If only one field value changes in a complex object, React may not figure out that the state object has changed, thus it does not update the component. Keep your state flat and simple.
*   The key on your list items, as mentioned in another answer. In fact, this can cause other unexpected behaviors as well. I've seen lists where items are repeatedly rendered (duplicates) because the keys aren't identical or the keys are just missing altogether. Always request the backend team to send unique ids everywhere possible! Avoid using array indexes for keys. Do not try to create unique ids on the front-end by using nanoid, uuid or random. Because ids created using above methods change each time the component updates (keys provided to a list need to be static and the same on each render). Creating unique ids is usually a backend concern. Try your best to not bring that requirement to the front-end. The front-end's responsibility is only to paint what data the backend returns and not create data on the fly.
*   If your useEffect, useCallback dependency arrays do not have the proper values set. Use ESLint to help you with this one! Also, this is one of the biggest causes for memory leaks in React. Clean up your state and event listeners in the return callback to avoid memory leaks. Because such memory leaks are awfully difficult to debug.
*   Always keep an eye on the console. It's your best friend at work. Solving warning and errors that show up in the console can fix a whole lot of nasty things - bugs and issues that you aren't even aware off.

A few things I can remember that I did wrong. In case it helps..

Actually, `forceUpdate()` is the only correct solution as `setState()` might **not** trigger a re-render if additional logic is implemented in `shouldComponentUpdate()` or when it simply returns `false`.

### forceUpdate()

> Calling `forceUpdate()` will cause `render()` to be called on the component, skipping `shouldComponentUpdate()`. _[more...](https://facebook.github.io/react/docs/component-api.html#forceupdate)_

### setState()

> `setState()` will always trigger a re-render unless conditional rendering logic is implemented in `shouldComponentUpdate()`. _[more...](https://facebook.github.io/react/docs/component-api.html#setstate)_

* * *

`forceUpdate()` can be called from within your component by `this.forceUpdate()`

* * *

Hooks: [How can I force component to re-render with hooks in React?](https://stackoverflow.com/questions/53215285/how-can-i-force-component-to-re-render-with-hooks-in-react/58606536#58606536)
-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------

* * *

### BTW: Are you mutating state or your nested properties don't propagate?

*   [How to update nested state properties in React](https://stackoverflow.com/a/50149659/985454)
*   [Sandbox](https://stackoverflow.com/questions/43040721/how-to-update-nested-state-properties-in-react/50149659?noredirect=1#comment109484301_50149659)

I Avoided `forceUpdate` by doing following
------------------------------------------

> **WRONG WAY** : do not use index as key

    this.state.rows.map((item, index) =>
       <MyComponent cell={item} key={index} />
    )
    

> **CORRECT WAY** : Use data id as key, it can be some guid etc

    this.state.rows.map((item) =>
       <MyComponent item={item} key={item.id} />
    )
    

so by doing such code improvement your component will be **UNIQUE** and render naturally

Can you force a React component to rerender without calling setState?

当我们在React项目中开发用户界面时，我们经常会用到几个核心概念，包括JSX Element、ReactNode和ReactElement。现在我将逐一解释这些概念，并提供使用的场景。

### JSX Element
JSX (JavaScript XML) 是一个React语法扩展，它允许我们在JavaScript代码中写类似HTML的标记。每当我们编写诸如 `<div>Hello World</div>` 这样的代码时，我们实际上创建了一个JSX Element。

**使用场景:**
- **直接在组件中编写UI:** 最直接的使用场景就是在函数组件或类组件中返回UI布局时。
  ```jsx
  function Welcome() {
    return <div>Welcome to React</div>;
  }
  ```
- **条件渲染:** 在需要根据条件判断来显示不同的UI元素时，通常会使用JSX Elements。
  ```jsx
  function Greeting({ isUserLoggedIn }) {
    return isUserLoggedIn ? <div>Welcome back!</div> : <div>Please sign in.</div>;
  }
  ```

### ReactNode
`ReactNode` 是React类型定义中的一个类型，它可以是字符串或数字类型的文本，JSX元素，JSX Fragment，`null` 或者 `undefined`，甚至是这些类型的数组。`ReactNode` 更多是用于类型定义，确保组件可以处理各种类型的子组件或值。

**使用场景:**
- **作为props或子组件:** 当编写可复用组件时，我们可以将其子元素类型指定为`ReactNode`，以接受多种类型的子元素。
  ```jsx
  type CardProps = {
    children: React.ReactNode;
  };

  function Card({ children }: CardProps) {
    return <div className="card">{children}</div>;
  }
  ```
- **渲染动态内容:** 在渲染不确定类型的内容时，使用`ReactNode`类型可以使得组件更加灵活。
  ```jsx
  const content: React.ReactNode = getContent(); // getContent可能返回字符串、元素或null
  return <div>{content}</div>;
  ```

### ReactElement
`ReactElement` 是对JSX Element的一种抽象，它们是由`React.createElement()`函数创建的对象。当JSX编译之后，每个JSX元素实际上都会变成一个`ReactElement`。

**使用场景:**
- **使用createElement创建元素:** 当我们需要在不使用JSX语法的环境中创建元素时，可以使用`React.createElement`。
  ```jsx
  function Button() {
    return React.createElement('button', null, 'Click me');
  }
  ```
- **类型定义:** 当我们需要明确一个变量或一个函数返回值应该是React元素时。
  ```tsx
  function getHeaderElement(): React.ReactElement {
    return <h1>Header</h1>;
  }
  ```

总结来说：
- **JSX Element** 是我们编写的类HTML代码，用于声明式地描述UI。
- **ReactNode** 是一个类型定义，涵盖了可以渲染的几乎所有类型的内容。
- **ReactElement** 是由React.createElement创建的对象，它是JSX元素的底层表示形式。

开发者会根据具体的应用场景，结合TypeScript或PropTypes的类型系统，来决定何时使用它们。这些类型的使用有助于确保组件的可复用性、可维护性，以及在不同的使用场景中保持类型的一致性。

> What is the difference between JSX.Element, ReactNode and ReactElement?

A [`ReactElement`](https://github.com/DefinitelyTyped/DefinitelyTyped/blob/master/types/react/index.d.ts#L318-L325) is an object with `type`, `props`, and `key` properties:

    interface ReactElement<
      P = any,
      T extends
        | string
        | JSXElementConstructor<any> = string
        | JSXElementConstructor<any>,
    > {
      type: T;
      props: P;
      key: string | null;
    }
    

A [`JSX.Element`](https://github.com/DefinitelyTyped/DefinitelyTyped/blob/master/types/react/index.d.ts#L4235) is a `ReactElement<any, any>`. It exists as various libraries can implement `JSX` in their own way:

    declare global {
      // …
      namespace JSX {
        // …
        interface Element extends React.ReactElement<any, any> {}
        // …
      }
      // …
    }
    

A [`ReactPortal`](https://github.com/DefinitelyTyped/DefinitelyTyped/blob/master/types/react/index.d.ts#L368-L370) is a `ReactElement` with a `children` property:

    interface ReactPortal extends ReactElement {
      children: ReactNode;
    }
    

A [`ReactNode`](https://github.com/DefinitelyTyped/DefinitelyTyped/blob/master/types/react/index.d.ts#L467-L478) is a `ReactElement`, `string`, `number`, `Iterable<ReactNode>`, `ReactPortal`, `boolean`, `null`, or `undefined`:

    type ReactNode =
      | ReactElement
      | string
      | number
      | Iterable<ReactNode>
      | ReactPortal
      | boolean
      | null
      | undefined;
    

Example:

    <div> // <- ReactElement
      <Component> // <- ReactElement
        {condition && 'text'} // <- ReactNode
      </Component>
    </div>
    

> Why do the render methods of class components return ReactNode, but function components return ReactElement?

This is due to [historical reasons](https://stackoverflow.com/a/59840095/5260024).

A [`Component.render`](https://github.com/DefinitelyTyped/DefinitelyTyped/blob/master/types/react/v17/index.d.ts#L433-L507) returns a `ReactNode`:

    class Component<P, S> {
      // …
      render(): ReactNode;
      // …
    }
    

A [`FunctionComponent`](https://github.com/DefinitelyTyped/DefinitelyTyped/blob/master/types/react/v17/index.d.ts#L543-L549) returns a `ReactElement<any, any> | null`:

    interface FunctionComponent<P = {}> {
      (props: PropsWithChildren<P>, context?: any): ReactElement<any, any> | null;
      propTypes?: WeakValidationMap<P> | undefined;
      contextTypes?: ValidationMap<any> | undefined;
      defaultProps?: Partial<P> | undefined;
      displayName?: string | undefined;
    }
    

> How do I solve this with respect to null?

Type it as `ReactElement | null` just as React does. Or let TypeScript infer the type.

> 1.) What is the difference between JSX.Element, ReactNode and ReactElement?

**ReactElement and JSX.Element** are the result of invoking [`React.createElement`](https://reactjs.org/docs/react-api.html#createelement) directly or via JSX transpilation. It is an object with `type`, `props` and `key`. [`JSX.Element`](https://github.com/DefinitelyTyped/DefinitelyTyped/blob/24f1d0c82da2d898acd03fbb3e692eba3c431f82/types/react/index.d.ts#L2882) is `ReactElement`, whose `props` and `type` have type `any`, so they are more or less the same.

    const jsx = <div>hello</div>
    const ele = React.createElement("div", null, "hello");
    

**ReactNode** is used as return type for `render()` in class components. It also is the default type for `children` attribute with [`PropsWithChildren`](https://github.com/DefinitelyTyped/DefinitelyTyped/blob/24f1d0c82da2d898acd03fbb3e692eba3c431f82/types/react/index.d.ts#L773).

    const Comp: FunctionComponent = props => <div>{props.children}</div> 
    // children?: React.ReactNode
    

It looks more complicated in the [React type declarations](https://github.com/DefinitelyTyped/DefinitelyTyped/blob/2034c45/types/react/index.d.ts#L203), but is _equivalent_ to:

    type ReactNode = {} | null | undefined;
    // super type `{}` has absorbed *all* other types, which are sub types of `{}`
    // so it is a very "broad" type (I don't want to say useless...)
    

You can assign almost everything to `ReactNode`. I usually would prefer stronger types, but there might be some valid cases to use it.

* * *

> 2.) Why do the render methods of class components return ReactNode, but function components return ReactElement?

**tl;dr:** It is a current TS type incompatibility [not related to core React](https://github.com/microsoft/TypeScript/issues/21699).

*   TS class component: returns `ReactNode` with `render()`, more permissive than React/JS
    
*   TS function component: returns `JSX.Element | null`, more restrictive than React/JS
    

In principle, `render()` in React/JS class components [supports the same return types](https://github.com/facebook/react/issues/12155#issuecomment-363089187) as a function component. With regard to TS, the different types are a type inconsistency still kept due to historical reasons and the need for backwards-compatibility.

Ideally a [valid return type](https://reactjs.org/docs/react-component.html#render) would probably look more like this:

    type ComponentReturnType = ReactElement | Array<ComponentReturnType> | string | number 
      | boolean | null // Note: undefined is invalid
    

* * *

> 3.) How do I solve this with respect to null?

Some options:

    // Use type inference; inferred return type is `JSX.Element | null`
    const MyComp1 = ({ condition }: { condition: boolean }) =>
        condition ? <div>Hello</div> : null
    
    // Use explicit function return types; Add `null`, if needed
    const MyComp2 = (): JSX.Element => <div>Hello</div>; 
    const MyComp3 = (): React.ReactElement => <div>Hello</div>;  
    // Option 3 is equivalent to 2 + we don't need to use a global (JSX namespace)
    
    // Use built-in `FunctionComponent` or `FC` type
    const MyComp4: React.FC<MyProps> = () => <div>Hello</div>;
    

_Note:_ Avoiding `React.FC` [won't save](https://www.typescriptlang.org/play/?jsx=2#code/JYWwDg9gTgLgBAJQKYEMDG8BmUIjgIilQ3wFgAoCtCAOwGd4BhXMOAXjgAoBKdgPgIAJJABsREMuWr14AQTCsOPfnAA8zcHAD0ArVrgApAMoANOKKQgkNeDACeYJHADkDKMBoBzZ3GB04NBDwKHDSbgCuGNBwmOE0GMC0MdHGZhZWNnQAdEA) you from the `JSX.Element | null` return type restriction.

Create React App recently [dropped `React.FC`](https://github.com/facebook/create-react-app/pull/8177) from its template, as it has some quirks like an implicit [`{children?: ReactNode}`](https://github.com/DefinitelyTyped/DefinitelyTyped/blob/2034c45/types/react/index.d.ts#L787) type definition. So using `React.FC` sparingly might be preferable.

In edge cases, you can add a type assertion or Fragments as workaround:

    const MyCompFragment: FunctionComponent = () => <>"Hello"</>
    const MyCompCast: FunctionComponent = () => "Hello" as any 
    // alternative to `as any`: `as unknown as JSX.Element | null`

**ReactElement** is the type for elements in React, either created via **JSX** or **React.createElement**.

    const a = <div/> // this is a ReactElement
    

**ReactNode** is wider, it can be text, number, boolean, null, undefined, a portal, a ReactElement, or an array of ReactNodes. It represents **anything that React can render**.

    const a = (
      <div>
         hello {[1, "world", true]} // this is a ReactNode
      </div>
    )
    

`JSX.Element` is an internal hook for Typescript. It is _set equal to_ ReactElement to tell Typescript that every JSX expressions should be typed as ReactElements. But if we'd use Preact, or other technologies using JSX it would be set to something else.

**Functional components** return `ReactElement | null`, so it cannot return a bare string or an array of ReactElements. It is a [known](https://github.com/DefinitelyTyped/DefinitelyTyped/issues/33006) [limitation](https://github.com/DefinitelyTyped/DefinitelyTyped/issues/20544). The workaround is to use **Fragments** :

    const Foo = () => {
      return <>hello world!</>  // this works
    }
    

**Class components'** render function return `ReactNode`, so there shouldn't be any problem.

[https://github.com/typescript-cheatsheets/react#useful-react-prop-type-examples](https://github.com/typescript-cheatsheets/react#useful-react-prop-type-examples)

    export declare interface AppProps {
      children1: JSX.Element; // bad, doesnt account for arrays
      children2: JSX.Element | JSX.Element[]; // meh, doesn't accept strings
      children3: React.ReactChildren; // despite the name, not at all an appropriate type; it is a utility
      children4: React.ReactChild[]; // better, accepts array children
      children: React.ReactNode; // best, accepts everything (see edge case below)
      functionChildren: (name: string) => React.ReactNode; // recommended function as a child render prop type
      style?: React.CSSProperties; // to pass through style props
      onChange?: React.FormEventHandler<HTMLInputElement>; // form events! the generic parameter is the type of event.target
      //  more info: https://react-typescript-cheatsheet.netlify.app/docs/advanced/patterns_by_usecase/#wrappingmirroring
      props: Props & React.ComponentPropsWithoutRef<"button">; // to impersonate all the props of a button element and explicitly not forwarding its ref
      props2: Props & React.ComponentPropsWithRef<MyButtonWithForwardRef>; // to impersonate all the props of MyButtonForwardedRef and explicitly forwarding its ref
    }

Let's understand JSX.Element vs React.ReactElement vs React.ReactNode step by step:

`JSX.Element` and `React.ReactElement`
======================================

`JSX.Element` and `React.ReactElement` are functionally the same type. They can be used interchangeably.

Consider below example:

    const element = <div className="greeting">Hello, world!</div>;
    

When the above JSX code runs, it doesn't directly create something you can see on the screen. Instead, it creates a JavaScript object that describes that piece of UI. This object is like a blueprint or a recipe. This is how this blueprint or recipe object will look like:

    const element = {
      type: 'div',
      props: {
        className: 'greeting',
        children: 'Hello, world!'
      }
    };
    

1.  **type**: This tells React what type of element we want to create. In this case, it's a `div`.
2.  **props**: This is an object that holds all the properties (or "props") that we've passed to our element. Here, we've passed a `className` prop with the value `'greeting'`.
3.  **children**: This is a special prop that represents the content inside our element. In this case, it's the string `'Hello, world!'`.

This object is what React uses to understand how to build and update the actual UI on the screen. When React sees this object, it knows to create a div element, give it a class of 'greeting', and put the text 'Hello, world!' inside it.

In a nutshell, we say A ReactElement is an object with a type and props.

So what is the difference between `JSX.Element` and `React.ReactElement`?
=========================================================================

`JSX.Element` is a TypeScript type for JSX expressions, and `React.ReactElement` is a React type for React elements.

Is this correct?
================

    const Component = ({
      children,
    }: {
      children: JSX.Element;
    }) => {
      return <div>{children}</div>;
    };
    
    
    // Usage
    
    <Component>hello world</Component>
    

In above stated example, TypeScript isn't happy because we declared the type of `children` to be `JSX.Element`, however, we are passing a string ("hello world") which is not a `JSX.Element`. Hence, we need a different type for `children` that can accept string, number, null, ReactElement ....

This is where `React.ReactNode` shines.

React.ReactNode
===============

As per below definition of `React.ReactNode`.

`React.ReactNode` is a ReactElement, string, number, ReactFragment, ReactPortal, boolean, null & undefined.

    declare namespace React {
      type ReactNode =
        | ReactElement
        | string
        | number
        | ReactFragment
        | ReactPortal
        | boolean
        | null
        | undefined;
    }
    

Example:

    const Component = ({
      children,
    }: {
      children: React.ReactNode
    }) => {
      return <div>{children}</div>;
    };
    
    
    // Usage
    <Component> Hello World </Component>
    

Now TypeScript is happy!!

Happy coding!

When to use JSX.Element vs ReactNode vs ReactElement?

在React中，向同一个元素节点添加多个CSS类可以通过以下几种常见的方法来实现：

### 使用字符串拼接

最简单直接的方法是将多个类名作为字符串拼接起来，然后将这个字符串赋值给元素的`className`属性。比如：

```jsx
function MyComponent() {
  return <div className="class1 class2 class3">Hello, world!</div>;
}
```

如果类名是动态计算的，你可以这样操作：

```jsx
function MyComponent({ isActive, isDisabled }) {
  const classes = `base-class ${isActive ? 'active' : ''} ${isDisabled ? 'disabled' : ''}`;
  return <div className={classes}>Content</div>;
}
```

### 使用数组和`join`方法

如果类名是动态的或者由多个条件控制，可以使用数组来收集所有需要应用的类名，然后使用`join`方法将数组转换成一个以空格分隔的字符串：

```jsx
function MyComponent({ isActive, isDisabled }) {
  const classList = ['base-class'];

  if (isActive) {
    classList.push('active');
  }

  if (isDisabled) {
    classList.push('disabled');
  }

  const className = classList.join(' ');
  return <div className={className}>Content</div>;
}
```

### 使用模板字符串

ES6引入了模板字符串，这使得在字符串中插入变量或者表达式变得更加方便。模板字符串使用反引号（\`）来包围字符串，并用`${}`来嵌入变量或表达式：

```jsx
function MyComponent({ isActive, isDisabled }) {
  const className = `base-class ${isActive ? 'active' : ''} ${isDisabled ? 'disabled' : ''}`;
  return <div className={className}>Content</div>;
}
```

### 使用第三方库

存在一些第三方库可以简化类名的条件组合，比如`classnames`库，该库可以在组件中非常方便地处理动态类名。使用`classnames`库时，你可以这样写：

```jsx
import classNames from 'classnames';

function MyComponent({ isActive, isDisabled }) {
  const className = classNames({
    'base-class': true,
    'active': isActive,
    'disabled': isDisabled
  });

  return <div className={className}>Content</div>;
}
```

以上就是在React中为同一个元素节点添加多个类名的几种常见方法。这些方法可以根据实际项目的需求和个人偏好选择使用。

我使用`ES6` [模板文字](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Template_literals)。例如：

    const error = this.state.valid ? '' : 'error'
    const classes = `form-control round-lg ${error}`
    

然后渲染它：

    <input className={classes} />
    

**单行版本：**

    <input className={`form-control round-lg ${this.state.valid ? '' : 'error'}`} />

当需要相当多的逻辑来决定使用（不）使用类时，我使用[类名](https://github.com/JedWatson/classnames)。一个**过于简单的例子**：

    ...
        var liClasses = classNames({
          'main-class': true,
          'activeClass': self.state.focused === index
        });
    
        return (<li className={liClasses}>{data.name}</li>);
    ...
    

也就是说，如果您不想包含依赖项，那么下面有更好的答案。

只需使用 JavaScript 即可。

    <li className={[activeClass, data.klass, "main-class"].join(' ')} />
    

如果要在对象中添加基于类的键和值，可以使用以下命令：

    function classNames(classes) {
      return Object.entries(classes)
        .filter(([key, value]) => value)
        .map(([key, value]) => key)
        .join(' ');
    }
    
    const classes = {
      'maybeClass': true,
      'otherClass': true,
      'probablyNotClass': false,
    };
    
    const myClassNames = classNames(classes);
    // Output: "maybeClass otherClass"
    
    <li className={myClassNames} />
    

或者更简单：

    const isEnabled = true;
    const isChecked = false;
    
    <li className={[isEnabled && 'enabled', isChecked && 'checked']
      .filter(e => !!e)
      .join(' ')
    } />
    // Output:
    // <li className={'enabled'} />

康卡特
---

无需花哨，我正在使用 CSS 模块，而且很简单

    import style from '/css/style.css';
    
    <div className={style.style1+ ' ' + style.style2} />
    

这将导致：

    <div class="src-client-css-pages-style1-selectionItem src-client-css-pages-style2">
    

换句话说，两种风格

条件句
---

与 if 使用相同的想法会很容易

    const class1 = doIHaveSomething ? style.style1 : 'backupClass';
    
    <div className={class1 + ' ' + style.style2} />
    

ES6
---

在过去一年左右的时间里，我一直在使用模板文字，所以我觉得它值得一提，我发现它非常具有表现力并且易于阅读：

    `${class1} anotherClass ${class1}`

这可以通过 ES6 模板文字来实现：

    <input className={`base-input-class ${class1} ${class2}`}>
    

（为了清晰起见进行了编辑）

React相关问题