查看远程 Git 分支的命令很简单。你可以使用如下命令：

```bash
git fetch --all
git branch -r
```

这里是每个命令的解释：

- `git fetch --all`：这个命令会从所有的远程仓库中抓取最新的数据。它会下载你本地不存在的任何数据，但不会自动合并或修改你当前的工作。

- `git branch -r`：该命令会列出所有远程分支。`-r` 参数表示 "remote"，即远程的意思。

有时候你可以仅使用 `git branch -r` 来查看远程分支，但如果你想确保看到的是最新的列表，最好先执行 `git fetch --all`。如果你只关心特定的远程仓库，可以使用 `git fetch <remote>` 替换 `git fetch --all`。

此外，还有一个命令可以查看远程分支和本地分支的所有信息：

```bash
git branch -a
```

这将显示所有本地和远程分支。在远程分支名称前通常会有一个 `remotes/` 前缀。例如，`remotes/origin/main` 表示名为 `origin` 的远程仓库上的 `main` 分支。

根据配置的是一个还是多个远程存储库，答案会有所不同。这样做的原因是，对于单个远程情况，可以简化一些命令，因为歧义较少。

**针对 Git 2.23 进行了更新：**对于旧版本，请参阅末尾的部分。

配备一个遥控器
-------

在这两种情况下，首先从远程存储库获取数据，以确保您已下载所有最新更改。

    $ git fetch
    

这将为您获取所有远程分支。您可以通过以下方式查看可结账的分支机构：

    $ git branch -v -a
    
    ...
    remotes/origin/test
    

以 开头的分支`remotes/*`可以被认为是远程分支的只读副本。要在分支上工作，您需要从中创建一个本地分支。这是通过 Git 命令`switch`（自 Git 2.23 起）通过指定远程分支的名称（减去远程名称）来完成的：

    $ git switch test
    

在这种情况下，Git 猜测（可以使用 禁用`--no-guess`）您正在尝试签出并跟踪具有相同名称的远程分支。

配备多个遥控器
-------

当存在多个远程存储库的情况下，需要显式命名远程存储库。

和以前一样，首先获取最新的远程更改：

    $ git fetch origin
    

这将为您获取所有远程分支。您可以通过以下方式查看可结账的分支机构：

    $ git branch -v -a
    

有了远程分支，您现在需要检查您感兴趣的分支`-c`以创建新的本地分支：

    $ git switch -c test origin/test
    

有关使用的更多信息`git switch`：

    $ man git-switch
    

Git 2.23 之前的版本
--------------

`git switch`在 Git 2.23 中添加，在此之前`git checkout`用于切换分支。

仅使用单个远程存储库签出：

    git checkout test
    

如果配置了多个远程存储库，那么它会变得有点长

    git checkout -b test <name of remote>/test

_**旁注：**_使用现代 Git (>= [1.6.6](https://raw.github.com/git/git/master/Documentation/RelNotes/1.6.6.txt) )，您可以只使用

    git checkout test
    

（请注意，它是“test”而不是“origin/test”）执行神奇的[DWIM](http://en.wikipedia.org/wiki/DWIM "做我的意思") -mery 并为您创建本地分支“test”，其上游将是远程跟踪分支“origin/test”。

* * *

in`* (no branch)`输出`git branch`意味着您位于未命名的分支上，处于所谓的“分离 HEAD”状态（HEAD 直接指向提交，并且不是对某些本地分支的符号引用）。如果您在此未命名分支上进行了一些提交，则始终可以在当前提交的基础上创建本地分支：

    git checkout -b test HEAD
    

* * *

评论中建议的更现代的方法：

> @Dennis：，`git checkout <non-branch>`例如`git checkout origin/test`导致分离的 HEAD / 未命名分支，而`git checkout test`或`git checkout -b test origin/test`导致本地分支`test`（远程跟踪分支`origin/test`作为_上游_） – Jakub Narębski Jan 9 '14 at 8:17

强调`git checkout origin/test`

在这种情况下，您可能想要创建一个`test`跟踪远程`test`分支的本地分支：

    $ git branch test origin/test
    

在早期版本中`git`，您需要一个显式`--track`选项，但现在当您从远程分支分支时，这是默认选项。

要创建本地分支**并**切换到它，请使用：

    $ git checkout -b test origin/test

[接受的答案](https://stackoverflow.com/a/1783426/456814)不适合您？
--------------------------------------------------------

虽然第一个和选定的答案在技术上是_正确的_，但您可能尚未从远程存储库检索所有对象和引用。如果是这种情况，您将收到以下错误：

    $ git checkout -b remote_branch origin/remote_branch
    

> 致命：git checkout：更新路径与切换分支不兼容。  
> 您是否打算签出无法解析为提交的“origin/remote\_branch”？

解决方案
----

如果您收到此消息，则必须在运行之前首先执行`git fetch origin`“where is 远程存储库的名称”操作。这是带有响应的完整示例：`origin``git checkout remote_branch`

    $ git fetch origin
    remote: Counting objects: 140, done.
    remote: Compressing objects: 100% (30/30), done.
    remote: Total 69 (delta 36), reused 66 (delta 33)
    Unpacking objects: 100% (69/69), done.
    From https://github.com/githubuser/repo-name
       e6ef1e0..5029161  develop    -> origin/develop
     * [new branch]      demo       -> origin/demo
       d80f8d7..359eab0  master     -> origin/master
    
    $ git checkout demo
    Branch demo set up to track remote branch demo from origin.
    Switched to a new branch 'demo'
    

正如您所看到的，运行`git fetch origin`检索了我们尚未设置为在本地计算机上跟踪的任何远程分支。从那里，由于我们现在有了对远程分支的引用，我们可以简单地运行`git checkout remote_branch`，我们将获得远程跟踪的好处。

我尝试了上面的解决方案，但没有成功。试试这个，它有效：

    git fetch origin 'remote_branch':'local_branch_name'
    

这将获取远程分支并创建一个带有名称的新本地分支（如果尚不存在）`local_branch_name`并跟踪其中的远程分支。

How do i check out a remote git branch

为了在 Git 中从当前工作目录中删除未跟踪的文件，您可以使用 `git clean` 命令。这个命令会删除工作区中所有没有被跟踪的文件，即那些在 .gitignore 文件中没有列出且不在 Git 版本控制下的文件。

以下是您可以使用的一些 `git clean` 选项：

- `-n` 或 `--dry-run`：用于模拟删除操作，显示哪些文件会被删除，但实际上并不执行删除操作。
- `-f` 或 `--force`：必须使用此选项才能实际执行删除，因为这是一项具有破坏性的操作，Git 默认不会执行它。
- `-d`：允许命令删除未跟踪的目录以及未跟踪的文件。
- `-x`：这将忽略 .gitignore 文件中的规则，删除所有未跟踪的文件，包括那些在 .gitignore 中指定的。
- `-X`：仅删除在 .gitignore 文件中忽略的未跟踪文件。

例如，如果您想要删除工作目录中的所有未跟踪文件（但保留未跟踪的目录），您可以这样做：

```shell
git clean -f
```

如果您还想删除未跟踪的目录，可以使用：

```shell
git clean -fd
```

如果您想查看哪些文件和目录将被删除（而不是实际删除它们），可以运行：

```shell
git clean -nfd
```

**注意**：`git clean` 是一个危险的操作，因为它删除的文件无法从 Git 历史中恢复。所以在运行 `git clean` 命令之前，确保您不需要工作目录中的未跟踪文件。务必先使用 `--dry-run` 选项来预览将要删除的内容。

> [git-clean](https://git-scm.com/docs/git-clean) - 从工作树中删除未跟踪的文件
> ---------------------------------------------------------------
> 
> ### 概要
> 
>     git clean [-d] [-f] [-i] [-n] [-q] [-e <pattern>] [-x | -X] [--] <path>…​
>     
> 
> ### 描述
> 
> **通过从当前目录开始**递归删除不受版本控制的文件来清理工作树。
> 
> 通常，仅删除 Git 未知的文件，但如果`-x`指定了该选项，则忽略的文件也会被删除。例如，这对于删除所有构建产品很有用。
> 
> 如果`<path>...`给出任何可选参数，则只有那些路径受到影响。

* * *

第 1 步是使用以下`-n`选项显示将删除的内容：

    # Print out the list of files and directories which will be removed (dry run)
    git clean -n -d
    

清洁步骤 -**请注意：这将删除文件**：

    # Delete the files from the repository
    git clean -f
    

*   要删除目录，请运行`git clean -f -d`或`git clean -fd`
*   要删除忽略的文件，请运行`git clean -f -X`或`git clean -fX`
*   要删除忽略和非忽略的文件，请运行`git clean -f -x`或`git clean -fx`

**请注意**`X`后两个命令的大小写差异。

如果`clean.requireForce`在您的配置中设置为“true”（默认值），则需要指定`-f`，否则实际上不会发生任何事情。

再次参阅[`git-clean`](http://git-scm.com/docs/git-clean)文档以获取更多信息。

* * *

> ### 选项
> 
> **`-f`,`--force`**
> 
> 如果 Git 配置变量 clean.requireForce 未设置为 false，则 git clean 将拒绝运行，除非给出`-f`、`-n`或`-i`。
> 
> **`-x`**
> 
> 不要使用从 .gitignore （每个目录）和 读取的标准忽略规则`$GIT_DIR/info/exclude`，但仍然使用`-e`选项给出的忽略规则。这允许删除所有未跟踪的文件，包括构建产品。这可以用来（可能与 git reset 结合使用）创建一个原始工作目录来测试干净的构建。
> 
> **`-X`**
> 
> 仅删除 Git 忽略的文件。这对于从头开始重建所有内容可能很有用，但保留手动创建的文件。
> 
> **`-n`,`--dry-run`**
> 
> 实际上不要删除任何东西，只是展示将要做什么。
> 
> **`-d`**
> 
> 除了未跟踪的文件之外，还删除未跟踪的目录。如果未跟踪的目录由不同的 Git 存储库管理，则默认情况下不会将其删除。`-f`如果您确实想删除这样的目录，请使用两次选项。

用于`git clean -f -d`确保**目录**也被删除。

1.  实际上不要删除任何东西，只是展示将要做什么。
    
        git clean -n
        
    
    或者
    
        git clean --dry-run
        
    
2.  除了未跟踪的文件之外，还删除未跟踪的目录。如果未跟踪的目录由不同的 Git 存储库管理，则默认情况下不会将其删除。`-f`如果您确实想删除这样的目录，请使用该选项两次。
    
        git clean -fd
        
    

然后您可以检查您的文件是否真的消失了`git status`。

我很惊讶之前没有人提到过这一点：

    git clean -i
    

这代表_交互式_，您将快速了解将要删除的内容，从而可以包含/排除受影响的文件。`--dry-run`总体而言，仍然比运行真正清洁之前的强制要快。

`-d`如果您还想处理空文件夹，则必须添加 a 。最后，它是一个很好的别名：

    git iclean
    

话虽如此，对于有经验的用户来说，额外手持交互式命令可能会很累。这些天我只是使用已经提到的`git clean -fd`

[`git-clean`\- 从工作树中删除未跟踪的文件](http://git-scm.com/docs/git-clean)

删除未跟踪文件的简单方法
------------

要删除所有未跟踪的文件，简单的方法是**首先添加所有文件**并**重置存储库，**如下所示

    git add --all
    git reset --hard HEAD
    

* * *

How do i remove local untracked files from the current git working tree

首先，将所有 `origin/<branch>`参考更新为最新：

```
git fetch --all
```

备份当前分支（例如 `master`）：

```
git branch backup-master
```

跳转到最新提交 `origin/master`并签出这些文件：

```
git reset --hard origin/master
```

### 解释：

`git fetch`从远程下载最新版本，而无需尝试合并或重新设置任何内容。

`git reset`将 master 分支重置为您刚刚获取的内容。该 `--hard`选项会更改工作树中的所有文件以匹配 `origin/master`.

---

### 维护当前的本地提交

\[\*\]：值得注意的是，可以通过在 `master`重置之前创建分支来维护当前的本地提交：

```
git checkout master
git branch new-branch-to-save-current-commits
git fetch --all
git reset --hard origin/master
```

此后，所有旧的提交都将保留在 `new-branch-to-save-current-commits`.

### 未提交的更改

未提交的更改，即使暂存（使用 `git add`），也会丢失。确保 `stash`或承诺您需要的任何事情。例如，运行以下命令：

```
git stash
```

稍后（在 之后 `git reset`），重新应用这些未提交的更改：

```
git stash pop
```

> 这可能会产生合并冲突。

这将删除所有未提交的更改，即使是暂存的，  
然后拉取：

    git reset --hard HEAD
    git pull
    

> 但任何未被 Git 跟踪的本地文件都不会受到影响。

**警告：`git clean`删除所有未跟踪的文件/目录并且无法撤消。**

* * *

有时只是`clean -f`没有帮助。如果您有未跟踪的目录，还需要 -d 选项：

    # WARNING: this can't be undone!
    
    git reset --hard HEAD
    git clean -f -d
    git pull
    

**警告：`git clean`删除所有未跟踪的文件/目录并且无法撤消。**

首先考虑使用`-n`( `--dry-run`) 标志。这将向您显示将删除的内容，而无需实际删除任何内容：

    git clean -n -f -d
    

输出示例：

    Would remove untracked-file-1.txt
    Would remove untracked-file-2.txt
    Would remove untracked/folder
    ...

就像刺猬一样，我认为答案很糟糕。但是，尽管刺猬的答案可能更好，但我认为它并没有达到应有的优雅。我发现做到这一点的方法是使用`fetch`明确`merge`的策略。只要本地更改不是您尝试强制覆盖的文件之一，这应该会保留您的本地更改。

### 首先提交您的更改

     git add *
     git commit -a -m "local file server commit message"
    

### 然后获取更改并覆盖（如果存在冲突）

     git fetch origin master
     git merge -s recursive -X theirs origin/master
    

`-X`是选项名称，`theirs`是该选项的值。如果存在冲突，您将选择使用`their`更改（另一个选项是更改）。`ours`

而不是这样做：

    git fetch --all
    git reset --hard origin/master
    

我建议执行以下操作：

    git fetch origin master
    git reset --hard origin/master
    

如果您要重置到 origin/master 分支，则无需获取所有遥控器和分支，对吗？

How do i force git pull to overwrite local files

`git pull` 和 `git fetch` 都是 Git 版本控制系统中用于从远程仓库获取最新更改的命令，但它们的行为有一些关键区别。

### git fetch
`git fetch` 命令用于从远程仓库下载本地仓库中不存在的所有信息。这包括获取所有远程分支的更新，但并不自动合并到当前工作分支中。`git fetch` 只是下载远程的最新数据到本地仓库，但不会改变用户的工作状态（即用户当前的工作目录内容和当前分支不会受到影响）。这允许用户在合并之前手动查看这些更改。

例如，如果你想要查看远程主分支的更改，但还不准备合并它们到你的本地主分支，你可以执行：

```shell
git fetch origin master
```

之后，你可以使用 `git diff` 命令来比较本地分支和远程分支的差异。

### git pull
`git pull` 实际上是 `git fetch` 紧接着一个 `git merge` 命令的组合。当运行 `git pull` 时，Git 会从远程仓库获取当前分支的最新更改，并尝试自动合并到本地的相应分支中。这意味着，如果你在主分支上执行 `git pull`，Git 会自动下载远程主分支的更新，并将它们合并到你的本地主分支。

例如，要更新你的本地主分支，你可以执行：

```shell
git pull origin master
```

这会获取远程主分支的更新并尝试将它们合并到你的本地主分支。

### 总结
- `git fetch` 是一种更为安全和细致的更新方式，因为它允许用户在不影响当前工作的情况下查看远程更改。
- `git pull` 是一种更为便捷的方式，因为它会自动下载并合并更改，但如果有合并冲突，需要用户手动解决。

在实际工作中，你可能会用 `git fetch` 来确保对远程仓库的更改有充分的了解和审查，然后再决定是否使用 `git merge` 来合并这些更改，或者用 `git rebase` 来整理本地提交历史。而 `git pull` 则适用于当你信任远程更改，并且想要快速更新你的本地分支时使用。

In the simplest terms, [`git pull`](http://git-scm.com/docs/git-pull) does a [`git fetch`](http://git-scm.com/docs/git-fetch) followed by a [`git merge`](http://git-scm.com/docs/git-merge).

* * *

`git fetch` updates your remote-tracking branches under `refs/remotes/<remote>/`. This operation is safe to run at any time since it never changes any of your local branches under `refs/heads`.

`git pull` brings a local branch up-to-date with its remote version, while also updating your other remote-tracking branches.

From the Git documentation for [`git pull`](http://git-scm.com/docs/git-pull):

> `git pull` runs `git fetch` with the given parameters and then depending on configuration options or command line flags, will call either `git rebase` or `git merge` to reconcile diverging branches.

*   `git pull` tries to automatically merge after fetching commits. _It is context sensitive_, so all pulled commits will be merged into your currently active branch. `git pull` automatically merges the commits **without letting you review them first**. If you don’t carefully manage your branches, you may run into frequent conflicts.
    
*   `git fetch` gathers any commits from the target branch that do not exist in the current branch and **stores them in your local repository**. However, **it does not merge them with your current branch**. This is particularly useful if you need to keep your repository up to date, but are working on something that might break if you update your files. To integrate the commits into your current branch, you must use `git merge` afterwards.

It is important to contrast the design philosophy of git with the philosophy of a more traditional source control tool like SVN.

Subversion was designed and built with a client/server model. There is a single repository that is the server, and several clients can fetch code from the server, work on it, then commit it back to the server. The assumption is that the client can always contact the server when it needs to perform an operation.

Git was designed to support a more distributed model with no need for a central repository (though you can certainly use one if you like). Also git was designed so that the client and the "server" don't need to be online at the same time. Git was designed so that people on an unreliable link could exchange code via email, even. It is possible to work completely disconnected and burn a CD to exchange code via git.

In order to support this model git maintains a local repository with your code and also an additional local repository that mirrors the state of the remote repository. By keeping a copy of the remote repository locally, git can figure out the changes needed even when the remote repository is not reachable. Later when you need to send the changes to someone else, git can transfer them as a set of changes from a point in time known to the remote repository.

*   **`git fetch`** is the command that says "bring my local copy of the remote repository up to date."
    
*   **`git pull`** says "bring the changes in the remote repository to where I keep my own code."
    

Normally **`git pull`** does this by doing a **`git fetch`** to bring the local copy of the remote repository up to date, and then merging the changes into your own code repository and possibly your working copy.

The take away is to keep in mind that there are often at least **three copies** of a project on your workstation. One copy is your own repository with your own commit history. The second copy is your working copy where you are editing and building. The third copy is your local "cached" copy of a remote repository.

Here is [Oliver Steele's image of how all it all fits together](http://blog.osteele.com/2008/05/my-git-workflow/):

![Git Data Transport Commands](https://i.stack.imgur.com/XwVzT.png)

One use case of `git fetch` is that the following will tell you any changes in the remote branch since your last pull... so you can check before doing an actual pull, which could change files in your current branch and working copy.

    git fetch
    git diff ...origin
    

See [`git diff`](https://git-scm.com/docs/git-diff) documentation regarding the double- `..` and triple-dot `...` syntax.

What is the difference between git pull and git fetch

如何重命名本地 Git 分支？,要在 Git 中重命名本地分支，您可以使用以下命令：

```bash
git branch -m <old-name> <new-name>
```

这里的 `<old-name>` 是当前分支的名称，`<new-name>` 是您想要的新分支名称。

例如，如果您的分支当前名称为 `feature-x` 并且您想将其重命名为 `feature-y`，则可以这样做：

```bash
git branch -m feature-x feature-y
```

请确保在重命名分支之前，您已经检出到了想要重命名的分支上：

```bash
git checkout feature-x
git branch -m feature-y
```

如果您尝试重命名当前没有检出的分支，您需要使用以下命令：

```bash
git branch -m <old-name> <new-name>
```

如果您已经将旧分支推送到远程仓库，并且也想要重命名远程分支，那么您需要先删除旧的远程分支，然后推送新的分支名称，并重新设置上游分支：

1. 删除远程的旧分支：

```bash
git push origin --delete <old-name>
```

2. 推送新的分支到远程，并设置上游分支：

```bash
git push origin -u <new-name>
```

请记得，在推送新的分支名称到远程仓库之前，确保没有其他团队成员正在使用旧的分支，因为这将影响所有使用该分支的人。最好是先与团队沟通，确保大家都知道分支名称的变更。

To rename the current branch:

    git branch -m <newname>
    

To rename a branch while pointed to any branch:

    git branch -m <oldname> <newname>
    

`-m` is short for `--move`.

* * *

To push the local branch and reset the upstream branch:

    git push origin -u <newname>
    

To delete the remote branch:

    git push origin --delete <oldname>
    

* * *

To create a `git rename` alias:

    git config --global alias.rename 'branch -m'
    

* * *

On Windows or another case-insensitive filesystem, use `-M` if there are only capitalization changes in the name. Otherwise, Git will throw a _"branch already exists"_ error.

    git branch -M <newname>

You can rename a local Git branch using the following command:

    git branch -m old_branch_name new_branch_name
    

Keep in mind that when you rename a branch, it still maintains its association with the old upstream branch if there was one.

To push changes to the `master` branch after renaming your local branch to `new_branch_name`, use the following command:

    git push origin new_branch_name:master
    

With this command, your changes will be pushed to the `master` branch on the remote repository. However, your local branch will still be named `new_branch_name`.

* * *

For more details, see: [How to rename your local branch name in Git](http://madhan-tech-updates.blogspot.in/2013/01/how-to-rename-your-local-branch-name-in.html).

To rename your current branch:

    git branch -m <newname>

Here are the steps to rename the branch:

1.  Switch to the branch which needs to be renamed
2.  `git branch -m <new_name>`
3.  `git push origin :<old_name>`
4.  `git push origin <new_name>:refs/heads/<new_name>`

**EDIT (12/01/2017):** Make sure you run command `git status` and check that the newly created branch is pointing to its own ref and not the older one. If you find the reference to the older branch, you need to unset the upstream using:

    git branch --unset-upstream

Rename the branch will be useful once your branch is finished. Then new stuff is coming, and you want to develop in the same branch instead of deleting it and create the new one.

From my experience, to rename a local and remote branch in Git you should do the following steps.

> Quoting from [Multiple States - Rename a local and remote branch in git](https://multiplestates.wordpress.com/2015/02/05/rename-a-local-and-remote-branch-in-git/)

### 1\. Rename your local branch

If you are on the branch you want to rename:

    git branch -m new-name
    

If you are on a different branch:

    git branch -m old-name new-name
    

### 2\. Delete the old-name remote branch and push the new-name local branch

    git push origin :old-name new-name
    

### 3\. Reset the upstream branch for the new-name local branch

    git push origin -u new-name

How can i rename a local git branch?

在Git中撤销最近的本地提交，您可以使用几种不同的方法，取决于您想要的结果。下面是两种常用的情况：

### 1. `git reset`（不影响工作目录）
如果您想要撤销提交但保留所做的更改以便重新提交，可以使用`git reset`命令。例如，要撤销最后一次提交并保留更改，可以使用：

```bash
git reset --soft HEAD~1
```

- `--soft` 选项意味着更改将保留在暂存区中，您可以编辑这些更改或直接重新提交。
- `HEAD~1` 表示当前分支的上一个提交，也就是要撤销的提交。

### 2. `git reset`（影响工作目录）
如果您不仅想要撤销提交，还想丢弃所有的更改，可以使用：

```bash
git reset --hard HEAD~1
```

- `--hard` 选项会将工作目录中的文件恢复到上一个提交的状态，即撤销所有更改。
- 同样，`HEAD~1` 表示当前分支的上一个提交。

### 注意事项
在使用`git reset`时要格外小心，因为`--hard`选项会丢弃所有未提交的更改。这个操作是不可逆的，所以在执行之前请确保不需要保留这些更改。

### 示例：

假设我不小心提交了一些不应该提交的敏感数据。为了解决这个问题，我可以使用`git reset`来撤销这次提交：

```bash
# 保留更改，撤销提交
git reset --soft HEAD~1

# 或者，丢弃更改，撤销提交
git reset --hard HEAD~1
```

在执行`--soft`选项之后，我可以检查和编辑这些敏感文件，删除敏感数据，并重新提交：

```bash
# 检查和编辑文件
# ...

# 添加更改到暂存区
git add .

# 重新提交
git commit -m "Remove sensitive data and redo the commit"
```

这样，原来的提交被撤销了，敏感数据从历史记录中移除，而我希望保留的更改仍然可以被包含在新的提交中。

最后，值得一提的是，如果已经将这些提交推送到了远程仓库，则需要在重置本地仓库后，使用`git push`命令的`--force`选项来覆盖远程仓库中的历史。不过这样做是有风险的，特别是如果其他人已经基于这些提交做了更多工作的情况下： 

```bash
git push origin <branch_name> --force
```

在这种情况下，最好先与团队成员沟通，并确保大家知道你将要做的变更。

撤消提交并重做
-------

    $ git commit -m "Something terribly misguided" # (0: Your Accident)
    $ git reset HEAD~                              # (1)
    [ edit files as necessary ]                    # (2)
    $ git add .                                    # (3)
    $ git commit -c ORIG_HEAD                      # (4)
    

1.  [`git reset`](https://git-scm.com/docs/git-reset)**是负责撤消**的命令。它将撤消您的最后一次提交，同时**保持您的工作树（磁盘上文件的状态）不变。**您需要再次添加它们，然后才能再次提交它们。
2.  对[工作树](https://git-scm.com/book/en/v2/Git-Tools-Reset-Demystified#_the_working_directory)文件进行更正。
3.  [`git add`](https://git-scm.com/docs/git-add)您想要包含在新提交中的任何内容。
4.  提交更改，重用旧的提交消息。`reset`将旧头复制到`.git/ORIG_HEAD`; [`commit`with`-c ORIG_HEAD`](https://git-scm.com/docs/git-commit#Documentation/git-commit.txt--cltcommitgt)将打开一个编辑器，其中最初包含旧提交的日志消息并允许您对其进行编辑。如果您不需要编辑消息，则可以使用该[`-C`](https://git-scm.com/docs/git-commit#Documentation/git-commit.txt--Cltcommitgt)选项。

**或者，要编辑先前的提交（或仅编辑其提交消息）**，[`commit --amend`](https://stackoverflow.com/q/179123/1146608)会将当前索引中的更改添加到先前的提交。

**要删除（而不是恢复）已推送到服务器的提交**`git push origin main --force[-with-lease]`，需要重写历史记录。[使用](https://stackoverflow.com/q/52823692/4096791)[它_几乎总是_`--force`一个坏主意；相反`--force-with-lease`](https://stackoverflow.com/q/52823692/4096791)，正如[git 手册](https://git-scm.com/docs)中所述：

> 如果您\[重写历史\]已经发表，您应该了解重写历史的含义。

* * *

### 进一步阅读

[您可以用来`git reflog`](https://stackoverflow.com/questions/34519665/how-to-move-head-back-to-a-previous-location-detached-head/34519716#34519716)确定要恢复到的提交的[SHA-1 。](https://stackoverflow.com/questions/34519665/how-to-move-head-back-to-a-previous-location-detached-head/34519716#34519716)获得此值后，请使用如上所述的命令序列。

* * *

`HEAD~`是相同的`HEAD~1`。文章[git 中的 HEAD 是什么？](https://stackoverflow.com/a/46350644/5175709)如果您想取消提交多个提交，这很有帮助。

如果您不知道它是如何工作的，那么撤消提交会有点可怕。但如果你真的理解的话，这实际上是非常容易的。我将向您展示撤消提交的 4 种不同方法。

假设你有这个，其中 C 是你的 HEAD，(F) 是你的文件的状态。

       (F)
    A-B-C
        ↑
      master
    

### 选项1：`git reset --hard`

您想要**销毁提交 C 并丢弃所有未提交的更改**。你做这个：

    git reset --hard HEAD~1
    

结果是：

     (F)
    A-B
      ↑
    master
    

现在 B 是 HEAD。因为您使用了`--hard`，所以您的文件将重置为提交 B 时的状态。

### 选项2：`git reset`

也许提交 C 并不是一场灾难，只是有点偏离。您想要**撤消提交，但保留更改**以进行一些编辑，然后再进行更好的提交。从这里重新开始，以 C 为 HEAD：

       (F)
    A-B-C
        ↑
      master
    

这样做，省略`--hard`：

    git reset HEAD~1
    

在这种情况下，结果是：

       (F)
    A-B-C
      ↑
    master
    

在这两种情况下，HEAD 只是指向最新提交的指针。当你执行 a 时`git reset HEAD~1`，你告诉 Git 将 HEAD 指针向后移动一次提交。但是（除非您使用`--hard`）您将保留文件原样。现在`git status`显示您已签入 C 的更改。您没有丢失任何东西！

### 选项 3：`git reset --soft`

对于最轻微的接触，您甚至可以**撤消您的提交，但保留您的文件和[索引](https://git.wiki.kernel.org/index.php/WhatIsTheIndex)**：

    git reset --soft HEAD~1
    

这不仅不会影响您的文件，甚至会影响您的_索引_。当您这样做时`git status`，您将看到索引中的文件与以前相同。事实上，在执行此命令之后，您可以执行`git commit`并且会重做刚刚进行的相同提交。

### 选项 4：您已这样做`git reset --hard`并且需要取回该代码

还有一件事：假设您像第一个示例一样**销毁了一个提交，****但后来发现您毕竟需要它**？运气不好，对吧？

不行，_还是有_办法找回来的。输入这个

    git reflog
    

[您将看到您移动过的（部分）提交SHA](https://en.wikipedia.org/wiki/SHA-1#Data_integrity)（即哈希值）列表。找到您销毁的提交，然后执行以下操作：

    git checkout -b someNewBranchName shaYouDestroyed
    

您现在已经恢复了该提交。Git 中的提交实际上在大约 90 天内不会被销毁，因此您通常可以返回并挽救您不想删除的提交。

有两种方法可以“撤消”上次提交，具体取决于您是否已经公开提交（推送到远程存储库）：

如何撤消本地提交
--------

假设我在本地提交，但现在我想删除该提交。

    git log
        commit 101: bad commit    # Latest commit. This would be called 'HEAD'.
        commit 100: good commit   # Second to last commit. This is the one we want.
    

要将所有内容恢复到上次提交之前的状态，我们需要`reset`之前的提交`HEAD`：

    git reset --soft HEAD^     # Use --soft if you want to keep your changes
    git reset --hard HEAD^     # Use --hard if you don't care about keeping the changes you made
    

现在`git log`将显示我们的最后一次提交已被删除。

如何撤消公共提交
--------

如果您已经公开提交，您将需要创建一个新的提交，它将“恢复”您在先前提交（当前 HEAD）中所做的更改。

    git revert HEAD
    

您的更改现在将被还原并准备好提交：

    git commit -m 'restoring the file I removed by accident'
    git log
        commit 102: restoring the file I removed by accident
        commit 101: removing a file we don't need
        commit 100: adding a file that we need
    

有关更多信息，请查看_[Git 基础知识 - 撤销操作](https://git-scm.com/book/en/v2/Git-Basics-Undoing-Things)_。

添加/删除文件以按照您想要的方式进行操作：

    git rm classdir
    git add sourcedir
    

然后修改提交：

    git commit --amend
    

之前的错误提交将被编辑以反映新的索引状态 - 换句话说，就像您从一开始就没有犯过错误一样。

请注意，只有在尚未推送时才应该执行此操作。如果您已推送，那么您只需正常提交修复即可。

这将添加一个新的提交，该提交将删除添加的文件。

    git rm yourfiles/*.class
    git commit -a -m "deleted all class files in folder 'yourfiles'"
    

* * *

或者您可以重写历史记录以撤消上次提交。

**警告**：此命令将**永久删除**对您提交的文件（以及任何其他文件）的修改`.java`，并从工作目录中删除所有更改：

    git reset --hard HEAD~1
    

to会将`hard reset`您`HEAD-1`的工作副本设置为错误提交之前的提交状态。


<h2>Undo a commit &amp; redo</h2>
<pre class="lang-bash s-code-block"><code data-highlighted="yes" class="hljs language-bash">$ git commit -m <span class="hljs-string">"Something terribly misguided"</span> <span class="hljs-comment"># (0: Your Accident)</span>
$ git reset HEAD~                              <span class="hljs-comment"># (1)</span>
[ edit files as necessary ]                    <span class="hljs-comment"># (2)</span>
$ git add .                                    <span class="hljs-comment"># (3)</span>
$ git commit -c ORIG_HEAD                      <span class="hljs-comment"># (4)</span>
</code></pre>
<ol>
<li><a href="https://git-scm.com/docs/git-reset" rel="noreferrer"><code>git reset</code></a> is the command responsible for the <strong>undo</strong>. It will undo your last commit while <strong>leaving your working tree (the state of your files on disk) untouched.</strong> You'll need to add them again before you can commit them again.</li>
<li>Make corrections to <a href="https://git-scm.com/book/en/v2/Git-Tools-Reset-Demystified#_the_working_directory" rel="noreferrer">working tree</a> files.</li>
<li><a href="https://git-scm.com/docs/git-add" rel="noreferrer"><code>git add</code></a> anything that you want to include in your new commit.</li>
<li>Commit the changes, reusing the old commit message. <code>reset</code> copied the old head to <code>.git/ORIG_HEAD</code>; <a href="https://git-scm.com/docs/git-commit#Documentation/git-commit.txt--cltcommitgt" rel="noreferrer"><code>commit</code> with <code>-c ORIG_HEAD</code></a> will open an editor, which initially contains the log message from the old commit and allows you to edit it. If you do not need to edit the message, you could use the <a href="https://git-scm.com/docs/git-commit#Documentation/git-commit.txt--Cltcommitgt" rel="noreferrer"><code>-C</code></a> option.</li>
</ol>
<p><strong>Alternatively, to edit the previous commit (or just its commit message)</strong>, <a href="https://stackoverflow.com/q/179123/1146608"><code>commit --amend</code></a> will add changes within the current index to the previous commit.</p>
<p><strong>To remove (not revert) a commit that has been pushed to the server</strong>, rewriting history with <code>git push origin main --force[-with-lease]</code> is necessary. <a href="https://stackoverflow.com/q/52823692/4096791">It's <em>almost always</em> a bad idea to use <code>--force</code>; prefer <code>--force-with-lease</code></a> instead, and as noted in <a href="https://git-scm.com/docs/git-commit#Documentation/git-commit.txt---amend" rel="noreferrer" title="Git - git-commit Documentation">the git manual</a>:</p>
<blockquote>
<p>You should understand the implications of rewriting history if you amend a commit that has already been published.</p>
</blockquote>
<hr>
<h3>Further Reading</h3>
<p><a href="https://stackoverflow.com/questions/34519665/how-to-move-head-back-to-a-previous-location-detached-head/34519716#34519716">You can use <code>git reflog</code> to determine the SHA-1</a> for the commit to which you wish to revert. Once you have this value, use the sequence of commands as explained above.</p>
<hr>
<p><code>HEAD~</code> is the same as <code>HEAD~1</code>. The article <a href="https://stackoverflow.com/a/46350644/5175709">What is the HEAD in git?</a> is helpful if you want to uncommit multiple commits.</p>
    


<p>Undoing a commit is a little scary if you don't know how it works.  But it's actually amazingly easy if you do understand. I'll show you the 4 different ways you can undo a commit.</p>
<p>Say you have this, where C is your HEAD and (F) is the state of your files.</p>
<pre><code>   (F)
A-B-C
    ↑
  master
</code></pre>
<h3>Option 1: <code>git reset --hard</code></h3>
<p>You want to <strong>destroy commit C and also throw away any uncommitted changes</strong>.  You do this:</p>
<pre><code>git reset --hard HEAD~1
</code></pre>
<p>The result is:</p>
<pre><code> (F)
A-B
  ↑
master
</code></pre>
<p>Now B is the HEAD.  Because you used <code>--hard</code>, your files are reset to their state at commit B.</p>
<h3>Option 2: <code>git reset</code></h3>
<p>Maybe commit C wasn't a disaster, but just a bit off.  You want to <strong>undo the commit but keep your changes</strong> for a bit of editing before you do a better commit.  Starting again from here, with C as your HEAD:</p>
<pre><code>   (F)
A-B-C
    ↑
  master
</code></pre>
<p>Do this, leaving off the <code>--hard</code>:</p>
<pre><code>git reset HEAD~1
</code></pre>
<p>In this case the result is:</p>
<pre><code>   (F)
A-B-C
  ↑
master
</code></pre>
<p>In both cases, HEAD is just a pointer to the latest commit.  When you do a <code>git reset HEAD~1</code>, you tell Git to move the HEAD pointer back one commit.  But (unless you use <code>--hard</code>) you leave your files as they were.  So now <code>git status</code> shows the changes you had checked into C.  You haven't lost a thing!</p>
<h3>Option 3: <code>git reset --soft</code></h3>
<p>For the lightest touch, you can even <strong>undo your commit but leave your files and your <a href="https://git.wiki.kernel.org/index.php/WhatIsTheIndex" rel="noreferrer">index</a></strong>:</p>
<pre><code>git reset --soft HEAD~1
</code></pre>
<p>This not only leaves your files alone, it even leaves your <em>index</em> alone.  When you do <code>git status</code>, you'll see that the same files are in the index as before.  In fact, right after this command, you could do <code>git commit</code> and you'd be redoing the same commit you just had.</p>
<h3>Option 4: you did <code>git reset --hard</code> and need to get that code back</h3>
<p>One more thing: Suppose you <strong>destroy a commit</strong> as in the first example, <strong>but then discover you needed it after all</strong>?  Tough luck, right?</p>
<p>Nope, there's <em>still</em> a way to get it back.  Type this</p>
<pre><code>git reflog
</code></pre>
<p>and you'll see a list of (partial) commit <a href="https://en.wikipedia.org/wiki/SHA-1#Data_integrity" rel="noreferrer">SHAs</a> (that is, hashes) that you've moved around in.  Find the commit you destroyed, and do this:</p>
<pre><code>git checkout -b someNewBranchName shaYouDestroyed
</code></pre>
<p>You've now resurrected that commit.  Commits don't actually get destroyed in Git for some 90 days, so you can usually go back and rescue one you didn't mean to get rid of.</p>
    


<p>There are two ways to "undo" your last commit, depending on whether or not you have already made your commit public (pushed to your remote repository):</p>
<h2>How to undo a local commit</h2>
<p>Let's say I committed locally, but now I want to remove that commit.</p>
<pre><code>git log
    commit 101: bad commit    # Latest commit. This would be called 'HEAD'.
    commit 100: good commit   # Second to last commit. This is the one we want.
</code></pre>
<p>To restore everything back to the way it was prior to the last commit, we need to <code>reset</code> to the commit before <code>HEAD</code>:</p>
<pre><code>git reset --soft HEAD^     # Use --soft if you want to keep your changes
git reset --hard HEAD^     # Use --hard if you don't care about keeping the changes you made
</code></pre>
<p>Now <code>git log</code> will show that our last commit has been removed.</p>
<h2>How to undo a public commit</h2>
<p>If you have already made your commits public, you will want to create a new commit which will "revert" the changes you made in your previous commit (current HEAD).</p>
<pre><code>git revert HEAD
</code></pre>
<p>Your changes will now be reverted and ready for you to commit:</p>
<pre><code>git commit -m 'restoring the file I removed by accident'
git log
    commit 102: restoring the file I removed by accident
    commit 101: removing a file we don't need
    commit 100: adding a file that we need
</code></pre>
<p>For more information, check out <em><a href="https://git-scm.com/book/en/v2/Git-Basics-Undoing-Things" rel="noreferrer">Git Basics - Undoing Things</a></em>.</p>
    


<p>Add/remove files to get things the way you want:</p>

<pre><code>git rm classdir
git add sourcedir
</code></pre>

<p>Then amend the commit:</p>

<pre><code>git commit --amend
</code></pre>

<p>The previous, erroneous commit will be edited to reflect the new index state - in other words, it'll be like you never made the mistake in the first place.</p>

<p>Note that you should only do this if you haven't pushed yet. If you have pushed, then you'll just have to commit a fix normally.</p>
    


<p>This will add a new commit which deletes the added files.</p>
<pre class="lang-bash s-code-block"><code data-highlighted="yes" class="hljs language-bash">git <span class="hljs-built_in">rm</span> yourfiles/*.class
git commit -a -m <span class="hljs-string">"deleted all class files in folder 'yourfiles'"</span>
</code></pre>
<hr>
<p>Or you can rewrite history to undo the last commit.</p>
<p><strong>Warning</strong>: this command will <strong>permanently remove</strong> the modifications to the <code>.java</code> files (and any other files) that you committed -- and delete all your changes from your working directory:</p>
<pre><code>git reset --hard HEAD~1
</code></pre>
<p>The <code>hard reset</code> to <code>HEAD-1</code> will set your working copy to the state of the commit before your wrong commit.</p>
    


<h2 id="to-change-the-last-commit-ayg9">To change the last commit</h2>
<p>Replace the files in the index:</p>
<pre><code>git rm --cached *.class
git add *.java
</code></pre>
<p>Then, if it's a private branch, <strong>amend</strong> the commit:</p>
<pre><code>git commit --amend
</code></pre>
<p>Or, if it's a shared branch, make a new commit:</p>
<pre><code>git commit -m 'Replace .class files with .java files'
</code></pre>
<br>
<p><em>(<strong>To change a previous commit</strong>, use the awesome <a href="https://stackoverflow.com/a/28421811/405550">interactive rebase</a>.)</em></p>
<hr>
<p>ProTip™: Add <code>*.class</code> to a <a href="https://help.github.com/articles/ignoring-files" rel="noreferrer">gitignore</a> to stop this happening again.</p>
<hr>
<h2 id="to-revert-a-commit-rotb">To revert a commit</h2>
<p>Amending a commit is the ideal solution if you need to change the last commit, but a more general solution is <code>reset</code>.</p>
<p>You can reset Git to any commit with:</p>
<pre><code>git reset @~N
</code></pre>
<p>Where <code>N</code> is the number of commits before <code>HEAD</code>, and <code>@~</code> resets to the previous commit.</p>
<p>Instead of amending the commit, you could use:</p>
<pre><code>git reset @~
git add *.java
git commit -m "Add .java files"
</code></pre>
<p>Check out <code>git help reset</code>, specifically the sections on <code>--soft</code> <code>--mixed</code> and <code>--hard</code>, for a better understanding of what this does.</p>
<h2 id="reflog-hdrm">Reflog</h2>
<p>If you mess up, you can always use the reflog to find dropped commits:</p>
<pre><code>$ git reset @~
$ git reflog
c4f708b HEAD@{0}: reset: moving to @~
2c52489 HEAD@{1}: commit: added some .class files
$ git reset 2c52489
... and you're back where you started
</code></pre>
<br>
    


<p>Use <code>git revert &lt;commit-id&gt;</code>.</p>

<p>To get the commit ID, just use <code>git log</code>.</p>
    


<p>If you are planning to undo a local commit entirely, whatever you change you did on the commit, and if you don't worry anything about that, just do the following command.</p>
<pre><code>git reset --hard HEAD^1
</code></pre>
<p>(This command will ignore your entire commit and your changes will be lost completely from your local working tree). If you want to undo your commit, but you want your changes in the staging area (before commit just like after <code>git add</code>) then do the following command.</p>
<pre><code>git reset --soft HEAD^1
</code></pre>
<p>Now your committed files come into the staging area. Suppose if you want to upstage the files, because you need to edit some wrong content, then do the following command</p>
<pre><code>git reset HEAD
</code></pre>
<p>Now committed files to come from the staged area into the unstaged area. Now files are ready to edit, so whatever you change, you want to go edit and added it and make a fresh/new commit.</p>
<p><a href="http://madhan-tech-updates.blogspot.in/2013/01/how-to-undo-your-local-git-commit.html" rel="noreferrer">More (link broken)</a> (<a href="https://web.archive.org/web/20170410191943/http://madhan-tech-updates.blogspot.in/2013/01/how-to-undo-your-local-git-commit.html" rel="noreferrer">Archived version</a>)</p>
    


<p>If you have <a href="https://github.com/visionmedia/git-extras" rel="noreferrer">Git Extras</a> installed, you can run <code>git undo</code> to undo the latest commit. <code>git undo 3</code> will undo the last three commits.</p>
    


<p>I wanted to undo the latest five commits in our shared repository. I looked up the revision id that I wanted to rollback to. Then I typed in the following.</p>

<pre><code>prompt&gt; git reset --hard 5a7404742c85
HEAD is now at 5a74047 Added one more page to catalogue
prompt&gt; git push origin master --force
Total 0 (delta 0), reused 0 (delta 0)
remote: bb/acl: neoneye is allowed. accepted payload.
To git@bitbucket.org:thecompany/prometheus.git
 + 09a6480...5a74047 master -&gt; master (forced update)
prompt&gt;
</code></pre>
    

How do i undo the most recent local commits in git

要删除本地和远程的 Git 分支，您可以执行以下步骤：

### 删除本地分支：

1. 首先，确保您没有检出到您想要删除的分支。如果您当前在该分支上，请切换到不同的分支，例如切换到 `main` 或 `master` 分支：

   ```bash
   git checkout main
   ```

   _注：如果您的默认分支不是 `main`，请使用您仓库的默认分支名称。_

2. 使用 `git branch -d <branch_name>` 来删除本地分支。这里的 `<branch_name>` 是您想要删除的分支名称。如果分支已经完全合并到上游分支，可以使用 `-d` 选项，如果想强制删除未合并的分支，可以使用 `-D` 选项。

   ```bash
   git branch -d branch_name
   ```

   若分支未合并且要强制删除：

   ```bash
   git branch -D branch_name
   ```

### 删除远程分支：

1. 使用 `git push` 命令和 `--delete` 选项来删除远程仓库的分支。同样，`<branch_name>` 是您想要删除的分支名称。

   ```bash
   git push origin --delete branch_name
   ```

   这里的 `origin` 是远程仓库的名称（默认通常是 `origin`），`branch_name` 是您要删除的远程分支名称。

### 综合示例：

如果您有一个名为 `feature-x` 的本地和远程分支需要删除，以下是综合的命令步骤：

1. 切换到不同的分支，如 `main`：
   ```bash
   git checkout main
   ```
2. 删除本地 `feature-x` 分支：
   ```bash
   git branch -d feature-x
   ```
3. 删除远程 `feature-x` 分支：
   ```bash
   git push origin --delete feature-x
   ```

确保在执行这些操作之前备份任何重要数据，因为删除分支是不可逆的操作。

Executive Summary
=================

    git push -d <remote_name> <branchname>
    git branch -d <branchname>
    

**Note:** In most cases, `<remote_name>` will be `origin`.

Delete Local Branch
===================

To delete the _**local**_ branch, use one of the following:

    git branch -d <branch_name>
    git branch -D <branch_name>
    

*   The `-d` option is an alias for `--delete`, which only deletes the branch if it has already been fully merged in its upstream branch.
*   The `-D` option is an alias for `--delete --force`, which deletes the branch "irrespective of its merged status." \[Source: `man git-branch`\]
*   As of [Git v2.3](https://github.com/git/git/blob/master/Documentation/RelNotes/2.3.0.txt), `git branch -d` (delete) learned to honor the `-f` (force) flag.
*   You will receive an error if you try to delete the currently selected branch.

Delete Remote Branch
====================

As of [Git v1.7.0](https://github.com/gitster/git/blob/master/Documentation/RelNotes/1.7.0.txt), you can delete a _**remote**_ branch using

    $ git push <remote_name> --delete <branch_name>
    

which might be easier to remember than

    $ git push <remote_name> :<branch_name>
    

which was added in [Git v1.5.0](https://github.com/gitster/git/blob/master/Documentation/RelNotes/1.5.0.txt) "to delete a remote branch or a tag."

Starting with [Git v2.8.0](https://github.com/git/git/blob/master/Documentation/RelNotes/2.8.0.txt), you can also use `git push` with the `-d` option as an alias for `--delete`. Therefore, the version of Git you have installed will dictate whether you need to use the easier or harder syntax.

Delete Remote Branch \[Original Answer from 5-Jan-2010\]
--------------------------------------------------------

From Chapter 3 of [_Pro Git_](http://git-scm.com/book/en/Git-Branching-Remote-Branches) by Scott Chacon:

> ### Deleting Remote Branches
> 
> Suppose you’re done with a remote branch — say, you and your collaborators are finished with a feature and have merged it into your remote’s main branch (or whatever branch your stable code-line is in). You can delete a remote branch using the rather obtuse syntax `git push [remotename] :[branch]`. If you want to delete your `serverfix` branch from the server, you run the following:
> 
>     $ git push origin :serverfix
>     To git@github.com:schacon/simplegit.git
>      - [deleted]         serverfix
>     
> 
> Boom. No more branches on your server. You may want to dog-ear this page, because you’ll need that command, and you’ll likely forget the syntax. A way to remember this command is by recalling the `git push [remotename] [localbranch]:[remotebranch]` syntax that we went over a bit earlier. If you leave off the `[localbranch]` portion, then you’re basically saying, “Take nothing on my side and make it be `[remotebranch]`.”

I ran `git push origin :bugfix`, and it worked beautifully. Scott Chacon was right—I will want to [dog-ear](http://en.wiktionary.org/wiki/dogear#Verb) that page (or virtually dog ear-by answering this on Stack Overflow).

Finally, execute the following on other machines to propagate changes:

    # Fetch changes from all remotes and locally delete 
    # remote deleted branches/tags etc
    # --prune will do the job :-;
    git fetch --all --prune

[Matthew’s answer](https://stackoverflow.com/a/2003515/2637261) is great for removing _remote_ branches and I also appreciate the explanation, but to make a simple distinction between the two commands:

*   to remove a _**local branch**_ from your machine: `git branch -d {local_branch}` (use `-D` instead to force deleting the branch without checking merged status);
    
*   to remove a _**remote branch**_ from the server: `git push origin -d {remote_branch}`.
    

Reference: _[Git: Delete a branch (local or remote)](https://makandracards.com/makandra/621-git-delete-a-branch-local-or-remote)_.

The _short answers_
-------------------

If you want more detailed explanations of the following commands, then see the long answers in the next section.

### Deleting a remote branch

    git push origin --delete <branch>  # Git version 1.7.0 or newer
    git push origin -d <branch>        # Shorter version (Git 1.7.0 or newer)
    git push origin :<branch>          # Git versions older than 1.7.0
    

### Deleting a local branch

    git branch --delete <branch>
    git branch -d <branch> # Shorter version
    git branch -D <branch> # Force-delete un-merged branches
    

### Deleting a local remote-tracking branch

    git branch --delete --remotes <remote>/<branch>
    git branch -dr <remote>/<branch> # Shorter
    
    git fetch <remote> --prune # Delete multiple obsolete remote-tracking branches
    git fetch <remote> -p      # Shorter
    

* * *

The _long answer_: there are three different branches to delete!
----------------------------------------------------------------

When you're dealing with deleting branches both locally and remotely, keep in mind that **there are three different branches involved**:

1.  The local branch `X`.
2.  The remote origin branch `X`.
3.  The local remote-tracking branch `origin/X` that tracks the remote branch `X`.

![Visualization of three branches](https://i.stack.imgur.com/NLAqw.png)

The original poster used:

    git branch -rd origin/bugfix
    

Which only deleted his **local remote-tracking branch** `origin/bugfix`, and not the actual remote branch `bugfix` on `origin`.

![Diagram 2](https://i.stack.imgur.com/iCOnz.png)

**To delete that actual remote branch**, you need

    git push origin --delete bugfix
    

![Diagram 3](https://i.stack.imgur.com/6Z3GY.png)

### Additional details

The following sections describe additional details to consider when deleting your remote and remote-tracking branches.

Pushing to delete remote branches also removes remote-tracking branches
-----------------------------------------------------------------------

Note that deleting the remote branch `X` from the command line using a `git push` **will also remove the local remote-tracking branch** `origin/X`, so it is not necessary to prune the obsolete remote-tracking branch with `git fetch --prune` or `git fetch -p`. However, it wouldn't hurt if you did it anyway.

You can verify that the remote-tracking branch `origin/X` was also deleted by running the following:

    # View just remote-tracking branches
    git branch --remotes
    git branch -r
    
    # View both strictly local as well as remote-tracking branches
    git branch --all
    git branch -a
    

Pruning the obsolete local remote-tracking branch origin/X
----------------------------------------------------------

If you didn't delete your remote branch `X` from the command line (like above), then your local repository will still contain (a now obsolete) remote-tracking branch `origin/X`. This can happen if you deleted a remote branch directly through GitHub's web interface, for example.

A typical way to remove these obsolete remote-tracking branches (since Git version 1.6.6) is to simply run `git fetch` with the `--prune` or shorter `-p`. **Note that this removes all obsolete local remote-tracking branches for any remote branches that no longer exist on the remote**:

    git fetch origin --prune
    git fetch origin -p # Shorter
    

Here is the relevant quote from the [1.6.6 release notes](https://github.com/git/git/blob/v2.0.0/Documentation/RelNotes/1.6.6.txt#L162-L166) (emphasis mine):

> **"git fetch" learned** `--all` and `--multiple` options, to run fetch from many repositories, and **`--prune` option to remove remote tracking branches that went stale.** These make "git remote update" and "git remote prune" less necessary (there is no plan to remove "remote update" nor "remote prune", though).

### Alternative to above automatic pruning for obsolete remote-tracking branches

Alternatively, instead of pruning your obsolete local remote-tracking branches through `git fetch -p`, _you can avoid making the extra network operation_ by just manually removing the branch(es) with the `--remotes` or `-r` flags:

    git branch --delete --remotes origin/X
    git branch -dr origin/X # Shorter
    

See Also
--------

*   [git-branch(1) Manual Page](https://jk.gs/git-branch.html).
*   [git-fetch(1) Manual Page](https://jk.gs/git-fetch.html).
*   [Pro Git § 3.5 Git Branching - Remote Branches](https://git-scm.com/book/en/Git-Branching-Remote-Branches).

### Steps for deleting a branch:

For deleting the **remote branch:**

    git push origin --delete <your_branch>
    

For deleting the **local branch**, you have **three ways**:

    1: git branch -D <branch_name>
    
    2: git branch --delete --force <branch_name>  # Same as -D
    
    3: git branch --delete  <branch_name>         # Error on unmerge
    

**Explain:** OK, just explain what's going on here!

Simply do `git push origin --delete` to **delete your remote branch _only_**, add the name of the branch at the end and this will delete and **push it to remote** at the same time...

Also, `git branch -D`, which simply delete the local branch **_only_**!...

`-D` stands for `--delete --force` which will delete the branch even it's not merged (force delete), but you can also use `-d` which stands for `--delete` which throw an error respective of the branch merge status...

I also create the **image below** to show the steps:

[![Delete a remote and local branch in git](https://i.stack.imgur.com/AKWYx.jpg)](https://i.stack.imgur.com/AKWYx.jpg)

You can also use the following to delete the remote branch

    git push --delete origin serverfix
    

Which does the same thing as

    git push origin :serverfix
    

but it may be easier to remember.

How to delete locally branch and remotely branch in git?

在使用`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

CSS 中的媒体查询（Media Queries）是一种非常有用的工具，它可以根据不同的设备特性来应用不同的样式规则。针对 iOS 设备的样式，可以通过特定的媒体查询来针对性地应用。

例如，可以使用 `-webkit-min-device-pixel-ratio` 特性或者 `orientation` 特性来针对 iOS 设备。以下是针对所有具有 Retina 屏幕的 iOS 设备（iPhone、iPad、iPod Touch 等）的媒体查询：

```css
@media only screen and (-webkit-min-device-pixel-ratio: 2), only screen and (min-device-pixel-ratio: 2) {
    /* 在这里编写针对 iOS Retina 设备的 CSS */
}
```

如果要更细致地区分，还可以根据设备的宽度或者高度来写媒体查询，因为不同的 iOS 设备（尤其是横竖屏切换时）的宽度和高度是不同的。比如，针对所有的 iPhone 设备（这里不区分是否为 Retina 屏幕），可以这样写：

```css
@media only screen and (max-device-width: 480px) {
    /* 在这里编写专门针对 iPhone 的 CSS */
}
```

对于 iPad，可以这样区分横竖屏：

```css
/* Portrait */
@media only screen 
  and (min-device-width: 768px) 
  and (max-device-width: 1024px) 
  and (orientation: portrait) {
  /* Styles */
}

/* Landscape */
@media only screen 
  and (min-device-width: 768px) 
  and (max-device-width: 1024px) 
  and (orientation: landscape) {
  /* Styles */
}
```

值得注意的是，目前市面上的设备种类繁多，iOS 设备也在不断更新，所以需要定期更新你的媒体查询以适应新的设备。此外，使用这些媒体查询时，还应该注意浏览器兼容性和隐私设置，因为某些浏览器可能不支持特定的查询，或者用户的隐私设置可能会限制某些CSS的应用。在CSS中，我们可以使用媒体查询(media queries)来为不同的设备和视口尺寸应用不同的样式。如果想要只针对iOS设备的话，可以使用针对特定设备特性的媒体查询。但是，需要注意的是，由于iOS设备的多样性和Web标准的推进，通常不建议只针对iOS设备编写CSS，而应该更注重响应式设计，以适应不同的屏幕尺寸和分辨率。

不过，如果确实有特殊需求只想针对iOS设备，可以使用以下的媒体查询示例：

```css
@media screen and (min-device-width : 375px) 
               and (max-device-width : 812px) 
               and (-webkit-device-pixel-ratio : 3) 
               and (orientation : portrait) {
  /* 在 iPhone X 上应用的样式 */
}
```

这个例子使用了`min-device-width`和`max-device-width`来指定设备的屏幕宽度范围，`-webkit-device-pixel-ratio`用来指定设备的像素比，`orientation`用来指定设备的方向。这些参数的组合可以较为准确地针对特定的iOS设备。

然而，这种方法有一些限制：

1. **设备更新**：随着新设备的发布，可能需要更新媒体查询以包括新的尺寸和像素密度。
2. **兼容性和维护**：仅针对iOS设备的样式可能导致不必要的复杂性和后期维护问题。
3. **Web标准**：建议根据Web标准进行设计，使用响应式布局来适配不同的设备和屏幕尺寸，而不是专注于特定品牌或平台。

因此，尽管可以使用媒体查询针对iOS设备，但是最好的做法是编写灵活的响应式CSS，以确保在各种设备上都能提供良好的用户体验。

如上所述，简短的答案是否定的。但我现在正在开发的应用程序中需要类似的东西，但 CSS 需要不同的区域仅限于页面的非常特定的区域。

如果您像我一样并且不需要提供完全不同的样式表，另一种选择是按照此问题所选答案中描述的方式检测运行 iOS 的设备：[检测设备是否为 iOS](https://stackoverflow.com/questions/9038625/detect-if-device-is-ios)

一旦您检测到 iOS 设备，您就可以使用 Javascript（例如，`document.getElementsByTagName("yourElementHere")[0].setAttribute("class", "iOS-device");`jQuery、PHP 等）向您的目标区域添加一个类，并使用预先存在的样式表相应地设置该类的样式。

    .iOS-device {
          style-you-want-to-set: yada;
    }

当您想要使用 CSS 媒体查询专门为 iOS 设备编写样式时，可以通过针对特定的设备特性（如屏幕尺寸、分辨率和操作系统特有的视口属性）来编写媒体查询。尽管我们不能直接查询设备是否为iOS设备，但我们可以使用一些常见的iOS设备的屏幕尺寸和分辨率作为参考来编写媒体查询。以下是一个简单的例子：

```css
@media only screen 
  and (min-device-width : 375px) 
  and (max-device-width : 812px) 
  and (-webkit-device-pixel-ratio : 3) 
  and (orientation : portrait) {
  /* 在这里编写针对特定iOS设备的样式，例如 iPhone X */
  body {
    background-color: lightblue;
  }
}
```

在这个媒体查询中，我们设置了几个条件：

- `min-device-width` 和 `max-device-width` 处于特定范围内，这个范围匹配了特定的 iPhone 设备。
- `-webkit-device-pixel-ratio` 是设备像素比，`3` 是 iPhone X 的设备像素比。
- `orientation` 是设备的方向，这里设置为 `portrait`（竖屏）。

需要注意的是，随着设备的更新和新增，可能需要更新媒体查询条件以适应新的设备。此外，一些媒体查询参数也可能在未来的iOS版本中发生变化，因此需要定期检查您的媒体查询代码，确保其仍然适用于最新的设备和操作系统。

要使用 CSS 媒体查询针对 iOS 设备应用样式，我们可以依赖于特定的设备和浏览器特性，如 `Webkit` 特有的前缀和设备分辨率。下面是一个使用媒体查询只针对 iOS 设备的示例：

```css
@media only screen 
  and (min-device-width : 320px) 
  and (max-device-width : 812px) 
  and (-webkit-min-device-pixel-ratio : 2) 
  and (orientation : portrait) {
    /* 在此处编写你的 CSS 规则 */
    body {
        background-color: #f0f0f0;
    }
}
```

这段样式声明是为了匹配一定分辨率范围内的 iOS 设备（如 iPhone 5/SE, 6/7/8, 6/7/8 Plus, X, XS, 11 Pro 等），并且具有 `2` 倍的像素比（`-webkit-min-device-pixel-ratio : 2`），且设备处于竖屏模式。`-webkit-` 前缀用于针对基于 Webkit 的浏览器，而 iOS 设备的 Safari 浏览器正是建立在这个引擎之上。

请注意，上述媒体查询可能并不完美地涵盖所有 iOS 设备，因为设备的尺寸和分辨率多种多样，而且新设备的发布也可能改变情况。因此，适配 iOS 设备的策略可能需要根据具体情况定期更新。

如果你想针对所有 iOS 设备，而不仅仅是 iPhone，那么你可以省略尺寸的限制，只使用 `-webkit-min-device-pixel-ratio` 这个特性。但这种方法也可能会影响到其他使用 Webkit 浏览器引擎的设备。因此，确保测试你的媒体查询以验证它们是否满足你的需求是非常重要的。

在CSS中，我们可以使用媒体查询(media queries)来为不同的设备和视口尺寸应用不同的样式。如果想要只针对iOS设备的话，可以使用针对特定设备特性的媒体查询。但是，需要注意的是，由于iOS设备的多样性和Web标准的推进，通常不建议只针对iOS设备编写CSS，而应该更注重响应式设计，以适应不同的屏幕尺寸和分辨率。

不过，如果确实有特殊需求只想针对iOS设备，可以使用以下的媒体查询示例：

```css
@media screen and (min-device-width : 375px) 
               and (max-device-width : 812px) 
               and (-webkit-device-pixel-ratio : 3) 
               and (orientation : portrait) {
  /* 在 iPhone X 上应用的样式 */
}
```

这个例子使用了`min-device-width`和`max-device-width`来指定设备的屏幕宽度范围，`-webkit-device-pixel-ratio`用来指定设备的像素比，`orientation`用来指定设备的方向。这些参数的组合可以较为准确地针对特定的iOS设备。

然而，这种方法有一些限制：

1. **设备更新**：随着新设备的发布，可能需要更新媒体查询以包括新的尺寸和像素密度。
2. **兼容性和维护**：仅针对iOS设备的样式可能导致不必要的复杂性和后期维护问题。
3. **Web标准**：建议根据Web标准进行设计，使用响应式布局来适配不同的设备和屏幕尺寸，而不是专注于特定品牌或平台。

因此，尽管可以使用媒体查询针对iOS设备，但是最好的做法是编写灵活的响应式CSS，以确保在各种设备上都能提供良好的用户体验。

要使用 CSS 媒体查询针对 iOS 设备应用样式，我们可以依赖于特定的设备和浏览器特性，如 `Webkit` 特有的前缀和设备分辨率。下面是一个使用媒体查询只针对 iOS 设备的示例：

```css
@media only screen 
  and (min-device-width : 320px) 
  and (max-device-width : 812px) 
  and (-webkit-min-device-pixel-ratio : 2) 
  and (orientation : portrait) {
    /* 在此处编写你的 CSS 规则 */
    body {
        background-color: #f0f0f0;
    }
}
```

这段样式声明是为了匹配一定分辨率范围内的 iOS 设备（如 iPhone 5/SE, 6/7/8, 6/7/8 Plus, X, XS, 11 Pro 等），并且具有 `2` 倍的像素比（`-webkit-min-device-pixel-ratio : 2`），且设备处于竖屏模式。`-webkit-` 前缀用于针对基于 Webkit 的浏览器，而 iOS 设备的 Safari 浏览器正是建立在这个引擎之上。

请注意，上述媒体查询可能并不完美地涵盖所有 iOS 设备，因为设备的尺寸和分辨率多种多样，而且新设备的发布也可能改变情况。因此，适配 iOS 设备的策略可能需要根据具体情况定期更新。

如果你想针对所有 iOS 设备，而不仅仅是 iPhone，那么你可以省略尺寸的限制，只使用 `-webkit-min-device-pixel-ratio` 这个特性。但这种方法也可能会影响到其他使用 Webkit 浏览器引擎的设备。因此，确保测试你的媒体查询以验证它们是否满足你的需求是非常重要的。CSS 中使用媒体查询（Media Queries）可以根据不同的设备特性来应用不同的样式规则。如果想特别针对 iOS 设备，我们需要定义一种特定的媒体查询，它能够识别出 iOS 设备的特征。然而，CSS 并没有直接针对 iOS 的媒体查询，因为媒体查询基于设备的能力而不是平台或操作系统。

不过，我们可以使用一些常见的iOS设备分辨率和特性（如设备的宽度、高度和像素比）来间接地定位大部分iOS设备。例如，iPhone、iPad和iPod通常都有特定的屏幕尺寸和分辨率。以下是一个CSS媒体查询的例子，它可能会捕捉到一些iOS设备，但不保证完全精确：

```css
/* iPhone 的横向和纵向 */
@media only screen 
  and (min-device-width : 375px) 
  and (max-device-width : 812px) 
  and (-webkit-min-device-pixel-ratio : 3) {
    /* 在这里编写针对特定设备的CSS代码 */
}

/* 特定于iPad的媒体查询 */
@media only screen 
  and (min-device-width : 768px) 
  and (max-device-width : 1024px) 
  and (-webkit-min-device-pixel-ratio : 2) {
    /* 在这里编写针对特定设备的CSS代码 */
}

/* 可能适用于大多数iOS设备的高像素比 */
@media only screen 
  and (-webkit-min-device-pixel-ratio : 2), 
  only screen 
  and (min--moz-device-pixel-ratio : 2),
  only screen 
  and (-o-min-device-pixel-ratio : 2/1),
  only screen 
  and (min-device-pixel-ratio : 2),
  only screen 
  and (min-resolution : 2dppx) {
    /* 在这里编写针对高像素比设备的CSS代码 */
}
```

但是，要注意，这样的媒体查询并不能保证只会被iOS设备使用，因为其他具有类似特征的非iOS设备（比如其他制造商的高分辨率手机或平板电脑）也可能匹配这些规则。

另一个可能的方法是用JavaScript来检测用户代理（User Agent）字符串中是否含有iOS特有的标识符，然后动态添加一个对应的类名到`<body>`标签或在页面上动态写入特定的CSS。但是这种方法同样不是完全可靠的，因为用户代理字符串可能被伪造或因浏览器更新而改变。

```javascript
if (/iPad|iPhone|iPod/.test(navigator.userAgent)) {
    document.documentElement.className += " ios-device";
}
```

然后，在CSS中，您可以这样做：

```css
.ios-device .some-class {
    /* 特定于 iOS 设备的样式 */
}
```

所以，在实际操作中，我们通常会根据设备的屏幕大小和分辨率来编写媒体查询，而不是试图创建一个完全针对iOS设备的查询。这种做法更加通用，并且更能适应各种设备的屏幕。

How to css media query to target only ios devices

在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?

在TypeScript中，遍历对象的键可以使用几种不同的方法。以下是一些常用的方法：

### 1. `for...in` 循环

`for...in` 循环是JavaScript语言中遍历对象属性的传统方式。这种方法会遍历对象自己的属性以及原型链上可枚举的属性。

```typescript
const obj = { a: 1, b: 2, c: 3 };

for (const key in obj) {
  if (obj.hasOwnProperty(key)) {
    console.log(key); // 输出 'a', 'b', 'c'
  }
}
```

使用 `hasOwnProperty` 是为了确保只遍历对象自己的属性，而不包括原型链上的属性。

### 2. `Object.keys()`

`Object.keys()` 方法会返回一个包含对象自身可枚举属性名称的数组。

```typescript
const obj = { a: 1, b: 2, c: 3 };

const keys = Object.keys(obj);
keys.forEach(key => {
  console.log(key); // 输出 'a', 'b', 'c'
});
```

这种方法不会遍历原型链上的属性。

### 3. `Object.entries()`

`Object.entries()` 方法返回一个给定对象自身可枚举属性的键值对数组。

```typescript
const obj = { a: 1, b: 2, c: 3 };

for (const [key, value] of Object.entries(obj)) {
  console.log(key); // 输出 'a', 'b', 'c'
}
```

类似于 `Object.keys()`，这种方法也不会包括原型链上的属性，并且提供了键和值。

### 4. `Object.getOwnPropertyNames()`

`Object.getOwnPropertyNames()` 方法返回一个数组，包含对象自身的所有属性（不仅仅是可枚举的属性）的名称。

```typescript
const obj = { a: 1, b: 2, c: 3 };

const propertyNames = Object.getOwnPropertyNames(obj);
propertyNames.forEach(name => {
  console.log(name); // 输出 'a', 'b', 'c'
});
```

这个方法可以获得对象所有自有属性的名称，包括不可枚举的属性。

### 例子

假设我们有一个表示用户信息的对象，并想要遍历这个对象的键：

```typescript
interface User {
  id: number;
  name: string;
  email: string;
}

const user: User = {
  id: 1,
  name: 'Jane Doe',
  email: 'jane.doe@example.com'
};

Object.keys(user).forEach(key => {
  console.log(key); // 输出 'id', 'name', 'email'
});
```

在这个例子中，我们使用了 `Object.keys()` 来遍历用户对象的键，并输出每个键。这种方法是常用且简洁的，适用于当你只需要对象的键时。

在TypeScript中使用这些方法时，也要注意对象的类型。如果对象的类型定义了可选属性或索引签名，那么在遍历时可能需要处理未定义的属性或动态键。

你已经很接近了，你只需要将 替换`=`为`:`. 您可以使用对象类型文字（请参阅规范第 3.5.3 节）或接口。使用对象类型文字与您所拥有的接近：

    var obj: { property: string; } = { property: "foo" };
    

但您也可以使用接口

    interface MyObjLayout {
        property: string;
    }
    
    var obj: MyObjLayout = { property: "foo" };

### 更新 2019-05-15（改进的 Code Pattern 作为替代方案）

经过多年使用`const`功能更多的代码并从中受益后，我建议在大多数情况下不要使用我原来的答案（本节下面的标题，即在构建对象时，强制类型系统进入特定类型而不是让它推断类型通常是表明出现问题）。

相反，我建议`const`尽可能多地使用变量，然后作为最后一步组成对象：

    const id = getId();
    const hasStarted = true;
    ...
    const hasFinished = false;
    ...
    return { hasStarted, hasFinished, id };
    

*   这将正确键入所有内容，而无需显式键入。
*   无需重新输入字段类型。
*   根据我的经验，这会产生最干净的代码。
*   这允许编译器提供更多的状态验证（例如，如果您在多个位置返回，编译器将确保始终返回相同类型的对象 - 这鼓励您在每个位置声明整个返回值 - 给出一个完全清晰的结果）该值的意图）。

### 奖励：可选字段 2022-09-29

    const id = getId();
    const optionalField = getOptionalValue();
    return {
        id,
        // This will always exist as a key in the object but it might be undefined
        optionalField,
        // This will only exist as a key in the object if it has a truthy value
        ...optionalField2 ? { optionalField } : {},
        // This will only exist as a key in the object if it is not null or undefined
        ...optionalField2 != null ? { optionalField } : {},
    };
    

### 添加 2020-02-26

如果您确实需要一个可以延迟初始化的类型：将其标记为可为空的联合类型（null 或 Type）。如果没有首先确保它具有值，类型系统将阻止您使用它。

在 中`tsconfig.json`，确保启用严格的 null 检查：

`"strictNullChecks": true`

然后使用此模式并允许类型系统保护您免受意外的空/未定义访问：

    
    
    const state = {
        instance: null as null | ApiService,
        // OR
        // instance: undefined as undefined | ApiService,
    
    };
    
    const useApi = () => {
        // If I try to use it here, the type system requires a safe way to access it
    
        // Simple lazy-initialization 
        const api = state?.instance ?? (state.instance = new ApiService());
        api.fun();
    
        // Also here are some ways to only access it if it has value:
    
        // The 'right' way: Typescript 3.7 required
        state.instance?.fun();
    
        // Or the old way: If you are stuck before Typescript 3.7
        state.instance && state.instance.fun();
    
        // Or the long winded way because the above just feels weird
        if (state.instance) { state.instance.fun(); }
    
        // Or the I came from C and can't check for nulls like they are booleans way
        if (state.instance != null) { state.instance.fun(); }
    
        // Or the I came from C and can't check for nulls like they are booleans 
        // AND I was told to always use triple === in javascript even with null checks way
        if (state.instance !== null && state.instance !== undefined) { state.instance.fun(); }
    };
    
    class ApiService {
        fun() {
            // Do something useful here
        }
    }
    

* * *

### 99% 的情况下不要执行以下操作：

### 2016-02-10 更新 - 处理 TSX（感谢@Josh）

使用`as`TSX 操作员。

    var obj = {
        property: null as string
    };
    

一个更长的例子：

    var call = {
        hasStarted: null as boolean,
        hasFinished: null as boolean,
        id: null as number,
    };
    

### 原答案

使用强制转换运算符可以使其简洁（通过将 null 强制转换为所需的类型）。

    var obj = {
        property: <string> null
    };
    

一个更长的例子：

    var call = {
        hasStarted: <boolean> null,
        hasFinished: <boolean> null,
        id: <number> null,
    };
    

这比拥有两部分（第一部分声明类型，第二部分声明默认值）要好得多：

    var callVerbose: {
        hasStarted: boolean;
        hasFinished: boolean;
        id: number;
    } = {
        hasStarted: null,
        hasFinished: null,
        id: null,
    };

我很惊讶没有人提到这一点，但您可以创建一个名为 的接口`ObjectLiteral`，它接受`key: value`类型对`string: any`：

    interface ObjectLiteral {
      [key: string]: any;
    }
    

然后你会像这样使用它：

    let data: ObjectLiteral = {
      hello: "world",
      goodbye: 1,
      // ...
    };
    

额外的好处是，您可以根据需要在任意数量的对象上多次重复使用此界面。

祝你好运。

您可以使用预定义的实用程序类型[**`Record<Keys, Type>`**](https://www.typescriptlang.org/docs/handbook/utility-types.html#recordkeys-type)：

    const obj: Record<string, string> = {
      property: "value",
    };
    

它允许为对象文字指定键：

    type Keys = "prop1" | "prop2"
    
    const obj: Record<Keys, string> = {
      prop1: "Hello",
      prop2: "Aloha",
      something: "anything" // TS Error: Type '{ prop1: string; prop2: string; something: string; }' is not assignable to type 'Record<Keys, string>'.
                            //   Object literal may only specify known properties, and 'something' does not exist in type 'Record<Keys, string>'.
    };
    

以及属性值的类型：

    type Keys = "prop1" | "prop2"
    type Value = "Hello" | "Aloha"
    
    const obj1: Record<Keys, Value> = {
      prop1: "Hello",
      prop2: "Hey", // TS Error: Type '"Hey"' is not assignable to type 'Value'.
    };

如果您尝试编写类型注释，语法为：

    var x: { property: string; } = { property: 'hello' };
    

如果您尝试编写对象文字，语法为：

    var x = { property: 'hello' };
    

您的代码尝试在值位置使用类型名称。

How to type definition in object literal in typescript

在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?

在TypeScript中，类型检查是自动发生的，并且是语言的核心特性之一。当你定义了一个`interface`，TypeScript会在编译时进行类型检查，以确保你遵守了该接口定义的结构。

举个例子来说，假设我们有以下的`interface`：

```typescript
interface IUser {
  name: string;
  age: number;
  isActive: boolean;
}
```

当你尝试创建一个`IUser`类型的对象时，TypeScript编译器会自动检查这个对象是否匹配`IUser`接口。例如：

```typescript
let user: IUser = {
  name: 'Alice',
  age: 30,
  isActive: true
};
```

在这个例子中，`user`对象遵循了`IUser`的结构，因此它会成功编译。但是，如果你尝试添加一个不在`interface`中的属性，或者遗漏了一个属性，TypeScript编译器会抛出一个错误：

```typescript
let user: IUser = {
  name: 'Bob',
  // 'age' 属性丢失将会导致编译错误
  isActive: true
};
```

会产生类似以下的错误：

```
Property 'age' is missing in type '{ name: string; isActive: boolean; }' but required in type 'IUser'.
```

除此以外，你还可以在函数中使用接口来进行类型检查。例如：

```typescript
function greetUser(user: IUser) {
  console.log(`Hello, ${user.name}!`);
}

greetUser({
  name: 'Charlie',
  age: 25,
  isActive: false
}); // 正确使用

greetUser({
  name: 'Dave'
  // 缺少其他属性将导致错误
});
```

对于函数`greetUser`，调用它时传入的参数需要符合`IUser`接口的结构，否则TypeScript编译器会提示错误。

总的来说，在TypeScript中，`interface`类型检查是静态的，发生在编译时，而不是运行时。编译器会根据你定义的接口来检查代码中的结构和类型，确保类型的正确性和一致性。这个特性在大型项目中特别有用，因为它可以在早期就发现潜在的错误和问题。

You can achieve what you want without the `instanceof` keyword as you can write custom type guards now:

    interface A {
        member: string;
    }
    
    function instanceOfA(object: any): object is A {
        return 'member' in object;
    }
    
    var a: any = {member: "foobar"};
    
    if (instanceOfA(a)) {
        alert(a.member);
    }
    

Lots of Members
===============

If you need to check a lot of members to determine whether an object matches your type, you could instead add a discriminator. The below is the most basic example, and requires you to manage your own discriminators... you'd need to get deeper into the patterns to ensure you avoid duplicate discriminators.

    interface A {
        discriminator: 'I-AM-A';
        member: string;
    }
    
    function instanceOfA(object: any): object is A {
        return object.discriminator === 'I-AM-A';
    }
    
    var a: any = {discriminator: 'I-AM-A', member: "foobar"};
    
    if (instanceOfA(a)) {
        alert(a.member);
    }

In TypeScript 1.6, [user-defined type guard](https://www.typescriptlang.org/docs/handbook/2/narrowing.html#using-type-predicates) will do the job.

    interface Foo {
        fooProperty: string;
    }
    
    interface Bar {
        barProperty: string;
    }
    
    function isFoo(object: any): object is Foo {
        return 'fooProperty' in object;
    }
    
    let object: Foo | Bar;
    
    if (isFoo(object)) {
        // `object` has type `Foo`.
        object.fooProperty;
    } else {
        // `object` has type `Bar`.
        object.barProperty;
    }
    

And just as Joe Yang mentioned: since TypeScript 2.0, you can even take the advantage of tagged union type.

    interface Foo {
        type: 'foo';
        fooProperty: string;
    }
    
    interface Bar {
        type: 'bar';
        barProperty: number;
    }
    
    let object: Foo | Bar;
    
    // You will see errors if `strictNullChecks` is enabled.
    if (object.type === 'foo') {
        // object has type `Foo`.
        object.fooProperty;
    } else {
        // object has type `Bar`.
        object.barProperty;
    }
    

And it works with `switch` too.

How about User-Defined Type Guards? [https://www.typescriptlang.org/docs/handbook/advanced-types.html](https://www.typescriptlang.org/docs/handbook/advanced-types.html)

    interface Bird {
        fly();
        layEggs();
    }
    
    interface Fish {
        swim();
        layEggs();
    }
    
    function isFish(pet: Fish | Bird): pet is Fish { //magic happens here
        return (<Fish>pet).swim !== undefined;
    }
    
    // Both calls to 'swim' and 'fly' are now okay.
    
    if (isFish(pet)) {
        pet.swim();
    }
    else {
        pet.fly();
    }

typescript 2.0 introduce tagged union

[Typescript 2.0 features](https://github.com/Microsoft/TypeScript/wiki/What's-new-in-TypeScript)

    interface Square {
        kind: "square";
        size: number;
    }
    
    interface Rectangle {
        kind: "rectangle";
        width: number;
        height: number;
    }
    
    interface Circle {
        kind: "circle";
        radius: number;
    }
    
    type Shape = Square | Rectangle | Circle;
    
    function area(s: Shape) {
        // In the following switch statement, the type of s is narrowed in each case clause
        // according to the value of the discriminant property, thus allowing the other properties
        // of that variant to be accessed without a type assertion.
        switch (s.kind) {
            case "square": return s.size * s.size;
            case "rectangle": return s.width * s.height;
            case "circle": return Math.PI * s.radius * s.radius;
        }
    }

Type guards in Typescript:
--------------------------

TS has **type guards** for this purpose. They define it in the following manner:

> Some expression that performs a runtime check that guarantees the type in some scope.

This basically means that the TS compiler can narrow down the type to a more specific type when it has sufficient information. For example:

    function foo (arg: number | string) {
        if (typeof arg === 'number') {
            // fine, type number has toFixed method
            arg.toFixed()
        } else {
            // Property 'toFixed' does not exist on type 'string'. Did you mean 'fixed'?
            arg.toFixed()
            // TSC can infer that the type is string because 
            // the possibility of type number is eliminated at the if statement
        }
    }
    

To come back to your question, we can also apply this concept of type guards to objects in order to determine their type. To define a type guard for objects, we need to define a function whose return type is a **type predicate**. For example:

    interface Dog {
        bark: () => void;
    }
    
    // The function isDog is a user defined type guard
    // the return type: 'pet is Dog' is a type predicate, 
    // it determines whether the object is a Dog
    function isDog(pet: object): pet is Dog {
      return (pet as Dog).bark !== undefined;
    }
    
    const dog: any = {bark: () => {console.log('woof')}};
    
    if (isDog(dog)) {
        // TS now knows that objects within this if statement are always type Dog
        // This is because the type guard isDog narrowed down the type to Dog
        dog.bark();
    }

How to check interface type with typescript

在命令行运行 TypeScript 文件需要几个步骤，我将一步一步详细解释这个过程。

### 第1步：安装Node.js

确保您的计算机上安装了Node.js。Node.js是一个JavaScript运行时，可以让您在服务器端运行JavaScript代码。如果您还没有安装Node.js，请前往官网下载并安装：

[Node.js官网](https://nodejs.org/)

### 第2步：安装TypeScript

通过命令行安装TypeScript编译器。使用npm（Node.js的包管理器）全局安装TypeScript可以使 `ts-node`命令在任何位置都可以使用。

```shell
npm install -g typescript
```

### 第3步：安装ts-node

`ts-node`是一个可以执行TypeScript文件并将它们直接在Node.js环境中运行的工具。它会在后台自动地调用TypeScript编译器将TypeScript代码转换成JavaScript代码，并立即执行转换后的代码。

```shell
npm install -g ts-node
```

### 第4步：编写TypeScript代码

在您喜欢的文本编辑器中创建一个新的TypeScript文件，例如 `example.ts`，并写入TypeScript代码。例如：

```typescript
// example.ts
function greet(person: string) {
  return "Hello, " + person + "!";
}

console.log(greet("world")); // 输出: Hello, world!
```

### 第5步：运行TypeScript文件

打开命令行工具，导航到包含 `example.ts`文件的目录，然后使用以下命令运行它：

```shell
ts-node example.ts
```

### 示例输出：

```plain
Hello, world!
```

`ts-node`会自动编译 `example.ts`文件到JavaScript，并在Node.js环境中执行。

以上就是在命令行中运行TypeScript文件的步骤。


> 我如何使用 Typescript 做同样的事情

您可以`tsc`使用以下命令在监视模式下运行`tsc -w -p .`，它将`.js`以实时方式为您生成文件，因此您可以`node foo.js`像平常一样运行

传输流节点
=====

有 ts-node ： https: [//github.com/TypeStrong/ts-node](https://github.com/TypeStrong/ts-node)它将动态编译代码并通过节点运行它 🌹

    npx ts-node src/foo.ts

运行以下命令并全局安装所需的包：

    npm install -g ts-node typescript '@types/node'
    

现在运行以下命令来执行打字稿文件：

    ts-node typescript-file.ts

我们有以下步骤：

1.  首先你需要安装打字稿
    
        npm install -g typescript
        
    
2.  创建一个文件 helloworld.ts
    
        function hello(person){
           return "Hello, " + person;
        }
        let user = "Aamod Tiwari";
        const result = hello(user);
        console.log("Result", result)
        
    
3.  打开命令提示符并键入以下命令
    
        tsc helloworld.ts
        
    
4.  再次运行命令
    
        node helloworld.js
        
    
5.  结果将显示在控制台上

你也可以试试tsx。tsx 是一个用于无缝运行 TypeScript 的 CLI 命令（替代 Node），它基于 esbuild 构建，因此速度非常快。

[https://github.com/esbuild-kit/tsx](https://github.com/esbuild-kit/tsx)

例子：

    npx tsx ./script.ts

要添加到上面的 @Aamod 答案，如果您想使用一个命令行来编译和运行代码，您可以使用以下命令：

视窗：

    tsc main.ts | node main.js
    

Linux / macOS：

    tsc main.ts && node main.js

所有问题