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

pupeno 10769 git git-pull git-fetch

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

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

Greg Hewgill.. 8965

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

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

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

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

Git文档:git pull

  • "A git pull"是你为了使你的存储库更新而做的事情"< - 不是fetch已经完成的存储库更新吗?你不是说它让你的本地分支机构与远程分支机构保持同步吗?合并:它将远程分支与这些分支的本地副本合并,或者它在这里合并到底是什么? (302认同)
  • @Albert:是的,措辞奇怪.`git pull`将始终合并到**当前分支**.因此,您从*中选择要拉出*的分支,然后将其拉入当前分支.*from*分支可以是本地的或远程的; 它甚至可以是一个远程分支,它不是一个注册的`git remote`(意思是你在`git pull`命令行上传递一个URL). (179认同)
  • @espertus:不会.推送永远不会自动进行合并.期望用户在本地解决任何合并冲突,然后*推回到远程. (118认同)
  • 注意学习Git的人:`pull`实际上不能通过`fetch`加上'merge`来模拟.我刚刚获取了一个只有远程分支指针发生变化的变化,而`merge`拒绝做任何事情.另一方面,`pull`快速转发我的跟踪分支. (95认同)
  • 如果我在`/ home/alice /`并且执行`git fetch/home/bob`,我应该将哪些参数传递给后续的`git merge`? (32认同)
  • git pull是git fetch的简写,后跟git merge FETCH_HEAD. (29认同)
  • 让我们想象一下,我只有一个`master`分支.哪些EXACT命令(带有所有必要选项)应该替换`git pull`命令? (13认同)
  • 是一个"混帐推"也是一个"混帐提取"(在其他方向),接着是"混帐合并"? (11认同)
  • 为什么特别不建议像cron作业那样自动为你做"git fetch"?没有不好的副作用浮现在脑海中,让我的远程分支更新而不必考虑它会很好. (9认同)
  • @Sbrocket:我不喜欢惊喜,特别是在使用我的源代码控制系统时.工作时从我的下方(甚至是远程的分支机构)改变分支可能会让人迷失方向. (9认同)
  • @romkyns我不太明白你的意思.你能否解释一下"我刚刚获取了一个只有远程分支指针发生变化的变化,并且合并拒绝做任何事情." 手段? (7认同)
  • 为什么不是`git update`? (6认同)
  • @AlexanderSupertramp:我根本不是这么说的.你的正常分支在`refs/heads`下.远程跟踪分支在`refs/remotes`下.`git fetch`命令在`refs/remotes`下更新你的远程跟踪分支,并且在`refs/heads`下不会改变任何东西. (6认同)
  • @ user2906759:Git在本地存储库中跟踪远程上所有分支的状态.谷歌"远程跟踪分支机构"获取有关此信息的大量信息. (5认同)
  • 或者,您可以通过执行`git fetch`,然后执行`git rebase origin/master`来使用远程仓库更新您的git仓库. (4认同)
  • **此操作永远不会更改您在refs/heads**下的任何本地分支机构** - 它会怎样做?我还是不太懂. (4认同)
  • @AlexanderSupertramp:如果您在理解Git术语时遇到问题,请提出一个新问题.评论部分不适合进行此讨论.谢谢. (4认同)
  • @AlexanderSupertramp:`git fetch`更新*远程跟踪*分支.这些是以`git branch -a`中的`remotes /`开头列出的分支,并且是远程存储库上分支的副本. (3认同)
  • 这里的关键区别是refs/remote和refs/heads.heads指的是你的本地工作分支,而remote指的是指向远程的分支,带有自你上一个git获取源的信息. (3认同)
  • @ dev-inside或者只是做`git pull --rebase` (2认同)
  • 这是git pull的真正运作方式吗?或者只是一个伪相似的行为?有没有人看过git pull的实现真的在引擎盖下使用git fetch和git merge?或者根本混帐拉有它自己的内在逻辑,在大多数情况下,在所有的人都执行同样的动作来获取,然后合并做什么,但可能不是? (2认同)
  • 现在我明白了为什么````````````````````````````````````````'`````'```'``完全无视我当地的"大师"!我希望在所有提及`pull`的教程中更好地强调这个重要的区别,并声称它与`fetch` +`merge`几乎相同.如果你是'拉扯'并且希望做一体化的话,"几乎"是非常重要的 - 从远程AND和本地合并获取+合并.惊喜 - 拉不从本地分支合并! (2认同)

Mouna Cheikh.. 1971

  • 当您使用时pull,Git会尝试自动为您完成工作.它是上下文敏感的,因此Git会将任何提取的提交合并到您当前正在处理的分支中. pull 自动合并提交而不让您先查看它们.如果您不密切管理您的分支机构,您可能会遇到频繁的冲突.

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

  • @elexhobby short put,`git fetch`只更新你的`.git /`目录(AKA:本地存储库),而不是`.git /`(AKA:工作树).它不会改变你的本地分支,也不会触及`master`.它接触`remotes/origin/master`(参见`git branch -avv`).如果您有更多遥控器,请尝试`git remote update`.这是一个命令中所有遥控器的`git fetch`. (98认同)
  • 同意,好评.这就是为什么我讨厌git pull.什么时候让修改工具为您编写代码是否有意义?并不是合并两个文件正在做什么?如果这两个编辑在文件中是物理上分开的,但是LOGICALLY有点怎么办? (29认同)
  • @Tino你的确是最重要的一点.人们可能不知道"远程"分支实际上存储为`.git/refs/remotes/origin /`中的一堆哈希. (18认同)
  • **当您获取时,Git会收集目标分支中当前分支中不存在的任何提交并将它们存储在本地存储库中** - 如何查看从远程数据库中提取的内容以及如何将其合并到我的当地分公司? (9认同)
  • @Tino我还不明白的是......有什么意义?如果只更新`.git`,为什么要使用fetch?什么是预期的好处以及我之后应该做什么? (8认同)
  • 一旦我明白一切都在进行'虽然'跟踪分支我终于真正理解了git.没有这些知识,它只是"魔术". (4认同)
  • 我觉得这个答案很棒.对我来说,通过git fetch实现目标的一个很好的组合是输入'git status',你会看到类似的东西:"没什么可提交,工作树干净"然后你可以输入'git fetch'然后输入'git status'和你会看到你的分支"在远程存储库之前"或者像那样.如果你输入"git pull",你将合并分支,但是如果你在某些提交方面领先或落后,你只需要使用'git fetch'来清楚你的本地存储库. (2认同)

MikeD.. 1105

将git的设计理念与更传统的源控制工具(如SVN)的理念进行对比非常重要.

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

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

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

  • git fetch 是命令"将我的远程存储库的本地副本更新."

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

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

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

  • 从技术上讲,本地和远程存储库实际上是同一个.在Git中,存储库是指向其父母的提交的[DAG](http://en.wikipedia.org/wiki/Directed_acyclic_graph).从技术上讲,分支只不过是有意义的提交名称.本地和远程分支之间的唯一区别是远程分支的前缀是`remoteName /`[Git from the ground up](http://newartisans.com/2008/04/git-from-the-bottom-up/)是一个非常好的阅读.一旦你理解了Git是如何工作的 - 它真的很简单_emple_,真的 - 一切都是有道理的. (62认同)
  • 有一个cron作业不是一个好主意的一个原因:通常在处理新票证或更新分支时,我喜欢看到正在获取的更改.如果在获取期间没有进行更改,我会更自信地问我的同事程序员'嘿,你推了吗?'.我也了解自上次提取以来存储库中有多少"流失".这也有助于我了解当前对此存储库所做的更改的数量和速度. (16认同)
  • 非常感谢您的解释.直到现在我才真正了解Git的设计,所以你不必拥有一个中央存储库.在描述Git时,每个人总是说"DVCS",但作为一个相对较新的程序员,这对我来说毫无意义.我从来没有**看过**CVCS,而且在与其他人(即Github)合作时我也从未使用过中心远程存储库,所以直到现在我还没有理解是什么让Git变得特别. (11认同)
  • 因此,基于此,为什么用cron作业进行git-fetch不是一个好主意?始终保留您在本地计算机上使用的遥控器的副本似乎是个好主意.事实上,我想编写一个脚本来检查我是否在过去24小时内更新了我的遥控器并将其与用于互联网连接的udev挂钩连接起来. (4认同)
  • @Nabheet事实是,Git是面向内容的.它只存储一次数据,并多次指向它.这就是为什么在Git中,即使是原始文件上的多个提交也不会对repo的大小产生太大影响,因为大多数对象都是相同的. (3认同)

Contango.. 745

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

在此输入图像描述

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

  • 使用`git clone`和`git merge`的更新图像将非常有用! (120认同)
  • 是的,请添加`git merge` - 它应该清楚地表明单独调用的`merge`与调用`pull`是不同的,因为`pull`只是从远程合并而忽略你本地提交的本地提交正在跟踪远程分支被拉出来. (16认同)
  • 有两个图表显示了由th3sly和thedarkpassenger在其他答案(下面)中克隆和合并. (10认同)
  • 一张图片胜过千言万语!具有克隆和合并数据的更新映像是否已准备就绪?除了图中已有的数据流之外的任何其他数据流? (9认同)
  • @Contango请添加克隆和合并.对像我这样的新手有用. (9认同)
  • rebase是否来自远程存储库?我认为rebase是对本地存储库的操作:https://git-scm.com/docs/git-rebase (3认同)
  • Rebase适用于您的本地存储库.令人困惑的是,最常见的用例是在"来自"远程存储库的东西之上重新定义您的工作. (2认同)
  • 这种"拉动或反叛"是错误的.因为当你拉,你实际上执行提取而不是合并.当您获取时,您将从远程分支到本地分支进行新的更改,但是,这是重要的部分,它尚未添加到您的文件中.就像变化被停在某个地方一样.如果合并它们,更改将添加到您的文件中.比你更改"融化"到你的文件并提交. (2认同)

用户甲.. 446

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

git fetch
git diff ...origin

  • @Compustretch不应该有空间.`git diff ... origin`相当于`git diff $(git-merge-base HEAD origin)origin`(参见`git diff [--options] <commit> ... <commit> [ - ] https://www.kernel.org/pub/software/scm/git/docs/git-diff.html#_description)的[<path> ...]`部分,与`git diff origin`不同; `git diff ... origin`在概念上是在`origin`中所做的更改,因为当前分支从`origin`分支,而`git diff origin`也包括在当前分支中所做的更改的反向,因为它从` origin`. (16认同)
  • 太棒了!我对这些点感到困惑,不是吗:git diff origin (11认同)
  • 为什么不`git diff ..origin`? (6认同)
  • git diff origin和git diff ..origin似乎工作但不是这个奇怪的东西 (3认同)

Gerardo.. 351

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

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

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

所以区别在于:

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

  • origin/master是一个本地分支,它是一个原始版本的COPY.获取时,更新local:/ origin/master.一旦你确实认为git中的所有东西都是一个分支,这很有意义,并且是一种非常强大的方法来维护不同的变更集,快速本地分支,合并和变基,并且通常从廉价分支中获得很多价值模型. (9认同)
  • 仅从远程/原点(github)获取到本地原点.但它不会将其合并到您的实际工作文件中.如果您执行拉取,它将获取并合并到您当前的工作文件 (2认同)

thedarkpasse.. 195

有时,视觉表示会有所帮助

在此输入图像描述

  • 我认为这张照片表明它也影响了当地的回购.也就是说,Git pull是影响本地仓库和工作副本的组合.现在它似乎只影响工作副本. (15认同)
  • @太极者无极而生同意 - 这个图像非常具有误导性,因为它使它看起来像`git pull`是_skipping_获取,这当然是不准确的. (7认同)
  • 什么是"本地存储库"和"工作副本"之间的区别?他们都不是电脑本地人吗? (4认同)

Snowcrash.. 189

简要地

git fetch类似pull但不合并.即它获取远程更新(refsobjects),但您的本地保持不变(即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 clonegit 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/

  • 如果你在git fetch之后对这些变化不满意怎么办?接下来做什么? (3认同)

Vinko Vrsalo.. 164

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.

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

  • @ e-satisf:远程分支也存储在您的机器本地.因此,当你执行`git fetch`时,它会从存储库中获取更改并更新本地远程分支.它不会影响跟踪本地远程分支的本地分支,因此不会影响您的工作副本.现在,当你执行`merge`时,它会将获取的更改与本地分支合并. (10认同)
  • 非常有趣,但我真的看不到你想要"只是代码"的用例.以及获取时代码会发生什么?它被删除了吗?遥控器发生了什么变化?如果你不合并,它如何进入你的repo而不删除你的代码? (4认同)

Antonio Bard.. 151

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

这是一个名为远程存储库的示例,origin以及一个名为master跟踪远程分支的分支origin/master:

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

  • 您可能想要跳过拉动,只需执行"git rebase origin"作为您已经获取更改的最后一步.原因是有人可能已经推动了自你进行提取以来的时间变化,这些都不会在你进行差异检查时进行获取. (33认同)

jfmercer.. 145

短期和简单的答案是,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),否则请勿使用此选项.

  • @JustinOhms如果`git pull --rebase`在给定的情况下不是正确的话,如果分两步完成它是否正确?如果这是正确的做法,那么分两步做什么又有什么好处呢? (2认同)
  • @JustinOhms你如何决定是否可以安全地改变变化?我会尝试git rebase,如果它弄得一团糟又回溯,在这种情况下我不妨做git pull --rebase.但也许你还有其他方法吗? (2认同)

Alireza.. 126

好的,这里有一些关于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 fetchgit pull一起工作......

git pull和git fetch

  • 如果您喜欢图像,那么请看一下git作弊表,这对于所有git命令都是相同的... http://ndpsoftware.com/git-cheatsheet.html (6认同)
  • 克隆是否也会影响本地存储库(从远程复制所有历史记录)? (2认同)

th3sly.. 121

在此输入图像描述

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

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

  • 人们,点击链接与不同的列进行交互.这张备忘单是我见过的最好的资源,可以完全理解每个命令之间的差异. (14认同)

Sazzad Hissa.. 119

奖金:

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

git pull --rebase

上面的命令是我git生活中最有用的命令,节省了大量的时间.

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

有关详细信息,请访问:http://gitolite.com/git-pull--rebase

  • 不错的提示,虽然值得一提的是新git用户rebase修改提交哈希值(我发现令人惊讶的是来自颠覆). (3认同)

Justus Romij.. 109

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

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


pn1 dude.. 99

我也在努力解决这个问题.事实上,我在谷歌搜索完全相同的问题.阅读所有这些答案终于在我脑海中画了一幅画,我决定尝试着看看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+               -
---------------------     -----------------------     -----------------------

这有助于我理解为什么抓取非常重要.


用户甲.. 89

GIT FetchGIT Pull之间的区别可以通过以下场景来解释:( 请记住,图片比单词更响亮!,我提供了图形表示)

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

因此, 初始状态的两个分支的,当你在分叉本地仓库主体工程会像这- ( A,BC在模块已经完成的项目)

在此输入图像描述

现在,你已经开始了新的模块(假设上工作D),当你完成D你想要它推到主分支模块,但与此同时发生的事情是你的一个队友已经制定了新的模块E,F并修改C.
所以现在发生的事情是您的本地存储库缺乏项目的原始进度,因此将更改推送到主分支可能会导致冲突并可能导致模块D出现故障.

在此输入图像描述

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

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

在此输入图像描述

所以现在您可以在将文件合并到存储库之前仔细监视这些文件.D如果需要,你也可以修改因为修改C.

在此输入图像描述

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

在此输入图像描述


Selvamani.. 82

我们简单地说:

git pull == git fetch + git merge

如果运行git pull,则无需将数据合并到本地.如果您运行git fetch,则意味着您必须运行git merge以获取本地计算机的最新代码.否则,如果没有合并,则不会更改本地机器代码.

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

  • 我宁愿说'git pull == git fetch + git merge` :) (2认同)

Michael Durr.. 80

git fetch将代码从远程服务器下拉到本地存储库中的跟踪分支.如果你的遥控器被命名为origin(默认值),那么这些分支会内origin/,例如origin/master,origin/mybranch-123等等.这些都不是你当前的分支,它们是本地从服务器这些分支的副本.

git pull做了git fetch但随后合并从跟踪分支代码到分支您当前的本地版本.如果你尚未做好应对这一改变的准备,那就git fetch先行.


用户甲.. 75

git fetch将检索远程分支机构,这样就可以git diffgit merge它们与当前分支.git pull将在当前分支跟踪的远程brach上运行fetch,然后合并结果.您可以使用git fetch以查看远程分支是否有任何更新,而无需将它们与本地分支合并.


Pinkesh Shar.. 71

Git Fetch

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

Git Merge

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

Git Pull

获取和合并运行得足够频繁,以便创建一个组合了两个pull的命令.Pull执行获取然后合并以将下载的提交添加到本地分支.


Rohitashv Si.. 50

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

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

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

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


Pawel Furman.. 44

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 mergegit rebase

git pullgit fetchgit merge


Donal.. 36

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

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

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

git pull另一方面,将远程存储库中的更改记录到您保留自己的代码的位置.通常,git pullgit fetch首先使远程存储库的本地副本更新,然后将更改合并到您自己的代码存储库以及可能的工作副本中.


Marcus Thorn.. 35

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 fetchgit merge.在实践中,git fetch可能更安全,因为在合并之前我们可以看到更改并决定是否合并.


Iggy.. 33

git pull ==(git fetch + git merge)

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

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


Pokemon.. 32

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

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

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


montells.. 31

努力做到清晰简单.

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


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

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


Saqib R... 29

git pull = git fetch + git merge 


Zhenxiao Hao.. 28

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

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

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


Animesh Shar.. 22

git pull

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

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

git fetch

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

git fetch
git rebase origin/master


g24l.. 22

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

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

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

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

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

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

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

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


Nan Xiao.. 20

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


Pragyaditya .. 17

据我所知,

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

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

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


miva2.. 8

简而言之:

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

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


ishandutta20.. 5

我相信大多数答案都能很好地解决这个问题.我会强调何时使用它而不是.

在此输入图像描述

当您需要获取其他开发人员的更新但希望继续您的工作不受阻碍时,Fetch非常有用.经常想下线和工作的人fetch用来获取最新的更新,直到他/她在线.之后,当她/她对自己的变化感到满意时,将分支中的变量合并到他/她的工作空间中.

而在线工作并且非常确定他们的变化并希望获得最新代码和merge直接使用的人pull.我很少使用,fetch因为检查最新的更新我通过GitHub网站检查它们,我总是离线工作.正如我所提到的,你可能会使用上述场景.


提问时间:

查看次数:

2484015 次

最近活跃:

7 月,1 周 前