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

Question

主持人注意:鉴于此问题已经发布了67个答案(其中一些已删除),请考虑在发布另一个问题之前是否提供任何新内容.

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

Answer 1

用最简单的术语来说,git pulla git fetch后跟一个git merge.

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

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

git pull您可以使用A 来使本地分支与其远程版本保持同步,同时还可以更新其他远程跟踪分支.

Git文档:git pull

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通过执行a git fetch来使远程存储库的本地副本更新,然后将更改合并到您自己的代码存储库以及可能的工作副本中.

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

Answer 4

以下是奥利弗·斯蒂尔(Oliver Steele)关于这一切如何融合在一起的形象:

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

Answer 5

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

git fetch
git diff ...origin

Answer 6

我花了一点时间来了解有什么区别,但这是一个简单的解释.master在您的localhost中是一个分支.

克隆存储库时,将整个存储库提取到本地主机.这意味着那时你有一个origin/master指针HEAD指向同一个指针HEAD.

当你开始工作并做提交时,你将主指针前进到HEAD你的提交.但是,origin/master指针仍指向克隆时的内容.

所以区别在于:

• 如果你这样做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还将向您展示您所有分支机构的确切情况 - 本地和远程.

这篇博文很有用:

git pull,git fetch和git clone(以及git rebase)之间的区别 - Mike Pearce

和覆盖git pull,git fetch,git clone和git rebase.

====

UPDATE

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

1. 从远程更新本地仓库(但不要合并):

   git fetch 
   

2. 下载更新后,让我们看看差异:

   git diff master origin/master 
   

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

   git pull
   

笔记:

在第2步:有关本地和远程分支之间的差异的更多信息,请参阅:如何比较本地git分支与其远程分支？

在第3步:git rebase origin在这里做一个可能更准确(例如在快速变化的回购).请参阅@Justin Ohms在另一个答案中的评论.

另见: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.

如果您想要合并历史记录,您可以提取,如果您只是"想要代码",则可以获取,因为有些人在这里标记了一些文章.

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在拉动之前,你应该知道潜在的合并冲突,并可以相应地准备你的本地分支.

除了推拉,一些工作流程涉及到git rebase,像这样的,这是我从链接的文章意译:

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

如果你发现自己处于这种状况,你可能会受到诱惑git pull --rebase.除非你真的,真的知道你在做什么,否则我会反对.此警告来自man页面git-pull版本2.3.5:

这是一种潜在危险的操作模式.它重写了历史,当你已经发布了这段历史时,它并不是一个好兆头.除非您仔细阅读git-rebase(1),否则请勿使用此选项.

Answer 12

好的,这里有一些关于git pull和的信息git fetch,所以你可以理解实际的差异...用几句简单的话来说,fetch获取最新数据,但不是代码更改而不会弄乱你当前的本地分支代码,但是拉取代码更改并将其合并到您的本地分支,继续阅读以获取有关每个分支的更多详细信息:

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-fetch 1的远程存储库的名称.可以命名任意远程引用(例如,标记的名称),甚至是具有相应远程跟踪分支的引用集合(例如,refs/heads/:refs/remotes/origin /),但通常它是名称远程存储库中的分支.

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

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

Answer 13

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

git fetch只需"下载"从远程到本地存储库的更改.git pull下载更改并将它们合并到当前分支中."在默认模式下,git pull是git fetch后面的简写git merge FETCH_HEAD."

Answer 14

奖金:

在谈到上述答案中的pull&fetch时,我想分享一个有趣的技巧,

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更新提取).

Answer 16

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

三个回购与取:

---------------------     -----------------------     -----------------------
- 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 Fetch和GIT Pull之间的区别可以通过以下场景来解释:( 请记住,图片比单词更响亮!,我提供了图形表示)

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

因此, 初始状态的两个分支的,当你在分叉本地仓库主体工程会像这- ( 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. 将新提交从远程分支复制到本地存储库中的此远程分支的副本.

   (回购回购业务) 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不会对本地分支进行任何更改,因此您需要将远程分支与配对的本地分支合并以合并新的提取更改.来自github

Answer 27

努力做到清晰简单.

该混帐拉命令实际上是一个shortcut对git的取指随后混帐合并或混帐底垫取决于您的配置命令.您可以配置Git存储库,以便git pull是一个fetch,后跟一个rebase.

Answer 28

实际上Git维护着您自己的代码和远程存储库的副本.

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

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

Answer 29

git pull = git fetch + git merge 

Answer 30

一个简单的初学者图形表示,

这里,

git pull  

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

但在 ,

git fetch

将从存储库中获取代码,我们需要通过使用手动重新绑定它 git rebase

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

1)git pull(rebase将自动完成):

git pull origin master

这里的原点是你的远程仓库主人是你的分支

2)git fetch(需要手动rebase):

git fetch origin master

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

git rebase origin/master

这会将代码重新绑定到本地.在那之前确保你在正确的分支.

Answer 31

来自ProGit§2.5Git Basics - 使用遥控器:从遥控器中取出和拉出:

请务必注意,该fetch命令会将数据提取到本地存储库 - 它不会自动将其与您的任何工作合并或修改您当前正在处理的工作.准备好后,您必须手动将其合并到您的工作中.

如果您设置了分支以跟踪远程分支,则可以使用该 git pull命令自动获取然后将远程分支合并到当前分支中.这对您来说可能是一个更简单或更舒适的工作流程; 默认情况下,该git clone命令会自动设置本地主分支以跟踪您克隆的服务器上的远程主分支(假设远程具有主分支).运行git pull通常从您最初克隆的服务器中提取数据,并自动尝试将其合并到您当前正在处理的代码中.

Answer 32

简单来说，如果您要在没有任何互联网连接的情况下跳上飞机...在出发之前，您可以这样做git fetch origin <master>。它会将所有更改取到您的计算机中，但将其与本地开发/工作区分开。

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

从这个很棒的Attlassian教程中：

的 git fetch命令将提交，文件和引用从远程存储库下载到本地存储库。

当您想查看其他所有人正在从事的工作时，获取就是您要做的。它与SVN更新类似，它使您可以查看中央历史记录的进展情况，但并不会强迫您将更改实际合并到存储库中。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提取将新提交存储在哪里？

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

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

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

2. 现在做ls -a。这将显示点文件，即以.You 开头的文件，然后将可以看到名为的目录.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目录中的标题。

一个很好的相关答案也可以在“ git fetch”本身放置在哪里？。

另外，请在Git分支命名约定中查找“斜杠表示法” 。它可以帮助您更好地了解Git如何将事物放置在不同目录中。

酷提示：

如果您获取了一个远程分支，例如：

git fetch origin feature/123

然后它将进入您的remotes目录。您的本地目录仍然不可用。但是，它通过DWIM简化了您到该远程分支的签出（执行我的意思）：

git checkout feature/123

您不再需要执行以下操作：

git checkout -b feature/123 origin/feature/123

有关更多信息，请点击此处

Answer 33

git pull

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

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

git fetch

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

git fetch
git rebase origin/master

Answer 34

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

通常,当您签出远程时,会创建一个跟踪远程的本地副本.

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

实际情况是,如果其他SWE正在同一个分支机构工作,而很少这种情况发生在小型的一个分支机构 - 一个项目场景中.

您在当地分支机构的工作仍然完好无损.要将更改带到本地分支,您必须合并/重新绑定远程分支的更改.

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

如果您的本地历史记录和远程历史记录存在冲突,则您将被迫在git push期间执行合并以发布更改.

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

Answer 35

从git备忘单:

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 36

所有分支都存储在 .git/refs

所有本地分支都存储在 .git/refs/heads

所有远程分支都存储在 .git/refs/remotes

该git fetch命令将提交、文件和引用从远程存储库下载到您的本地存储库。当您想查看其他人一直在做什么时，获取就是您所做的。

所以当你做git fetch所有的文件时，提交和引用都被下载到

这个目录 .git/refs/remotes

您可以切换到这些分支以查看更改。

此外，您可以根据需要合并它们。

git pull 只需下载这些更改并将它们合并到当前分支。

例子

如果你想看到远程分支的工作dev/jd/feature/auth，你只需要做

git fetch origin dev/jd/feature/auth

看到变化或工作进展做，

git checkout dev/jd/feature/auth

但是，如果您还想在当前分支中获取并合并它们，请执行以下操作，

git pull origin dev/jd/feature/auth

如果你这样做git fetch origin branch_name，它将获取分支，现在你可以切换到你想要的这个分支并查看更改。您的本地 master 或其他本地分支机构不会受到影响。但是git pull origin branch_name会获取分支并合并到当前分支。

Answer 37

据我所知,

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

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

这个url必须有助于进一步理解:git pull,git fetch和git clone(以及git rebase)之间的区别.

Answer 38

简单解释：

git fetch

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

git pull

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

Answer 39

简而言之:

git fetch:看看是否有新东西.

git pull:拿走新东西,把它放在你的东西之上.

Answer 40

Git 获取

帮助您了解来自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 pull本质上等价于git fetch那么git merge