【问题标题】：What are the differences between local branch, local tracking branch, remote branch and remote tracking branch?本地分支、本地跟踪分支、远程分支和远程跟踪分支有什么区别？
【发布时间】：2013-04-30 18:32:18
【问题描述】：

我刚开始使用 Git，我对不同的分支感到非常困惑。谁能帮我弄清楚以下分支类型是什么？

当地分支机构
本地跟踪分支
远程分支
远程跟踪分支

它们之间有什么区别？它们如何相互协作？

我猜快速演示代码会很有帮助。

【问题讨论】：

标签： git version-control git-branch git-remote

【解决方案1】：

这是长答案。

遥控器：

如果您以协作方式使用 Git，您可能需要将您的提交与其他机器或位置同步。在 Git 的术语中，每台机器或位置都称为 remote，每台机器或位置都可能有一个或多个分支。大多数情况下，您只有一个，名为origin。要列出所有遥控器，请运行 git remote:

$ git remote
bitbucket
origin

您可以通过运行git remote -v 来查看这些远程名称是哪些位置的快捷方式：

$ git remote -v
bitbucket git@bitbucket.org:flimm/example.git (fetch)
bitbucket git@bitbucket.org:flimm/example.git (push)
origin git@github.com:Flimm/example.git (fetch)
origin git@github.com:Flimm/example.git (push)

每个遥控器在.git/refs/remotes/下都有一个目录：

$ ls -F .git/refs/remotes/
bitbucket/ origin/

您机器上的分支：

TLDR：在您的本地机器上，您拥有三种类型的分支：本地非跟踪分支、本地跟踪分支和远程跟踪分支。在远程机器上，您只有一种类型的分支。

1。当地分支机构

你可以通过运行git branch来查看你机器上所有本地分支的列表：

$ git branch
master
new-feature

每个本地分支在.git/refs/heads/下都有一个文件：

$ ls -F .git/refs/heads/
master new-feature

您的机器上有两种类型的本地分支：非跟踪本地分支和跟踪本地分支。

1.1 非跟踪本地分支

非跟踪本地分支不与任何其他分支关联。您可以通过运行git branch <branchname> 创建一个。

1.2。跟踪当地分支机构

跟踪本地分支与另一个分支相关联，通常是远程跟踪分支。您可以通过运行 git branch --track <branchname> [<start-point>] 创建一个。

您可以使用git branch -vv查看您当地的哪一个分支机构正在跟踪分支机构：

$ git branch -vv
master      b31f87c85 [origin/master] Example commit message
new-feature b760e04ed Another example commit message

从该命令的输出中，您可以看到本地分支master 正在跟踪远程跟踪分支origin/master，而本地分支new-feature 没有跟踪任何内容。

查看哪些分支正在跟踪分支的另一种方法是查看.git/config。

跟踪本地分支机构很有用。它们允许您运行git pull 和git push，而无需指定要使用哪个上游分支。如果该分支未设置为跟踪另一个分支，您将收到如下错误：

$ git checkout new-feature
$ git pull
There is no tracking information for the current branch.
Please specify which branch you want to merge with.
See git-pull(1) for details

    git pull <remote> <branch>

If you wish to set tracking information for this branch you can do so with:

    git branch --set-upstream new-feature <remote>/<branch>

2。远程跟踪分支（仍在您的机器上）

您可以通过运行git branch -r 查看您机器上所有远程跟踪分支的列表：

$ git branch -r
bitbucket/master
origin/master
origin/new-branch

每个远程跟踪分支在.git/refs/remotes/<remote>/下都有一个文件：

$ tree -F .git/refs/remotes/
.git/refs/remotes/
├── bitbucket/
│   └── master
└── origin/
    ├── master
    └── new-branch

将您的远程跟踪分支视为远程计算机所包含内容的本地缓存。您可以使用 git fetch 更新您的远程跟踪分支，git pull 在幕后使用。

即使远程跟踪分支的所有数据都本地存储在您的计算机上（如缓存），它仍然永远不会被称为本地分支。（至少，我不会这么称呼它！）它只是被称为远程跟踪分支。

远程机器上的分支：

运行git remote show <remote>可以查看所有远程分支（即远程机器上的分支）：

$ git remote show origin
* remote origin
  Fetch URL: git@github.com:Flimm/example.git
  Push  URL: git@github.com:Flimm/example.git
  HEAD branch: master
  Remote branches:
    io-socket-ip            new (next fetch will store in remotes/origin)
    master                  tracked
    new-branch              tracked
  Local ref configured for 'git pull':
    master     merges with remote master
    new-branch merges with remote new-branch
  Local ref configured for 'git push':
    master     pushes to master     (up to date)
    new-branch pushes to new-branch (fast-forwardable)

这个git remote 命令通过网络查询远程机器的分支。它不会更新本地计算机上的远程跟踪分支，请使用 git fetch 或 git pull。

从输出中，您可以通过查看“远程分支”标题下查看远程计算机上存在的所有分支（忽略标记为“陈旧”的行）。

如果您可以登录到远程计算机并在文件系统中找到存储库，则可以查看其在refs/heads/ 下的所有分支。

备忘单：

要安全地删除本地分支，无论是跟踪还是非跟踪：
```
  git branch -d <branchname>
```
要强制删除本地分支，无论是跟踪还是非跟踪：
```
  git branch -D <branchname>
```
删除远程跟踪分支：
```
  git branch -rd <remote>/<branchname>
```

创建一个新的本地非跟踪分支：

  git branch <branchname> [<start-point>]

创建一个新的本地跟踪分支：（请注意，如果指定了<start-point>，并且是像origin/foobar 这样的远程跟踪分支，则自动包含--track 标志）
```
  git branch --track <branchname> [<start-point]
```
例子：
```
  git branch --track hello-kitty origin/hello-kitty
```

要删除远程机器上的分支：

  git push --delete <remote> <branchname>

删除所有过时的远程跟踪分支，即远程机器上的相应分支不再存在：
```
  git remote prune <remote>
```

您可能已经注意到，在某些命令中，您使用<remote>/<branch>，而在其他命令中，则使用<remote> <branch>。示例：git branch origin/hello-kitty 和 git push --delete origin hello-kitty。

这可能看起来很随意，但有一种简单的方法可以记住何时使用斜线以及何时使用空格。当您使用斜线时，您指的是您自己机器上的远程跟踪分支，而当您使用空格时，您实际上是在通过网络处理远程机器上的分支。

【讨论】：

我将使用创建分支并在一个 cmd 中转到分支：git checkout -b mynewbranch
我喜欢关于空格和斜线之间区别的最后一点！

【解决方案2】：

本地分支是只有您（本地用户）可以看到的分支。它仅存在于您的本地计算机上。

git branch myNewBranch        # Create local branch named "myNewBranch"

远程分支是远程位置的分支（大多数情况下为origin）。您可以将新创建的本地分支myNewBranch 推送到origin。现在其他用户可以跟踪它。

git push -u origin myNewBranch   # Pushes your newly created local branch "myNewBranch"
                                 # to the remote "origin".
                                 # So now a new branch named "myNewBranch" is
                                 # created on the remote machine named "origin"

远程跟踪分支是远程分支的本地副本。当使用上面的命令将myNewBranch 推送到origin 时，会在您的机器上创建一个名为origin/myNewBranch 的远程跟踪分支。这个远程跟踪分支在origin 上跟踪远程分支myNewBranch。您可以使用git fetch 或git pull 更新您的远程跟踪分支，使其与远程分支同步。

git pull origin myNewBranch      # Pulls new commits from branch "myNewBranch" 
                                 # on remote "origin" into remote tracking
                                 # branch on your machine "origin/myNewBranch".
                                 # Here "origin/myNewBranch" is your copy of
                                 # "myNewBranch" on "origin"

本地跟踪分支是跟踪另一个分支的本地分支。这样您就可以向/从另一个分支推送/拉取提交。大多数情况下，本地跟踪分支跟踪远程跟踪分支。当您使用带有-u 选项（如上所示）的git push 命令将本地分支推送到origin 时，您设置了本地分支myNewBranch 以跟踪远程跟踪分支origin/myNewBranch。使用 git push 和 git pull 时需要这样做，而无需指定要推送或拉取的上游。

git checkout myNewBranch      # Switch to myNewBranch
git pull                      # Updates remote tracking branch "origin/myNewBranch"
                              # to be in sync with the remote branch "myNewBranch"
                              # on "origin".
                              # Pulls these new commits from "origin/myNewBranch"
                              # to local branch "myNewBranch which you just switched to.

【讨论】：

对于本地跟踪分支的定义，是不是和本地分支推送到远程后一样？
@mskw 不，本地跟踪分支和本地（非跟踪）分支的关联不同。本地分支不与任何分支关联。它只是孤立地存在于本地机器上的一个分支。本地跟踪分支与远程跟踪分支相关联。因此，您可以相互推/拉提交。
有一个疑问，在 Visual Studio 中，当我克隆一个 Repo 时，默认情况下我会得到一个跟踪 origin/main 的本地 main。因此，在本地 main 上进行的任何推送都会将更改推送到 origin/main。如果我基于本地 main 创建另一个本地分支 (foo)，它是否仍会跟踪 origin/main？如果我尝试在 foo 中推送我的更改，它会成功吗？
@SandeepKumar: foo 将是一个本地分支（不跟踪任何远程），直到你推送它。一旦你推送它，它将创建一个 origin/foo 并跟踪它。

【解决方案3】：

当地分公司：

您机器上的一个分支，您可以在其中工作并添加提交。您可以使用git branch 列出这些分支。

本地分支（带跟踪）：

配置为对应远程分支的普通本地分支。这样做的好处是能够git pull 和git push，而无需指定存储库和分支名称。跟踪还会导致git status 在您的分支在远程之前或之后通知您。

远程分支：

只是远程存储库上的一个分支——通常在 GitHub 等服务器上。

远程跟踪分支：

远程分支的本地副本。永远不应编辑此分支。其目的是跟踪远程分支的当前状态。可以使用git branch -r 查看远程跟踪分支，通常看起来类似于origin/master（repo 名称后跟斜杠，后跟分支名称）。运行git fetch 将更新远程跟踪分支以反映相应远程分支的状态。

git branch -avv 是我个人最喜欢的，它可以快速概览我的机器上的哪些分支、远程上的哪些分支以及每个分支中的最新提交。 -a 部分指定应显示所有分支（远程和本地）。末尾的v 代表详细（它显示最后的提交哈希和消息）。感谢@Flimm 指出第二个v 添加了有关哪个本地分支正在跟踪哪个远程的信息。

【讨论】：

我不明白本地跟踪和远程跟踪分支之间的区别 - 前者对应于原点，后者对应于远程机器。但那些不是一回事吗？那不就是通常在 github 上的 repo 吗？
@akantoword 我更新了答案以试图澄清一点。基本上，远程跟踪分支只是远程分支的本地副本，不用于工作。具有跟踪功能的本地分支用于工作。
@EricMathison 好的，但是有什么办法可以强制执行吗？如果您不小心对远程跟踪分支进行了更改，会发生什么？此外，这可能是一个不同的问题，但在处理分叉的 GitHub 项目时，我对 origin 和 upstream 感到困惑，尤其是那些我无法直接提交的项目。
@GlennSlayden Git 不会让您错误地编辑远程跟踪分支。（我只是为了好玩。哈哈。）你最终会得到一个与任何分支名称无关的新提交。
@GlennSlayden origin 只是远程仓库的常规名称。 upstream 是另一个常规名称（用于从您的 repo 派生的远程 repo）。这些名称没有什么特别之处，您可以随意调用远程仓库的任何本地副本。

【解决方案4】：

概述

TL;DR - 这是有条理的，因此您可以跳到您需要了解的内容。

以下是我将介绍的内容：

快速概览 - 4 种类型的分支是什么以及在哪里可以找到它们
简短词汇表 - 与分支相关的基本原则和术语
调查 - 如何检查您的本地和远程分支机构
相关文件 - 配置文件
配置 - 如何查看和设置您的分支配置
协作 - 如何使用远程分支

快速概览

local 分支是我们local 存储库中的一个名称，它指的是here 的头。

remote 分支是remote 存储库上的一个名称，它指的是那里的头部。

一个简单的branch是一个引用某件事的本地名称：

它直接指向本地头，（即指向特定的提交；不断增长的提示）

tracking-branch 是一个本地名称，它引用了两件事：

它直接指向本地头，（即指向特定的提交；不断增长的提示），和
它象征性地指向远程存储库上的第二个分支。

有两种跟踪分支：

local - 分支指向本地头部。
这些称为本地-tracking-branches。 （更多内容见下文。）
remote - 分支指向远程头的本地副本。
这些称为远程-tracking-branches。 （更多内容见下文。）

以下是 4 种类型的分支，我们在哪里看到它们，以及它们的映射方式：

WHERE    ---BRANCH TYPE--------     --REFERENCE TARGETS-------

--------------------------------------------------------------
Remote   simple branch -----------> remote head (a commit ID)

--------------------------------------------------------------
Local    simple branch -----------> local  head (a commit ID)


Local    local  tracking-branch --> local  head (a commit ID1)
                                --> Remote-name/branch-name

Local    remote tracking-branch --> local  head (a commit ID2)
                                --> Remote-name/branch-name
--------------------------------------------------------------

简短词汇表

Remote 和 Branch 这两个术语似乎超载了。

tracking branch 这个短语特别令人困惑，因为它与 tracking-branch 并不是一回事。

'a snapshot'      - A recording of the state of one or more files 
                    and their contents at a given moment in time.

'a commit'        - A container holding one snapshot, the date and
                    time it was  recorded, who recorded it, and a
                    comment to say what it's all about.

'a repository'    - A repository of commits, organized so we can 
                    look thru them, going backwards in time.

                    Much like photos added in sequence to a photo
                    album book, to record our own history, each commit
                    contains a snapshot of the exact state of our
                    project at a given moment in time.
                    
                    It is used to be able to look backwards in time to
                    how it was at any recorded previous time.

'Remote'          - (Upper case) Short for 'a named remote repository'
                                 (of commits, of snapshots)

'remote'          - (Lower case) Located on  another     git repository
'local'           -              Located on  your local  git repository

'a head'          - A specific young commit, with no children yet of
                    it's own (i.e. no other commits yet pointing to it),
                    but which may link backwards in time to one or more
                    of it's natural parents.

                    Also called a growing tip.
                    Initially set to a <start-point>. 


'a branch'        - A symbolic name (i.e. an identifier) pointing
                    to one specific head, and possibly, depending on
                    the branch type, also pointing to a remote branch.

                    The term 'branch' can also refer to a specific
                    linked list of multiple commits (plural), starting 
                    from the growing tip (or most recent baby), and 
                    linking offspring to their parent(s) backwards in
                    time.

'tracks'          - As we move forward, tracks are what we leave behind.

'tracked'         - To be followed, as in, to come afterwards, or after
                    the fact, by way of the evidence left behind, of the
                    a state of being of the thing being tracked, as it
                    moves forwards in time.

'tracking'        - The process of capturing and organizing snapshots of
                    our project so we can later look backwards in time
                    to find how it previously was.

'tracking-branch' - This term is somewhat redundant, and confusing, 
                    but does have a specific, important meaning.

                    I have deliberately added the hyphen, because this
                    term does NOT mean simply 'tracking branch'.  (Grab
                    your aspirin, and a cold pack for your head, lol.)


                    Because all branches in git are used for, and only
                    used for, tracking your project, therefore it could
                    be said that ALL branches are actually 
                    'tracking-branches', but we don't call them that.

                    Instead we call them, simply 'branches'.


                    But then what is a 'tracking-branch'?

         TL;DR      A 'tracking-branch' is a local name that points to
                    two branches at the same time.
                    
                      So when you read  'tracking-branch,  it might be 
                      helpful to instead think:  'branch-pair'.

                        (Normal branches only point to one thing, the
                        head, which is the commit at a growing tip.
                        And they do not have any symbolic pointers.)


                    1) The first branch a 'tracking-branch' points to
                    is the same as for any other branch:  a local head,
                    (i.e. a young commit in our local repository without 
                    any children.)  This is where a tracking-branch
                    keeps a full local copy of a remote branch.

                      Note that it doesn't necessiarialy hold a full
                      duplicate copy of the entire second, remote 
                      repository.  If you have cloned the remote 
                      repository then you already have most, if not all
                      of their commits in your own local repository.


                    2) The second branch a 'tracking-branch' points to
                    is a branch on a remote repository.

                      It does this with a <remote-name>/<branch-name>.
                      The 'remote-name' is used to find the URL to the 
                      remote repository.  See `git remote -v`.

                    Why point to two branches?  

                      This is to be able to operate on two heads at the
                      same time, like to copy commits from one head to
                      the other as `git fetch` and `git push` does.


                    We have two types of 'tracking-branches' (both on
                    our local repository):
                    
                      'local  tracking-branches', 
                           with a simple     branch name,  and
                           
                      'remote tracking-branches', 
                           with a path-style branch name.
                           
                      See `git branch -avv`.  For example:

这里输出的第一两行是local tracking-branches。 master 前缀的星号 (*) 告诉我们 master 当前是默认分支（即检出到我们工作区的内容）。顺便说一句，名称master 是refs/heads/master 的缩写。
第三行输出是一个简单的本地分支。
第 4 行输出不是根本不是一个分支，而是第二个本地 HEAD（除了我们正常的本地 HEAD），它指向默认的远程跟踪分支，或者其中一个在此示例中遵循分支。使用git remote set-head <remote-name> <remote tracking-branch name> 进行设置。（请注意，这也与git remote show <remote-name> 返回的 HEAD 不同，后者是远程存储库 HEAD 的下载值。）
最后两行输出是远程跟踪分支。

请注意，所有分支都引用一个提交 ID（十六进制数）。 remotes/origin/HEAD 不是分支所以没有这个。

另请注意，前两行和最后两行还具有对远程分支（在本例中名为 origin）的分支的符号引用。

这里的“master”是我们本地的工作分支。而remotes/origin/master 是名为master 的分支的本地副本，从我们称为origin 的远程获取（通过git fetch、git clone 或git pull）。

（顺便说一句，origin 是我们最初克隆的远程存储库的默认名称，使用 git clone 命令。）

                    So our 'remote tracking-branches' are not remote 
                    branches, on a remote repository, but rather are 
                    local branches, which have a local head of their
                    own, pointing to a local commit, and also at the 
                    same time symbolically pointing, to a remote 
                    branch.

                    With `git branch -avv`, notice how two branches can
                    point to origin/remote:
                    
                    * the first  being the  'local-tracking-branch' 
                      with the name        'master', and with the
                      '[origin/master]' extra clause,  and 
                      
                    * the second being the 'remote-tracking-branch'
                      with the name 'origin/master'.


                    NOTE: Though they point to the same remote branch, 
                    the local commit head is not always the same!
                    
                    Thus they are actually two different branches.  
                    
                    The 'local-tracking-branch' is our working branch, 
                    and the 'remote-tracking-branch' is a copy of the 
                    remote's branch that we cloned from or fetched to
                    update.

调查

遥控器

git remote                      # List names of known Remotes  

git remote -v                   # List names of known Remotes and
                                #   show the 2 URL's pointing to them  
                                #
                                #  See '[remote "<names>"]' in
                                #    $ cat .git/config

远程分支（位于远程存储库中）

git remote show <remote-name>   # Download and view 
                                #   a specific Remote's info.

# for example, let's download the information for 
# two remotes named origin and upstream:

前导星号 (*) 是一个项目符号，用于标记来自给定远程的数据的开始。我们请求从两个遥控器下载，所以我们有两个项目符号。
第 1 行输出给出了遥控器的名称，以单词“remote”开头。
第 2 行和第 3 行 报告了我们为名为 origin 的远程配置的本地配置的 获取和推送 URL。也可以通过git remote -v查看它们。
第 4 行报告 来自远程存储库的 HEAD。你不能设置这个 HEAD。也不和本地 HEAD 一样，也不是从 git branch -avv 远程读取的本地
从 第 6 行 开始是远程存储库拥有的分支列表。

远程分支：主跟踪跟踪更新
然后 torek 说this 剩下的行：

所有 git remote show 所做的就是通过互联网电话使用git ls-remote 调用[远程]，并将它们的引用与您的引用进行比较，以猜测git fetch 和git push 会做什么，基于这些结果。（如果你使用git pull，那就意味着运行git fetch，然后运行git merge。git remote show 命令也试图猜测它会做什么。）

本地分支（位于本地存储库中）

git branch -avv  # Show ALL  'local branches', verbosely;  (3 types):


git branch -rv   # -- type 1 -------------------------------------
                 # Show ONLY 'local branches' that point to
                 # 'remote branches' (-r = remote; -v = verbose)
                 #
                 #   This lists your 'Remote tracking branches'!
                 #     From:  $ tree .git/refs/remotes/*
                 #
                 #      They allow us to move snapshots between
                 #       repositories, and to keep a copy of
                 #       Remote's branches locally.

git branch -vv   # -- types 2 and 3 ------------------------------
                 # Show ONLY 'local branches', that point to local
                 # things, but his includes two different types of
                 #  branches mixed together, for example:

* master  de430b6 [origin/master] <comment describing this branch>
  updates 3c40299 [origin/updates] <comment describing this branch>
  foo     de430b6  <comment describing this branch>

请注意，名为 master 和 updates（上图）的前两个分支在其提交编号之后都有一个附加字段。例如，对于名为“master”的分支，此字段为[origin/master]。

这告诉我们，这两个分支不是普通的本地分支，而是本地跟踪分支。与上面的“远程跟踪分支”类似，它们也象征性地指向远程分支。因此，在这种情况下，master 不仅指向本地存储库中的分支head，而且还指向远程存储库中的origin/master。

这些额外的字段由 .git/config 中的参数设置。

相比之下，foo 这里是一个简单、正常的分支，即不跟踪。

配置

使用git branch, git checkout -b 创建，或通过使用git clone 克隆远程存储库，或者通过直接编辑.git/config 或使用这些来明确管理：

遥控器

通过克隆 git 存储库隐式使用 git remote 创建 git clone.

git remote add - 显式添加新的远程名称（到 .git/config）
git remote rename
git remote remove - 删除远程
git remote prune - 删除已在远程删除的任何本地远程跟踪分支

设置属性：

git set-url - 设置一个 url，或者为遥控器替换一个 url
git set-url --add - 将 url 附加到远程的 url 列表中
git set-url --delete - 删除所有匹配模式的网址
git set-branches - 更改跟踪分支的集合
git set-branches --add - 追加，而不是完全替换当前跟踪的分支列表
git set-head - 设置 default 远程分支（即远程的 HEAD）
git set-head --auto - 查询远程以设置远程分支的本地 HEAD
git set-head --delete - 删除 default 远程分支（即远程的 HEAD）

分支机构

git branch  [--set-upstream | --track | --no-track]  [-l] [-f]               <NewBranchName> [<start-point>]   # create branch         (start point defaults to HEAD)

git branch  (--set-upstream-to=<upstream-branch> | -u <upstream-branch>)       [<BranchName>]                  #   link to upstream branch
git branch --unset-upstream                                                    [<BranchName>]                  # unlink to upstream branch


git branch --edit-description                                                  [<BranchName>]                  # edit   branch description


git branch (-m | -- move | -M)                              [<oldBranchName>] <newBranchName>                  # rename (move) branch; -M = force

git branch (-d |           -D) [-r]                                             <BranchName>...                # delete branch

合作

使用默认配置，当您git clone 这会自动设置您的遥控器和跟踪分支。但请注意，有些配置设置会禁用或更改其工作方式。

提示使用git fetch 和git push 上的--dry-run 选项，在执行此操作之前先查看会发生什么。

使用 git fetch（可能通过调用 git pull）更新远程提交的本地副本以使您保持最新状态。

如果不包含 a 则使用默认值。您可以在[remote "<remote-name>"] 下的fetch= 属性中查看.git/config 中的默认值。这可能看起来像这样：

[remote "origin"]
    fetch = +refs/heads/*:refs/remotes/origin/*

语法是[+]?<source>:<destination>。这意味着从.git/refs/heads/* 获取参考（通常是提交和标签），它们是远程存储库中正常的简单分支，并将它们放入我们的本地.git/refs/remotes/origin/* 分支，这是我们的跟踪分支。酷，嗯！顺便说一句，“+”表示更新，即使这不会是快进。

使用 git push <remote> <branch> 将本地提交发送到您有权写入的远程存储库。

我希望这一切都是正确的。

【讨论】：

遥控器：

您机器上的分支：

1。当地分支机构

1.1 非跟踪本地分支

1.2。跟踪当地分支机构

2。远程跟踪分支（仍在您的机器上）

远程机器上的分支：

备忘单：

概述

快速概览

简短词汇表

调查

相关文件

配置

合作