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

Git 如何重命名本地分支？

在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`的工作副本设置为错误提交之前的提交状态。

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相关问题

Git 如何重命名本地分支？

Git 如何撤消最近的本地提交记录？

Git 如何删除本地分支和远程分支？