it-swarm.cn

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

主持人注意: 鉴于此问题已经 六十七个答案 发布到它(其中一些已删除),请考虑您是否 贡献任何新内容 在发布另一个之前。

git pullgit fetch之间有什么区别?

10967
pupeno

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

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

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

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

Git文档: git pull

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

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

1969
Mouna Cheikhna

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

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

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

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

  • git fetch是一个命令,说“使我的远程存储库的本地副本更新。” 

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

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

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

1104
MikeD

这是 Oliver Steele关于它们如何组合在一起的形象

enter image description here

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

744
Contango

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

git fetch
git diff ...Origin
446
mepster

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

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

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

所以区别在于:

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

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

enter image description here

195
thedarkpassenger

简要

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 pullgit fetchgit 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/

189
Snowcrash
 git-pull  - 从另一个存储库或本地分支获取并合并
大纲
 
 git pull ... 
说明
 
使用给定参数运行git-fetch,并调用git-merge将
检索到的头部合并到当前分支中。使用--rebase,调用git-rebase 
而不是git-merge。[。_____。] [。_____。]请注意,您可以使用。 (当前目录)作为<repository>从本地存储库中提取
  - 这在将本地分支
合并到当前分支时很有用。[。_____。] [。_____。]另请注意那些选项意味着git-pull本身和底层的git-merge 
必须在git-fetch的选项之前给出。[。_____。]

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

164
Vinko Vrsalovic

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

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

git checkout master                                                  
git fetch                                        
git diff Origin/master
git rebase Origin master
151
Antonio Bardazzi

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

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

145
jfmercer

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

git fetch

它将所有 refs objects 和任何新分支下载到本地存储库...

从一个或多个其他存储库中获取分支和/或标记(统称为“refs”),以及完成其历史所需的对象。更新远程跟踪分支(有关控制此行为的方法,请参阅下面的说明)。

默认情况下,任何指向正在获取的历史记录的标记都是。效果是获取指向您感兴趣的分支的标签。可以通过使用 - --tags或--no-tags选项或通过配置[。]来更改此默认行为。 ____。] remote..tagOpt。通过使用明确获取标签的refspec,[。_____。]您可以获取不指向您感兴趣的分支的标签。

git fetch既可以从一个命名的存储库或URL中获取,也可以从一个存储库中获取,如果给出并且有一个遥控器。配置文件中的条目。 (参见git-config 1 )。

如果没有指定遥控器,默认情况下,Origin遥控器将被使用,除非为当前分支配置了上游分支。

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


git pull

它将来自 remote 的更改应用于 当前分支 in local ...

将来自远程存储库的更改合并到当前分支中。[。_____。]在默认模式下,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设置的当前分支的“remote”和“merge”配置中读取的。


我还创建了 visual 下面来向您展示git fetchgit pull如何协同工作......

git pull and git fetch

126
Alireza

enter image description here

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

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

121
th3sly

奖金:

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

git pull --rebase

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

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

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

119
Sazzad Hissain Khan

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

                                         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更新)。
109
Justus Romijn

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

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

99
pn1 dude

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

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

因此,当您在本地存储库上分叉主项目时,两个分支的 初始状态将是这样的 - (Aname __,_ Bname__和Cname__是已完成项目的模块)

enter image description here

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

enter image description here

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

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

enter image description here

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

enter image description here

2. Git Pull-这将使用Origin/main分支更新你的本地分支,即实际上它的作用是Git Fetch和Git的组合一个接一个地合并。 但这可能是因为冲突发生,因此建议使用Git Pull和干净的副本。

enter image description here

89
Aman Tiwari

我们简单地说:

git pull == git fetch + git merge

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

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

82
Selvamani

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

git pull执行git fetch但是also将跟踪分支中的代码合并到该分支的当前本地版本中。如果您还没有准备好进行更改,请先git fetch

80
Michael Durrant

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

75
ntanase

Git Fetch

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

Git Merge

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

Git Pull

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

71
Pinkesh Sharma

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

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

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

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

50
Rohitashv Singhal

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

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

    (回购回购操作)[email protected] >> remote/Origin/[email protected]

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

    (内部回购操作)remote/Origin/[email protected] >> [email protected]

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

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

git术语中,第1步是git fetch,第2步是git mergegit rebase

git pullgit fetchgit merge

44
Pawel Furmaniak

git pullgit fetch有什么区别?

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

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

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

36
Donal

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

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

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

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

    git pull Origin master

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

35
Marcus Thornton

git pull ==(git fetch + git merge) 

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

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

33
Iggy

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

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

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

32
Pokemon

努力做到清晰简单。

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

31
montells

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

enter image description here

这里,

git pull  

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

但在 , 

git fetch 

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

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

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

git pull Origin master

here Origin 是你的远程repo master 是你的分支

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

git fetch Origin master

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

git rebase Origin/master

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

30
Mohideen ibn Mohammed
git pull = git fetch + git merge 
29
Saqib R.

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

重要的是要注意fetch命令将数据拉到您的本地存储库 - 它不会自动将其与您的任何工作合并或修改您当前正在处理的。当你准备好时,你必须手动将它合并到你的工作中。

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

28
Zhenxiao Hao

git pull  

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

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

git fetch

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

git fetch
git rebase Origin/master
22
Animesh Sharma

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

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

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

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

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

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

如果您的本地历史记录和远程历史记录存在冲突,则您将被迫在git Push中进行合并以发布更改。

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

22
g24l

来自 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
20
Nan Xiao

据我所知, 

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

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

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

17
Pragyaditya Das

简而言之:

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

git pull:把新东西放在你的东西之上。 

8
miva2

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

Enter image description here

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

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

5
ishandutta2007

Git Fetch

帮助您了解git repository的最新更新。假设您使用GitFlow在团队中工作,团队正在处理多个branches(功能)。使用git fetch --allcommand,您可以了解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

此命令用当前branchrepository状态更新branch。让我们继续GitFlow。多个功能branchesmergeddevelop分支,当你想为项目开发新功能时,你必须转到develop branch并执行git pull以获得developbranch的当前状态。

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

3
Andrei Todorut

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

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

1
Arnel Lenteria

从这个真棒 Attlassian 教程: 

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

当你想看到每个人else一直在做什么时,你会做什么。它与svn update类似,它可以让您了解中央历史记录的进展情况,但它并不会强制您将更改实际合并到存储库中。 Git 将获取的内容与现有本地内容隔离 ,它绝对 对您的本地开发工作没有影响 。必须使用git checkout命令显式检出提取的内容。这使得在将提交与本地存储库集成之前,可以采用一种安全的方式来审核提交。

从远程仓库下载内容时,git pullgit fetch命令可用于完成任务。您可以将git fetch视为两个命令的“安全”版本。它将下载远程内容,但不会更新本地repo的工作状态,使您当前的工作保持不变。 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在哪里存储新的提交?

好问题。它把它放在与工作副本隔离的地方。但又在哪里?我们来看看。

在您的项目目录中(即您执行gitname__命令的位置)执行: 

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

  2. 现在做ls -a。这将显示 点文件 即以.开头的文件然后您将能够看到名为:.git的目录。 

  3. cd .git。这显然会改变你的目录。 
  4. 有趣的来了;做lsname__。您将看到目录列表。我们正在寻找refsname__。做cd refs
  5. 看到所有目录中的内容很有意思,但让我们关注其中两个。 headsname__和remotesname__。使用cdname__来检查它们。 
  6. 您执行的任何git fetch将更新/.git/refs/remotes目录中的项目。它不会更新/.git/refs/heads目录中的任何内容。
  7. 任何git pull将首先执行git fetch,更新/.git/refs/remotes目录中的项目,然后与您的本地合并,然后更改/.git/refs/heads目录中的头部。 

一个非常好的相关答案也可以找到 'git fetch'放在哪里?

还要从 Git分支命名约定 post查找“Slash notation”。

1
Honey