“git pull”和“git fetch”有什么区别？

小开

最佳答案

用最简单的术语来说，git pull做了一个git fetch操作，然后是一个git merge操作。

git fetch更新refs/remotes//下的远程跟踪分支。此操作在任何时候都可以安全运行，因为它永远不会更改refs/heads下的任何本地分支。

git pull使本地分支以其远程版本更新，同时还更新您的其他远程跟踪分支。

从git pull的Git留档：

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

小开

git-pull - Fetch from and merge with another repository or a local branchSYNOPSIS
git pull   …DESCRIPTION
Runs git-fetch with the given parameters, and calls git-merge to merge theretrieved head(s) into the current branch. With --rebase, calls git-rebaseinstead of git-merge.
Note that you can use . (current directory) as the <repository> to pullfrom the local repository — this is useful when merging local branchesinto the current branch.
Also note that options meant for git-pull itself and underlying git-mergemust be given before the options meant for git-fetch.

如果你想合并历史，你会拉，如果你只是想要代码，你会取回，因为有人在这里标记了一些文章。

小开

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

git fetchgit diff ...origin

请参阅git diff文档关于双..和三个点...语法。

小开

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

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

git checkout mastergit fetchgit diff origin/mastergit rebase origin master

小开

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

非常重要的是要注意git pull将不管你喜不喜欢自动合并。当然，这可能会导致合并冲突。假设您的远程是origin，您的分支是master。如果您在拉取之前git diff origin/master，您应该对潜在的合并冲突有一些了解，并且可以相应地准备您的本地分支。

除了拉和推，一些工作流程涉及git rebase，比如这个，我从链接的文章中解释：

git pull origin mastergit checkout foo-branchgit rebase mastergit push origin foo-branch

如果你发现自己处于这样的情况，你可能会被诱惑git pull --rebase。除非你真的，真的知道你在做什么，否则我建议不要这样做。这个警告来自git-pull的man页面，版本2.3.5：

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

小开

git pull尝试在获取提交后自动合并。它是上下文敏感的，因此所有提取的提交都将合并到您当前活动的分支中。git pull自动合并提交而不让你先看。如果您不仔细管理您的分支，您可能会遇到频繁的冲突。
git fetch从目标分支收集当前分支和将它们存储在本地存储库中中不存在的任何提交。但是，它不会将它们与您当前的分支合并。如果您需要保持存储库最新，但正在处理可能在更新文件时中断的内容，这特别有用。要将提交集成到当前分支中，您必须在之后使用git merge。

小开

我花了一点时间才明白其中的区别，但这是一个简单的解释。

当您克隆存储库时，您会将整个存储库获取到您的本地主机。这意味着此时您有一个指向HEAD的源/主指针和指向相同HEAD的主指针。

当您开始工作并进行提交时，您将主指针前进到HEAD+您的提交。但是原始/主指针仍然指向您克隆时的位置。

所以区别将是：

如果您执行git fetch，它将仅获取远程存储库（github）中的所有更改并将原始/主指针移动到HEAD。同时，您的本地分支主机将继续指向它所在的位置。
如果您执行git pull，它将基本上获取（如前所述）并将任何新更改合并到您的主分支并将指针移动到HEAD。

小开

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

三个repos有一个获取：

---------------------     -----------------------     ------------------------ 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+               ----------------------     -----------------------     -----------------------

这帮助我理解了为什么获取非常重要。

小开

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

小开

我们只是说：

git pull == git fetch + git merge

如果您运行git pull，则不需要将数据合并到本地。如果您运行git fetch，则意味着您必须运行git merge才能将最新代码发送到本地机器。否则，未经合并不会更改本地机器代码。

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

小开

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

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

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

为了支持这种模式，git维护一个包含您的代码的本地存储库，以及一个反映远程存储库状态的额外本地存储库。通过在本地保留远程存储库的副本，即使远程存储库无法访问，git也可以找出所需的更改。稍后，当您需要将更改发送给其他人时，git可以将它们作为一组更改从远程存储库已知的时间点传输。

git fetch是“使远程存储库的本地副本保持最新”的命令。

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

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

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

小开

更简单地说
git fetch获取更新但不合并它们。
git pull在引擎盖下做了git fetch，然后做了merge。
简要
git fetch类似于pull，但不合并。即它获取远程更新（refs和objects），但您的本地保持不变（即origin/master更新，但master保持不变）。
git pull从远程下拉并立即合并。
更多
git clone克隆存储库。
git rebase将当前分支中不在上游分支中的内容保存到临时区域。您的分支现在与开始更改之前相同。因此，git pull -rebase将下拉远程更改，倒回本地分支，在当前分支顶部逐一重播更改，直到您更新为止。
此外，git branch -a将向您展示所有分支（本地和远程）的确切情况。
这篇博客文章很有用：
git拉取，git获取和git克隆（和git rebase）之间的区别-Mike Pearce
包括git pull、git fetch、git clone和git rebase。
更新
我想我会更新这个来展示你在实践中是如何使用它的。
从远程更新您的本地存储库（但不要合并）：
git fetch
下载更新后，让我们看看差异：
git diff master origin/master
如果您对这些更新感到满意，请合并：
git pull
备注：
关于第2步：有关本地和远程之间差异的更多信息，请参阅：如何比较本地Git分支与其远程分支
关于第3步：在这里执行git rebase origin可能更准确（例如在快速变化的存储库上）。参见另一个答案中的@贾斯汀欧姆评论。
另见：http://longair.net/blog/2009/04/16/git-fetch-and-merge/
另请注意：我在pull中提到了merge，但是您可以将pull配置为使用rebase。

小开

git pull和git fetch的区别在于：

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

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

即git拉取=git获取+git合并…

小开

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

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

小开

git拉取==（git获取+git合并）

git get不会更改到本地分支。

如果您已经有一个本地存储库，其中为所需的项目设置了远程，则可以使用git get ch获取现有远程的所有分支和标签……获取不会对本地分支进行任何更改，因此您需要将远程分支与配对的本地分支合并以合并新获取的更改。从github

小开

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

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

（仓库到仓库操作）master@remote >> remote/origin/master@local
将新提交集成到本地分支

内部仓库操作remote/origin/master@local >> master@local

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

在最后一个共同祖先之后分叉本地分支，并添加与本地存储库独有的提交并行的新提交，通过合并提交完成，关闭分叉。
在最后一个共同祖先之后插入新提交，并重新应用本地存储库独有的提交。

在git术语中，步骤1是git fetch，步骤2是git merge或git rebase

git pull是git fetch和git merge

小开

我希望有一些可视化的情况来掌握这些东西。也许其他开发人员也想看到它，所以这是我的补充。我不完全确定这一切都是正确的，所以如果你发现任何错误，请发表评论。

LOCAL SYSTEM. ====================================================================== . ================= =================== =============REMOTE REPOSITORY . REMOTE REPOSITORY LOCAL REPOSITORY WORKING COPY(ORIGIN) . (CACHED)for example, . mirror of thea github repo. . remote repoCan also be .multiple repo's ...FETCH *------------------>*Your local cache of the remote is updated with the origin (or multipleexternal 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 commitwill update the origin. In git, a commit is only done to your local repo..PUSH *<---------------------------------------*Synchronizes your changes back into the origin.

具有远程获取镜像的一些主要优点是：

性能（滚动所有提交和消息，而不尝试通过网络挤压它）
反馈关于本地存储库的状态（例如，我使用艾特莱森的SourceTree，它会给我一个灯泡，指示我是提前提交还是落后于原始提交。此信息可以使用GIT FETCH更新）。

小开

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

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

     上面的命令意味着从远程主分支下载最新版本的主分支到原始主分支。然后比较本地主分支和原始主分支。最后，合并。
Git拉取：Git将从远程获取最新版本并合并到本地。

   git pull origin master

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

小开

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

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

小开

git pull和git fetch有什么区别？

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

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

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

小开

这里是奥利弗·斯蒂尔关于这一切是如何结合在一起的形象：

小开

git pull = git fetch + git merge

小开

git拉取

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

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

获取文件

你必须显式应用这些更改。这可以通过以下方式完成：

git fetchgit rebase origin/master

小开

git拉取命令实际上是获取文件的shortcut，然后是git合并或gitrebase命令，具体取决于您的配置。您可以配置您的Git存储库，以便git拉取是一个获取，然后是一个rebase。

小开

实际上Git维护了您自己代码的副本远程存储库。

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

命令git pull将远程存储库中的更改带到您保存自己代码的地方。通常情况下，git pull首先执行“git get ch”以使远程存储库的本地副本保持最新，然后将更改合并到您自己的代码存储库中，可能还有您的工作副本。

小开

必须牢记git的本质。您有远程和本地分支（不一定相同）。与其他源代码控制系统相比，这可能有点令人困惑。

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

git get将与远程分支一起工作并更新您的信息。

如果其他SWE在同一个分支中工作，实际上就是这种情况，而在小型的一个开发-一个分支-一个项目场景中很少出现这种情况。

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

git拉取完全执行这两个步骤（即--rebase到rebase而不是合并）

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

因此，这实际上取决于您的工作环境的性质和使用的体验。

小开

奖金：
在上面的答案中谈到拉取时，我想分享一个有趣的技巧，
git pull --rebase
上面的命令是我git生活中最有用的命令，节省了很多时间。
在将您的新提交推送到服务器之前，请尝试此命令，它将自动同步最新的服务器更改（使用获取+合并），并将您的提交放在git日志的顶部。无需担心手动拉/合并。
查看详情：http://gitolite.com/git-pull--rebase

小开

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

小开

使用GitFetch

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

gitmerge

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

GitPull

获取和合并经常一起运行，以至于创建了一个组合两者的命令，拉，。拉执行获取然后合并以将下载的提交添加到您的本地分支中。

小开

GITFetch和GIT拉取之间的区别可以用以下场景来解释：（请记住，图片比文字更响亮！，我提供了图片表示）
让我们举一个例子，你正在和你的团队成员一起做一个项目。所以项目将有一个主分支，所有贡献者必须将其分叉到他们自己的本地存储库，然后在这个本地分支上工作以修改/添加模块，然后推回到主分支。
所以，当您在本地存储库上分叉主项目时，两个分支的初始状态将是这样的-（A、B和C是项目已经完成的模块）
现在，你已经开始处理新模块（假设D），当你完成D模块时，你想把它推到主分支，但与此同时，你的一个队友开发了新的模块E，F和修改C。
所以现在发生的事情是，您的本地存储库缺乏项目的原始进度，因此将您的更改推送到主分支可能会导致冲突，并可能导致您的模块D出现故障。
为了避免这些问题并与项目的原始进度并行工作，有两种方法：
1. Git Fetch-这将下载对原始/主分支项目所做的所有更改，这些更改不存在于您的本地分支中。并将等待Git Merge命令将已获取的更改应用到您的存储库或分支。
所以现在您可以在将文件合并到您的存储库之前仔细监控文件。如果需要，您还可以修改D，因为修改了C。
2. Git Pull-这将使用原始/主分支更新您的本地分支，即实际上它所做的是一个接一个的Git Fetch和Git合并的组合。但这可能会导致冲突发生，因此建议将Git Pull与干净的副本一起使用。

小开

好的，这里有一些关于git pull和git fetch的信息，所以你可以理解实际的差异……简单地说，获取获得最新的数据，但不是代码更改，也不会弄乱你当前的本地分支代码，但拉获得代码更改并将其合并到本地分支，继续阅读以获取有关每个分支的更多详细信息：
获取文件
它将下载所有裁判和对象以及任何新分支到您的本地存储库…
从一个或多个分支和/或标签（统称为“refs”）中获取其他存储库，以及完成它们所需的对象历史记录。远程跟踪分支已更新（请参阅说明下面的方法来控制这种行为）。
默认情况下，任何指向正在获取的历史记录的标记都是也获取；效果是获取指向分支的标签可以使用以下命令更改此默认行为--tags或--no-tags选项或通过配置远程… tagOpt。通过使用显式获取标签的refspec，您可以获取不指向您感兴趣的分支的标签我也是
git get可以从单个命名的存储库或URL或从几个存储库一次如果是给定的，有一个远程。配置文件中的条目。（参见git-config1）。
当没有指定远程时，默认情况下，原始远程将是使用，除非有为当前配置的上游分支分支。
获取的引用的名称，以及对象名称它们指向，被写入. git/FETCH_HEAD由脚本或其他git命令使用，例如git-ull。
git拉取
它将在本地应用从远程到当前分支的更改…
将远程存储库中的更改合并到当前分支中。在其默认模式下，git拉取是git获取的简写，然后是git合并FETCH_HEAD。
更准确地说，git ull使用给定的参数运行git get调用git合并将检索到的分支头合并到当前使用--rebase，它运行git rebase而不是git合并。
应该是传递给远程存储库的名称可以命名任意远程引用（例如，标签的名称），甚至是具有相应的引用的集合远程跟踪分支（例如，refs/head/： refs/远程/来源/），但通常它是远程存储库中分支的名称。
默认值和从当前分支的“远程”和“合并”配置，由#创建分支
我还创建了下面的视觉，向您展示git fetch和git pull如何协同工作…

小开

初学者的简单图形表示，

在这里，

git pull

将从存储库中获取代码并使用您的本地……在git拉取中，有可能创建新的提交。

但在，

获取文件

将从存储库中获取代码，我们需要使用git rebase手动重新设置它

例如：我要从服务器主机获取并将其重新定位在我的本地主机中。

1）git拉取（rebase会自动完成）：

git pull origin master

这里起源是您的远程存储库大师是您的分支

2）git get ch（需要手动rebase）：

git fetch origin master

它将从原始获取服务器更改。它将在您的本地，直到您重新建立在您自己的基础上。我们需要通过检查代码手动修复冲突。

git rebase origin/master

这将把代码重新定位到本地。在那之前，确保你在正确的分支中。

小开

使用GitFetch

帮助您了解git repository的最新更新。假设您在使用GitFlow的团队中工作，团队正在处理多个branches（功能）。使用git fetch --allcommand，您可以在repository中了解所有新的branches。

大多数git fetch与git reset一起使用。例如，您想将所有本地更改恢复到当前存储库状态。

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

git拉取

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

GitFlowhttps://gist.github.com/peterdeweese/4251497的文档

小开

简单地说，如果你要在没有任何互联网连接的情况下跳上飞机……在离开之前，你可以做git fetch origin <branch>。它会将所有更改获取到您的计算机中，但将其与本地开发/工作区分开。
在飞机上，您可以更改本地工作区，然后将其与之前获取的内容合并，然后解决潜在的合并冲突所有这些都无需连接到Internet。除非有人对远程存储库进行了新的更改，否则一旦您到达目的地，您将执行git push origin <branch>并去喝咖啡。
来自这个很棒的艾特莱森教程：
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拉取将影响您的.git/refs/remotes和.git/refs/heads/
嗯……所以如果我不使用git fetch更新工作副本，那么我在哪里进行更改？Git在哪里获取存储新提交？
好问题。首先，heads或remotes不存储新的提交。他们只有指针要提交。所以用git fetch，你下载最新的git对象（blob，tree，提交。要完全理解对象，请观看这个关于git内部的视频），但只更新你的remotes指针以指向该分支的最新提交。它仍然与你的工作副本隔离，因为你的分支在heads目录中的指针没有更新。它只会在merge/pull时更新。但是在哪里？让我们来看看。
在您的项目目录（即执行git命令的地方）中执行：
ls。这将显示文件和目录。没什么酷的，我知道。
现在执行ls -a。这将显示点文件，即以.开头的文件然后您将能够看到一个名为：.git的目录。
执行cd .git。这显然会更改您的目录。
现在有趣的部分来了；做ls。您将看到一个目录列表。我们正在寻找refs。做cd refs。
查看所有目录中的内容很有趣，但让我们关注其中两个。heads和remotes。使用cd也可以检查它们的内部。
任何git fetch将更新/.git/refs/remotes目录中的指针。它不会更新/.git/refs/heads目录中的任何内容。
任何git pull将首先执行git fetch并更新/.git/refs/remotes目录中的项目。然后它将还与您的本地合并，然后更改/.git/refs/heads目录内的头部。
一个很好的相关答案也可以在在哪里'git获取'的地方本身？中找到。
此外，从Git分支命名约定帖子中寻找“斜线符号”。它可以帮助您更好地理解Git如何将事物放置在不同的目录中。
才能看到真正的区别
只要做到：
git fetch origin mastergit checkout master
如果远程主机已更新，您将收到这样的消息：
Your branch is behind 'origin/master' by 2 commits, and can be fast-forwarded.(use "git pull" to update your local branch)
如果你没有fetch而只是git checkout master，那么你的本地git就不会知道添加了2个提交。它只会说：
Already on 'master'Your branch is up to date with 'origin/master'.
但这是过时和不正确的。这是因为git只会根据它所知道的给你反馈。它忘记了它还没有拉下的新提交…
有没有办法在本地处理分支时查看远程所做的新更改？
一些IDE（例如Xcode）非常聪明，使用git fetch的结果，并且可以注释当前工作分支的远程分支中已更改的代码行。如果该行已被本地更改和远程分支更改，那么该行会被注释为红色。这不是合并冲突。这是潜在合并冲突。这是一个头推，您可以在从远程分支执行git pull之前使用它来解决未来的合并冲突。
有趣提示：
如果您获取了远程分支，例如：
git fetch origin feature/123
然后这将进入您的远程目录。它仍然不适用于您的本地目录。但是，它通过DWIM简化了您对该远程分支的结帐（按我的意思做）：
git checkout feature/123
你不再需要做：
git checkout -b feature/123 origin/feature/123
阅读更多关于这里

小开

所有分支都存储在.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，它将获取分支，现在您可以切换到您想要的此分支并查看更改。您的本地主分支或其他本地分支不会受到影响。但是git pull origin branch_name会获取分支并合并到当前分支。

小开

简单解释：

git fetch

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

git pull

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

小开

这个图形可能会有所帮助。git pull本质上相当于git fetch然后git merge

提交答案

使用前必读

意见 & 问题反馈

极客学习笔记

ICP 证:鄂ICP备15004824号-2

友情链接