Git是一个由林纳斯·托瓦兹为了更好地管理linux内核开发而创立的分布式版本控制／软件配置管理软件。需要注意的是和GNU Interactive Tools，一个类似Norton Commander界面的文件管理器相区分。



文件`.gitignore`用于告诉 Git 应忽略哪些文件和文件夹。通常，这些文件是构建工件、临时文件或不属于存储库的其他类型的文件。Git 将忽略符合文件中模式的任何目录或文件`.gitignore`。

例子：

    # Ignore .DS_Store files
    .DS_Store
    
    # Ignore build artifacts
    build/
    
    # Ignore log files
    *.log
    

* * *

相反， `.gitkeep`Git 中使用文件来维护否则为空的目录。默认情况下，Git 不会跟踪空文件夹，因此`.gitkeep`如果您希望将文件保留在存储库中，则必须将文件添加到该目录。文件名比文件的实际内容更重要。

`.gitkeep`文件示例

    # This file is used to keep the directory empty in Git
    

* * *

总之。该`.gitignore`命令用于告诉 Git 要忽略哪些文件和文件夹。要维护一个否则为空的 Git 目录，请使用`.gitkeep`. 它们彼此不同并且具有不同的功能。

`.gitkeep`没有记录，因为它不是 Git 的功能。

Git[无法添加完全空的目录](https://git.wiki.kernel.org/index.php/Git_FAQ#Can_I_add_empty_directories.3F)。想要在 Git 中跟踪空目录的人已经创建了将调用的文件放入`.gitkeep`这些目录中的约定。该文件可以被命名为任何名称；Git 没有赋予这个名称特殊的意义。

有一个相互竞争的约定，`.gitignore`即向空目录添加文件以跟踪它们，但有些人认为这令人困惑，因为目标是保留空目录，而不是忽略它们；`.gitignore`还用于列出在查找未跟踪的文件时应被 Git 忽略的文件。

`.gitkeep`只是一个占位符。一个虚拟文件，因此 Git 不会忘记该目录，因为 Git 只跟踪文件。

---

如果您想要一个空目录并确保它对于 Git 保持“干净”，请创建一个 `.gitignore`包含以下行的目录：

```
# .gitignore sample
# Ignore all files in this dir...
*

# ... except for this one.
!.gitignore
```

如果您希望只有一种类型的文件对 Git 可见，下面是如何过滤除所有文件之外的 `.gitignore`所有内容的示例 `.txt`：

```
# .gitignore to keep just .txt files
# Filter everything...
*

# ... except the .gitignore...
!.gitignore

# ... and all text files.
!*.txt
```

.gitignore
    

是一个文本文件，包含目录中 git 将忽略或不在存储库中添加/更新的文件列表。

    .gitkeep
    

由于 Git 删除或不向存储库添加空目录，因此 .gitkeep 是一种在存储库中保留空目录的 hack（我不认为它被正式命名为 Git 的一部分）。

只需执行 a`touch /path/to/emptydirectory/.gitkeep`添加文件，Git 现在就可以在存储库中维护此目录。

许多人更喜欢使用，只是`.keep`因为该约定与 git 无关。

Gitignore 和 gitkeep 之间有什么区别

要更改某次提交记录的提交作者，可以使用`git commit --amend`命令来修改最近的提交，或者如果需要更改更早的提交，则可以使用`git rebase`命令。下面我会详细解释这两种情况的操作步骤。

### 使用`git commit --amend`

如果你要更改的是最近的提交，可以使用`git commit --amend`选项来重新指定提交作者。以下是操作步骤：

1. 打开命令行或终端。
2. 切换到需要更改提交作者的仓库目录。
3. 执行以下命令来更改最近一次提交的作者信息：

   ```sh
   git commit --amend --author="新作者名 <新作者邮箱>"
   ```
   
   例如，如果我要将作者更改为“John Doe”和他的邮箱“johndoe@example.com”，命令将是：

   ```sh
   git commit --amend --author="John Doe <johndoe@example.com>"
   ```

4. 这会打开一个文本编辑器，允许你修改提交信息。保存并关闭编辑器后，提交的作者信息将被更新。

请注意，这种方式会修改最后一次提交并创建一个新的提交哈希，所以如果您已经将提交推送到远程仓库，之后必须使用`git push --force`来覆盖远程仓库上的提交记录。

### 使用`git rebase`

如果需要更改较早的提交记录的作者，可以使用`git rebase`命令。这里是一个简化的例子：

1. 打开命令行或终端。
2. 切换到你的仓库目录。
3. 找出需要修改作者的提交的哈希值。可以使用`git log`查看提交历史。
4. 运行`git rebase`命令开始交互式变基操作：

   ```sh
   git rebase -i <哈希值的前一次提交>
   ```
   
   例如，如果哈希值是`abcd1234`，则命令将是：
   
   ```sh
   git rebase -i abcd1234^
   ```

5. 在打开的文本编辑器中，将要更改的提交前面的`pick`改为`edit`。
6. 保存并关闭编辑器。
7. 当rebasing到指定的提交时，执行以下命令来更改作者信息：

   ```sh
   git commit --amend --author="新作者名 <新作者邮箱>"
   ```

   使用相同的例子，“John Doe”的命令将是：

   ```sh
   git commit --amend --author="John Doe <johndoe@example.com>"
   ```

8. 完成作者信息的修改后，继续rebase进程：

   ```sh
   git rebase --continue
   ```

9. 如果有冲突，解决它们并使用`git add`将更改的文件标记为已解决。
10. 重新运行`git rebase --continue`直到rebase完成。

由于这将改变历史中每个后续提交的哈希值，如果这些提交已经被推送到远程仓库，你可能需要使用`git push --force`来更新远程仓库。

在执行这些操作时，请务必意识到，修改公共历史是一个危险的行为，因为它可以对其他协作者造成混淆和额外的工作。因此，这些操作应该只在确实必要，且仓库的其他协作者都同意的情况下进行。

从历史记录中比您需要修改的提交更早的点进行交互式变基 ( `git rebase -i <earliercommit>`)。在要重新设置基准的提交列表中，将文本从`pick`更改`edit`为要修改的哈希值旁边的文本。然后当 git 提示您更改提交时，请使用以下命令：

    git commit --amend --author="Author Name <email@address.com>" --no-edit
    

* * *

例如，如果您的提交历史记录是as `A-B-C-D-E-F`，并且您想更改和的作者，那么您会...`F``HEAD``C``D`

1.  指定`git rebase -i B`（这是执行[命令](https://help.github.com/articles/about-git-rebase/#an-example-of-using-git-rebase)[后您将看到的示例`git rebase -i B`](https://help.github.com/articles/about-git-rebase/#an-example-of-using-git-rebase)）
    *   如果您需要编辑`A`，请使用`git rebase -i --root`
2.  `C`将和`D`from`pick`的行更改为`edit`
3.  退出编辑器（对于 vim，这将是按 Esc，然后键入`:wq`）。
4.  一旦变基开始，它首先会暂停在`C`
5.  你会`git commit --amend --author="Author Name <email@address.com>"`
6.  然后`git rebase --continue`
7.  它会再次暂停在`D`
8.  然后你`git commit --amend --author="Author Name <email@address.com>"`又会
9.  `git rebase --continue`
10.  变基将完成。
11.  用于使用`git push -f`更新的提交来更新您的源。

这个问题的[公认答案](https://stackoverflow.com/a/3042512/3357935)是交互式变基的巧妙使用，但不幸的是，如果我们试图更改作者的提交曾经位于随后合并的分支上，那么它会出现冲突。更一般地说，它不起作用当处理混乱的历史记录时。

由于我担心运行依赖于设置和取消设置环境变量来重写 git 历史记录的脚本，因此我正在根据[这篇文章编写一个新答案，该答案与](https://help.github.com/articles/changing-author-info/)[此答案](https://stackoverflow.com/a/3404304/391161)类似，但更完整。

与链接的答案不同，以下内容经过测试并有效。为了清楚地说明起见，假设`03f482d6`我们正在尝试替换其作者的提交，并且`42627abe`是新作者的提交。

1.  检查我们正在尝试修改的提交：
    
         git checkout 03f482d6
        
    
2.  让作者改变：
    
         git commit --amend --author "New Author Name <New Author Email>"
        
    
    现在我们有了一个新的提交，哈希值假设为`42627abe`。
    
3.  查看原来的分支。
    
4.  在本地用新提交替换旧提交：
    
         git replace 03f482d6 42627abe
        
    
5.  根据替换重写所有未来的提交：
    
         git filter-branch -- --all
        
    
6.  取下替换件以保持清洁：
    
         git replace -d 03f482d6
        
    
7.  推新历史：
    
         git push --force-with-lease
        
    
    （仅在后者失败时使用`--force`，`--force-with-lease`并且仅在使用`git log`and/or进行健全性检查后使用`git diff`。）
    

您可以直接 rebase 到新的提交，而不是执行步骤 4-5：

    git rebase -i 42627abe

如果您只想更改**上次提交**的作者，您可以这样做：

*   重置当前存储库的作者：
    
    `git config --local user.name "Alex Smith"`
    
    `git config --local user.email alex@email.com`
    
*   现在重置提交的作者，无需编辑：
    
    `git commit --amend --reset-author --no-edit`
    
*   强制推送您的更改而不覆盖其他任何人的提交：
    
    `git push --force-with-lease`
    

请注意，这也会更改作者时间戳。

要对**最后 N 次提交**执行此操作：

`git rebase --onto HEAD~N --exec "git commit --amend --reset-author --no-edit" HEAD~N`

Github 文档包含[一个脚本，用于替换分支中所有提交的提交者信息](https://help.github.com/articles/changing-author-info/)（现在无法检索，这是[最后一个快照](https://web.archive.org/web/20200823163529/https://docs.github.com/en/github/using-git/changing-author-info#changing-the-git-history-of-your-repository-using-a-script)）。

更改变量值后从终端运行以下脚本

    #!/bin/sh
     
    git filter-branch --env-filter '
     
    OLD_EMAIL="your-old-email@example.com"
    CORRECT_NAME="Your Correct Name"
    CORRECT_EMAIL="your-correct-email@example.com"
    
    if [ "$GIT_COMMITTER_EMAIL" = "$OLD_EMAIL" ]
    then
        export GIT_COMMITTER_NAME="$CORRECT_NAME"
        export GIT_COMMITTER_EMAIL="$CORRECT_EMAIL"
    fi
    if [ "$GIT_AUTHOR_EMAIL" = "$OLD_EMAIL" ]
    then
        export GIT_AUTHOR_NAME="$CORRECT_NAME"
        export GIT_AUTHOR_EMAIL="$CORRECT_EMAIL"
    fi
    ' --tag-name-filter cat -- --branches --tags
    

将更正后的历史记录推送到 GitHub：

    git push --force --tags origin 'refs/heads/*'
    

或者，如果您想推送分支的选定引用，则使用

    git push --force --tags origin 'refs/heads/develop'

您可以使用以下命令更改上次提交的作者。

`git commit --amend --author="Author Name <email@address.com>"`

然而，如果你想更改多个提交的作者姓名，那就有点棘手了。您需要启动交互式变基，然后将提交标记为编辑，然后一一修改并完成。

1.  开始变基`git rebase -i`。
    
2.  `pick`将关键字更改`edit`为要更改作者姓名的提交。
    
3.  然后关闭编辑器。对于初学者，请点击`Escape`然后输入`:wq`并点击`Enter`。
    

然后你会看到你的终端就像什么都没发生一样。实际上，您正处于交互式变基过程中。现在是时候使用上面的命令修改提交的作者姓名了。它将再次打开编辑器。退出并继续使用 进行变基`git rebase --continue`。对要编辑的提交计数重复相同的操作。当您收到消息时，您可以确保交互式变基已完成`No rebase in progress?`。

在Git中，如果你想要更改单个提交的提交作者，你可以使用`git commit --amend --author="Author Name <email@example.com>"` 命令。但这只会影响最新的提交。如果你需要更改历史中特定的一个旧的提交，你可以使用`git rebase -i` 命令，然后选择要修改的提交，并使用`rebase`期间的`edit`功能。

下面是详细的步骤来更改一个旧的提交的作者：

1. 使用`git log`找到你想要更改的提交的哈希值。

2. 启动交互式变基操作，选择要修改的提交之前的一个提交作为基础。例如，如果你想要修改的提交哈希是`abc123`，则执行：

   ```sh
   git rebase -i abc123^
   ```

   注意：`^`表示选择这个哈希之前的提交，因为我们需要对这个特定的提交作出修改。

3. 在弹出的编辑器中，你会看到一系列提交列表。找到你想要修改的提交，将它前面的`pick`改为`edit`。

4. 保存并退出编辑器。Git现在将会暂停变基操作，并允许你修改那个特定的提交。

5. 现在你可以使用以下命令来更改提交的作者：

   ```sh
   git commit --amend --author="New Author Name <newauthor@example.com>" --no-edit
   ```

   `--no-edit`参数表示保持提交信息不变。如果你也想要编辑提交信息，可以省略这个参数。

6. 一旦完成，继续变基进程：

   ```sh
   git rebase --continue
   ```

   如果有冲突，解决冲突后需要用`git add`将文件标记为已解决，然后再次运行`git rebase --continue`。

7. 完成变基后，如果你更改的是已经推送到远程仓库的提交，你需要强制推送你的更改：

   ```sh
   git push origin branch_name --force
   ```

   或者，如果你是在共享分支上工作，可能更喜欢使用：

   ```sh
   git push origin branch_name --force-with-lease
   ```

   这种方法更安全一些，因为它会在远程分支有你本地不知道的新提交时防止推送。

请注意，更改历史提交，并且强制推送到远程仓库会重写共享的分支历史，这可能会对其他协作者造成影响。在进行这类操作前，最好和你的团队沟通，并确认这是一个可接受的操作。

Git 如何更改某一次提交的提交作者？

当您想要修改特定的提交时，Git 提供了一些工具来帮助您实现这个目的。以下是几种常见的方法：

### 1. `git commit --amend`
如果您刚刚做了一个提交，并且想要修改它（例如，修复一个打字错误、忘记添加一个文件、或者想要更改提交信息），您可以使用 `git commit --amend` 命令。这将打开一个编辑器，让您可以修改当前提交的信息，或者添加忘记的更改。

**例子**:
```bash
git commit --amend -m "新的提交信息"
```

### 2. `git rebase -i`
对于较早的提交，如果需要修改，您可以使用交互式变基(`git rebase -i`)。这会打开一个TODO列表，让您可以选择需要修改的提交。

**例子**:
```bash
git rebase -i HEAD~3  # 查看最近三个提交并选择编辑
```

在打开的编辑器中，将您想要修改的提交前面的 `pick` 改为 `edit`，然后保存退出。Git 将会停在您选择的那个提交，允许您做出修改。

```bash
# 修改文件并将它们添加到暂存区
git add .

# 使用 --amend 选项来修改提交
git commit --amend

# 继续变基过程
git rebase --continue
```

### 3. `git filter-branch`
如果需要修改很早以前的提交，或者做一些复杂的历史修改，可以使用 `git filter-branch` 命令。这是一个强大但复杂的工具，可以对历史中的多个提交进行修改。

**例子**:
```bash
git filter-branch --env-filter '
OLD_EMAIL="your-old-email@example.com"
CORRECT_NAME="Your Correct Name"
CORRECT_EMAIL="your-correct-email@example.com"

if [ "$GIT_COMMITTER_EMAIL" = "$OLD_EMAIL" ]
then
    export GIT_COMMITTER_NAME="$CORRECT_NAME"
    export GIT_COMMITTER_EMAIL="$CORRECT_EMAIL"
fi
if [ "$GIT_AUTHOR_EMAIL" = "$OLD_EMAIL" ]
then
    export GIT_AUTHOR_NAME="$CORRECT_NAME"
    export GIT_AUTHOR_EMAIL="$CORRECT_EMAIL"
fi
' --tag-name-filter cat -- --branches --tags
```

### 警告
修改已经提交到公共仓库的历史是一个危险的操作，因为它会改变历史中的提交ID（SHA-1哈希）。如果其他人已经基于这些提交做了工作，他们将不得不处理合并冲突或重新基于新的历史。因此，在修改公共仓库的历史之前，请确保这是必要的，并且您已经通知了所有相关的合作伙伴。

在每一种情况下，都要确保您对 Git 有足够的了解，以避免数据丢失。在执行任何修改历史的操作之前，最好是先备份您的仓库。

使用[`git rebase`](https://www.atlassian.com/git/tutorials/rewriting-history/git-rebase)。例如，要修改 commit `bbc643cd`，请运行：

    git rebase --interactive bbc643cd~
    

`~`请注意命令末尾的波形符，因为您需要在上一次提交的基础上重新应用提交`bbc643cd`（即`bbc643cd~`）。

在默认编辑器中，在提到 的行中修改`pick`为。`edit``bbc643cd`

保存文件并退出。git 会解释并自动执行文件中的命令。您会发现自己处于刚刚创建 commit 的先前情况`bbc643cd`。

此时，`bbc643cd`这是您的最后一次提交，您可以[轻松修改它](https://www.atlassian.com/git/tutorials/rewriting-history#git-commit--amend)。进行更改，然后使用以下命令提交它们：

    git commit --all --amend --no-edit
    

之后，使用以下命令返回到之前的 HEAD 提交：

    git rebase --continue
    

**警告：请注意，这将更改该提交****以及所有子**提交的 SHA-1——换句话说，这将重写从该点开始的历史记录。如果使用命令进行推送，则[可以中断存储库执行此操作](https://stackoverflow.com/a/3926832/1269037)`git push --force`。

使用很棒的交互式变基：
-----------

    git rebase -i    # Show your commits in a text editor
    

找到所需的提交，更改`pick`为`e`( `edit`)，然后保存并关闭文件。Git 将回退到该提交，允许您：

*   用于`git commit --amend`进行更改，或
*   用于`git reset @~`放弃最后一次提交，但不放弃对文件的更改（即带您到编辑文件但尚未提交时所在的位置）。

后者对于执行更复杂的操作（例如拆分为多个提交）很有用。

然后，运行`git rebase --continue`，Git 将在修改后的提交之上重播后续更改。可能会要求您修复一些合并冲突。

_注意：`@`是 的简写`HEAD`，`~`是指定提交之前的提交。_

_在 Git 文档中阅读有关[重写历史的更多信息。](https://git-scm.herokuapp.com/book/en/v2/Git-Tools-Rewriting-History)_

  

不要害怕重新建立基础
----------

专业提示™：不要害怕尝试重写历史记录的“危险”命令\* — 默认情况下，Git 在 90 天内不会删除您的提交；你可以在转发日志中找到它们：

    $ git reset @~3   # go back 3 commits
    $ git reflog
    c4f708b HEAD@{0}: reset: moving to @~3
    2c52489 HEAD@{1}: commit: more changes
    4a5246d HEAD@{2}: commit: make important changes
    e8571e4 HEAD@{3}: commit: make some changes
    ... earlier commits ...
    $ git reset 2c52489
    ... and you're back where you started
    

\*_注意诸如`--hard`和`--force`等选项 - 它们可能会丢弃数据。_  
\* _另外，不要重写您正在协作的任何分支上的历史记录。_

  

* * *

在许多系统上，`git rebase -i`会默认打开 Vim。Vim 的工作方式与大多数现代文本编辑器不同，因此请了解[如何使用 Vim 进行变基](https://stackoverflow.com/a/28421811/405550)。如果您想使用其他编辑器，请将其更改为`git config --global core.editor your-favorite-text-editor`.

当我需要更深入地修复历史记录中的先前提交时，我经常使用交互式[变基](http://git-scm.com/docs/git-rebase)。`--autosquash`它本质上加速了 ZelluX 的答案所说明的过程，并且当您需要编辑多个提交时特别方便。

从文档中：

> `--autosquash`
> 
> 当提交日志消息以“squash！…​”（或“fixup！…​”）开头，并且存在标题以相同…​开头的提交时，自动修改rebase -i的todo列表，以便该提交标记为压缩发生在要修改的提交之后

假设您有这样的历史记录：

    $ git log --graph --oneline
    * b42d293 Commit3
    * e8adec4 Commit2
    * faaf19f Commit1
    

并且您有想要修改为 Commit2 的更改，然后使用以下命令提交更改

    $ git commit -m "fixup! Commit2"
    

或者，您可以使用 commit-sha 代替提交消息，甚至`"fixup! e8adec4`只是提交消息的前缀。

然后在之前的提交上启动交互式变基

    $ git rebase e8adec4^ -i --autosquash
    

您的编辑器将打开并显示已正确排序的提交

    pick e8adec4 Commit2
    fixup 54e1a99 fixup! Commit2
    pick b42d293 Commit3
    

您所需要做的就是保存并退出

基于[文档](https://help.github.com/articles/changing-a-commit-message/)

**修改较旧的消息或多个提交消息**

    git rebase -i HEAD~3 
    

上面显示了当前分支上最近 3 次提交的列表，如果需要更多，请将 3 更改为其他内容。该列表将类似于以下内容：

    pick e499d89 Delete CNAME
    pick 0c39034 Better README
    pick f7fde4a Change the commit message but push the same commit.
    

在要更改的每个提交消息之前将**pick**替换为**reword 。**假设您更改列表中的第二个提交，您的文件将如下所示：

    pick e499d89 Delete CNAME
    reword 0c39034 Better README
    pick f7fde4a Change the commit message but push the same commit.
    

保存并关闭提交列表文件，这将弹出一个新的编辑器供您更改提交消息，更改提交消息并保存。

最后，强制推送修改后的提交。

    git push --force

### 修改特定提交的步骤

1. **定位提交**: 首先，我们需要找到要修改的提交。可以通过 `git log`命令查看提交历史，确定要修改的提交的哈希值。
2. **交互式变基**: 使用 `git rebase -i`命令进行交互式变基。该命令将打开一个文本编辑器，列出待选的提交列表。这需要指定基底提交的哈希值或使用 `HEAD`的相对引用，例如 `HEAD~3`表示当前分支最后三个提交。
3. **挑选提交**: 在交互式变基的列表中，找到要修改的提交，并将该行前的命令从 `pick`改为 `edit`。然后保存并退出编辑器，Git将暂停在那个提交上，允许你进行更改。
4. **修改提交**: 在此步骤中，可以进行所需的文件更改。完成后，使用 `git add`命令将这些更改加入暂存区。
5. **应用修改**: 使用 `git commit --amend`命令来修改那个提交。可以在此时修改提交信息，或者保留原始提交信息。
6. **继续变基操作**: 更改完成并提交后，使用 `git rebase --continue`来继续之前的变基操作。Git将应用剩余的提交。
7. **处理冲突**: 如果在变基过程中遇到冲突，需要手动解决冲突，然后使用 `git add`命令标记为已解决。之后再次使用 `git rebase --continue`。
8. **完成变基**: 一旦所有的冲突都解决了，且所有的提交都被顺利地应用，变基操作就完成了。

### 注意事项

- **不要在公共分支上修改历史**：修改已经推送到远程且被他人使用的分支的提交历史是非常危险的做法，因为它会改变历史，需要其他人进行强制拉取（`git pull --force`）。
- **备份分支**：在进行变基之前，建议创建一个备份分支，以便发生错误时可以恢复到原始状态。

### 实战示例

假如我在工作中修复了一个bug，并提交了这个更改。但之后我发现提交消息写错了，或者我忘记了把一些重要的改动加入到提交中，我就需要对这个提交进行修改。以下是我具体操作的一个例子：

```shell
# 查看提交历史，找到要修改的提交的哈希值
git log

# 假设要修改的提交是3个提交前的那个
git rebase -i HEAD~3

# 这会打开一个文本编辑器，我会将要修改的提交行前的指令从'pick'改为'edit'
# 保存退出编辑器之后，Git会停在那个提交上

# 做必要的文件修改
# ...

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

# 修改提交信息或者保留原来的提交信息
git commit --amend

# 继续变基过程
git rebase --continue

# 解决可能出现的任何冲突，并继续
# ...

# 变基完成
```

通过这样的步骤，我可以修改特定的提交，并确保项目的历史保持清晰和有序。

Git 如何修改特定的提交

当在 Git 中遇到合并冲突时，如果您决定不继续完成合并过程，并希望中止合并，您可以使用以下命令来重置合并状态：

```bash
git merge --abort
```

或者，在某些旧版本的 Git 中，您可能需要使用:

```bash
git reset --merge
```

使用 `git merge --abort` 命令将会恢复到合并操作之前的状态，并尝试重建合并操作开始前的文件和索引的状态。

如果合并之前您的工作目录是干净的（没有未提交的改动），那么 `git merge --abort` 就会让您的工作目录回到合并操作之前完全一样的状态。如果合并操作之前有未提交的改动，那些改动依然会保留在工作目录中，但可能需要手动解决任何因合并操作引入的冲突。

例如，假设我在 `feature` 分支上开发了一项新功能，现在我想将这些改动合并到 `master` 分支。当我运行 `git merge feature` 时，我遇到了冲突。我意识到现在不是解决这些冲突的好时机，或者我决定采取不同的策略来整合这些变更，因此我决定中止合并。我就会运行 `git merge --abort`，这样我就可以回到合并之前的状态，重新考虑我的合并策略。

由于您`pull`不成功，那么`HEAD`(not `HEAD^`) 是您分支上的最后一个“有效”提交：

    git reset --hard HEAD
    

您想要的另一部分是让他们的更改覆盖您的更改。

旧版本的 git 允许您使用“他们的”合并策略：

    git pull --strategy=theirs remote_branch
    

[但正如Junio Hamano](http://marc.info/?l=git&m=121637513604413&w=2)（Git 维护者）在本消息中所解释的那样，此内容已被删除。[正如链接](http://marc.info/?l=git&m=121637513604413&w=2)中所述，您可以这样做：

    git fetch origin
    git reset --hard origin

如果您的 git 版本 >= 1.6.1，则可以使用`git reset --merge`.

另外，正如 @Michael Johnson 提到的，如果你的 git 版本 >= 1.7.4，你也可以使用`git merge --abort`.

与往常一样，请确保在开始合并之前没有未提交的更改。

来自[git merge 手册页](https://www.kernel.org/pub/software/scm/git/docs/git-merge.html)

`git merge --abort`相当于`git reset --merge`何时`MERGE_HEAD`存在。

`MERGE_HEAD`当合并正在进行时出现。

另外，关于开始合并时未提交的更改：

如果您不想在开始合并之前提交更改，只需`git stash`在合并之前以及`git stash pop`完成合并或中止合并之后提交即可。

git merge --abort
    

> 中止当前的冲突解决过程，并尝试重建合并前的状态。
> 
> 如果合并开始时存在未提交的工作树更改，`git merge --abort`则在某些情况下将无法重建这些更改。因此，建议在运行 git merge 之前始终提交或存储更改。
> 
> `git merge --abort`相当于`git reset --merge`何时 `MERGE_HEAD`存在。

[http://www.git-scm.com/docs/git-merge](http://www.git-scm.com/docs/git-merge)

我想这是`git reset`你需要的。

请注意，这`git revert`意味着非常不同的东西，例如，`svn revert`在 Subversion 中，恢复将丢弃您的（未提交的）更改，将文件从存储库返回到当前版本，而`git revert`“撤消”提交。

`git reset`应该做相当于 的事情`svn revert`，即放弃不需要的更改。

对于 git >= 1.6.1：

    git merge --abort
    

对于旧版本的 git，这可以完成工作：

    git reset --merge
    

或者

    git reset --hard

Git 合并冲突过程中如何中止合并进度？

`git add -A` 和 `git add .` 在许多情况下的表现是相似的，但它们在某些特定的git版本和情境下会有不同的行为。下面是它们的主要区别：

- `git add -A`：这个命令是 `git add --all` 的缩写，它会添加所有在工作目录中的变更到暂存区（staging area），包括文件的添加、修改和删除。这个操作会影响整个仓库。

- `git add .`：这个命令只会添加当前目录及其子目录中的新文件和修改过的文件到暂存区，并不会添加删除的文件。这个操作只影响当前目录和子目录。

在较新的Git版本中（比如从2.0版本开始），`git add .` 和 `git add -A` 在执行时几乎是等效的，因为 `git add .` 也会包括删除的文件。但是，`git add .` 的作用范围仅限于当前目录，而 `git add -A` 可以在仓库中任何位置执行，它会影响整个仓库。

简而言之，如果你想确保包括所有类型的变更（添加、修改、删除）并且希望这种添加操作适用于整个仓库，使用 `git add -A` 是比较安全的选择。如果你只关心当前目录及其子目录的变更，可以使用 `git add .`。在使用时，确保理解你正在使用的Git版本的行为，因为这可能影响命令的准确行为。

_此答案仅适用于**Git 版本 1.x**。对于 Git 版本 2.x，请参阅其他答案。_

* * *

**概括：**

*   `git add -A`阶段**所有变化**
    
*   `git add .`暂存新文件和修改，**但不删除**（在当前目录及其子目录上）。
    
*   `git add -u`阶段修改和删除，**无需新文件**
    

* * *

**细节：**

`git add -A`相当于 `git add .; git add -u`.

重要的一点`git add .`是，它会查看工作树，并将所有这些路径添加到暂存的更改（如果它们已更改或是新的且未被忽略），它不会暂存任何“rm”操作。

`git add -u`查看所有_已_跟踪的文件，如果这些文件不同或已被删除，则暂存对这些文件的更改。它不会添加任何新文件，它只会暂存对已跟踪文件的更改。

`git add -A`是执行这两项操作的便捷捷径。

您可以使用类似以下内容测试差异（请注意，对于 Git 版本 2.x，您的输出`git add .` `git status` **将**有所不同）：

    git init
    echo Change me > change-me
    echo Delete me > delete-me
    git add change-me delete-me
    git commit -m initial
    
    echo OK >> change-me
    rm delete-me
    echo Add me > add-me
    
    git status
    # Changed but not updated:
    #   modified:   change-me
    #   deleted:    delete-me
    # Untracked files:
    #   add-me
    
    git add .
    git status
    
    # Changes to be committed:
    #   new file:   add-me
    #   modified:   change-me
    # Changed but not updated:
    #   deleted:    delete-me
    
    git reset
    
    git add -u
    git status
    
    # Changes to be committed:
    #   modified:   change-me
    #   deleted:    delete-me
    # Untracked files:
    #   add-me
    
    git reset
    
    git add -A
    git status
    
    # Changes to be committed:
    #   new file:   add-me
    #   modified:   change-me
    #   deleted:    delete-me

### Git 版本 1.x

命令

新文件

修改文件

已删除的文件

描述

`git add -A`

✔️

✔️

✔️

暂存所有（新的、修改的、删除的）文件

`git add .`

✔️

✔️

❌

仅在当前文件夹中暂存新文件和修改后的文件

`git add -u`

❌

✔️

✔️

仅阶段修改和删除的文件

### Git 版本 2.x

命令

新文件

修改文件

已删除的文件

描述

`git add -A`

✔️

✔️

✔️

暂存所有（新的、修改的、删除的）文件

`git add .`

✔️

✔️

✔️

暂存当前文件夹中的所有（新的、修改的、删除的）文件

`git add --ignore-removal .`

✔️

✔️

❌

仅暂存新文件和修改后的文件

`git add -u`

❌

✔️

✔️

仅阶段修改和删除的文件

### 长格式标志：

*   `git add -A`相当于`git add --all`
*   `git add -u`相当于`git add --update`

### 进一步阅读：

*   [Git 初学者：权威的实用指南](https://stackoverflow.com/q/315911/12860895)
*   [学习 Git 的资源](https://try.github.io)
*   [学习 Git 分支](https://learngitbranching.js.org)
*   [用 D3 解释 Git](https://onlywei.github.io/explain-git-with-d3)

对于[**Git 2.0，`git add -A`默认值是：`git add .`equals`git add -A .`**](https://github.com/git/git/blob/f99a38c0121456822f8a9dfb7928eefceaa98201/Documentation/RelNotes/2.0.0.txt#L32-L36)。

> `git add <path>`与现在的“ ”相同`git add -A <path>`，这样“ `git add dir/`”就会注意到您从目录中删除的路径并记录删除情况。  
> 在旧版本的 Git 中，“ `git add <path>`”忽略了删除。
> 
> 如果您确实愿意，可以说“ `git add --ignore-removal <path>`”仅在 中添加添加或修改的路径。`<path>`

`git add -A`就像`git add :/`（[添加顶部 git repo 文件夹中的所有内容](https://stackoverflow.com/a/31951899/6309)）。  
请注意，git 2.7（2015 年 11 月）将允许您添加名为“ `:`”的文件夹！  
请参阅[Junio C Hamano (](https://github.com/gitster) [)的](https://github.com/gitster)[提交 29abb33](https://github.com/git/git/commit/29abb33978f713cd0a5cc3687bf61077b0928840)（2015 年 10 月 25 日）。 [`gitster`](https://github.com/gitster)

* * *

请注意，[从 git 2.0（2014 年第一季度或第二季度）开始](https://github.com/git/git/blob/master/Documentation/RelNotes/1.8.3.txt#L19-L30)，在谈论**`git add .`**（工作树中的当前路径）时，您也必须`.`在其他命令中使用“” 。`git add`

这意味着：

> “ `git add -A .`”相当于“ `git add .; git add -u .`”

（注意和的额外“ `.`” ）`git add -A``git add -u`

因为`git add -A`or会在**整个工作树上**`git add -u`操作（仅从 git 2.0 开始），而不仅仅是在当前路径上。

> 这些命令将对**Git 2.0 中的整个树进行操作，以与“ `git commit -a`”和其他命令**保持一致。因为没有机制可以使“ `git add -u`”表现得像“ `git add -u .`”，所以对于那些习惯“ `git add -u`”（没有路径规范）仅更新当前子目录中路径的索引的人来说，开始训练他们的手指明确地说“是很重要的” `git add -u .`“在 Git 2.0 到来之前他们就是这么想的。
> 
> **当这些命令在没有路径规范的情况下运行以及在当前目录之外进行本地更改时，会发出警告，**因为在这种情况下，Git 2.0 中的行为将与今天的版本不同。

根据[查尔斯的指示](https://stackoverflow.com/questions/572549/difference-between-git-add-a-and-git-add/572660#572660)，经过测试，我提出的理解如下：

    # For the next commit
    $ git add .   # Add only files created/modified to the index and not those deleted
    $ git add -u  # Add only files deleted/modified to the index and not those created
    $ git add -A  # Do both operations at once, add to all files to the index
    

这篇博文也可能有助于了解在什么情况下可以应用这些命令：_[从 Git 工作目录中删除已删除的文件](http://www.geekgumbo.com/2010/05/16/removing-deleted-files-from-your-git-working-directory/)_。

_在 2.0 中不再如此。`add .`等于`add -A`同一路径，唯一的区别是树的其他路径中是否有新文件_

`git add -A` 和 `git add .` 在许多情况下的表现是相似的，但它们在某些特定的git版本和情境下会有不同的行为。下面是它们的主要区别：

* `git add -A`：这个命令是 `git add --all` 的缩写，它会添加所有在工作目录中的变更到暂存区（staging area），包括文件的添加、修改和删除。这个操作会影响整个仓库。
* `git add .`：这个命令只会添加当前目录及其子目录中的新文件和修改过的文件到暂存区，并不会添加删除的文件。这个操作只影响当前目录和子目录。

在较新的Git版本中（比如从2.0版本开始），`git add .` 和 `git add -A` 在执行时几乎是等效的，因为 `git add .` 也会包括删除的文件。但是，`git add .` 的作用范围仅限于当前目录，而 `git add -A` 可以在仓库中任何位置执行，它会影响整个仓库。

简而言之，如果你想确保包括所有类型的变更（添加、修改、删除）并且希望这种添加操作适用于整个仓库，使用 `git add -A` 是比较安全的选择。如果你只关心当前目录及其子目录的变更，可以使用 `git add .`。在使用时，确保理解你正在使用的Git版本的行为，因为这可能影响命令的准确行为。

Git add a 和 git add 有什么区别？

当您想要将本地的 Git 标签（tag）推送到远程仓库时，您可以使用 `git push` 命令来完成这个操作。这里有两种主要的情况：一种是推送单个标签，另一种是推送多个标签。下面我会详细解释这两种情况的操作方法。

### 推送单个标签到远程仓库

假设您已经创建了一个本地标签 `v1.0`，如果要将这个标签推送到远程仓库，您可以使用以下命令：

```shell
git push origin v1.0
```

这里，`origin` 是远程仓库的默认名称，`v1.0` 是您要推送的标签名称。执行这个命令后，标签 `v1.0` 就会被推送到远程仓库中。

### 推送所有本地新建的标签到远程仓库

如果您想要一次性推送所有本地新建的标签到远程仓库，可以使用：

```shell
git push origin --tags
```

这条命令会推送所有本地新建的标签到 `origin` 远程仓库。需要注意的是，这个命令不会推送已经删除的标签。

### 示例

假设您正在进行一个项目的版本发布，您创建了一个名为 `v2.0` 的标签来标记这个发布版本：

```shell
git tag v2.0
```

创建标签后，您确认这个标签可以被推送到远程仓库与团队共享：

```shell
git push origin v2.0
```

这样，您的团队成员就可以通过拉取远程标签来获取这个特定的项目快照了。

如果您的团队采取了版本号策略，并且您有一系列的标签（比如 `v1.1`, `v1.2`, `v2.0` 等）需要一起推送，那么您可能会选择推送所有标签：

```shell
git push origin --tags
```

以上就是如何将 Git 标签推送到远程存储库的方法


推送**单个**标签：

    git push origin <tag_name>
    

以下命令应推送**所有**标签（**不推荐**）：

    # not recommended
    git push --tags

**`git push --follow-tags`**

这是 Git 1.8.3 中引入的一个明智的选项：

    git push --follow-tags
    

它推送两个提交，并且仅推送同时满足以下条件的标签：

*   带注释的
*   从推送的提交中可以到达（祖先）

这是明智的，因为：

*   您应该只将带注释的标签推送到远程，并保留轻量级标签用于本地开发，以避免标签冲突。另请参阅：[带注释的标签和未注释的标签有什么区别？](https://stackoverflow.com/questions/11514075)
*   它不会将带注释的标签推送到不相关的分支上

正是出于这些原因，`--tags`应该避免。

Git 2.4[添加了](https://github.com/git/git/commit/61ca378275e83c48343c74a849ff0dcdef9abc91)`push.followTags`默认打开该标志的选项，您可以使用以下命令进行设置：

    git config --global push.followTags true
    

或者添加`followTags = true`到文件`[push]`的部分`~/.gitconfig`。

### 视觉工作室代码

`"git.followTagsWhenSync": true`要在 Visual Studio Code 中激活此功能，请根据用户或工作区设置变量。[GitHub](https://github.com/microsoft/vscode/issues/103281)

要推送特定内容，一个标签执行以下操作 `git push origin tag_name`

为了扩展[Trevor 的答案](https://stackoverflow.com/a/5195913/456814)，您可以一次推送单个标签或所有标签。

推送单个标签
------

    git push <remote> <tag>
    

[这是解释这一点的相关文档](https://www.kernel.org/pub/software/scm/git/docs/git-push.html)的摘要（为简洁起见，省略了一些命令选项）：

>     git push [[<repository> [<refspec>…]]
>     
>     <refspec>...
>     
> 
> 参数的格式`<refspec>`是...源 ref `<src>`，后跟冒号`:`，然后是目标 ref `<dst>`...
> 
> 告诉`<dst>`远程端的哪个引用通过此推送进行更新...如果`:<dst>`省略，`<src>`则将更新相同的引用...
> 
> 标签的`<tag>`含义与 相同`refs/tags/<tag>:refs/tags/<tag>`。

一次推送所有标签
--------

    git push --tags <remote>
    # Or
    git push <remote> --tags
    

[以下是相关文档](https://www.kernel.org/pub/software/scm/git/docs/git-push.html)的摘要（为简洁起见，省略了一些命令选项）：

>     git push [--all | --mirror | --tags] [<repository> [<refspec>…]]
>     
>     --tags
>     
> 
> `refs/tags`除了命令行上明确列出的参考规范之外，所有参考文献都会被推送。

在当前分支中添加标签。如果您想为您的 master 创建标签，请首先签出 master。

    git tag tag_name
    

检查是否创建

    git tag
    

推入您的远程源

    git push origin tag_name

Git 如何将 tag 推送到远程存储库？

如何列出提交中的所有文件？,要列出一个 Git 提交中的所有文件，你可以使用 `git show` 命令结合 `--name-only` 或者 `--name-status` 选项。这里是如何操作的：

1. 使用 `--name-only` 选项：

```sh
git show --name-only <commit-hash>
```

`<commit-hash>` 是你想要查看的提交的哈希值。这个命令会列出那个提交中更改（包括添加和删除）的所有文件名。

2. 使用 `--name-status` 选项：

```sh
git show --name-status <commit-hash>
```

这个命令不仅会列出文件名，还会显示每个文件的状态，比如 `M` 代表修改（Modified），`A` 代表添加（Added），`D` 代表删除（Deleted）。

如果你只是想要获得文件列表，而不想看到提交的其他信息（比如 diff 或者提交信息），你可以使用 `--pretty=format:` 来避免打印提交的其他信息：

```sh
git show --pretty=format: --name-only <commit-hash>
```

或者：

```sh
git show --pretty=format: --name-status <commit-hash>
```

如果你不知道提交的哈希值，但是知道是最近的提交，你可以使用 `HEAD` 指向最新的提交，或者使用 `HEAD~1` 来表示最新提交的前一个提交，以此类推。例如，列出最近提交中的所有文件：

```sh
git show --pretty=format: --name-only HEAD
```

此外，如果你想要查看某个特定分支或标签中最后一次提交修改了哪些文件，你可以将分支名或标签名替换 `HEAD`。例如，查看名为 `feature-branch` 的分支的最后一次提交：

```sh
git show --pretty=format: --name-only feature-branch
```

使用这些方法，你可以很容易地查看 Git 提交中包含的所有文件。

**首选方式**（因为它是一个_管道_命令；旨在编程）：

    $ git diff-tree --no-commit-id --name-only bd61ad98 -r
    index.html
    javascript/application.js
    javascript/ie6.js
    

**另一种方式**（对于脚本来说不太受欢迎，因为它是一个_瓷器_命令；意味着面向用户）

    $ git show --pretty="" --name-only bd61ad98    
    index.html
    javascript/application.js
    javascript/ie6.js
    

* * *

*   抑制`--no-commit-id`提交 ID 输出。
*   该`--pretty`参数指定一个空格式字符串以避免开头出现混乱。
*   该`--name-only`参数仅显示受影响的文件名（感谢 Hank）。`--name-status`如果您想查看每个文件发生了什么（**删除**、**修改**、**添加**） ，请改为使用
*   参数`-r`是递归到子树

如果你想获取已更改文件的列表：

    git diff-tree --no-commit-id --name-only -r <commit-ish>
    

如果你想获取一次提交中所有文件的列表，你可以使用

    git ls-tree --name-only -r <commit-ish>

我只是假设这[`gitk`](https://git-scm.com/docs/gitk)不是我们所希望的。在这种情况下，请尝试`git show --name-only <sha>`。

**我个人将--stat**和**\--oneline**与**show**命令结合使用：

    git show --stat --oneline HEAD
    git show --stat --oneline b24f5fb
    git show --stat --oneline HEAD^^..HEAD
    

如果您不喜欢/想要添加/删除统计信息，可以将**\--stat**替换为**\--name-only**

    git show --name-only --oneline HEAD
    git show --name-only --oneline b24f5fb
    git show --name-only --oneline HEAD^^..HEAD

你也可以做

    git log --name-only
    

您可以浏览各种提交、提交消息和更改的文件。

输入 q 即可恢复提示。

Git 如何列出提交中的所有文件？

当您在Git中工作时，有时会发现自己在错误的分支上进行了一些更改，或者决定您的修改应该在新的分支上进行，以保持主分支的清洁或为了其他原因。幸运的是，Git提供了灵活性，允许您将尚未提交的更改移至新的分支。以下是步骤：

1. **检查当前更改**：
   在移动更改之前，您应该查看当前工作目录和暂存区的状态。可以使用以下命令：
   ```
   git status
   ```
   这将显示当前更改的状态，无论是已经暂存(staged)还是尚未暂存(unstaged)。

2. **创建并切换到新分支**：
   如果您已经暂存了更改，首先应该将这些更改取消暂存（如果您希望这些更改也被移动到新分支）。然后，创建并切换到新分支，可以使用以下命令：
   ```
   git checkout -b new-branch-name
   ```
   这个命令会创建一个名为 `new-branch-name` 的新分支，并切换到那个分支。

3. **添加和提交更改**：
   现在您已经在新分支上，可以添加并提交您的更改。使用以下命令来添加所有更改到暂存区：
   ```
   git add .
   ```
   或者，如果您想要添加特定文件，可以使用：
   ```
   git add <file-path>
   ```
   接下来，将更改提交到您的新分支：
   ```
   git commit -m "Commit message explaining the changes"
   ```

4. **（可选）保持主分支清洁**：
   如果您刚才从主分支（比如说 `main` 或 `master`）上创建了新分支，并且不想让这些更改出现在主分支上，您可以切回主分支并撤消这些更改。首先，切换回主分支：
   ``` 
   git checkout main
   ```
   然后，使用以下命令来撤销未提交的更改：
   ```
   git reset --hard
   ```
   这将重置主分支，将其恢复到最后一次提交的状态，丢弃所有未提交的更改。请注意，这是一个危险的操作，因为它会丢弃所有未提交的更改。在使用 `git reset --hard` 之前，请确保您不需要这些未提交的更改。

这就是将未提交的工作移动到新分支的基本过程。 让我们看一个具体的例子：

假设您正在主分支 `main` 上工作，并且进行了一些更改，现在您想要将这些更改移到一个新的分支 `feature-x`。

1. 检查更改:
   ```sh
   git status
   ```
2. 创建并切换到新分支 `feature-x`:
   ```sh
   git checkout -b feature-x
   ```
3. 添加所有更改并提交它们到新分支:
   ```sh
   git add .
   git commit -m "Start working on feature X"
   ```
4. 如果需要，切换回 `main` 分支并撤销更改:
   ```sh
   git checkout main
   git reset --hard
   ```

现在，新分支 `feature-x` 包含了之前未提交的工作，而 `main` 分支保持不变。

### 2020 更新/Git 2.23

Git 2.23 添加了新的[`switch`](https://git-scm.com/docs/git-switch)子命令，试图消除由于超载使用[`checkout`](https://git-scm.com/docs/git-checkout)（切换分支、恢复文件、分离 HEAD 等）而产生的一些混乱。

从此版本的 Git 开始，将 checkout 命令替换为：

    git switch -c <new-branch>
    

行为是相同的并且保持不变。

* * *

### 2020 年更新之前/Git 2.23

使用以下内容：

    git checkout -b <new-branch>
    

这将使您当前的分支保持原样，创建并签出一个新分支并保留所有更改。然后，您可以暂存要提交的文件中的更改：

    git add <files>
    

并承诺您的_新分支_：

    git commit -m "<Brief description of this commit>"
    

工作目录中的更改和索引中暂存的更改_尚不属于任何分支_。这会更改这些修改结束的分支。

您无需_重置_原始分支，它会保持原样。最后一次提交`<old-branch>`仍然是相同的。因此你`checkout -b`然后承诺。

将当前更改保存到临时存储中：

1. `$ git stash`
2. 基于此存储创建一个新分支，并切换到新分支：

   `$ git stash branch <new-branch> stash@{0}`

提示：使用 Tab 键来减少输入存储名称。

**如果您在编码时一直**在主分支上进行提交，但现在想要将这些提交移动到不同的分支，这是一种快速方法：

1.  将当前历史记录复制到新分支，同时也带来所有未提交的更改：
    
         git checkout -b <new-feature-branch>
        
    
2.  现在强制原来的“混乱”分支回滚：（不切换到它）
    
         git branch -f <previous-branch> <earlier-commit-id>
        
    
    例如：
    
         git branch -f master origin/master
        
    
    或者如果您已进行 4 次提交：
    
         git branch -f master HEAD~4
        
    

_**警告：**_ `git branch -f master origin/master`将_重置该分支的跟踪信息_。因此，如果您将`master`分支配置为推送到其他地方，`origin/master`那么该配置将会丢失。

_**警告：**_如果在分支后进行变基，则存在某些提交可能会丢失的危险，如此处[所述](https://stackoverflow.com/a/36463546/99777)。避免这种情况的唯一方法是使用cherry-pick 创建新的历史记录。该链接描述了最安全、万无一失的方法，尽管不太方便。（如果您有未提交的更改，则可能需要`git stash`在开始和`git stash pop`结束时进行更改。）

常见的情况如下：我忘记为新功能创建新分支，并在旧功能分支中完成所有工作。我已将所有“旧”工作提交给 master 分支，并且我希望我的新分支从“master”中成长。我还没有对我的新工作做出任何承诺。这是分支结构：“master”->“Old\_feature”

    git stash 
    git checkout master
    git checkout -b "New_branch"
    git stash apply

如果您提交它，您还可以选择单个提交 ID。当我开始在 master 中工作，然后想在推送到我的 origin/ 之前创建一个本地分支时，我经常这样做。

    git cherry-pick <commitID>
    

[正如此处](https://git-scm.com/docs/git-cherry-pick)所述，您可以使用cherry-pick做很多事情，但这可能是您的一个用例。

Git 如何将现有的未提交工作转移到新分支？

首先，创建一个新的本地分支并检查它：

    git checkout -b <branch-name>
    

当您将其推送到远程服务器时，会自动创建远程分支：

    git push <remote-name> <branch-name> 
    

`<remote-name>`通常是`origin`，这是 git 为您克隆的远程服务器提供的名称。然后，您的同事可以简单地拉动该分支。

但请注意，形式上，格式为：

    git push <remote-name> <local-branch-name>:<remote-branch-name>
    

但是当您省略一个时，它会假设两个分支名称相同。话虽如此，但请**注意**，不要犯仅指定`:<remote-branch-name>`（使用冒号）的严重错误，否则远程分支将被删除！

* * *

为了让后续的人`git pull`知道该怎么做，您可能想使用：

    git push --set-upstream <remote-name> <local-branch-name> 
    

如下所述，该`--set-upstream`选项设置上游分支：

> 对于每个最新或成功推送的分支，添加上游（跟踪）引用，由无参数 git-pull(1) 和其他命令使用。

首先，您必须在本地创建分支

    git checkout -b your_branch
    

之后，您可以在本地分支中工作，当您准备好共享分支时，推送它。下一个命令将分支推送到远程存储库原点并跟踪它

    git push -u origin your_branch
    

队友可以通过以下方式到达您的分支机构：

    git fetch
    git checkout origin/your_branch
    

您可以继续在分支中工作并在需要时推送，而无需向 git Push 传递参数（无参数 git Push 会将 master 推送到远程 master，将本地 your\_branch 推送到远程 your\_branch，等等...）

    git push
    

队友可以通过提交来推送到您的分支，然后显式推送

    # ... work ...
    git commit
    # ... work ...
    git commit
    git push origin HEAD:refs/heads/your_branch
    

或者跟踪分支以避免 git push 的参数

    git checkout --track -b your_branch origin/your_branch
    # ... work ...
    git commit
    # ... work ...
    git commit
    git push

简单的 Git 2.0+ 解决方案：
------------------

从 Git 2.0开始**，行为变得更加简单**：

您可以配置 git**`push.default = current`**让生活更轻松：

我添加了这个，所以现在我可以将一个新分支推向上游

    $ git push -u
    

`-u`将跟踪同名的远程分支。现在通过此配置，您将自动猜测对 git Push 的远程引用。来自[git.config 文档](http://git-scm.com/docs/git-config)：

> **默认推送**
> 
> 定义在没有明确给出 refspec 的情况下 git push 应采取的操作。
> 
> **`push.default = current`**\- 推送当前分支以更新接收端同名分支。适用于中央和非中央工作流程。

对我来说，这很好地简化了我的日常 Git 工作流程。配置设置负责“通常”的用例，即您在本地添加分支并希望远程创建它。`git co remote_branch_name`另外，我可以通过执行操作（而不是使用`--set-upstream-to`标志）轻松地从远程创建本地分支。

我知道这个问题和接受的答案相当旧，但行为已经改变，因此现在存在配置选项以使您的工作流程更简单。

要添加到全局 Git 配置，请在命令行上运行：

    $ git config --global push.default current

正如前面的答案中所说，

    git push <remote-name> <local-branch-name>:<remote-branch-name>
    

足以推动当地分支机构。

您的同事可以使用以下命令拉取所有远程分支（包括新分支）：

    git remote update
    

然后，要在分支上进行更改，通常的流程是：

    git checkout -b <local-branch-name> <remote-name>/<remote-branch-name>

基于当前分支在本地创建一个新分支：

    git checkout -b newbranch
    

像平常一样进行任何更改。然后，将其推向上游：

    git push -u origin HEAD
    

这是将当前分支推送到同名分支并跟踪它的快捷方式，以便您将来`origin`不需要指定。`origin HEAD`

Git 如何创建远程分支？

git branch
    

应该显示您的存储库的所有本地分支。带星号的分支是您当前的分支。

* * *

要仅检索您所在分支的名称：

    git rev-parse --abbrev-ref HEAD
    

2.22 版本添加了[_“打印当前分支的名称”_](https://www.git-scm.com/docs/git-branch#Documentation/git-branch.txt---show-current)`--show-current`选项。该组合也适用于第一次提交之前新初始化的存储库：[](https://www.git-scm.com/docs/git-branch#Documentation/git-branch.txt---show-current)

    git branch --show-current

要仅显示您所在的当前分支的名称：

```
git rev-parse --abbrev-ref HEAD
```

参考：[仅显示 Git 中的当前分支](https://stackoverflow.com/a/1418022/367456)

您还可以`git symbolic-ref HEAD`显示完整的参考规范。

仅显示 Git v1.8 及更高版本中的分支名称（感谢 Greg 指出这一点）：

    git symbolic-ref --short HEAD
    

在 Git v1.7+ 上您还可以执行以下操作：

    git rev-parse --abbrev-ref HEAD
    

如果您在一个分支上，则两者应该给出相同的分支名称。如果你有超然的头脑，答案就会有所不同。

> _**笔记：**_
> 
> 在早期的客户端上，这似乎有效：
> 
>     git symbolic-ref HEAD | sed -e "s/^refs\/heads\///"
>     
> 
> – _达里恩 2014 年 3 月 26 日_

为了我自己的参考（但可能对其他人有用），我概述了该线程中提到的大多数（基本命令行）技术，每个技术都应用于多个用例： HEAD 是（指向）：

*   本地分支（主）
*   远程跟踪分支，与本地分支同步（origin/master 与 master 相同提交）
*   远程跟踪分支，与本地分支不同步（origin/feature-foo）
*   标签（v1.2.3）
*   子模块（在子模块目录内运行）
*   一般独立头（以上都不是）

结果：

*   `git branch | sed -n '/\* /s///p'`
    *   当地分行：`master`
    *   远程跟踪分支（同步）：`(detached from origin/master)`
    *   远程跟踪分支（不同步）：`(detached from origin/feature-foo)`
    *   标签：`(detached from v1.2.3)`
    *   子模块：`(HEAD detached at 285f294)`
    *   一般独立头：`(detached from 285f294)`
*   `git status | head -1`
    *   当地分行：`# On branch master`
    *   远程跟踪分支（同步）：`# HEAD detached at origin/master`
    *   远程跟踪分支（不同步）：`# HEAD detached at origin/feature-foo`
    *   标签：`# HEAD detached at v1.2.3`
    *   子模块：`# HEAD detached at 285f294`
    *   一般独立头：`# HEAD detached at 285f294`
*   `git describe --all`
    *   当地分行：`heads/master`
    *   远程跟踪分支（同步）：（`heads/master`注意：_不是_ `remotes/origin/master`）
    *   远程跟踪分支（不同步）：`remotes/origin/feature-foo`
    *   标签：`v1.2.3`
    *   子模块：`remotes/origin/HEAD`
    *   一般独立头：`v1.0.6-5-g2393761`
*   `cat .git/HEAD`:
    *   当地分行：`ref: refs/heads/master`
    *   子模块：`cat: .git/HEAD: Not a directory`
    *   所有其他用例：相应提交的 SHA
*   `git rev-parse --abbrev-ref HEAD`
    *   当地分行：`master`
    *   所有其他用例：`HEAD`
*   `git symbolic-ref --short HEAD`
    *   当地分行：`master`
    *   所有其他用例：`fatal: ref HEAD is not a symbolic ref`

（仅供参考，这是使用 git 版本 1.8.3.1 完成的）

从 git 2.22 版本开始，你可以使用：

    git branch --show-current
    

根据手册页：

> 打印当前分支的名称。在分离头状态下，不打印任何内容。

在 Git 中，有几种方法可以获取当前分支的名称，这里将介绍两种常用的方法：

### 1. 使用 `git branch` 命令

运行 `git branch` 命令时，它会列出仓库中的所有分支。当前分支会以一个星号 (*) 标记显示在列表中。例如：

```bash
$ git branch
  main
* develop
  feature-xyz
```

在这个例子中，当前分支是 `develop`。

### 2. 使用 `git rev-parse` 命令

如果需要在脚本中使用或者想要直接获取当前分支的名称，可以使用 `git rev-parse` 命令。这种方式会直接输出当前分支的名称，而不会显示其他分支信息。命令如下：

```bash
$ git rev-parse --abbrev-ref HEAD
```

这条命令会输出当前分支的名称。例如，如果当前分支是 `develop`，则输出会是：

```
develop
```

这个方法很适合自动化脚本中，因为它直接返回当前分支的名称，而不包含其他额外信息。

### 示例使用场景

假设我在一个软件开发项目中工作，项目采用 Git 进行版本控制。我需要确保我正在 `feature-new-ui` 分支上开发新的用户界面功能。为了验证我当前的工作环境，我可以使用以下命令：

```bash
$ git rev-parse --abbrev-ref HEAD
```

如果返回的分支名称是 `feature-new-ui`，那么我可以安心地继续我的开发任务；如果不是，我需要切换到正确的分支上。

这样的命令使用可以有效避免在错误的分支上进行开发，减少将来可能出现的合并冲突或错误。

Git 如何获取当前分支名称？

首先，当您克隆一个Git仓库时，默认情况下，`git clone` 命令将克隆远程仓库中的所有分支，但是在本地只会创建一个跟踪远程仓库`origin/master`分支的分支，即`master`分支。这意味着您的本地仓库中已经包含了远程仓库中所有分支的信息，但是为了切换到这些远程分支，您需要在本地创建相对应的跟踪分支。

如果您需要在本地显式地创建并切换到所有远程分支的跟踪分支，可以按照以下步骤操作：

1. 首先克隆远程仓库：
   ```shell
   git clone [remote-url]
   ```
   这样操作会创建所有远程分支的引用，在`.git/refs/remotes/origin/`目录下。

2. 接下来，您可以使用`git branch -a` 查看所有分支，包括远程分支。

3. 然后，对于每个远程分支，您可以使用以下命令创建本地分支并建立跟踪关系：
   ```shell
   git checkout -b [branch-name] origin/[branch-name]
   ```
   这个命令会创建一个新的本地分支`[branch-name]`，并设置它跟踪对应的远程分支。

例如，如果远程仓库有一个名为`feature`的分支，我想要在本地创建并切换到这个分支，我将会执行：
```shell
git checkout -b feature origin/feature
```

如果您希望自动化这个过程，可以使用下面的脚本在克隆后创建并切换到所有远程分支的本地跟踪分支：
```shell
# 克隆仓库
git clone [remote-url]

# 进入仓库目录
cd [repository-name]

# 遍历所有远程分支并创建本地跟踪分支
for branch in `git branch -r | grep -v '\->'`; do
    if [ "origin/HEAD" != "$branch" ]; then
        git checkout -b `echo $branch | sed 's/origin\///'` $branch
    fi
done

# 切换回主分支
git checkout master
```

这段脚本会克隆远程仓库，并为除了HEAD以外的所有远程分支创建本地分支，然后切换回主分支。注意，您需要替换`[remote-url]`和`[repository-name]`为实际的远程仓库URL和仓库名称。

首先，克隆一个远程[Git](http://en.wikipedia.org/wiki/Git_%28software%29)存储库并[`cd`](http://en.wikipedia.org/wiki/Cd_%28command%29)进入其中：

    $ git clone git://example.com/myproject
    $ cd myproject
    

接下来，查看存储库中的本地分支：

    $ git branch
    * master
    

但是您的存储库中还隐藏着其他分支！使用`-a`标志查看这些：

    $ git branch -a
    * master
      remotes/origin/HEAD
      remotes/origin/master
      remotes/origin/v1.0-stable
      remotes/origin/experimental
    

要快速浏览上游分支，请直接查看：

    $ git checkout origin/experimental
    

要处理该分支，请创建一个本地跟踪分支，这是通过以下方式自动完成的：

    $ git checkout experimental
    
    Branch experimental set up to track remote branch experimental from origin.
    Switched to a new branch 'experimental'
    

这里，“新分支”仅意味着从索引中获取分支并在本地为您创建。正如_上_一行告诉您的，正在设置分支来跟踪远程分支，这通常意味着 origin/branch\_name 分支。

您的本地分支机构现在应该显示：

    $ git branch
    * experimental
      master
    

您可以使用以下命令跟踪多个远程存储库`git remote`：

    $ git remote add win32 git://example.com/users/joe/myproject-win32-port
    $ git branch -a
    * master
      remotes/origin/HEAD
      remotes/origin/master
      remotes/origin/v1.0-stable
      remotes/origin/experimental
      remotes/win32/master
      remotes/win32/new-widgets
    

此时，事情变得非常疯狂，所以运行`gitk`看看发生了什么：

    $ gitk --all &

如果想一次获取许多远程分支，请执行以下操作：

```
git pull --all
```

现在，您可以根据需要签出任何分支，而无需访问远程存储库。

这个[Bash](http://en.wikipedia.org/wiki/Bash_%28Unix_shell%29)脚本帮助了我：

    #!/bin/bash
    for branch in $(git branch --all | grep '^\s*remotes' | egrep --invert-match '(:?HEAD|master)$'); do
        git branch --track "${branch##*/}" "$branch"
    done
    

它将为所有远程分支创建跟踪分支，但 master 除外（您可能从原始克隆命令中获得）。我想你可能还需要做一个

    git fetch --all
    git pull --all
    

为了确定。

> **一行**：`git branch -a | grep -v HEAD | perl -ne 'chomp($_); s|^\*?\s*||; if (m|(.+)/(.+)| && not $d{$2}) {print qq(git branch --track $2 $1/$2\n)} else {$d{$_}=1}' | csh -xfs`  
> 像往常一样：在复制我们所知的 rm -rf Universe 之前测试您的设置
> 
> _一行的积分归用户 cfi_

使用该`--mirror`选项似乎可以正确复制`remote`跟踪分支。但是，它将存储库设置为裸存储库，因此您必须随后将其恢复为普通存储库。

    git clone --mirror path/to/original path/to/dest/.git
    cd path/to/dest
    git config --bool core.bare false
    git checkout anybranch
    

参考：[Git 常见问题解答：如何克隆包含所有远程跟踪分支的存储库？](https://git.wiki.kernel.org/index.php/Git_FAQ#How_do_I_clone_a_repository_with_all_remotely_tracked_branches.3F)

您可以轻松切换到分支，而无需使用花哨的“git checkout -b somebranch origin/somebranch”语法。你可以做：

    git checkout somebranch
    

Git 会自动做正确的事情：

    $ git checkout somebranch
    Branch somebranch set up to track remote branch somebranch from origin.
    Switched to a new branch 'somebranch'
    

Git 会检查一个远程分支中是否存在同名分支，如果存在，它会以与您明确指定它是远程分支相同的方式进行跟踪。来自 Git 1.8.2.1 的 git-checkout 手册页：

> 如果未找到 <branch>，但在一个远程（称为 <remote>）中确实存在具有匹配名称的跟踪分支，则视为等同于
> 
>     $ git checkout -b <branch> --track <remote>/<branch>
>

Git 如何克隆所有远程分支?

在Git中，空目录本身不会被包含在版本控制中。这是因为Git跟踪文件的变化，而不是目录。但是，常见的做法是在需要跟踪的空目录里添加一个名为 `.gitignore` 的文件。

以下是将空目录添加到Git存储库的步骤：

1. 在你的本地文件系统中创建你想要跟踪的空目录。例如，你想跟踪名为 `empty-folder` 的目录：

   ```bash
   mkdir empty-folder
   ```

2. 在这个空目录中创建一个 `.gitignore` 文件。这个文件可以包含一些规则来告诉Git忽略哪些文件，但在这种情况下，我们只是用它来保持目录的存在。打开文本编辑器，创建一个名为 `.gitignore` 的文件，并写入以下内容：

   ```
   # Ignore everything in this directory
   *
   # Except this file
   !.gitignore
   ```

3. 这样，`.gitignore` 文件会告诉Git忽略该目录下的所有文件（`*` 表示所有文件），但不包括 `.gitignore` 文件自身（`!.gitignore`）。

4. 将新建的 `.gitignore` 文件添加到版本控制中：

   ```bash
   git add empty-folder/.gitignore
   ```

5. 提交更改到你的Git存储库：

   ```bash
   git commit -m "Add empty-folder with .gitignore"
   ```

6. 将更改推送到远程仓库（如果有的话）：

   ```bash
   git push
   ```

使用这种方法，虽然目录是空的，但其中的 `.gitignore` 文件确保了Git将目录包含在版本控制中。这是在Git中处理空目录的常见方式。

使目录（在存储库中）保持（几乎）为空的另一种方法是`.gitignore`在该目录中创建一个包含以下四行的文件：

    # Ignore everything in this directory
    *
    # Except this file
    !.gitignore
    

那么您就不必像 m104 的解决[方案](https://stackoverflow.com/a/180917/32453)中那样正确地获得订单。

这还有一个好处，即当您执行 git status 时，该目录中的文件不会显示为“未跟踪”。

使[@GreenAsJade](https://stackoverflow.com/users/554807/greenasjade)的评论持久化：

> 我认为值得注意的是，这个解决方案恰好满足了问题的要求，但可能不是许多查看这个问题的人所寻求的。此解决方案保证目录保持为空。它说“我真的不想在这里签入文件”。与“我这里还没有任何文件要签入，但我需要这里的目录，文件可能稍后会出现”相反。

你不能。请参阅[Git 常见问题解答](https://git.wiki.kernel.org/index.php/GitFaq#Can_I_add_empty_directories.3F)。

> 目前 git 索引（暂存区域）的设计仅允许列出文件，并且没有人有足够的能力进行更改以允许空目录，并且足够关心这种情况并进行补救。
> 
> 在目录中添加文件时会自动添加目录。也就是说，目录永远不需要添加到存储库中，并且不会自行跟踪。
> 
> 你可以说“ `git add <dir>`”，它就会在其中添加文件。
> 
> 如果您确实需要在结账中存在一个目录，您应该在其中创建一个文件。.gitignore 非常适合此目的；您可以将其留空，或填写您希望在目录中显示的文件的名称。

`.gitkeep`在目录中创建一个名为的空文件，然后`git add`将其命名为.

默认情况下，这将是类 Unix 系统上的隐藏文件，但它会强制 Git 承认该目录的存在，因为它现在有内容。

另请注意，该文件的名称没有什么特别之处。您可以将其命名为您想要的任何名称。Git 关心的只是文件夹中有东西。

您始终可以在该目录中放置一个自述文件，并解释为什么您希望在存储库中使用此目录（否则为空目录）。

touch .placeholder
    

在 Linux 上，这会创建一个名为 的空文件`.placeholder`。就其价值而言，这个名称与 git 无关，并且这种方法用于系统中的其他各个地方，例如`/etc/cron.d/.placeholder`. 其次，正如另一位用户所指出的，`.git`可以为 Git 本身用于配置目的的文件和目录保留前缀约定。

或者，正如另一个[答案](https://stackoverflow.com/a/5305908/)中所述，**该目录可以包含一个描述性[`README.md`文件](https://stackoverflow.com/questions/8655937/github-readme-and-readme-md)**。

无论哪种方式，这都要求文件的存在不会导致您的应用程序崩溃。

Git 如何将空目录添加到存储库？

要删除远程仓库中的标签（Tag），您可以使用 `git push` 命令结合 `--delete` 选项。这里有一个步骤说明和示例：

**步骤 1:** 首先，您需要确定要删除的远程标签的名称。您可以通过以下命令查看所有远程标签：

```sh
git fetch --tags
git tag -l
```

假设您要删除的远程标签名称为 `v1.0`。

**步骤 2:** 接下来，您可以使用以下命令删除远程标签：

```sh
git push --delete origin v1.0
```

这里，`origin` 是您要删除标签的远程仓库的名称（通常情况下远程仓库默认叫做 `origin`），`v1.0` 是要删除的标签名称。

**示例:**

假设我有一个远程仓库，在这个仓库中有一个标签 `v1.0`，现在我需要删除它。我会这样操作：

1. 首先，我确认标签存在：

    ```sh
    git fetch --tags
    git tag -l
    ```
   
    这会列出所有的标签，确认 `v1.0` 在列表中。

2. 然后，我使用命令删除远程标签：

    ```sh
    git push --delete origin v1.0
    ```
   
    这个命令告诉 Git 我要推送一个删除操作到远程仓库 `origin`，目标是删除 `v1.0` 标签。

执行这个命令后，远程仓库中的 `v1.0` 标签将被删除。也可以使用 `:refs/tags/v1.0` 这样的语法来指定要删除的标签，但是上面提到的 `--delete` 选项更加直观易懂。

此外，在进行此类操作之前，通常需要确认您有足够的权限删除远程仓库中的标签，因为在多人协作的项目中，这可能会影响其他人的工作。

您可以将“空”引用推送到远程标记名称：

    git push origin :tagname
    

或者，更具体地说，使用该`--delete`选项（或者`-d`如果您的 git 版本早于 1.8.0）：

    git push --delete origin tagname
    

请注意，git 具有标签命名空间和分支命名空间，因此您可以对分支和标签使用相同的名称。如果你想确保不会意外删除分支而不是标签，你可以指定 full ref ，它永远不会删除分支：

    git push origin :refs/tags/tagname
    

如果还需要删除本地标签，请使用：

    git tag --delete tagname
    

* * *

### 背景

将分支、标签或其他引用推送到远程存储库涉及指定“哪个存储库、什么源、什么目的地？”

    git push remote-repo source-ref:destination-ref
    

将主分支推送到源的主分支的真实示例是：

    git push origin refs/heads/master:refs/heads/master
    

由于默认路径，可以缩短为：

    git push origin master:master
    

标签的工作方式相同：

    git push origin refs/tags/release-1.0:refs/tags/release-1.0
    

也可以缩短为：

    git push origin release-1.0:release-1.0
    

通过省略源引用（冒号之前的部分），您可以将“无内容”推送到目标，从而删除远程端的引用。

直接的方法：

```
git push --delete origin YOUR_TAG_NAME
```

如果您有要删除的远程标签`v0.1.0`，并且您的远程是`origin`，那么只需：

    git push origin :refs/tags/v0.1.0
    

如果还需要在本地删除标签：

    git tag -d v0.1.0
    

请参阅[**Adam Franco**的回答](https://stackoverflow.com/a/5480292/535871)`:`，了解 Git 不寻常的删除语法的解释。

**删除所有本地标签并获取远程标签列表**：

    git tag -l | xargs git tag -d
    git fetch
    

**删除所有远程标签**

    git tag -l | xargs -n 1 git push --delete origin
    

**清理本地标签**

    git tag -l | xargs git tag -d

`git push --delete origin $TAGNAME`是正确的方法（除了本地删除）。

但是：请确保使用 Git 2.31+（2021 年第一季度）。

“ [`git push $there --delete`](https://github.com/git/git/blob/140045821aa78da3a80a7d7c8f707b955e1ab40d/Documentation/git-push.txt)” ( [man](https://git-scm.com/docs/git-push) )应该被诊断为错误，但却变成了匹配的推送，并已在 Git 2.31 (Q1 2021) 中得到纠正。

请参阅[Junio C Hamano (](https://github.com/gitster) [)的](https://github.com/gitster)[提交 20e4164](https://github.com/git/git/commit/20e416409fc2bc260faf65a0fc74927ed0d3ca12)（2021 年 2 月 23 日）。（由[Junio C Hamano 合并 --](https://github.com/gitster) [\--](https://github.com/gitster)在[提交 1400458](https://github.com/git/git/commit/140045821aa78da3a80a7d7c8f707b955e1ab40d)中，2021 年 2 月 25 日）[`gitster`](https://github.com/gitster)  
[`gitster`](https://github.com/gitster)[](https://github.com/git/git/commit/140045821aa78da3a80a7d7c8f707b955e1ab40d)

> [`push`](https://github.com/git/git/commit/20e416409fc2bc260faf65a0fc74927ed0d3ca12): 不变成`--delete ''`匹配推送
> ----------------------------------------------------------------------------------------------------------
> 
> 关注者：蒂尔曼·沃格尔

> 当我们将语法糖“ [`git push remote --delete`](https://github.com/git/git/blob/20e416409fc2bc260faf65a0fc74927ed0d3ca12/Documentation/git-push.txt#L182)” （[man](https://git-scm.com/docs/git-push#Documentation/git-push.txt---delete)） `<ref>`添加到“ [`git push`](https://github.com/git/git/blob/20e416409fc2bc260faf65a0fc74927ed0d3ca12/Documentation/git-push.txt)” （[man](https://git-scm.com/docs/git-push)）作为规范（[man](https://git-scm.com/docs/git-push#Documentation/git-push.txt-remoterejected)）的同义词时： [f517f1f](https://github.com/git/git/commit/f517f1f2e9c9e3abe0fde1b3c9a7bb20fdb5ba55)处的语法（“ ：（[man](https://git-scm.com/docs/git-add)）作为：foo的语法糖”，2009-12-30， Git v1.7.0-rc0 -- [merge](https://github.com/git/git/commit/84d52cabe7044786b5cc448ffeb97b7c1e667156)），我们不够仔细以确保它不为空。[`git push remote`](https://github.com/git/git/blob/20e416409fc2bc260faf65a0fc74927ed0d3ca12/Documentation/git-push.txt#L453)[](https://git-scm.com/docs/git-push#Documentation/git-push.txt-remoterejected)[](https://github.com/git/git/commit/f517f1f2e9c9e3abe0fde1b3c9a7bb20fdb5ba55)`builtin-push`[`add`](https://github.com/git/git/blob/f517f1f2e9c9e3abe0fde1b3c9a7bb20fdb5ba55/Documentation/git-add.txt)[](https://git-scm.com/docs/git-add) `--delete`[](https://github.com/git/git/commit/84d52cabe7044786b5cc448ffeb97b7c1e667156)`<ref>`
> 
> 盲目地将“”重写`--delete <ref>`为“ `:<ref>`”意味着空字符串`<ref>`会导致refspec“ `:`”，这是要求“匹配”推送的语法，不会删除任何内容。
> 
> 更糟糕的是，如果有可以快进的匹配参考，它们就会过早地发布，即使用户觉得它们还没有准备好被推出，这将是一场真正的灾难。

假设您想要的提交的哈希值是`c5f567`：

    git checkout c5f567 -- file1/to/restore file2/to/restore
    

git [checkout](https://git-scm.com/docs/git-checkout)手册页提供了更多信息。

如果您想恢复到之前的提交`c5f567`，请追加`~1`（其中 1 是您要返回的提交数，可以是任何值）：

    git checkout c5f567~1 -- file1/to/restore file2/to/restore
    

附带说明一下，我一直对这个命令感到不舒服，因为它既用于普通的事情（在分支之间进行更改），也用于不寻常的破坏性事情（丢弃工作目录中的更改）。

`--`命令中的含义可以参考[在Git中，`--`(dash dash) 是什么意思？](https://stackoverflow.com/questions/22750028/in-git-what-does-dash-dash-mean)

* * *

还有一个新[`git restore`](https://git-scm.com/docs/git-restore)命令专门用于恢复已修改的工作副本文件。如果你的 git 足够新，你可以使用这个命令，但文档附带一个警告：

> 该命令是实验性的。行为可能会改变。

因为`git restore`它是实验性的，所以还不应该被推广为这个问题的主要答案。当该命令不再标记为“实验性”时，则可以修改此答案以推广`git restore`. \[在撰写本文时，该`git restore`命令已被标记为“实验”至少四年。\]

您可以使用 diff 命令快速查看对文件所做的更改：

    git diff <commit hash> <filename>
    

然后要将特定文件恢复到该提交，请使用重置命令：

    git reset <commit hash> <filename>
    

`--hard`如果您有本地修改，您可能需要使用该选项。

管理航路点的一个好的工作流程是使用标签在时间轴中清晰地标记点。我不太明白你的最后一句话，但你可能想要的是从之前的时间点分出一个分支。为此，请使用方便的结帐命令：

    git checkout <commit hash>
    git checkout -b <new branch name>
    

当您准备好合并这些更改时，您可以根据主线重新调整基础：

    git checkout <my branch>
    git rebase master
    git checkout master
    git merge <my branch>

您可以使用对 git 提交的任何引用，包括 SHA-1（如果最方便的话）。重点是该命令如下所示：

`git checkout [commit-ref] -- [filename]`

git checkout -- foo
    

这将重置`foo`为 HEAD。你也可以：

    git checkout HEAD^ foo
    

进行一次修订等

从 git v2.23.0 开始，有一个新的[git Restore](https://git-scm.com/docs/git-restore/2.23.0)方法，该方法应该承担部分`git checkout`责任（即使接受的答案也提到这`git checkout`非常令人困惑）。[请参阅github 博客](https://github.blog/2019-08-16-highlights-from-git-2-23/)上的更改要点。

`source`此命令的默认行为是使用来自参数的内容（在您的情况下将是提交哈希）恢复工作树的状态。

因此，根据 Greg Hewgill 的回答（假设提交哈希为`c5f567`），命令将如下所示：

    git restore --source=c5f567 file1/to/restore file2/to/restore
    

或者如果你想恢复到c5f567之前一次提交的内容：

    git restore --source=c5f567~1 file1/to/restore file2/to/restore

Git 如何将文件重置或还原为特定的提交版本？

`git rebase`无需或 即可相当轻松地完成此操作 `git merge --squash`。在此示例中，我们将压缩最后 3 个提交。

如果您想从头开始编写新的提交消息，这就足够了：

```
git reset --soft HEAD~3
git commit
```

如果您想开始编辑新的提交消息与现有提交消息的串联（即类似于 pick/squash/squash/…/squash `git rebase -i`指令列表将开始您的操作），那么您需要提取这些消息并通过他们 `git commit`：

```
git reset --soft HEAD~3 && 
git commit --edit -m"$(git log --format=%B --reverse HEAD..HEAD@{1})"
```

这两种方法都以相同的方式将最后三个提交压缩为一个新的提交。软重置只是将 HEAD 重新指向您不想压缩的最后一次提交。

软重置不会触及索引和工作树，从而使索引处于新提交所需的状态（即，它已经具有您要“丢弃”的提交的所有更改）。

在第二次及后续提交中使用`git rebase -i <after-this-commit>`“pick”并将其替换为“squash”或“fixup”，如[手册](http://git-scm.com/docs/git-rebase#_interactive_mode)中所述。

在此示例中，`<after-this-commit>`是 SHA1 哈希值或当前分支 HEAD 的相对位置，从中分析提交以进行 rebase 命令。例如，如果用户希望查看过去来自当前 HEAD 的 5 次提交，则命令为`git rebase -i HEAD~5`。

您可以使用 `git merge --squash`它，这比 `git rebase -i`. 假设您在 master 上，并且想要将最后 12 次提交压缩为一次。

警告：首先确保您提交了您的工作 - 检查是否 `git status`干净（因为 `git reset --hard`将丢弃分阶段和未分阶段的更改）

然后：

```
# Reset the current branch to the commit just before the last 12:
git reset --hard HEAD~12

# HEAD@{1} is where the branch was just before the previous command.
# This command sets the state of the index to be as it would just
# after a merge from that commit:
git merge --squash HEAD@{1}

# Commit those squashed changes.  The commit message will be helpfully
# prepopulated with the commit messages of all the squashed commits:
git commit
```

的[文档 `git merge`](http://www.kernel.org/pub/software/scm/git/docs/git-merge.html) `--squash`更详细地描述了该选项。

无需 rebase 的简单解决方案：

```
git reset --soft HEAD~2 
git commit -m "new commit message"
git push -f
```

其中 2 意味着最后两次提交将被压缩，您可以将其替换为任意数字

我建议`git reset`尽可能避免——尤其是对于 Git 新手。除非您确实需要基于_多次_提交来自动化流程，否则有一种不太奇特的方法......

1.  将要压缩的提交放在工作分支上（如果还没有）——为此使用 gitk
2.  查看目标分支（例如“master”）
3.  `git merge --squash (working branch name)`
4.  `git commit`

提交消息将根据挤压进行预填充。

Git 如何用将最后 n 个提交压缩在一起，生成一个提交记录？

对于那些想知道它为什么有效的人 

您想返回 C，并将 D 和 E 移动到新分支。

一开始看起来是这样的：

```
A-B-C-D-E (HEAD)
        ↑
      master
```

后 `git branch newBranch`：

```
    newBranch
        ↓
A-B-C-D-E (HEAD)
        ↑
      master
```

后 `git reset --hard HEAD~2`：

```
    newBranch
        ↓
A-B-C-D-E (HEAD)
    ↑
  master
```

由于分支只是一个指针，因此_master指向最后一次提交。当您创建newBranch_时，您只需创建一个指向最后一次提交的新指针。然后使用 `git reset`您将_主_指针移回两个提交。但由于您没有移动_newBranch_，它仍然指向它最初所做的提交。

当你想要将最近的提交移动到一个新分支时，你可以按照以下步骤操作。这里假设你已经在你的本地仓库中，并且你所要移动的提交已经在当前的分支上。

1. **创建一个新分支**，但不要切换到那个分支：

   <pre><section class="markdown-code"><div class="markdown-code__head"><div class="markdown-code__head-language"><span>sh</span><span class="i-icon i-icon-copy"><svg width="16" height="16" viewBox="0 0 48 48" fill="none"><path d="M13 12.4316V7.8125C13 6.2592 14.2592 5 15.8125 5H40.1875C41.7408 5 43 6.2592 43 7.8125V32.1875C43 33.7408 41.7408 35 40.1875 35H35.5163" stroke="#333" stroke-width="4" stroke-linecap="round" stroke-linejoin="round"></path><path d="M32.1875 13H7.8125C6.2592 13 5 14.2592 5 15.8125V40.1875C5 41.7408 6.2592 43 7.8125 43H32.1875C33.7408 43 35 41.7408 35 40.1875V15.8125C35 14.2592 33.7408 13 32.1875 13Z" fill="none" stroke="#333" stroke-width="4" stroke-linejoin="round"></path></svg></span></div></div><div><code class="language-sh"><span>git branch new-branch-name</span></code></div></section></pre>
2. **重置当前分支的HEAD**到你想要移动的提交的父提交。如果你只想移动最近的一个提交，可以执行：

   <pre><section class="markdown-code"><div class="markdown-code__head"><div class="markdown-code__head-language"><span>sh</span><span class="i-icon i-icon-copy"><svg width="16" height="16" viewBox="0 0 48 48" fill="none"><path d="M13 12.4316V7.8125C13 6.2592 14.2592 5 15.8125 5H40.1875C41.7408 5 43 6.2592 43 7.8125V32.1875C43 33.7408 41.7408 35 40.1875 35H35.5163" stroke="#333" stroke-width="4" stroke-linecap="round" stroke-linejoin="round"></path><path d="M32.1875 13H7.8125C6.2592 13 5 14.2592 5 15.8125V40.1875C5 41.7408 6.2592 43 7.8125 43H32.1875C33.7408 43 35 41.7408 35 40.1875V15.8125C35 14.2592 33.7408 13 32.1875 13Z" fill="none" stroke="#333" stroke-width="4" stroke-linejoin="round"></path></svg></span></div></div><div><code class="language-sh"><span>git reset --hard HEAD~1</span></code></div></section></pre>

   如果是最近的几个提交，可以将 `1`替换为相应的数字。
3. **切换到新分支**：

   <pre><section class="markdown-code"><div class="markdown-code__head"><div class="markdown-code__head-language"><span>sh</span><span class="i-icon i-icon-copy"><svg width="16" height="16" viewBox="0 0 48 48" fill="none"><path d="M13 12.4316V7.8125C13 6.2592 14.2592 5 15.8125 5H40.1875C41.7408 5 43 6.2592 43 7.8125V32.1875C43 33.7408 41.7408 35 40.1875 35H35.5163" stroke="#333" stroke-width="4" stroke-linecap="round" stroke-linejoin="round"></path><path d="M32.1875 13H7.8125C6.2592 13 5 14.2592 5 15.8125V40.1875C5 41.7408 6.2592 43 7.8125 43H32.1875C33.7408 43 35 41.7408 35 40.1875V15.8125C35 14.2592 33.7408 13 32.1875 13Z" fill="none" stroke="#333" stroke-width="4" stroke-linejoin="round"></path></svg></span></div></div><div><code class="language-sh"><span>git checkout new-branch-name</span></code></div></section></pre>

下面是这个过程的一个示例：

假设你的最近一次提交是你想要移动到新分支的提交。

首先，创建新分支但停留在当前分支： 

<pre><section class="markdown-code"><div class="markdown-code__head"><div class="markdown-code__head-language"><span>sh</span><span class="i-icon i-icon-copy"><svg width="16" height="16" viewBox="0 0 48 48" fill="none"><path d="M13 12.4316V7.8125C13 6.2592 14.2592 5 15.8125 5H40.1875C41.7408 5 43 6.2592 43 7.8125V32.1875C43 33.7408 41.7408 35 40.1875 35H35.5163" stroke="#333" stroke-width="4" stroke-linecap="round" stroke-linejoin="round"></path><path d="M32.1875 13H7.8125C6.2592 13 5 14.2592 5 15.8125V40.1875C5 41.7408 6.2592 43 7.8125 43H32.1875C33.7408 43 35 41.7408 35 40.1875V15.8125C35 14.2592 33.7408 13 32.1875 13Z" fill="none" stroke="#333" stroke-width="4" stroke-linejoin="round"></path></svg></span></div></div><div><code class="language-sh"><span>git branch new-feature</span></code></div></section></pre>

接着，使用 `git reset`将当前分支重置到上一次提交（即移动前的状态）：

<pre><section class="markdown-code"><div class="markdown-code__head"><div class="markdown-code__head-language"><span>sh</span><span class="i-icon i-icon-copy"><svg width="16" height="16" viewBox="0 0 48 48" fill="none"><path d="M13 12.4316V7.8125C13 6.2592 14.2592 5 15.8125 5H40.1875C41.7408 5 43 6.2592 43 7.8125V32.1875C43 33.7408 41.7408 35 40.1875 35H35.5163" stroke="#333" stroke-width="4" stroke-linecap="round" stroke-linejoin="round"></path><path d="M32.1875 13H7.8125C6.2592 13 5 14.2592 5 15.8125V40.1875C5 41.7408 6.2592 43 7.8125 43H32.1875C33.7408 43 35 41.7408 35 40.1875V15.8125C35 14.2592 33.7408 13 32.1875 13Z" fill="none" stroke="#333" stroke-width="4" stroke-linejoin="round"></path></svg></span></div></div><div><code class="language-sh"><span>git reset --hard HEAD~1</span></code></div></section></pre>

然后，切换到你的新分支：

<pre><section class="markdown-code"><div class="markdown-code__head"><div class="markdown-code__head-language"><span>sh</span><span class="i-icon i-icon-copy"><svg width="16" height="16" viewBox="0 0 48 48" fill="none"><path d="M13 12.4316V7.8125C13 6.2592 14.2592 5 15.8125 5H40.1875C41.7408 5 43 6.2592 43 7.8125V32.1875C43 33.7408 41.7408 35 40.1875 35H35.5163" stroke="#333" stroke-width="4" stroke-linecap="round" stroke-linejoin="round"></path><path d="M32.1875 13H7.8125C6.2592 13 5 14.2592 5 15.8125V40.1875C5 41.7408 6.2592 43 7.8125 43H32.1875C33.7408 43 35 41.7408 35 40.1875V15.8125C35 14.2592 33.7408 13 32.1875 13Z" fill="none" stroke="#333" stroke-width="4" stroke-linejoin="round"></path></svg></span></div></div><div><code class="language-sh"><span>git checkout new-feature</span></code></div></section></pre>

现在，你的最近一次提交在 `new-feature`分支上，而原分支则回到了移动提交之前的状态。

请注意，使用 `git reset --hard`会丢弃当前分支上 `HEAD`之后的改动，所以在执行这个命令之前，请确保你确实不需要这些改动或者已经将它们保存在别的地方。如果你想保留对这些文件的更改而不是提交，可以使用 `git reset --soft`，这样改动会保留在工作目录中。

一般来说...
=======

sykora 公开的方法是这种情况下的最佳选择。但有时并不是最简单的，也不是通用的方法。对于一般方法，请使用_gitcherry-pick_：

要实现 OP 想要的目标，需要分两步：

第 1 步 - 记下您想要的 master 提交`newbranch`
===================================

执行

    git checkout master
    git log
    

记下您想要的（比如 3）提交的哈希值`newbranch`。这里我将使用：  
C commit: `9aa1233`  
D commit: `453ac3d`  
E commit:`612ecb3`

> **注意：**您可以使用前七个字符或整个提交哈希

第 2 步 - 将它们放在`newbranch`
========================

    git checkout newbranch
    git cherry-pick 612ecb3
    git cherry-pick 453ac3d
    git cherry-pick 9aa1233
    

或者（在 Git 1.7.2+ 上，使用范围）
=======================

    git checkout newbranch
    git cherry-pick 612ecb3~1..9aa1233
    

_gitcherry-pick_将这三个提交应用于 newbranch。

以前的大多数答案都是危险的错误！
----------------

不要这样做：

    git branch -t newbranch
    git reset --hard HEAD~3
    git checkout newbranch
    

当您下次运行`git rebase`（或`git pull --rebase`）时，这 3 个提交将被默默地丢弃`newbranch`！（见下面的解释）

**相反，这样做：**

    git reset --keep HEAD~3
    git checkout -t -b newbranch
    git cherry-pick ..HEAD@{2}
    

*   首先，它会丢弃最近的 3 个提交（`--keep`类似于`--hard`，但更安全，因为失败而不是丢弃未提交的更改）。
*   然后它分叉了`newbranch`。
*   然后它会挑选这 3 个提交回到`newbranch`. 由于它们不再被分支引用，因此它通过使用 git 的[reflog](http://gitready.com/intermediate/2009/02/09/reflog-your-safety-net.html)来实现：是用于引用 2 个操作之前的`HEAD@{2}`提交，即在我们 1. 签出和 2. 用于丢弃 3 个提交之前。`HEAD``newbranch``git reset`

_警告：默认情况下，reflog 是启用的，但如果您手动禁用它（例如，通过使用“裸”git 存储库），则在运行后将无法恢复 3 次提交`git reset --keep HEAD~3`。_

不依赖 reflog 的替代方案是：

    # newbranch will omit the 3 most recent commits.
    git checkout -b newbranch HEAD~3
    git branch --set-upstream-to=oldbranch
    # Cherry-picks the extra commits from oldbranch.
    git cherry-pick ..oldbranch
    # Discards the 3 most recent commits from oldbranch.
    git branch --force oldbranch oldbranch~3
    

（如果您愿意，可以写`@{-1}`\- 之前签出的分支 - 而不是`oldbranch`）。

* * *

技术说明
----

为什么`git rebase`在第一个示例之后要丢弃 3 次提交？这是因为`git rebase`没有参数`--fork-point`默认启用该选项，它使用本地引用日志来尝试对强制推送的上游分支保持鲁棒性。

假设您在 origin/master 包含提交 M1、M2、M3 时对其进行了分支，然后自己进行了三个提交：

    M1--M2--M3  <-- origin/master
             \
              T1--T2--T3  <-- topic
    

但随后有人通过强制推送 origin/master 来删除 M2 来重写历史：

    M1--M3'  <-- origin/master
     \
      M2--M3--T1--T2--T3  <-- topic
    

使用本地引用日志，`git rebase`可以看到您是从 origin/master 分支的早期版本分叉的，因此 M2 和 M3 提交实际上并不是主题分支的一部分。因此，它合理地假设，由于 M2 已从上游分支中删除，因此一旦主题分支重新建立基础，您就不再希望它出现在主题分支中：

    M1--M3'  <-- origin/master
         \
          T1'--T2'--T3'  <-- topic (rebased)
    

这种行为是有道理的，并且通常是变基时正确的做法。

所以以下命令失败的原因是：

    git branch -t newbranch
    git reset --hard HEAD~3
    git checkout newbranch
    

是因为他们将重新记录置于错误的状态。Git 认为`newbranch`在包含 3 个提交的修订版中分叉了上游分支，然后重写`reset --hard`上游的历史记录以删除提交，因此下次运行时`git rebase`它会像已从上游删除的任何其他提交一样丢弃它们。

但在这种特殊情况下，我们希望将这 3 个提交视为主题分支的一部分。为了实现这一点，我们需要在不包含 3 次提交的早期版本中分叉上游。这就是我建议的解决方案所做的，因此它们都使重新日志保持正确的状态。

[有关更多详细信息，请参阅git rebase](https://git-scm.com/docs/git-rebase)和[git merge-base](https://git-scm.com/docs/git-merge-base)`--fork-point`文档中的定义。[](https://git-scm.com/docs/git-rebase)[](https://git-scm.com/docs/git-merge-base)

还有另一种方法可以做到这一点，只需使用 2 个命令。还可以保持您当前的工作树完好无损。

    git checkout -b newbranch # switch to a new branch
    git branch -f master HEAD~3 # make master point to some older commit
    

**旧版本**\- 在我了解之前`git branch -f`

    git checkout -b newbranch # switch to a new branch
    git push . +HEAD~3:master # make master point to some older commit 
    

能够`push`做到这一点`.`是一个很好的技巧。

Git 如何将最近的提交移动到新的分支？

查看远程 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`并跟踪其中的远程分支。

Git 如何 check out 远程分支？

为了在 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
    

* * *

Git 如何从当前工作树中删除本地未跟踪的文件？

首先，将所有 `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 分支，则无需获取所有遥控器和分支，对吗？

如何强制使用 git pull 覆盖本地文件？

`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.

Git相关问题