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



如何重命名本地 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 "Something terribly misguided" # (0: Your Accident)
$ git reset HEAD~ # (1)
[ edit files as necessary ] # (2)
$ git add . # (3)
$ git commit -c ORIG_HEAD # (4)
</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 undo. It will undo your last commit while leaving your working tree (the state of your files on disk) untouched. 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>
Alternatively, to edit the previous commit (or just its commit message), <a href="https://stackoverflow.com/q/179123/1146608"><code>commit --amend</code></a> will add changes within the current index to the previous commit.
To remove (not revert) a commit that has been pushed to the server, rewriting history with <code>git push origin main --force[-with-lease]</code> is necessary. <a href="https://stackoverflow.com/q/52823692/4096791">It's almost always 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>:
<blockquote>
You should understand the implications of rewriting history if you amend a commit that has already been published.
</blockquote>
<hr>
<h3>Further Reading</h3>
<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.
<hr>
<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.

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.
Say you have this, where C is your HEAD and (F) is the state of your files.
<pre><code> (F)
A-B-C
 ↑
 master
</code></pre>
<h3>Option 1: <code>git reset --hard</code></h3>
You want to destroy commit C and also throw away any uncommitted changes. You do this:
<pre><code>git reset --hard HEAD~1
</code></pre>
The result is:
<pre><code> (F)
A-B
 ↑
master
</code></pre>
Now B is the HEAD. Because you used <code>--hard</code>, your files are reset to their state at commit B.
<h3>Option 2: <code>git reset</code></h3>
Maybe commit C wasn't a disaster, but just a bit off. You want to undo the commit but keep your changes for a bit of editing before you do a better commit. Starting again from here, with C as your HEAD:
<pre><code> (F)
A-B-C
 ↑
 master
</code></pre>
Do this, leaving off the <code>--hard</code>:
<pre><code>git reset HEAD~1
</code></pre>
In this case the result is:
<pre><code> (F)
A-B-C
 ↑
master
</code></pre>
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!
<h3>Option 3: <code>git reset --soft</code></h3>
For the lightest touch, you can even undo your commit but leave your files and your <a href="https://git.wiki.kernel.org/index.php/WhatIsTheIndex" rel="noreferrer">index</a>:
<pre><code>git reset --soft HEAD~1
</code></pre>
This not only leaves your files alone, it even leaves your index 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.
<h3>Option 4: you did <code>git reset --hard</code> and need to get that code back</h3>
One more thing: Suppose you destroy a commit as in the first example, but then discover you needed it after all? Tough luck, right?
Nope, there's still a way to get it back. Type this
<pre><code>git reflog
</code></pre>
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:
<pre><code>git checkout -b someNewBranchName shaYouDestroyed
</code></pre>
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.

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):
<h2>How to undo a local commit</h2>
Let's say I committed locally, but now I want to remove that commit.
<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>
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>:
<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>
Now <code>git log</code> will show that our last commit has been removed.
<h2>How to undo a public commit</h2>
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).
<pre><code>git revert HEAD
</code></pre>
Your changes will now be reverted and ready for you to commit:
<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>
For more information, check out <a href="https://git-scm.com/book/en/v2/Git-Basics-Undoing-Things" rel="noreferrer">Git Basics - Undoing Things</a>.

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

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

Then amend the commit:

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

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.

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.

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

<h2 id="to-change-the-last-commit-ayg9">To change the last commit</h2>
Replace the files in the index:
<pre><code>git rm --cached *.class
git add *.java
</code></pre>
Then, if it's a private branch, amend the commit:
<pre><code>git commit --amend
</code></pre>
Or, if it's a shared branch, make a new commit:
<pre><code>git commit -m 'Replace .class files with .java files'
</code></pre>
 
(To change a previous commit, use the awesome <a href="https://stackoverflow.com/a/28421811/405550">interactive rebase</a>.)
<hr>
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.
<hr>
<h2 id="to-revert-a-commit-rotb">To revert a commit</h2>
Amending a commit is the ideal solution if you need to change the last commit, but a more general solution is <code>reset</code>.
You can reset Git to any commit with:
<pre><code>git reset @~N
</code></pre>
Where <code>N</code> is the number of commits before <code>HEAD</code>, and <code>@~</code> resets to the previous commit.
Instead of amending the commit, you could use:
<pre><code>git reset @~
git add *.java
git commit -m "Add .java files"
</code></pre>
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.
<h2 id="reflog-hdrm">Reflog</h2>
If you mess up, you can always use the reflog to find dropped commits:
<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>

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

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

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.
<pre><code>git reset --hard HEAD^1
</code></pre>
(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.
<pre><code>git reset --soft HEAD^1
</code></pre>
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
<pre><code>git reset HEAD
</code></pre>
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.
<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>)

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.

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.

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

Git相关问题

How can i rename a local git branch?

How do i undo the most recent local commits in git

How to delete locally branch and remotely branch in git?