Quelle est la différence entre 'git pull' et 'git fetch'?

Note du modérateur Étant donné que soixante-sept réponses ont déjà été envoyées à cette question (certaines d'entre elles ont été supprimées), déterminez si vous ajoutez quelque chose de nouveau avant d'en envoyer une autre.

Quelles sont les différences entre git pull et git fetch ?

10 500
15 нояб. ensemble pupeno 15 nov. 2008-11-15 12:51 '08 à 12:51 2008-11-15 12:51
@ 46 réponses
  • 1
  • 2

Dans les termes les plus simples, git pull exécute une git fetch suivie par une git merge .

Vous pouvez faire git fetch à tout moment pour mettre à jour les branches de suivi à distance dans refs/remotes/<remote>/ .

Cette opération ne change jamais aucune de vos propres branches locales dans les refs/heads et est sécurisée sans changer la copie de travail. J'ai même entendu dire que des gens exécutent périodiquement git fetch dans un job cron en tâche de fond (bien que je ne le recommande pas).

Un git pull est ce que vous feriez pour mettre à jour la branche locale avec votre version distante, ainsi que pour mettre à jour d'autres branches de suivi à distance.

Documentation Git: Git pull

8755
15 нояб. Réponse donnée par Greg Hewgill le 15 novembre 2008-11-15 12:52 '08 à 12:52 2008-11-15 12:52
  • Lorsque vous utilisez le pull , Git essaie de faire votre travail automatiquement pour vous. Ceci dépend du contexte , donc Git fusionnera tous les commits push dans la branche sur laquelle vous travaillez actuellement. pull fusionne automatiquement les commits sans que vous ne les voyiez au préalable .

  • Lorsque vous fetch , Git collecte tous les commits de la branche cible qui n'existent pas dans votre branche actuelle, mais les stockent dans votre référentiel local . Cependant, il ne les combine pas avec votre branche actuelle . Ceci est particulièrement utile si vous devez constamment mettre à jour votre référentiel, mais travaillez sur ce qui pourrait casser si vous mettez à jour vos fichiers. Pour intégrer les commits dans la branche principale, utilisez la merge .

border=0
1919
18 авг. réponse donnée par Mouna Cheikhna 18 août. 2011-08-18 11:53 '11 à 11:53 2011-08-18 11:53

Il est important d'opposer la philosophie de conception de git à la philosophie d'un outil de gestion de source plus traditionnel, tel que SVN.

Subversion a été conçu et construit à l'aide d'un modèle client / serveur. Il existe un seul référentiel, qui est un serveur, et plusieurs clients peuvent extraire du code du serveur, l'utiliser avec, puis le transférer à nouveau sur le serveur. On suppose que le client peut toujours contacter le serveur lorsqu'il doit effectuer une opération.

Git a été conçu pour prendre en charge un modèle plus distribué sans recourir à un référentiel central (bien que vous puissiez certainement l'utiliser si vous le souhaitez). En outre, git a été conçu de manière à ce que le client et le "serveur" ne soient pas en ligne au même moment. Git a été conçu pour que les utilisateurs d'un lien peu fiable puissent même échanger leur code par courrier électronique. Vous pouvez complètement désactiver le travail et graver un CD pour échanger du code via git.

Pour prendre en charge ce modèle, git maintient un référentiel local avec votre code, ainsi qu'un référentiel local supplémentaire reflétant l'état du référentiel distant. En stockant localement une copie du référentiel distant, git peut déterminer les modifications nécessaires, même si le référentiel distant n'est pas disponible. Plus tard, lorsque vous aurez besoin d'envoyer des modifications à quelqu'un d'autre, git peut les transférer sous forme d'un ensemble de modifications à partir du moment connu dans le référentiel distant.

  • git fetch est une commande qui dit: "Apporter ma copie locale du référentiel distant à ce jour."

  • git pull dit: "Apporter des modifications au référentiel distant où je garde mon propre code."

Pour ce faire, git pull normalement git fetch pour mettre à jour une copie locale du référentiel distant, puis fusionner les modifications dans votre propre référentiel de code et éventuellement votre copie de travail.

Supprimez cette option pour garder à l’esprit qu’il existe souvent au moins trois copies du projet sur votre poste de travail. Une copie est votre propre référentiel avec son propre historique de validation. La deuxième copie est votre copie de travail, où vous éditez et construisez. La troisième copie est votre copie locale "en cache" du référentiel distant.

1066
31 марта '13 в 21:43 2013-03-31 21:43 la réponse est donnée par MikeD le 31 mars 13 à 21:43 2013-03-31 21:43
711
09 июня '15 в 16:30 2015-06-09 16:30 la réponse est donnée à Contango le 09 juin 2015 à 16h30. 2015-06-09 16:30

Une utilisation de git fetch est que le message suivant vous informera de tous les changements survenus dans la branche distante depuis le dernier extraction ... afin que vous puissiez vérifier avant de réaliser l'extraction proprement dite, ce qui peut modifier les fichiers de votre branche actuelle et en exécuter une copie. .

 git fetch git diff ...origin 
437
07 мая '10 в 22:23 2010-05-07 22:23 la réponse est donnée à Mepster le 07 mai 2010 à 10h23. 2010-05-07 22:23

Je devais comprendre un peu la différence, mais c’est une explication simple. master dans votre localhost est une branche.

Lorsque vous clonez un référentiel, vous obtenez le référentiel complet pour l'hôte local. Cela signifie qu’à ce stade, le pointeur origine / maître sur HEAD et le maître pointant sur le même HEAD .

lorsque vous commencez à travailler et que vous faites cela, vous transférez le pointeur principal vers HEAD + vos fixations. Mais le pointeur origine / maître indique toujours ce que c'était quand vous avez cloné.

Ainsi, la différence sera:

  • Si vous exécutez git fetch , il extraira simplement toutes les modifications du référentiel distant ( GitHub ) et déplacera le pointeur de départ / maître sur HEAD . En attendant, votre assistant de succursale local continuera d'indiquer où il se trouve.
  • Si vous git pull , il va essentiellement extraire (comme expliqué précédemment) et fusionner toutes les nouvelles modifications dans la branche principale et déplacer le pointeur sur HEAD .
347
11 мая '12 в 21:37 2012-05-11 21:37 la réponse est donnée Gerardo le 11 mai '12 à 21:37 2012-05-11 21:37

Parfois, une présentation visuelle aide.

2019

25 янв. la réponse est donnée par thearkark passenger le 25 janvier . 2016-01-25 20:28 '16 à 20:28 pm 2016-01-25 20:28

brièvement

git fetch est similaire à pull mais ne se fusionne pas. c'est-à-dire il extrait les mises à jour distantes ( refs et objects ), mais votre local reste inchangé (c’est-à-dire que l’ origin/master mis à jour, mais le master reste identique).

git pull retiré de la console et fusionne instantanément.

Plus

git clone reposent.

git rebase enregistre le matériel de votre branche actuelle qui ne se trouve pas dans la branche ascendante dans la zone temporaire. Votre fil est maintenant le même qu'avant de commencer vos modifications. Ainsi, git pull -rebase retirera les modifications supprimées, rembobinera votre branche locale, répétera les modifications en haut de la branche actuelle une par une, jusqu'à ce que vous soyez au courant des derniers développements.

De plus, git branch -a vous montrera exactement ce qui se passe dans toutes vos branches - locales et distantes.

Ce blog a été utile:

Différence entre git pull, git fetch et git clone (et git rebase) - Mike Pierce

et couvre git pull , git fetch , git clone et git rebase .

====

MISE À JOUR

Je pensais l'actualiser pour montrer comment vous l'aviez utilisé dans la pratique.

  1. Mettez à jour votre référentiel local à partir d'un périphérique distant (mais n'unissez pas):

     git fetch 
  2. Après avoir téléchargé les mises à jour, voyez les différences:

     git diff master origin/master 
  3. Si vous êtes satisfait de ces mises à jour, fusionnez:

     git pull 

Notes:

Au cours de l'étape 2: pour plus d'informations sur les différences entre les périphériques locaux et distants, voir la section: Comment comparer une branche git locale à une branche distante?

A l'étape 3: il est très probablement plus précis (par exemple, dans un git rebase origin à changement rapide) de créer l' git rebase origin . Voir @Justin Ohms Comment dans une autre réponse.

Voir aussi: http://longair.net/blog/2009/04/16/git-fetch-and-merge/

170
13 апр. Répondre Snowcrash 13 avr. 2013-04-13 20:31 13 à 20h31 2013-04-13 20:31
 git-pull - récupère et fusionne avec un autre référentiel ou une branche locale SYNOPSIS git pull ... DESCRIPTION Lance le git-fetch  têtes récupérées dans la branche en cours.  Avec --rebase, appelle git-rebase  au lieu de git-merge. Notez que vous pouvez utiliser.  (répertoire en cours) en tant que <référentiel> à extraire  depuis le référentiel local - utile lors de la fusion de branches locales  dans la branche actuelle. Git-pull  pour git-fetch.

Vous tireriez, si vous voulez que les histoires fusionnent, vous obtiendriez si vous "vouliez le code", parce que certains d'entre eux ont mis des articles ici.

161
15 нояб. Réponse donnée par Vinko Vrsalovic le 15 novembre 2008-11-15 12:52 '08 à 12:52 2008-11-15 12:52

Vous pouvez extraire du référentiel distant, voir les différences, puis extraire ou fusionner.

Voici un exemple de référentiel distant nommé origin et d'une branche nommée master , qui suit la branche d' origin/master distante:

 git checkout master git fetch git diff origin/master git rebase origin master 
147
21 марта '11 в 14:07 2011-03-21 14:07 la réponse est donnée par Antonio Bardazzi, le 21 mars 2011 à 14:07. 2011-03-21 14:07

La réponse courte et simple est que git pull est juste git fetch suivi de git merge .

Il est très important de noter que git pull fusionne automatiquement, que cela vous plaise ou non . Ceci, bien sûr, peut conduire à la fusion de conflits. Disons que votre console est d' origin et votre branche est master . Si vous êtes git diff origin/master avant de tirer, vous devez être conscient des conflits de fusion potentiels et préparer votre branche locale en conséquence.

En plus de tirer et de cliquer, certains flux de travail incluent git rebase , par exemple celui-ci, que je paraphrase d'un article connexe:

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

Si vous vous trouvez dans cette situation, vous pouvez être tenté par git pull --rebase . Si vous ne savez vraiment pas ce que vous faites, je vous conseillerais de le faire. Voici un avertissement de la page de manuel de git-pull , version 2.3.5 :

C'est un mode de fonctionnement potentiellement dangereux. Il réécrit une histoire qui ne laisse pas présager que vous avez déjà publié cette histoire. N'utilisez pas ce paramètre si vous n'avez pas lu attentivement git-rebase (1).

139
15 мая '11 в 23:53 2011-05-15 23:53 la réponse est donnée par jfmercer le 15 mai 2011 à 23:53. 2011-05-15 23:53

2019

117
06 февр. la réponse est donnée le 06 février 2015-02-06 14:48 '15 à 14:48 2015-02-06 14:48

Voici quelques informations sur git pull et git fetch , afin que vous puissiez comprendre les différences réelles ... en quelques mots simples, fetch récupère les données les plus récentes, mais ne modifie pas le code et ne contactera pas le code de votre branche locale actuelle, mais extrayez le code avec les modifications. et le fusionner dans votre branche locale, continuez pour obtenir des informations plus détaillées sur chacun:

aller chercher

Il téléchargera tous les liens , les objets et toutes les nouvelles branches dans votre référentiel local ...

Choisissez des branches et / ou des balises (ensemble, "refs") dans un ou plusieurs autres référentiels, ainsi que les objets nécessaires pour compléter leurs récits. Mise à jour des branches de suivi à distance (voir Description ci-dessous pour savoir comment contrôler ce problème).

Par défaut, toute balise qui pointe vers des histoires extraites est également récupérée. l’effet consiste à extraire des balises qui pointent vers les branches qui vous intéressent. Ce comportement par défaut peut être modifié à l'aide des options --tags ou --no-tags ou en définissant remote..tagOpt. En utilisant refspec, qui extrait explicitement les balises, vous pouvez extraire des balises qui ne pointent pas vers les branches qui vous intéressent.

git fetch peut être récupéré à partir d'un seul référentiel nommé ou d'une seule URL, ou de plusieurs référentiels à la fois, le cas échéant, et s'il existe des consoles. écrire dans le fichier de configuration. (Voir Git-config 1 ).

Si aucun périphérique distant n'est spécifié, la source de démarrage par défaut est utilisée, sauf si une branche en amont est configurée pour la branche en cours.

Les noms des liens sélectionnés, ainsi que les noms des objets sur lesquels ils pointent, sont enregistrés in.git / FETCH_HEAD. Ces informations peuvent être utilisées par des scripts ou d’autres commandes git, telles que git-pull.


git pull

Il appliquera les modifications de la branche distante à la branche en cours dans le local

Inclut les modifications d'un référentiel distant vers la branche actuelle. Dans le mode par défaut, git pull est une abréviation de git fetch, suivie de git merge FETCH_HEAD.

Plus spécifiquement, git pull exécute git fetch avec les paramètres donnés et appelle git merge pour fusionner les en-têtes de branche reçus dans la branche actuelle. En utilisant --rebase, il lance git rebase au lieu de git merge.

devrait être le nom du référentiel distant passé à git-fetch 1 . peut appeler une référence distante arbitraire (par exemple, le nom de la balise) ou même une collection de liens avec les branches de suivi distantes correspondantes (par exemple, refs / heads /: refs / remotes / origin /), mais il s’agit généralement du nom de la branche dans le référentiel distant.

Les valeurs par défaut pour et sont lues à partir des configurations "remote" et "merge" pour la branche actuelle, comme défini par git-branch --track.


Je crée également une image visuelle ci-dessous pour vous montrer comment git fetch et git pull fonctionnent ensemble ...

2019

Bonus:

En parlant d’étirement et d’extraction dans les réponses ci-dessus, je voudrais partager un tour intéressant,

git pull --rebase

Cette commande ci-dessus est la commande la plus utile dans ma vie de git, qui a permis de gagner beaucoup de temps.

Avant d'envoyer de nouveaux commits sur le serveur, essayez cette commande. Elle synchronisera automatiquement les dernières modifications apportées au serveur (à l'aide de fetch + merge) et placera votre message au début dans le journal git. Pas besoin de s'inquiéter de la traction / fusion des mains.

Trouvez des informations sur: http://gitolite.com/git-pull--rebase

113
23 дек. La réponse est donnée par Sazzad Hissain Khan le 23 décembre. 2015-12-23 18:31 '15 à 18:31 2015-12-23 18:31

J'aime avoir une sorte de représentation visuelle de la situation pour comprendre ces choses. Peut-être que d'autres développeurs aimeraient également voir cela, alors voici mon ajout. Je ne suis pas tout à fait sûr que tout est correct, alors veuillez commenter si vous trouvez des erreurs.

  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 . . . FETCH *------------------>* Your local cache of the remote is updated with the origin (or multiple external sources, that is git 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. 

Les principaux avantages d'une image miroir de la console sont les suivants:

  • Performance (défilement de tous les commits et messages sans essayer de le compresser via le réseau)
  • Retour sur l'état de votre référentiel local (par exemple, j'utilise Atlassian SourceTree, ce qui me donnera une ampoule indiquant si je vais avancer ou reculer par rapport à la source. Mettre à jour avec GIT FETCH).
107
20 февр. La réponse est donnée par Justus Romijn le 20 février. 2014-02-20 00:18 14 à 0:18 2014-02-20 00:18

J'ai aussi eu du mal avec ça. En fait, je suis arrivé ici avec Google Search pour exactement la même question. Après avoir lu toutes ces réponses, j'ai finalement dessiné une image dans ma tête et j'ai décidé d'essayer de gérer l'état de 2 référentiels et d'un sandbox, ainsi que les actions exécutées avec le temps, en regardant leur version. Donc, c'est ce que je suis venu avec. S'il vous plaît corrigez-moi si je me suis planté.

Trois dépôts avec un échantillon:

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

Trois dépôts avec une charge

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

Cela m'a aidé à comprendre pourquoi l'échantillonnage est très important.

95
17 июля '12 в 19:43 2012-07-17 19:43 la réponse est donnée pn1 mec 17 juillet 12 à 19:43 2012-07-17 19:43

La différence entre GIT Fetch et GIT Pull peut s'expliquer par le scénario suivant: (Rappelez-vous que les images parlent plus que les mots! J'ai fourni une représentation graphique)

Supposons que vous travaillez sur un projet avec des membres de votre équipe. Ainsi, ils constitueront l’une des divisions principales du projet et tous les participants devront s’établir dans leur propre référentiel local, puis travailler sur cette branche locale pour modifier / ajouter des modules, puis revenir à la branche principale.

Ainsi, l’état initial des deux branches, lorsque vous diviserez le projet principal dans votre référentiel local, sera comme ceci- ( A , B et C sont les modules déjà terminés dans le projet)

2019

07 февр. La réponse est donnée par Aman Tiwari le 7 février. 2017-02-07 17:15 17 à 17h15 2017-02-07 17h15

Nous disons simplement:

 git pull == git fetch + git merge 

Si vous exécutez git pull , vous n'avez pas besoin de fusionner des données avec des données locales. Если вы запустите git fetch , это означает, что вы должны запустить git merge для получения последнего кода на вашем локальном компьютере. В противном случае локальный машинный код не будет изменен без слияния.