'git pull'和'git fetch'有什么区别？

Question

  

版主注意：鉴于此问题已经发布了六十七个答案（其中一些被删除），请考虑您是否在发布另一个之前，提供任何新的 。

git pull和git fetch之间有什么区别？

Answer 1

用最简单的术语来说，git pull执行git fetch后跟git merge。

您可以随时git fetch更新refs/remotes/<remote>/下的远程跟踪分支。

此操作永远不会更改refs/heads下您自己的任何本地分支机构，并且可以安全地执行此操作而无需更改您的工作副本。我甚至听说有人在后台的cron作业中定期运行git fetch（虽然我不建议这样做）。

您可以采用git pull来使本地分支机构与其远程版本保持同步，同时还可以更新其他远程跟踪分支机构。

Git文档 - git pull：

  

在默认模式下，git pull是git fetch的简写，后跟git merge FETCH_HEAD。

Answer 2

• 当您使用pull时，Git会尝试自动为您完成工作。 它是上下文相关的，因此Git会将任何提取的提交合并到您当前使用的分支中。pull 会自动合并提交，而不会让您先查看它们 。如果您不密切管理您的分支机构，则可能会经常发生冲突。

• 当您fetch时，Git会收集目标分支中当前分支中不存在的任何提交，将它们存储在本地存储库中。但是，它不会将它们与您当前的分支合并。如果您需要使您的存储库保持最新，但在更新文件时正在处理可能会中断的内容，这将非常有用。 要将提交集成到主分支中，请使用merge。

Answer 3

将git的设计理念与更传统的源代码控制工具（如SVN）的理念进行对比非常重要。

Subversion是使用客户端/服务器模型设计和构建的。有一个存储库是服务器，有几个客户端可以从服务器获取代码，对其进行处理，然后将其提交回服务器。假设客户端可以在需要执行操作时始终联系服务器。

Git旨在支持更加分散的模型而不需要中央存储库（尽管如果您愿意，您当然可以使用它）。此外，git的设计使客户端和“服务器”不需要同时在线。 Git的设计使得不可靠链接的人们甚至可以通过电子邮件交换代码。可以完全断开连接并刻录CD以通过git交换代码。

为了支持这个模型，git使用您的代码维护一个本地存储库，还有一个镜像远程存储库状态的附加本地存储库。通过在本地保留远程存储库的副本，即使无法访问远程存储库，git也可以确定所需的更改。稍后当您需要将更改发送给其他人时，git可以将它们作为一组更改从远程存储库已知的时间点进行传输。

• git fetch 是显示“使我的远程存储库的本地副本保持最新状态”的命令。

• git pull 说“将远程存储库中的更改带到我保留自己代码的位置。”

通常 git pull 通过执行 git fetch 来使远程存储库的本地副本更新，然后合并更改到您自己的代码存储库以及可能的工作副本。

需要注意的是，工作站上的项目通常至少有三个项目。一个副本是您自己的存储库，具有您自己的提交历史记第二个副本是您正在编辑和构建的工作副本。第三个副本是远程存储库的本地“缓存”副本。

Answer 4

以下是Oliver Steele's image of how all it all fits together：

如果有足够的兴趣，我想我可以更新图片以添加git clone和git merge ...

Answer 5

git fetch的一个用例是，以下将告诉您自上次拉动以来远程分支中的任何更改...因此您可以在执行实际拉动之前进行检查，这可能会更改当前分支中的文件和工作副本。

git fetch
git diff ...origin

Answer 6

我要花一点时间来了解有什么区别，但这是一个简单的解释。您本地主机中的master是一个分支。

克隆存储库时，将整个存储库提取到本地主机。这意味着那时你有一个指向HEAD的主/指针和指向同一HEAD的主指针。

当你开始工作并做提交时，你将主指针前进到HEAD +你的提交。但是，原始/主指针仍指向克隆时的内容。

所以区别在于：

• 如果您执行git fetch，它将只获取远程存储库中的所有更改（GitHub）并将原点/主指针移动到HEAD。与此同时，您当地的分公司主人将继续指向它所在的位置。
• 如果您执行git pull，它将基本上进行提取（如前所述）并将任何新更改合并到主分支并将指针移至HEAD。

Answer 7

有时视觉表现会有所帮助。

Answer 8

<强>简言之

git fetch与pull类似，但不合并。即它获取远程更新（refs和objects），但您的本地保持不变（即origin/master更新，但master保持不变。

git pull从遥控器上拉下来并立即合并。

更多

git clone克隆回购。

git rebase将当前分支中不在上游分支中的内容保存到临时区域。您的分支现在与开始更改之前的分支相同。因此，git pull -rebase将关闭远程更改，回退本地分支，逐个重播您当前分支的顶部更改，直到您获得最新信息。

此外，git branch -a会告诉您所有分支机构的确切情况 - 本地和远程分支。

这篇博文很有用：

The difference between git pull, git fetch and git clone (and git rebase) - Mike Pearce

并涵盖git pull，git fetch，git clone和git rebase。

====

更新

我以为我会更新这个以显示你在实践中如何实际使用它。

1. 从远程更新您的本地仓库（但不要合并）：

   git fetch 
   

2. 下载更新后，让我们看看差异：

   git diff master origin/master 
   

3. 如果您对这些更新感到满意，请合并：

   git pull
   

注意：

在第2步：有关本地和遥控器之间差异的更多信息，请参阅：How to compare a local git branch with its remote branch?

在第3步：在这里做git rebase origin可能更准确（例如在快速变化的回购中）。请参阅另一个答案中的@Justin Ohms comment。

另请参阅：http://longair.net/blog/2009/04/16/git-fetch-and-merge/

Answer 9

git-pull - Fetch from and merge with another repository or a local branch
SYNOPSIS

git pull   …
DESCRIPTION

Runs git-fetch with the given parameters, and calls git-merge to merge the 
retrieved head(s) into the current branch. With --rebase, calls git-rebase 
instead of git-merge.

Note that you can use . (current directory) as the <repository> to pull 
from the local repository — this is useful when merging local branches 
into the current branch.

Also note that options meant for git-pull itself and underlying git-merge 
must be given before the options meant for git-fetch.

如果您想要合并历史记录，您可以选择，如果您只是想要“codez”，则需要提取，因为某些人已在此处标记了一些文章。

Answer 10

您可以从远程存储库中获取，查看差异，然后拉取或合并。

这是一个名为origin的远程存储库和一个名为master的分支跟踪远程分支origin/master的示例：

git checkout master                                                  
git fetch                                        
git diff origin/master
git rebase origin master

Answer 11

简单明了的答案是git pull只是git fetch后跟git merge。

非常重要的是要注意git pull 会自动合并您是否喜欢。当然，这可能导致合并冲突。假设你的遥控器是origin，你的分支是master。如果您在拉动之前git diff origin/master，您应该知道潜在的合并冲突，并可以相应地准备您的本地分支。

除了拉动和推动之外，some workflows还涉及git rebase，例如这个，我在链接的文章中解释过：

git pull origin master
git checkout foo-branch
git rebase master
git push origin foo-branch

如果你发现自己处于这种情况，你可能会被诱惑git pull --rebase。除非你真的，真的知道你在做什么，否则我会反对。此警告来自man版本git-pull的{​​{1}}页面：

  

这是一种潜在的危险操作模式。它改写了   历史，当你发表那段历史时，这并不是个好兆头   已经。除非您已阅读git-rebase（1），否则请勿使用此选项   小心。

Answer 12

好的，以下是有关git pull和git fetch的一些信息，因此您可以通过简单的单词获取来了解实际差异... strong>获取最新数据，但不是代码更改而不会弄乱您当前的本地分支代码，但 pull 获取代码更改并将其合并到您的本地分支，继续阅读以获取更多详细信息关于每个：

git fetch

它会将所有参考和对象以及所有新分支下载到您的本地资源库...

  

从一个或多个获取分支和/或标记（统称为“refs”）   其他存储库，以及完成它们所需的对象   历史。远程跟踪分支已更新（请参阅说明   以下是控制此行为的方法。）

     

默认情况下，指向要获取的历史记录的任何标记都是   也取了效果是获取指向分支的标签   您感兴趣的是。可以使用更改此默认行为   --tags或--no-tags选项或通过配置   remote..tagOpt。通过使用明确提取标签的refspec，   你可以获取不指向你感兴趣的分支的标签   同样。

     

git fetch可以从单个命名存储库或URL获取，或者   如果给出了几个存储库，并且有一个存储库   遥控器。配置文件中的条目。 （参见git-config 1）。

     

如果未指定遥控器，则默认情况下为原点遥控器   使用，除非有为当前配置的上游分支   分支。

     

提取的引用名称以及对象名称   他们指向，写入.git / FETCH_HEAD。这些信息可能是   由脚本或其他git命令使用，例如git-pull。

git pull

它会将远程中的更改应用于本地的当前分支 ...

  

将来自远程存储库的更改合并到当前分支中。   在默认模式下，git pull是git fetch的简写，后跟   git merge FETCH_HEAD。

     

更确切地说，git pull使用给定的参数运行git fetch   调用git merge将检索到的分支头合并到当前   科。使用--rebase，它运行git rebase而不是git merge。

     

应该是传递给的远程存储库的名称   GIT中取1。可以命名任意远程引用（例如，   标签的名称）甚至是具有相应标志的refs集合   远程跟踪分支（例如，refs / heads / ：refs / remotes / origin / ），   但通常它是远程存储库中分支的名称。

     

从中读取和的默认值   由当前分支设置的“远程”和“合并”配置   git-branch --track。

我还在下面创建视觉，向您展示git fetch和git pull如何一起工作......

Answer 13

这种交互式图形表示非常有助于理解git：http://ndpsoftware.com/git-cheatsheet.html

git fetch只是＆＃34;下载＆＃34;从远程到本地存储库的更改。 git pull下载更改并将其合并到当前分支中。 ＆＃34;在默认模式下，git pull是git fetch的简写，后跟git merge FETCH_HEAD。＆＃34;

Answer 14

加成：

说到拉＆amp;取得上述答案，我想分享一个有趣的技巧，

的 git pull --rebase

以上命令是我git生活中最有用的命令，节省了大量时间。

在将新提交推送到服务器之前，请尝试此命令，它将自动同步最新的服务器更改（使用fetch + merge），并将您的提交放在git log的顶部。无需担心手动拉/合并。

详情请见：http://gitolite.com/git-pull--rebase

Answer 15

我喜欢用一些视觉表现来掌握这些事情。也许其他开发者也希望看到它，所以这是我的补充。我不完全确定这一切都是正确的，所以如果你发现任何错误请发表评论。

                                         LOCAL SYSTEM
                  . =====================================================    
================= . =================  ===================  =============
REMOTE REPOSITORY . REMOTE REPOSITORY  LOCAL REPOSITORY     WORKING COPY
(ORIGIN)          . (CACHED)           
for example,      . mirror of the      
a github repo.    . remote repo
Can also be       .
multiple repo's   .
                  .
                  .
FETCH  *------------------>*
Your local cache of the remote is updated with the origin (or multiple
external sources, that is git's distributed nature)
                  .
PULL   *-------------------------------------------------------->*
changes are merged directly into your local copy. when conflicts occur, 
you are asked for decisions.
                  .
COMMIT            .                             *<---------------*
When coming from, for example, subversion, you might think that a commit
will update the origin. In git, a commit is only done to your local repo.
                  .
PUSH   *<---------------------------------------*
Synchronizes your changes back into the origin.

获取遥控器镜像的一些主要优点是：

• 效果（滚动所有提交和消息，而不是试图通过网络挤压它）
• 反馈关于你当地回购的状态（例如，我使用Atlassian的SourceTree，它会给我一个灯泡，表明我是否提交了与原点相比提前或落后。这个信息可以用GIT FETCH更新。

Answer 16

我也在努力解决这个问题。事实上，我在谷歌搜索完全相同的问题。阅读所有这些答案终于在我脑海中画了一幅画，我决定尝试着看看2个存储库和1个沙盒的状态以及随着时间的推移在观看它们的版本时执行的操作。所以这就是我想出来的。如果我搞砸了，请纠正我。

带有fetch的三个回购：

---------------------     -----------------------     -----------------------
- Remote Repo       -     - Remote Repo         -     - Remote Repo         -
-                   -     - gets pushed         -     -                     -
- @ R01             -     - @ R02               -     - @ R02               -
---------------------     -----------------------     -----------------------

---------------------     -----------------------     -----------------------
- Local Repo        -     - Local Repo          -     - Local Repo          -
- pull              -     -                     -     - fetch               -
- @ R01             -     - @ R01               -     - @ R02               -
---------------------     -----------------------     -----------------------

---------------------     -----------------------     -----------------------
- Local Sandbox     -     - Local Sandbox       -     - Local Sandbox       -
- Checkout          -     - new work done       -     -                     -
- @ R01             -     - @ R01+              -     - @R01+               -
---------------------     -----------------------     -----------------------

带拉的三个回购

---------------------     -----------------------     -----------------------
- Remote Repo       -     - Remote Repo         -     - Remote Repo         -
-                   -     - gets pushed         -     -                     -
- @ R01             -     - @ R02               -     - @ R02               -
---------------------     -----------------------     -----------------------

---------------------     -----------------------     -----------------------
- Local Repo        -     - Local Repo          -     - Local Repo          -
- pull              -     -                     -     - pull                -
- @ R01             -     - @ R01               -     - @ R02               -
---------------------     -----------------------     -----------------------

---------------------     -----------------------     -----------------------
- Local Sandbox     -     - Local Sandbox       -     - Local Sandbox       -
- Checkout          -     - new work done       -     - merged with R02     -
- @ R01             -     - @ R01+              -     - @R02+               -
---------------------     -----------------------     -----------------------

这有助于我理解为什么提取非常重要。

Answer 17

GIT抓取和 GIT拉之间的区别可以通过以下方案解释： （请记住，图片胜于文字！，我提供了图片表示）

让我们举一个例子，说明您正在与团队成员一起开展项目。因此，他们将成为项目的一个主要分支，所有贡献者必须将其分叉到他们自己的本地存储库，然后在本地分支上工作以修改/添加模块，然后返回主分支。

所以， 在本地存储库中分叉主项目时，两个分支的初始状态将是这样的 - （A，B和C已经完成的模块该项目）

现在，您已经开始处理新模块（假设D），当您完成D模块时，您想将其推送到主分支，但同时发生的是一个您的队友已经开发了新模块E，F和修改后的C 所以现在发生的事情是您的本地存储库缺少项目的原始进度，因此将更改推送到主分支可能会导致冲突并可能导致模块D出现故障。

为避免此类问题并与项目的原始进度并行工作，他们有两种方式：

<强> 1。 Git Fetch - 这将下载对原始/主分支项目所做的所有更改，这些更改在本地分支中不存在。并将等待Git Merge命令将已提取的更改应用于您的存储库或分支。

现在，您可以在将文件合并到存储库之前仔细监视这些文件。如果需要，您还可以修改D，因为修改了C。

<强> 2。 Git Pull - 这将使用origin / main分支更新本地分支，即实际上它的作用是Git Fetch和Git的组合一个接一个地合并。 但这可能会导致冲突发生，所以建议使用Git Pull和干净的副本。

Answer 18

我们只是说：

git pull == git fetch + git merge

如果您运行git pull，则无需将数据合并到本地。如果您运行git fetch，则表示您必须运行git merge才能获取本地计算机的最新代码。否则，如果没有合并，则不会更改本地机器代码。

所以在Git Gui中，当你进行提取时，你必须合并数据。获取本身不会使您的本地代码更改。您可以通过提取更新代码来检查 一旦取得并看到;它不会改变的代码。然后你合并......你会看到改变的代码。

Answer 19

git fetch将代码从远程服务器下拉到本地存储库中的跟踪分支。如果您的遥控器名为origin（默认设置），则这些分支将位于origin/内，例如origin/master，origin/mybranch-123等。这些不是您当前的分支机构，它们是是来自服务器的那些分支的本地副本。

git pull执行git fetch，但也将跟踪分支中的代码合并到您当前的该分支的本地版本中。如果您尚未准备好进行更改，请先git fetch。

Answer 20

git fetch将检索远程分支，以便您可以使用当前分支git diff或git merge。 git pull将在当前分支跟踪的远程brach上运行fetch，然后合并结果。您可以使用git fetch查看远程分支是否有任何更新，而无需将它们与本地分支合并。

Answer 21

Git Fetch

您可以通过提取将更改从源下载到本地分支。 Fetch向远程仓库询问其他人已经提交的所有提交但您没有在本地仓库上提交。 Fetch下载这些提交并将它们添加到本地存储库。

Git Merge

您可以使用merge命令应用通过fetch下载的更改。合并将从fetch中检索提交，并尝试将它们添加到本地分支。合并将保留本地更改的提交历史记录，以便当您使用push共享分支时，Git将知道其他人如何合并您的更改。

Git Pull

获取和合并运行得足够频繁，以至于创建了一个结合了两者的命令pull。 Pull执行获取然后合并以将下载的提交添加到本地分支。

Answer 22

git pull和git fetch之间的唯一区别是：

git pull从远程分支拉出并合并它。

git fetch仅从远程分支获取但不合并

即。 git pull = git fetch + git merge ...

Answer 23

Git允许在较新的提交后应用按时间顺序排列的旧提交。 因此，在存储库之间传递提交的行为分为两个步骤：

1. 将新提交从远程分支复制到本地存储库中此远程分支的副本。

   （repo to repo operation）master@remote >> remote/origin/master@local

2. 将新提交集成到本地分支

   （内部回购操作）remote/origin/master@local >> master@local

有两种方法可以执行第2步。您可以：

1. 在最后一个共同祖先之后的fork本地分支，并添加与本地存储库唯一的提交并行的新提交，通过合并提交，关闭fork来最终确定。
2. 在最后一个共同祖先之后插入新提交，并重新应用对本地存储库唯一的提交。

在git术语中，第1步为git fetch，第2步为git merge或git rebase

git pull是git fetch和git merge

Answer 24

Git使用两个命令从远程到本地获取最新版本的分支：

1. git fetch：Git将从远程到本地获取最新版本，但它不会自动合并。 git fetch origin master git log -p master..origin/master git merge origin/master

   上述命令意味着从远程到原始主分支的原点下载最新版本的主分支。然后比较本地主分支和原始主分支。最后，合并。

2. git pull：Git将从远程获取最新版本并合并到本地。

   git pull origin master

   上述命令相当于git fetch和git merge。在实践中，git fetch可能更安全，因为在合并之前我们可以看到更改并决定是否合并。

Answer 25

  

git pull和git fetch之间的区别是什么？

要理解这一点，首先需要了解您的本地git不仅维护本地存储库，还维护远程存储库的本地副本。

git fetch使您的远程存储库的本地副本保持最新状态。例如，如果您的远程存储库是GitHub - 您可能希望将远程存储库中所做的任何更改提取到远程存储库的本地副本。这将允许您执行比较或合并等操作。

另一方面，

git pull会将远程存储库中的更改记录到您保留自己代码的位置。通常，git pull将首先执行git fetch以使远程存储库的本地副本保持最新，然后它会将更改合并到您自己的代码存储库以及可能的工作副本中。

Answer 26

git pull ==（git fetch + git merge）

git fetch不会更改为本地分支。

如果您已经有一个本地存储库，其中包含为所需项目设置的远程数据库，则可以使用git fetch获取现有远程数据库的所有分支和标记。 ... Fetch不会对本地分支进行任何更改，因此您需要将远程分支与配对的本地分支合并以合并新的提取更改。 from github

Answer 27

努力做到清晰简单。

git pull 命令实际上是 git fetch 的shortcut，然后是 git merge 或 git rebase 命令，具体取决于您的配置。您可以配置Git存储库，以便 git pull 是一个提取，然后是一个rebase。

Answer 28

实际上Git会保留您自己代码的副本 远程存储库。

命令git fetch通过从远程存储库获取数据使您的本地副本保持最新。我们需要这个的原因是因为其他人可能对代码进行了一些更改，并且您希望自己更新。

命令git pull将远程存储库中的更改带到您保存自己代码的位置。通常，git pull通过首先执行'git fetch'来使远程存储库的本地副本更新来完成此操作，然后将更改合并到您自己的代码存储库以及可能的工作副本中。

Answer 29

list.size()

Answer 30

初学者的简单图形表示，

这里，

git pull  

将从您的本地获取存储库和rebase的代码...在git pull中可能会创建新的提交。

但在，

git fetch

将从存储库中获取代码，我们需要使用git rebase

手动重新绑定它

例如：我将从服务器主服务器获取并在我的本地主服务器中重新绑定它。

1）git pull（rebase将自动完成）：

git pull origin master

此处来源是您的远程回购主是您的分支

2）git fetch（需要手动重新绑定）：

git fetch origin master

它将从源获取服务器更改。它会在你的本地，直到你自己改变它。我们需要通过检查代码手动修复冲突。

git rebase origin/master

这会将代码重新绑定到本地。在此之前，请确保您处于正确的分支。

Answer 31

来自Pro Git § 2.5 Git Basics - Working with Remotes: Fetching and Pulling from Your Remotes：

  

值得注意的是，fetch命令会将数据提取到本地存储库 - 但事实并非如此   自动将其与您的任何作品合并或修改您的作品   目前正在努力。您必须手动将其合并到您的工作中   当你准备好了。

     

如果您设置了分支来跟踪远程分支，则可以使用   git pull命令自动获取然后合并远程   分支到您当前的分支。这可能更容易或更多   舒适的工作流程;默认情况下，git clone命令   自动设置本地主分支以跟踪远程   你克隆的服务器上的master分支（假设远程有一个   主分支）。运行git pull通常从中获取数据   您最初克隆的服务器并自动尝试合并它   进入你目前正在处理的代码。

Answer 32

git pull

它使用单个命令执行两个功能。

它获取对远程分支所做的所有更改，然后将这些更改合并到本地分支中。您还可以通过传递--rebase来修改pull的行为。合并和rebase之间的区别可以是here

git fetch

Git fetch只执行git pull的一半工作。它只是将远程更改带入您的本地仓库，但不会将它们应用到您的分支机构。您必须明确应用这些更改。这可以按如下方式完成：

git fetch
git rebase origin/master

Answer 33

必须牢记git的本质。你有遥控器和你当地的分支机构（不一定相同）。与其他源控制系统相比，这可能有点令人困惑。

通常在结帐远程时，会创建跟踪远程的本地副本。

git fetch将与远程分支一起使用并更新您的信息。

实际情况是，如果其他SWE在同一个分支机构中工作，很少在小型机构中进行 - 一个分支 - 一个项目场景。

您在当地分行的工作仍然完好无损。为了将更改带到本地分支，您必须合并/重新定义远程分支的更改。

git pull完成了这两个步骤（即--rebase到rebase而不是merge）

如果您的本地历史记录和远程历史记录存在冲突，您将被迫在git推送期间进行合并以发布更改。

因此，它实际上取决于您的工作环境的性质，并体验使用的内容。

Answer 34

来自git cheat sheet：

git fetch <remote> // Download all changes from <remote>, but don't integrate into HEAD
git pull <remote> <branch> // Download changes and directly merge/integrate into HEAD

Answer 35

据我所知，

Git pull - 从指定的遥控器（由用户指定）向下拉，并立即将其合并到我们目前所在的分支中。它基本上是Fetch和Merge命令的混合。

Git Fetch - 与 Pull 相同，但不会进行任何合并。因此，您可以在合并之前仔细监视文件。

此网址必须有助于进一步了解：The difference between git pull, git fetch and git clone (and git rebase).

Answer 36

简单来说，如果您要跳上没有互联网的飞机……在出发前，您可以进行git fetch origin <master>。它会将所有更改取到您的计算机中，但将其与本地开发/工作区分开。

在飞机上，您可以更改本地工作区，然后将其与您获取的内容合并，并解决潜在的合并冲突，而无需互联网。并且除非有人对远程仓库进行了 new 冲突的更改，否则一旦到达目的地，您就可以git push origin <branch>去喝咖啡

---

此出色的Attlassian教程中：

  

git fetch命令从以下位置下载提交，文件和引用：   远程存储库到本地存储库中。

     

当您想了解所有人 拥有的东西时，便是获取操作   一直在努力。它与svn update类似，它可以让您看到   中央历史如何发展，但这并不会迫使您   实际上将更改合并到您的存储库中。 Git 隔离   从现有本地内容中获取内容，   对您的本地开发工作没有影响。必须使用git checkout命令显式检出已提取的内容。这使得   在将提交与之集成之前，获取一种安全的方式来审查提交   您的本地存储库。

     

从远程存储库下载内容时，可以使用git pull和git fetch命令来完成任务。你可以考虑   git fetch这两个命令的“安全”版本。它将下载   远程内容，但不会更新本地存储库的工作状态，   保留您当前的工作。 git pull更具攻击性   或者，它将下载活动本地的远程内容   分支并立即执行git merge以创建合并提交   用于新的远程内容。如果您有正在进行的更改   这将导致冲突并启动合并冲突解决方案   流。

---

使用git pull：

• 您没有任何隔离。
• 它会影响您的本地发展。
• 不需要显式签出。因为它隐式地执行git merge。
• 这基本上是不安全的。这很进取。
• 与git fetch仅影响.git/refs/remotes的情况不同，git pull将同时影响.git/refs/remotes 和 .git/refs/heads/

---

嗯...所以，如果我不使用git fetch更新工作副本，那么我在哪里进行更改？ git fetch在哪里存储新提交？

很好的问题。它将其放置在与工作副本隔离的位置。但是又在哪里？让我们找出答案。

在您的项目目录（即您执行git命令的位置）中：

1. ls。这将显示文件和目录。我知道这没什么。

2. 现在执行ls -a。这将显示dot files，即以.开头的文件，然后您将能够看到名为.git的目录。

3. 执行cd .git。显然，这将更改您的目录。
4. 现在是有趣的部分了；做ls。您将看到目录列表。我们正在寻找refs。做cd refs。
5. 查看所有目录中的内容很有趣，但让我们集中关注其中两个。 heads和remotes。也使用cd检查它们的内部。
6. 您执行的任何git fetch都将更新/.git/refs/remotes目录中的项目。它不会更新/.git/refs/heads目录中的任何内容。
7. 任何git pull都会先执行git fetch，更新/.git/refs/remotes目录中的项目，然后与本地合并，然后更改/.git/refs/heads目录中的标题。

---

也可以找到一个很好的相关答案Where does 'git fetch' place itself?

还要在Git branch naming conventions帖子中查找“斜线符号”。它可以帮助您更好地了解git如何将事物放置在不同目录中

Answer 37

简而言之：

git fetch：看看是否有新东西。

git pull：抓住新东西，把它放在你的东西之上。

Answer 38

简单说明：

git fetch

获取元数据。如果您要签出最近创建的分支，则可能要在签出之前进行提取。

git pull

从远程获取元数据，还将文件从远程移动并合并到分支上

Answer 39

此图形可能会有所帮助。 git pull本质上等同于git fetch，然后等于git merge

Answer 40

Git Fetch

帮助您了解git repository的最新更新。我们假设您使用GitFlow在团队中工作，其中团队负责多个branches（功能）。使用git fetch --all command，您可以了解branches内的所有新repository。

大部分git fetch与git reset一起使用。例如，您希望将所有本地更改还原为当前存储库状态。

git fetch --all // get known about latest updates
git reset --hard origin/[branch] // revert to current branch state

Git pull

此命令会使用当前branch repository状态更新您的branch。让我们继续GitFlow。多个功能branches为merged到develop分支，当您要为项目开发新功能时，您必须转到开发branch并执行git pull获取当前状态develop branch

  

GitFlow的文档https://gist.github.com/peterdeweese/4251497

Answer 41

所有分支都存储在.git/refs
中 所有本地分支都存储在.git/refs/heads
中 所有远程分支都存储在.git/refs/remotes

中

  

git fetch命令从以下位置下载提交，文件和引用：   远程存储库到本地存储库中。抓取是您要做的事   您想看看其他人正在做什么。

因此，当您git fetch执行所有操作时，所有文件，提交和引用都将下载到该.git/refs/remotes中 您可以切换到这些分支以查看更改。 您可以根据需要合并它们。

  

git pull不仅下载这些更改，还将它们合并到   当前分支。<< / p>

示例
如果要查看远程分支dev/jd/feature/auth的工作，只需执行
git fetch origin dev/jd/feature/auth。
现在，
git checkout dev/jd/feature/auth
查看更改或工作进度。

如果您执行git fetch origin，它将获取所有分支，现在您可以切换到所需的任何位置。您的本地管理员或其他本地分支机构不会受到影响。

Answer 42

我只想添加一些其他信息。 git pull是

git fetch 

跟着

git merge --ff

添加到合并中的此选项是不创建合并提交的原因。

Answer 43

我相信大多数答案都很好地回答了差异。我会强调何时使用哪个。

当您需要获取其他开发人员的更新但又希望继续进行自己的工作时，获取很有用。经常想离线工作的人使用fetch来获取最新更新，直到她/他在线。稍后，当她/她对更改感到满意时，将其从分支合并到他/她的工作区中。

鉴于那些正在网上工作并且非常确定自己的更改并希望获得最新代码并且merge的人立即使用pull。我很少使用fetch，因为要检查最新更新，请通过GitHub网站进行检查，而我始终离线工作。正如我提到的，您可能已经在上述情况下使用了。

Answer 44

Git fetch将远程存储库的目录同步到您的本地。它不会将文件/代码更改从远程合并到您的本地分支。

Git pull下载与当前本地分支相关的更改，然后将其合并。

Answer 45

有关该主题的精彩文章：https://www.git-tower.com/learn/git/faq/difference-between-git-fetch-git-pull

Answer 46

如大多数回答一样，毫无疑问git-pull是git-fetch plus merge。我想指出：

  

如果要在合并之前进行检查，则应使用 git-fetch，然后使用git-pull 。

在cronjob上这样做非常有用，如下面的脚本所示：

#!/bin/sh

git fetch upstream
if [ `git rev-list HEAD...upstream/master --count` -eq 0 ]
then
    echo "all the same, do nothing"
else
    echo "update exist, let's pull"
    git pull upstream master
    git push origin master
fi

Answer 47

一个git仓库包含不可变的数据blob和一些可变的指针/引用/名称（我们称它们为分支，HEADS）以提高可用性（从理论上讲，git可以是纯附加存储，只能通过提交哈希访问）。

不可变blob通常最终总是在所有贡献者之间共享。每个开发人员都在自己的计算机上拥有所有这些副本。

git fetch将最新的Blob和远程可变文件下载到您的计算机上。

它不会更改您的可变文件，也不会创建以前某个位置不存在的任何blob。

git pull是git fetch，然后是git merge。 git merge创建以前在远程存储库中不存在的新blob，并更新您的可变文件（您的引用）。

Answer 48

git 获取来源

git fetch 实际上只从远程存储库下载新数据 - 但它不会将任何这些新数据集成到您的工作文件中。 Fetch 非常适合以全新的视角了解远程存储库中发生的所有事情。 由于它的“无害”性质，您可以放心：fetch 永远不会操纵、破坏或搞砸任何东西。这意味着您永远无法获取足够频繁的数据。

git pull origin master

相比之下，git pull 用于不同的目标：使用来自远程服务器的最新更改来更新当前的 HEAD 分支。这意味着 pull 不仅下载新数据；它还直接将其集成到您当前的工作副本文件中。这有几个后果：

我们需要使用 git merge 后跟 git pull

Answer 49

简而言之：

Git Fetch类似于SQL SELECT。它只会向您显示某些内容，而不会更新或更改任何内容。

Git Pull就像SQL SELECT，然后，更新我的本地副本。