origin - git push




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

Et quelle est la différence entre git pullet git fetch?

Pour comprendre cela, vous devez d’abord comprendre que votre git local ne gère pas seulement votre référentiel local, il conserve également une copie locale du référentiel distant.

git fetchmet à jour votre copie locale du référentiel distant. Par exemple, si votre référentiel distant est GitHub - vous pouvez extraire toutes les modifications apportées dans le référentiel distant à votre copie locale, le référentiel distant. Cela vous permettra d'effectuer des opérations telles que la comparaison ou la fusion.

git pulld'autre part, réduira les modifications dans le référentiel distant pour que vous conserviez votre propre code. En règle générale, git pullcommencez git fetchpar mettre à jour la copie locale du référentiel distant, puis fusionnera les modifications dans votre propre référentiel de code et éventuellement votre copie de travail.

Remarque du modérateur: étant donné que soixante-sept réponses ont déjà été attribuées à cette question (certaines d'entre elles ont été supprimées), déterminez si vous contribuez ou non à de nouvelles contributions avant d'en poster une autre.

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


Prime:

En parlant de tirer et chercher 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 de transmettre vos nouveaux commits au serveur, essayez cette commande. Elle synchronisera automatiquement les dernières modifications apportées au serveur (avec une extraction + une fusion) et placera votre validation en haut dans le journal git. Pas besoin de s'inquiéter de l'extraction / fusion manuelle.

Vous trouverez des détails sur: http://gitolite.com/git-pull--rebase


Dans les termes les plus simples, git pull effectue un git fetch suivi d'une git merge .

Vous pouvez effectuer une git fetch à tout moment pour mettre à jour vos branches de suivi à distance sous refs/remotes/<remote>/ .

Cette opération ne change jamais aucune de vos propres succursales locales sous les refs/heads , et vous pouvez le faire sans modifier votre copie de travail. J'ai même entendu parler de personnes exécutant git fetch régulièrement dans un travail cron en arrière-plan (bien que je ne recommande pas de le faire).

Un git pull est ce que vous feriez pour mettre à jour une branche locale avec sa version distante, tout en mettant à jour vos autres branches de suivi à distance.

Documentation Git: git pull


Il est important d'opposer la philosophie de conception de git à celle d'un outil de contrôle de source plus traditionnel tel que SVN.

Subversion a été conçu et construit avec un modèle client / serveur. Il existe un seul référentiel qui est le serveur, et plusieurs clients peuvent extraire du code du serveur, le travailler, puis le renvoyer sur le serveur. L'hypothèse est 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é ne nécessitant pas de référentiel central (bien que vous puissiez certainement en utiliser un si vous le souhaitez). Aussi, git a été conçu pour que le client et le "serveur" n'aient pas besoin d'être en ligne en même temps. Git a été conçu pour que même les personnes disposant d'un lien peu fiable puissent échanger du code par courrier électronique. Il est possible de travailler complètement déconnecté et de graver un CD pour échanger du code via git.

Afin de prendre en charge ce modèle, git gère 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 conservant localement une copie du référentiel distant, git peut déterminer les modifications nécessaires même lorsque le référentiel distant est inaccessible. Plus tard, lorsque vous devrez envoyer les modifications à quelqu'un d'autre, git pourra les transférer sous forme d'un ensemble de modifications à partir d'un moment connu du référentiel distant.

  • git fetch est la commande qui dit "mettre à jour ma copie locale du référentiel distant".

  • git pull dit "apporte les modifications dans le référentiel distant là où je garde mon propre code."

Normalement, git pull fait en effectuant une git fetch pour mettre à jour la copie locale du référentiel distant, puis en fusionnant les modifications dans votre propre référentiel de code et éventuellement votre copie de travail.

Il faut garder à l'esprit qu'il y a souvent au moins trois copies d'un projet sur votre poste de travail. Une copie est votre propre référentiel avec votre propre historique de validation. La seconde copie est votre copie de travail sur laquelle vous éditez et construisez. La troisième copie est votre copie locale "en cache" d'un référentiel distant.


La réponse courte et facile est que git pull est simplement git fetch suivi de git merge .

Il est très important de noter que git pull fusionnera automatiquement que cela vous plaise ou non . Bien entendu, cela pourrait entraîner des conflits de fusion. Disons que votre télécommande est l' origin et votre branche est master . Si vous avez git diff origin/master avant de tirer, vous devriez avoir une idée des conflits de fusion potentiels et préparer votre branche locale en conséquence.

En plus de tirer et de pousser, certains flux de travail impliquent git rebase , comme celui-ci, que je paraphrase de l'article lié:

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

Si vous vous trouvez dans une telle situation, vous serez peut-être tenté de vous git pull --rebase . À moins que vous ne sachiez vraiment ce que vous faites, je déconseillerais cela. Cet avertissement provient de la page de manuel de git-pull , version 2.3.5 :

C'est un mode de fonctionnement potentiellement dangereux. Il réécrit l’histoire, ce qui augure mal lorsque vous avez déjà publié cette histoire. N'utilisez cette option que si vous avez lu attentivement git-rebase (1).


Parfois, une représentation visuelle aide.



Vous pouvez récupérer depuis un référentiel distant, voir les différences, puis extraire ou fusionner.

Voici un exemple pour un référentiel distant appelé origin et une branche appelée master surveillant l' origin/master la branche distante:

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

git fetchrécupérera les branches à distance afin que vous puissiez git diffou git mergeeux avec la branche courante. git pullexécutera la recherche sur le canal distant suivi par la branche actuelle, puis fusionnera le résultat. Vous pouvez git fetchvérifier s'il existe des mises à jour de la branche distante sans les fusionner avec votre branche locale.


Brièvement

git fetch est similaire à pull mais ne fusionne pas. c'est-à-dire qu'il récupère les mises à jour à distance ( refs et objects ) mais que votre adresse locale reste la même (c'est-à-dire que l' origin/master est mis à jour mais que le master reste le même).

git pull tire une télécommande et fusionne instantanément.

Plus

git clone clone un repo.

git rebase enregistre dans une zone temporaire des éléments de votre branche actuelle qui ne se trouve pas dans la branche en amont. Votre branche est maintenant la même qu'avant de commencer vos modifications. Ainsi, git pull -rebase affichera les modifications distantes, rembobinera votre branche locale, repassera vos modifications une par une au-dessus de votre branche actuelle, jusqu'à ce que vous soyez à jour.

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

Ce blog a été utile:

La différence entre git pull, git fetch et git clone (et git rebase) - Mike Pearce

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

====

METTRE À JOUR

Je pensais que je mettrais à jour ceci pour montrer comment vous l'utiliseriez réellement dans la pratique.

  1. Mettez à jour votre référentiel local à partir de la télécommande (mais ne fusionnez pas):

    aller chercher

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

    origine du maître git diff / master

  3. Si vous êtes satisfait de ces mises à jour, alors fusionnez:

    git pull

Remarques:

Étape 2: Pour plus d'informations sur les différences entre les télécommandes locales et distantes, voir: comparer les branches git locales avec les branches distantes?

A l'étape 3: Il est probablement plus précis (par exemple, sur un git rebase origin changement rapide) de faire une git rebase origin ici. Voir le commentaire de @Justin Ohms dans une autre réponse.

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


OK , 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 pas les modifications de code et ne va pas perturber le code de votre branche locale actuelle , mais récupérez les changements de code et fusionnez-les avec votre branche locale, continuez pour obtenir plus de détails sur chacun:

aller chercher

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

Récupérez les branches et / ou les balises (collectivement, les "références") d'un ou de plusieurs autres référentiels, ainsi que les objets nécessaires pour compléter leur historique. Les branches de suivi à distance sont mises à jour (voir la description ci-dessous pour savoir comment contrôler ce problème).

Par défaut, toute balise pointant dans les historiques en cours d'extraction est également extraite. l'effet consiste à récupérer les 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 configurant remote..tagOpt. En utilisant un refspec qui récupère les balises de manière explicite, vous pouvez également récupérer des balises qui ne pointent pas dans les branches qui vous intéressent.

git fetch peut être récupéré à partir d'un seul référentiel nommé ou d'une URL, ou de plusieurs référentiels à la fois s'il est indiqué et s'il existe une télécommande. entrée dans le fichier de configuration. (Voir git-config 1 ).

Si aucune commande distante n'est spécifiée, la commande d'origine distante sera utilisée par défaut, sauf si une branche en amont est configurée pour la branche actuelle.

Les noms des références extraites, ainsi que les noms d'objet sur lesquels ils pointent, sont écrits dans .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 télécommande à la branche actuelle en local ...

Incorpore les modifications d'un référentiel distant dans la branche actuelle. Dans son mode par défaut, git pull est un raccourci pour git fetch suivi de git merge FETCH_HEAD.

Plus précisément, git pull exécute git fetch avec les paramètres donnés et appelle git fusionner pour fusionner les têtes de branches récupérées dans la branche actuelle. Avec --rebase, il exécute git rebase au lieu de git merge.

devrait être le nom d'un référentiel distant tel que transmis à git-fetch 1 . pouvez nommer une référence distante arbitraire (par exemple, le nom d'une balise) ou même une collection de références avec les branches de suivi à distance correspondantes (par exemple, refs / heads / : refs / remotes / origin / ), mais il s'agit généralement du nom d'une branche dans le référentiel distant.

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

Je crée également le visuel ci-dessous pour vous montrer comment git fetch et git pull fonctionnent ensemble ...

1


En réalité, Git conserve une copie de votre propre code et du référentiel distant.

La commande git fetchmet à jour votre copie locale en extrayant les données du référentiel distant. Nous avons besoin de cela parce que quelqu'un d'autre a peut-être apporté des modifications au code et que vous souhaitez rester à jour.

La commande git pullapporte les modifications dans le référentiel distant là où vous conservez votre propre code. git pullCela se fait normalement en faisant d'abord un 'git fetch' pour mettre à jour la copie locale du référentiel distant, puis il fusionne les modifications dans votre propre référentiel de code et éventuellement votre copie de travail.


Git obtient la branche de la dernière version de la télécommande au local en utilisant deux commandes:

  1. git fetch: Git va obtenir la dernière version de distant en local, mais ne se fusionne pas automatiquement. git fetch origin master git log -p master..origin/master git merge origin/master

    Les commandes ci-dessus signifient que télécharger la dernière version de la branche principale de la branche d'origine à la branche principale d'origine. Et compare ensuite la branche maître locale et la branche maître d'origine. Enfin, fusionnez.

  2. git pull: Git va obtenir la dernière version de la télécommande et se fondre dans la version locale.

    git pull origin master

    La commande ci-dessus est l'équivalent de git fetchet git merge. En pratique, git fetchpeut - être plus en sécurité, car avant la fusion, nous pouvons voir les modifications et décider de la fusion.


Nous disons simplement:

git pull == git fetch + git merge

Si vous exécutez git pull, vous n'avez pas besoin de fusionner les données en local. Si vous exécutez git fetch, cela signifie que vous devez exécuter git mergepour obtenir le dernier code sur votre ordinateur local. Sinon, le code machine local ne serait pas modifié sans fusion.

Ainsi, dans Git Gui, lorsque vous effectuez une récupération, vous devez fusionner les données. Aller chercher lui-même ne fera pas les changements de code chez votre section locale. Vous pouvez vérifier cela lorsque vous mettez à jour le code en récupérant une fois chercher et voir; le code ne changera pas. Ensuite, vous fusionnez ... Vous verrez le code modifié.


git pull == (git fetch + fusion de git)

git fetch ne change pas en branches locales.

Si vous avez déjà un référentiel local avec une configuration distante pour le projet souhaité, vous pouvez récupérer toutes les branches et les balises de la télécommande existante à l'aide de git fetch. ... Fetch n'apporte aucune modification aux branches locales; vous devez donc fusionner une branche distante avec une branche locale appariée pour intégrer les modifications apportées à la récupération. de github


Cette représentation graphique interactive est très utile pour comprendre git: http://ndpsoftware.com/git-cheatsheet.html

git fetch "télécharge" simplement les modifications de la télécommande vers votre référentiel local. git pull télécharge les modifications et les fusionne dans votre branche actuelle. "Dans son mode par défaut, git pull est un raccourci pour git fetch suivi de git merge FETCH_HEAD ."


J'ai eu du mal avec cela aussi. En fait, je suis arrivé ici avec une recherche google de la même question. En lisant toutes ces réponses, j’ai fini par avoir une image dans ma tête et j’ai décidé de tenter de comprendre l’état des 2 dépôts, un bac à sable et des actions effectuées au fil du temps tout en regardant leur version. Alors voici ce que je suis venu avec. S'il vous plaît, corrigez-moi si je me suis planté ailleurs.

Les trois pensions avec un chercher:

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

Les trois repos avec un pull

---------------------     -----------------------     -----------------------
- 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 une extraction est assez importante.


La différence entre GIT Fetch et GIT Pull peut être expliquée avec le scénario suivant: (N'oubliez pas que les images parlent plus que les mots !, j'ai fourni une représentation imagée)

Prenons un exemple montrant que vous travaillez sur un projet avec les membres de votre équipe. Il s’agit donc d’une branche principale du projet et tous les contributeurs doivent le bifurquer vers leur propre référentiel local, puis travailler sur cette branche locale pour modifier / ajouter des modules, puis revenir à la branche principale.

Ainsi, état initial des deux branches lorsque vous fourchue le projet principal de votre référentiel local sera comme this- ( A, Bet Csont des modules déjà terminé du projet)

Maintenant, vous avez commencé à travailler sur le nouveau module (supposons D) et lorsque vous avez terminé le Dmodule que vous voulez pousser à la branche principale, mais en attendant ce qui se passe est que l' un de vos coéquipiers a développé un nouveau module E, Fet modifié C.
C’est donc maintenant que votre référentiel local manque de l’avancement du projet et que, par conséquent, le fait de modifier vos modifications dans la branche principale peut entraîner des conflits et un Ddysfonctionnement du module .

Pour éviter de tels problèmes et travailler en parallèle avec l'avancement original du projet, il existe deux manières:

1. Git Fetch - Ceci téléchargera toutes les modifications apportées au projet origine / branche principale qui ne sont pas présentes dans votre branche locale. Et attendra que la commande Git Merge applique les modifications extraites dans votre référentiel ou votre branche.

Alors maintenant, vous pouvez surveiller attentivement les fichiers avant de les fusionner dans votre référentiel. Et vous pouvez également modifier Dsi nécessaire en raison de Modifié C.

2. Git Pull- Ceci mettra à jour votre branche locale avec son origine / branche principale, c’est-à-dire qu’elle combine Git Fetch et Git fusionnent les unes après les autres. Mais cela peut causer des conflits, il est donc recommandé d’utiliser Git Pull avec une copie vierge.


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.

Si vous voulez fusionner les historiques, vous tirez si vous voulez simplement «vouloir le code», car une personne a balisé des articles dans les environs.


git pull = git fetch + git merge 




git-fetch