40 题: 'git pull'和'git fetch'有什么区别?

在...创建的问题 Sat, Nov 3, 2018 12:00 AM
  

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

git pullgit fetch之间有什么区别?

    
11047
  1. 我发现这篇写得很好的文章关于git fetch和git pull值得阅读: longair.net/blog/2009/04/16/git-fetch-and-merge
    2010-09-16 06:57:47Z
  2. 作为我们工作流程的一部分,我们的替代方法已成为git fetch; git reset --hard origin/master。它可以消除局部变化,使您与主人保持同步但是确保您不仅仅是在当前变化的基础上进行新的更改并弄得一团糟。我们已经使用了一段时间,它在实践中基本上感觉更安全。请务必先添加/commit /stash任何正在进行的工作!
    2014-05-04 14:32:18Z
  3. 确保您知道如何正确使用git stash。如果你问的是'拉'和'获取',那么'stash'也可能需要解释......
    2014-12-09 20:09:04Z
  4. 来自Mercurial的很多人继续使用“git pull”,认为它相当于“hg pull”。但事实并非如此。 Git相当于“hg pull”是“git fetch”。
    2015-06-29 10:15:53Z
  5. git fetch命令使用分支获取更新的代码,并且还将在本地获取新添加的分支,git pull命令仅获取当前分支的更新代码
    2017-07-27 11:43:31Z
  6. 醇>
    30答案                              30 跨度>                         

    用最简单的术语来说,git pullgit fetch,后面是git merge

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

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

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

    Git文档 - git pull

      

    在默认模式下,git pullgit fetch的简写,后跟git merge FETCH_HEAD

        
    9187
    2019-05-02 18:52:15Z
    1. “A”git pull“是你为了使你的存储库更新而做的事情”&lt; - 不是fetch已经完成的存储库更新吗?你不是说它让你的本地分支机构与远程分支机构保持同步吗?合并:它将远程分支与这些分支的本地副本合并,或者它在这里合并到底是什么?
      2009-11-10 12:13:21Z
    2. @Albert:是的,它措辞奇怪。 git pull将始终合并到当前分支。因此,您选择要从拉出的分支,然后将其拉入当前分支。 来自分支可以是本地的或远程的;它甚至可以是一个远程分支,它不是一个注册的git remote(意思是你在git pull命令行上传递一个URL)。
      2010-06-06 10:10:08Z
    3. @ espertus:No。Pushing永远不会自动进行合并。用户需要在本地解决任何合并冲突,然后推回到遥控器。
      2011-03-17 00:41:04Z
    4. 如果我在/home/alice/并且执行git fetch /home/bob,我应该将哪些参数传递给后续的git merge
      2011-05-27 19:38:02Z
    5. 注意人们学习Git:pull实际上不能被fetch加上merge模拟。我刚刚获取了一个只有远程分支指针发生变化的变化,merge拒绝做任何事情。另一方面,pull快速转发我的跟踪分支。
      2012-09-28 16:23:00Z
    6. 醇>
    • 当您使用pull时,Git会尝试自动为您完成工作。 它是上下文相关的,因此Git会将任何提取的提交合并到您当前正在使用的分支中.pull 会自动合并提交,而不会让您先审核。如果您不密切管理您的分支机构,则可能会经常发生冲突。

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

    2022
    2015-04-18 18:47:14Z
    1. 同意,好评。这就是为什么我讨厌git pull。什么时候让修改工具为您编写代码是否有意义?并不是合并两个文件正在做什么?如果这两个编辑在文件中是物理上分开的,但是LOGICALLY在赔率?
      怎么办?
      2013-05-13 18:44:23Z
    2. @ elexhobby short put,git fetch只更新您的.git/目录(AKA:本地存储库),.git/之外没有任何内容(AKA:工作树)。它不会改变你的本地分支,也不会触及master。虽然它接触remotes/origin/master(见git branch -avv)。如果您有更多遥控器,请尝试git remote update。这是一个命令中所有遥控器的git fetch
      2013-07-17 06:48:09Z
    3. @ Tino你的确是最重要的一点。人们可能不知道“远程”分支实际上存储为.git/refs/remotes/origin/中的一堆哈希值。
      2013-09-12 21:49:41Z
    4. 当你获取时,Git会收集目标分支中当前分支中不存在的任何提交并将它们存储在本地存储库中 - 如何查看从遥控器带来的内容以及如何将其合并到我的本地分支?
      2014-06-13 01:40:52Z
    5. @ Tino我还不明白的是......有什么意义?如果只更新.git,为什么要使用fetch?什么是预期的好处以及我之后应该做什么?
      2016-03-23 12:19:54Z
    6. 醇>

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

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

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

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

    • git fetch 是显示“使我的远程存储库的本地副本更新”的命令。

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

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

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

        
    1125
    2018-08-24 20:01:19Z
    1. 从技术上讲,本地和远程存储库实际上是同一个存储库。在Git中,存储库是指向其父母的 DAG 。从技术上讲,分支只不过是有意义的提交名称。本地和远程分支之间的唯一区别是远程分支的前缀是remoteName/ Git从头开始是一个非常好的阅读。一旦你理解了Git是如何工作的 - 而且它很漂亮简单,真的 - 一切都很有意义。
      2013-08-14 09:51:05Z
    2. 非常感谢您的解释。直到现在我才真正了解Git的设计,所以你不必拥有一个中央存储库。在描述Git时,每个人总是说“DVCS”,但作为一个相对较新的程序员,这对我来说毫无意义。我从来没有看过 CVCS,而且在与其他人(即Github)合作时我也从未使用过中心远程存储库,所以直到现在我还没理解是什么让Git变得特别
      2013-08-15 02:17:04Z
    3. 因此,基于此,为什么用cron作业进行git-fetch不是一个好主意?始终保留您在本地计算机上使用的遥控器的副本似乎是个好主意。事实上,我想编写一个脚本来检查我是否在过去24小时内更新了我的遥控器并将其与用于互联网连接的udev挂钩连接起来。
      2013-08-15 02:23:38Z
    4. 拥有cron作业不是一个好主意的一个原因是:通常在处理新票证或更新分支时,我喜欢查看正在获取的更改。如果在获取期间没有进行更改,我会更自信地问我的同事程序员'嘿,你推了吗?'。我也了解自上次提取以来存储库中有多少“流失”。这也有助于我了解当前对此存储库进行更改的数量和速度。
      2014-07-23 11:47:01Z
    5. @ Nabheet事情就是这样,Git是面向内容的。它存储da只有一次,并指向它多次。这就是为什么在Git中,即使是原始文件上的多次提交也不会对repo的大小产生太大影响,因为大多数对象都是相同的。
      2016-11-05 09:43:18Z
    6. 醇>

    以下是 Oliver Steele关于这一切如何融合的形象

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

        
    775
    2018-03-19 19:21:23Z
    1. git clonegit merge的更新图像将非常有用!
      2015-09-08 14:23:51Z
    2. 是的,请添加git merge - 它应该清楚地显示merge单独调用与调用pull不同,因为pull仅从远程合并而忽略了您的本地提交跟踪远程分支的本地分支。
      2015-10-21 19:57:33Z
    3. 一张图片胜过千言万语!具有克隆和合并数据的更新映像是否已准备就绪?除了图中已有的数据之外还有其他任何数据流吗?
      2015-11-25 00:27:05Z
    4. @ Contango请添加克隆和合并。对像我这样的新手有用。
      2016-01-15 16:02:32Z
    5. 有两个图表显示了th3sly和thedarkpassenger在其他答案(下面)中克隆和合并。
      2016-08-12 00:42:46Z
    6. 醇>

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

     
    git fetch
    git diff ...origin
    
        
    455
    2013-08-01 19:38:09Z
    1. 很棒的补充!我被点弄糊涂了,不是吗:git diff origin
      2010-07-27 12:15:09Z
    2. 为什么不git diff ..origin
      2012-02-12 23:47:33Z
    3. git diff origin和git diff ..origin似乎工作但不是很奇怪......东西
      2013-01-08 19:32:06Z
    4. @ Compustretch不应该有空格。 git diff ...origin相当于git diff $(git-merge-base HEAD origin) origin(参见git diff [--options] <commit>...<commit> [--] [<path>…]部分“rel =”nofollow noreferrer“ > kernel.org/pub/software/scm/git/docs/git-diff.html#_description ),与git diff origin不同; git diff ...origin在概念上是origin中的变化,因为当前分支从origin分支,而git diff origin也包括与当前分支的变化相反,因为它从origin分支。
      2013-08-01 19:34:28Z
    5. 没有..命令对我有用(在Windows上),但git diff origin/master有效,如下所述
      2014-02-20 09:07:13Z
    6. 醇>

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

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

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

    所以区别在于:

    • 如果您执行git fetch,它将只获取远程存储库中的所有更改( GitHub )并将原点/主指针移动到HEAD。与此同时,您当地的分公司主人将继续指向它所在的位置。
    • 如果您执行git pull,它将基本上执行(如前所述)并将任何新更改合并到主分支并将指针移动到HEAD
    356
    2016-01-02 04:52:49Z
    1. origin /master是一个本地分支,它是原始主数据的COPY。获取时,更新local:/origin /master。一旦你确实认为git中的所有东西都是一个分支,这很有意义,并且是一种非常强大的方法来维护不同的变更集,快速本地分支,合并和变基,并且通常从廉价分支中获得很多价值模型。
      2013-05-28 16:00:14Z
    2. 仍然令人困惑。我认为git fetch是将远程仓库中的更改直接下载到您的本地仓库中,但不提交它们 - 即,它们仍然需要添加/提交到您的本地仓库。
      2015-02-26 14:57:50Z
    3. fetch仅从远程/原点(github)拉到本地原点。但它不会将其合并到您的实际工作文件中。如果您执行拉取,它将获取并合并到您当前的工作文件
      2015-02-26 19:45:36Z
    4. 醇>

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

        
    202
    2016-01-25 17:28:50Z
    1. 我认为图片显示它也影响了当地的回购。也就是说,Git pull是影响本地仓库和工作副本的组合。现在它似乎只影响工作副本。
      2016-02-14 18:51:46Z
    2. @太极者无极而生同意 - 这个图像非常具有误导性,因为它使得它看起来像git pull 跳过获取,当然是不准确的。
      2016-08-20 15:33:23Z
    3. “本地存储库”和“工作副本”之间的区别是什么?它们不是计算机本地的吗?
      2017-11-16 03:12:58Z
    4. git fetch的用途是什么?如何看看本地存储库和工作副本有什么区别?
      2019-03-13 06:56:33Z
    5. @ theITvideos不,它不是。当您提交时,本地存储库是您的代码所在的位置(来自工作存储库)。 (当你按下它时会转到远程仓库。)
      2019-03-13 06:59:04Z
    6. 醇>

    简言之强>

    git fetchpull类似,但未合并。即它获取远程更新(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

    ====

    更新

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

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

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

       
      git diff master origin/master 
      
    3. 如果您对这些更新感到满意,请合并:

       
      git pull
      
    4. 醇>

      注意:

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

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

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

          
    195
    2018-11-28 20:18:32Z
    1. 听起来好像有人只是想让本地代码反映“小费”,他们应该使用git clone。我把小费放在引号中,因为我认为这意味着无论大师是什么以及有人会从github.com“下载为zip”
      2013-09-12 08:27:15Z
    2. 如果你对git fetch后的更改不满意怎么办?下一步做什么?
      2015-03-24 06:06:37Z
    3. 关于rebase的段落正是我所寻找的。关于将所有内容归零,从远程更新,然后重播您之前提交的更改在您工作时发生的整个想法。假设它是正确的完美解释。 ;)
      2016-03-03 00:01:20Z
    4. 醇>
     
    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”,则需要提取,因为某些人已在此处标记了一些文章。

        
    168
    2008-11-15 09:52:50Z
    1. 非常有趣,但我真的看不到你想要“只是代码”的用例。以及获取时代码会发生什么?它被删除了吗?遥控器发生了什么变化?如果不合并,如何在没有删除代码的情况下进入您的仓库?
      2010-03-27 16:21:55Z
    2. @ e-satisf:远程分支也存储在您的计算机本地。因此,当您执行git fetch时,它会从存储库中获取更改并更新您的本地远程数据库科。它不会影响跟踪本地远程分支的本地分支,因此不会影响您的工作副本。现在,当您执行merge时,它会将获取的更改与您的本地分支合并。
      2011-10-31 04:23:36Z
    3. fetch命令的一个简单用例:执行涉及其他人最近提交的耗时操作,例如合并或代码审查,仅访问您的最新版本date本地存储库没有网络连接要求,因为您以前使用fetch来快速下载所需的所有内容(例如,当您访问其他开发人员并连接到其他存储库的网络时)。 pull命令会下载相同的提交,但它执行的合并可能是不合需要的。
      2013-09-19 10:25:33Z
    4. 醇>

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

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

     
    git checkout master                                                  
    git fetch                                        
    git diff origin/master
    git rebase origin master
    
        
    153
    2015-03-15 22:20:04Z
    1. 您可能想要跳过拉动,只需执行“git rebase origin”作为您已经获取更改的最后一步。原因是有人可能已经推动了自你进行提取以来的时间变化,并且这些都不会在你进行差异检查时获取。
      2012-08-31 20:02:48Z
    2. 醇>

    简单易行的答案是,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。除非你真的,真的知道你在做什么,否则我会反对。此警告来自mangit-pull,版本2.3.5

      

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

        
    145
    2018-09-24 15:28:49Z
    1. @ JustinOhms如果git pull --rebase在给定情况下不是正确的事情,如果分两步完成它是否正确?如果这是正确的做法,那么分两步完成它会带来什么好处呢?
      2013-05-23 21:56:38Z
    2. @ Kaz - 因为rebase不是自动的。首先获取更改允许您进行判断调用。它不能解决您已推送的变基历史问题。它将允许您查看是否可以安全地修改尚未推送的更改。
      2013-05-24 21:11:52Z
    3. @ JustinOhms你如何决定是否可以安全地改变变化?我会尝试git rebase,如果它弄得一团糟又回溯,在这种情况下我不妨做git pull --rebase。但也许你有其他方式?
      2013-05-25 06:14:19Z
    4. @ KaZ gitk允许您直观地看到分支结构。它将显示您的本地头部,遥控器和分支结构相对于您所获取的位置。这样,您可以确保不重新定义基于祖先的已获取的更改,这些更改优先于已经推送到远程的祖先。
      2013-05-28 19:18:02Z
    5. 当您处理尚未推送的本地分支时,请使用rebase。如果您正在处理遥控器中存在的分支,rebase可能会导致一些令人讨厌的问题,因此您应该更喜欢常规的merge
      2014-12-01 08:39:57Z
    6. 醇>

    好的,这里有一些关于git pullgit fetch的信息,所以你可以理解实际的差异......用简单的话说, fetch 获取最新的数据,但是不是代码更改,也不会弄乱您当前的本地分支代码,但 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-fetch 1 。可以命名任意远程引用(例如,   标签的名称)甚至是具有相应标志的refs集合   远程跟踪分支(例如,refs /heads /:refs /remotes /origin /),   但通常它是远程存储库中分支的名称。

         

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


    我还在下面创建视觉,向您展示git fetchgit pull如何协同工作......

        
    129
    2018-09-28 10:38:33Z
    1. 如果您喜欢图像,那么请看一下git作弊表,这对所有git命令来说都是一样的...... ndpsoftware.com/git-cheatsheet.html
      2018-05-20 16:42:23Z
    2. 克隆是否也会影响本地存储库(从远程复制所有历史记录)?
      2018-07-04 04:38:54Z
    3. 醇>

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

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

        
    123
    2016-12-09 10:02:01Z
    1. 人,点击链接与不同的列进行交互。这张备忘单是我见过的最好的资源,可以完全理解每个命令之间的差异。
      2016-10-04 00:41:48Z
    2. 醇>

    加成:

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

    git pull --rebase

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

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

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

        
    119
    2016-08-08 16:56:17Z
    1. 不错的提示,虽然值得一提的是新git用户rebase修改提交哈希值(我发现令人惊讶的是来自颠覆)。
      2016-09-20 12:57:00Z
    2. 你能解释一下git pullgit pull --rebase之间的区别吗?
      2018-01-17 07:02:10Z
    3. 2018-10-24 08:00:20Z
    4. 醇>

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

     
                                             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)。
    111
    2014-07-25 07:01:35Z
    1. git pull是否也执行合并,即全部执行他的工作副本?
      2014-03-24 17:28:47Z
    2. 好点,是的,它会将所有更改都放在您的工作副本中,然后您可以将其自己提交到本地仓库中。我将更新视觉。
      2014-03-25 07:50:20Z
    3. @ JustusRomijn拉不同时更新本地存储库吗?原点和工作副本星号之间不应该有星号吗?
      2015-01-08 09:34:07Z
    4. @ user764754当您拉动时,您的工作副本会获得更改(您可能还需要解决一些冲突)。您仍然必须将其提交到本地存储库。
      2015-01-12 07:17:24Z
    5. @ JustusRomijn:感谢您的插图。如果您可以通过说明重置,樱桃选择等操作的效果来使图表更加全面,那将会很棒的状态。
      2015-01-17 12:42:39Z
    6. 醇>

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

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

        
    102
    2017-05-31 19:41:16Z
    1. 并不难以阅读:方框表示回购的状态,每行中的报告操作在第2行中从左到右发生变化盒子。标签R0n是git中的标签,带有+的标签是尚未公开的标签。 Sanbox用于您的工作文件夹,它与repo文件夹不同,后者存储了提交的内容。
      2017-08-30 07:57:02Z
    2. 醇>

    GIT抓取 GIT拉之间的区别可以通过以下方案解释: (请记住,图片胜于文字!,我提供了图片表示)

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

    所以, 在本地存储库中分叉主项目时,两个分支的初始状态将是这样的 - (A,BC是已完成项目的模块)

    现在,您已经开始研究新模块(假设为D),当您完成D模块时,您想将其推送到主分支,但同时发生的情况是您的一个团队成员开发了新的模块EF和修改C
    所以现在发生的事情是您的本地存储库缺乏项目的原始进度,因此将更改推送到主分支可能会导致冲突并可能导致模块D出现故障。

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

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

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

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

        
    91
    2018-03-03 04:13:05Z
    1. 如果您可以将“Main Branch”更改为“Remote Repo”,那将是一个很好的答案。
      2018-06-04 00:17:05Z
    2. 醇>

    我们只是说:

     
    git pull == git fetch + git merge
    

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

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

        
    82
    2013-07-17 13:35:56Z
    1. 我宁愿说git pull == git fetch + git merge:)
      2013-06-07 10:38:29Z
    2. git pull --rebase = git fetch + git rebase
      2013-07-17 07:06:50Z
    3. 醇>

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

    git pull执行git fetch将跟踪分支中的代码合并到该分支的当前本地版本中。如果你尚未做好应对这一改变的准备,那么首先只需git fetch

        
    79
    2016-06-01 00:59:49Z

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

        
    75
    2013-03-09 20:31:48Z

    Git Fetch

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

    Git Merge

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

    Git Pull

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

        
    69
    2017-06-16 18:15:10Z

    git pullgit fetch之间的唯一区别是:

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

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

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

        
    49
    2013-06-05 15:47:06Z
    1. 如果git认为你落后于提交并且可以“快进”,那么两者都没有帮助,当我最终完成整个事情并重新开始时。愚蠢的Git,请让我最新,这样我就可以回去工作了吗?
      2013-09-11 22:01:21Z
    2. 醇>

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

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

      (回购回购业务)rm -rf

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

      (内部回购操作)master@remote >> remote/origin/master@local

    3. 醇>

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

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

        remote/origin/master@local >> master@local术语中,步骤1为git,步骤2为git fetchgit merge

        git rebasegit pullgit fetch

            
    43
    2013-11-28 17:03:45Z

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

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

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

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

       git merge origin/master

      上面的命令相当于git pull origin mastergit fetch。在实践中,git merge可能更安全,因为在合并之前我们可以看到更改并决定是否合并。

    35
    2014-08-12 04:00:07Z
      

    git fetchgit pull有什么区别?

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

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

    另一方面,

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

        
    35
    2015-07-11 10:22:46Z

    git pull ==(git fetch + git merge)

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

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

        
    32
    2013-09-19 22:41:11Z

    努力做到清晰简单。

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

        
    31
    2015-07-29 18:38:48Z

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

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

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

        
    31
    2017-08-17 20:51:46Z
     git pull     
    30
    2015-07-12 03:54:52Z

    初学者的简单图形表示,

    这里,

     
    git pull = git fetch + git merge 
    

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

    但在,

    git fetch

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

    git pull  
    
    手动重新绑定它

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

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

     git rebase

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

    2)git fetch(需要手动重新绑定):

     
    git pull origin master
    

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

     
    git fetch origin master
    

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

        
    29
    2017-07-12 06:23:41Z
    1. 不错的图表,但您可能想要解释为什么在图表显示“merge”时使用“rebase”。
      2018-10-10 09:33:37Z
    2. merge将表示另一个分支提交并生成包含提交作为引用的新提交。但是rebase将复制来自另一个分支的提交,它不会创建新的提交而不是复制
      2018-10-10 11:00:51Z
    3. 醇>
    git rebase origin/master
    
来源放置 这里