• lorsque vous utilisez pull , Git essaie de faire automatiquement votre travail à votre place. Il est sensible au contexte , donc, Git va fusionner tout tiré s'engage dans la branche dans laquelle vous travaillez actuellement. pull fusionne automatiquement les commits sans vous permettre de les réviser en premier . Si vous ne gérez pas vos succursales de près, vous pourriez vous heurter à des conflits fréquents.

• Lorsque vous fetch , Git rassemble toutes les propagations de la branche cible qui n'existent pas dans votre branche actuelle et les stocke dans votre dépôt local . Toutefois, ne les fusionne pas avec votre branche actuelle . Ceci est particulièrement utile si vous avez besoin de garder votre dépôt à jour, mais travaillez sur quelque chose qui pourrait casser si vous mettez à jour vos fichiers. Pour intégrer les commits dans votre branche principale, vous utilisez merge .

il est important de comparer la philosophie de conception de git avec celle d'un outil de contrôle des sources plus traditionnel comme SVN.

Subversion a été conçu et construit avec un modèle client/serveur. Il y a un seul dépôt qui est le serveur, et plusieurs clients peuvent récupérer du code à partir du serveur, travailler dessus, puis le renvoyer au serveur. L'hypothèse est que le client peut toujours contacter le serveur lorsqu'il a besoin d'effectuer une opération.

Git a été conçu pour prendre en charge un modèle plus distribué sans avoir besoin d'un dépôt central (bien que vous puissiez certainement en utiliser un si vous le souhaitez). Aussi git a été conçu de sorte que le client et le serveur n'a pas besoin d'être en ligne en même temps. Git a été conçu pour que les personnes sur un lien non fiable puissent échanger du code par e-mail, même. Il est possible de travailler complètement déconnecté et graver un CD pour échanger du code via git.

pour supporter ce modèle git maintient un dépôt local avec votre code et un autre référentiel local qui reflète l'état du dépôt distant. En conservant une copie du dépôt distant localement, git peut comprendre les changements nécessaires même lorsque le dépôt distant n'est pas accessible. Plus tard, quand vous en avez besoin pour envoyer les modifications à quelqu'un d'autre, git peut transférer dans un ensemble de modifications à partir d'un point connu sur le dépôt distant.

• git fetch est la commande qui dit " mettre à jour ma copie locale du dépôt distant."

• git pull dit " apporter les modifications dans le dépôt distant à l'endroit où je garde mon propre code."

normalement git pull fait ceci en faisant un git fetch pour apporter la copie locale de la télécommande mise à jour du dépôt, puis fusion des modifications dans votre propre dépôt de code et éventuellement votre copie de travail.

L'emporter est de garder à l'esprit qu'il y a souvent au moins trois copies d'un projet sur votre poste de travail. Une copie de votre dépôt avec votre propre commettre l'histoire. La deuxième copie est votre copie de travail où vous éditez et construisez. La troisième copie est votre copie locale "mise en cache" d'un dépôt distant.

Voici L'image D'Oliver Steele de la façon dont tout va ensemble :

S'il y a un intérêt suffisant, je suppose que je pourrais mettre à jour l'image pour ajouter git clone et git merge ...

un cas d'utilisation de git fetch est que ce qui suit vous indiquera tout changement dans la branche distante depuis votre dernière traction... ainsi, vous pouvez vérifier avant de faire un tir réel, qui pourrait changer les fichiers dans votre branche actuelle et la copie de travail.

git fetch
git diff ...origin

cela m'a coûté un peu de comprendre quelle était la différence, mais c'est une explication simple. master dans votre localhost est une branche.

lorsque vous clonez un dépôt, vous récupérez le dépôt entier sur votre hôte local. Cela signifie qu'à ce moment-là, vous avez un pointeur d'origine/maître vers HEAD et un pointeur maître pointant vers le même HEAD .

quand vous commencez à travailler et faites vous avancer le pointeur maître à HEAD + vos commits. Mais le pointeur origine/master indique toujours ce que c'était quand vous avez cloné.

ainsi la différence sera:

• si vous faites un git fetch il récupérera toutes les modifications dans le dépôt distant ( GitHub ) et déplacera le pointeur origine/maître vers HEAD . Pendant ce temps, votre chef de service local vous indiquera où il en est.
• Si vous faites un git pull , il va faire essentiellement fetch (comme expliqué précédemment) et fusionner toutes les nouvelles modifications à votre branche principale et déplacer le pointeur à HEAD .

parfois, une représentation visuelle aide.

brièvement

git fetch est similaire à pull mais ne fusionne pas. i.e. il récupère les mises à jour à distance ( refs et objects ) mais votre local reste le même (i.e. origin/master est mis à jour mais master reste le même) .

git pull sort d'une télécommande et fusionne instantanément.

plus

git clone les clones de pensions de titres.

git rebase permet d'enregistrer dans une zone temporaire des éléments de votre branche courante qui ne se trouvent pas dans la branche amont. Votre branche est maintenant la même qu'avant que vous commenciez vos changements. Donc, git pull -rebase va tirer vers le bas les changements à distance, rembobinez votre branche locale, rejouez vos changements sur le dessus de votre branche actuelle un par un jusqu'à ce que vous êtes à jour.

aussi, git branch -a vous montrera exactement ce qui se passe avec toutes vos branches - local et à distance.

ce billet de blog a été utile:

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

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

= = = =

UPDATE

j'ai pensé mettre à jour ceci pour montrer comment vous l'utiliseriez en pratique.

1. mise à Jour de votre local pensions à partir de la télécommande (mais ne pas les fusionner):

   git fetch

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

   git diff maître origin/master

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

   git pull

Notes:

Sur l'étape 2: Pour en savoir plus sur les différences entre les collectivités locales et les télécommandes, voir: comparer git local succursale de succursale à distance?

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

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

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.

vous tirez si vous voulez les histoires fusionnées, vous récupérez si vous "voulez juste le codez" comme une personne a été tagging quelques articles autour d'ici.

vous pouvez récupérer à partir d'un dépôt distant, voir les différences et ensuite tirer ou fusionner.

ceci est un exemple pour un dépôt distant appelé origin et une branche appelée master suivi de la branche distante origin/master :

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

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 va fusionner automatiquement que vous le vouliez ou non . Cela pourrait, bien sûr, entraîner des conflits de fusion. Disons que votre télécommande est origin et votre branche est master . Si vous git diff origin/master avant de tirer, vous devriez avoir une idée des conflits de fusion potentiels et pourrait préparer votre succursale locale en conséquence.

en plus de tirer et de pousser, certains workflows 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 pourriez être tenté de git pull --rebase . À moins que vous ne sachiez vraiment ce que vous faites, je vous le déconseille. Cet avertissement vient de la page man pour git-pull , version 2.3.5 :

il s'agit d'un mode de fonctionnement potentiellement dangereux. Il réécrit l'histoire, ce qui n'est pas de bon augure quand vous avez publié cette histoire déjà. N'utilisez cette option que si vous avez lu git-rebase(1) soigneusement.

Bonus:

En parlant de pull & fetch dans les réponses ci-dessus, je voudrais partager un truc intéressant,

git pull --rebase

cette commande ci-dessus est la commande la plus utile dans ma vie git qui a sauvé beaucoup de temps.

avant de pousser vos nouvelles propagations vers le serveur, essayez cette commande et elle synchronisera automatiquement les dernières modifications du serveur (avec une fusion fetch+) et placez votre commit en haut de git log. Pas besoin de vous soucier de la traction/fusion manuelle.

pour plus de détails: http://gitolite.com/git-pull--rebase

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

git fetch il suffit de "télécharger" les modifications de la télécommande vers votre dépôt 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 par git merge FETCH_HEAD ."

j'aime avoir une représentation visuelle de la situation pour saisir ces choses. Peut-être que d'autres développeurs aimeraient voir aussi, alors voici ma plus. Je ne suis pas totalement sûr que tout soit correct, alors s'il vous plaît 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'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.

certains avantages majeurs pour avoir un miroir récupéré de la télécommande sont:

• Performance en essayant de faire à travers le réseau)
• Feedback sur l'état de votre repo local (par exemple, J'utilise la SourceTree D'Atlassian, qui me donnera une ampoule indiquant si je m'engage devant ou derrière par rapport à l'origine. Cette information peut être mise à jour avec un FETCH GIT).

OK , voici quelques informations sur git pull et git fetch , pour que vous puissiez comprendre les différences réelles... en quelques mots simples, fetch obtient les dernières données, mais pas les changements de code et ne va pas à la pagaille avec votre code de branche locale actuelle, mais pull obtenir les changements de code et de le fusionner votre branche locale, lire la suite pour obtenir plus de détails sur chacun:

git fetch

il téléchargera tous les réfs et objets et toute nouvelle branche vers votre dépôt local...

récupération de branches et/ou des balises (collectivement, les "arbitres") d'un ou de plusieurs d'autres dépôts, ainsi que les objets nécessaires pour compléter leur histoire. Les branches de suivi à distance sont mises à jour (voir la description de ci-dessous pour les moyens de contrôler ce comportement).

par par défaut, toute balise qui pointe vers les histoires récupérées est aussi récupéré; l'effet est de récupérer les tags qui pointent vers les branches qui vous êtes intéressé dans. Ce comportement par défaut peut être modifié en utilisant les options --tags ou --no-tags ou en configurant distant..tagOpt. En utilisant un refspec qui récupère explicitement les tags, vous pouvez récupérer des étiquettes qui ne pointent pas dans les branches que vous êtes intéressé en tant que bien.

git fetch peut fetch à partir d'un seul nom un dépôt ou une URL, ou de plusieurs dépôts à la fois si est donnée et il ya un Remote. entrée dans le fichier de configuration. (Voir git-config 1 ).

quand aucune télécommande n'est spécifiée, par défaut la télécommande d'origine sera utilisé, sauf s'il y a une branche amont configurée pour le courant direction.

les noms des réf qui sont récupérés, ainsi que les noms des objets ils, sont écrits à .git / FETCH_HEAD. Cette information peut être utilisé par des scripts ou d'autres commandes git, comme git-pull.

git pull

Il appliquera les changements de à distance à la branche en local...

incorpore les changements d'un dépôt distant dans la branche courante. Dans son mode par défaut, git pull est 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 la fusion git pour fusionner les têtes de branche récupérées dans le courant direction. Avec -- rebase, il exécute git rebase au lieu de git merge.

devrait être le nom d'un dépôt distant, tel qu'adopté à git-fetch 1 . peut nommer un ref à distance arbitraire (par exemple, le nom d'une balise) ou même un collection de références correspondants branches de télésurveillance (par exemple, réfs / heads / : réfs / remotes/origin / ), mais habituellement, c'est le nom d'une branche dans le dépôt distant.

valeurs par défaut pour et sont lus à partir de la configuration "remote" et "merge" pour la branche courante définie par git-branche --piste.

je crée aussi le visuel ci-dessous pour vous montrer comment git fetch et git pull travailler ensemble...

j'ai lutté avec cette. En fait, je suis arrivé ici avec une recherche google exactement la même question. En lisant toutes ces réponses, j'ai finalement peint un tableau dans ma tête et j'ai décidé d'essayer de le mettre en bas en regardant l'état des 2 dépôts et 1 bac à sable et les actions effectuées au fil du temps tout en regardant la version d'eux. Voici donc ce que j'ai trouvé. S'il vous plaît corrigez-moi si j'ai foiré n'importe où.

les trois repos avec un 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+               -
---------------------     -----------------------     -----------------------

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 un fetch est assez important.

la différence entre git Fetch et git Pull peut s'expliquer par le scénario suivant: (en gardant à l'esprit que les images parlent plus fort que les mots! Je fournis la représentation picturale)

prenons un exemple que vous travaillez sur un projet avec les membres de votre équipe. Ainsi, leur sera une Branche principale du projet et à tous les contributeurs doivent fourche à leurs propres le dépôt local et puis travailler sur cette branche locale pour modifier / ajouter des modules puis repousser à la branche principale.

So, état Initial des deux Branches lorsque vous avez bifurqué le projet principal sur votre dépôt local sera comme ceci - ( A , B et C sont des Modules déjà terminés du projet)

maintenant, vous avez commencé à travailler sur le nouveau module (supposons D ) et lorsque vous avez terminé le module D vous voulez le pousser à la branche principale, mais en attendant ce qui se passe est que l'un de vos coéquipiers a développé le nouveau Module E , F et modifié C .

Donc maintenant ce qui s'est passé, c'est que votre dépôt local manque derrière la progression originale du projet et donc pousser vos changements à la branche principale peut conduire à conflit et peut causer un dysfonctionnement de votre Module D .

pour éviter de tels problèmes et travailler en parallèle avec l'avancement initial du projet, il y a deux façons:

1. Git Fetch - cela va télécharger tous les changements qui ont été apportés au projet de branche principale/origine qui ne sont pas présents dans votre branche locale. Et attendez que la commande git Merge applique les modifications qui ont été récupérées dans votre dépôt ou votre branche.

Alors maintenant, Vous pouvez surveiller attentivement les fichiers avant de les fusionner à votre dépôt. Et vous pouvez également modifier D si nécessaire en raison de modifié C .

2. Git Pull - cela mettra à jour votre branche locale avec l'origine/branche principale c'est-à-dire qu'en fait ce qu'elle fait est une combinaison de git Fetch et de git merge l'un après l'autre. mais cela peut causer des conflits de se produire, il est donc recommandé d'utiliser git Pull avec une copie propre.

nous disons simplement:

git pull == git fetch + git merge

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

donc dans le Git Gui, quand vous récupérez, vous devez fusionner les données. Fetch lui-même ne fera pas les changements de code à votre local. Vous pouvez vérifier que lorsque vous mettez à jour le code en allant chercher une fois que fetch et see; le code il ne changera pas. Puis de les fusionner... Vous verrez le code modifié.

git fetch tire le code du serveur distant vers vos branches de suivi dans votre dépôt local. Si votre télécommande s'appelle origin (la valeur par défaut), alors ces branches seront dans origin/ , par exemple origin/master , origin/mybranch-123 , etc. Ce ne sont pas vos branches actuelles, ce sont des copies locales de ces branches à partir du serveur.

git pull est-ce un git fetch mais alors aussi fusionne le code de suivi de branche dans votre version locale de cette branche. Si vous n'êtes pas encore prêt pour les changements, juste git fetch d'abord.

git fetch récupérera les branches distantes pour que vous puissiez les git diff ou git merge avec la branche courante. git pull exécutera fetch sur la brach distante tracée par la branche courante puis fusionnera le résultat. Vous pouvez utiliser git fetch pour voir s'il y a des mises à jour de la branche distante sans qu'il soit nécessaire de les fusionner avec votre branche locale.

Git Fetch

vous téléchargez des modifications à votre branche locale d'origine par fetch. Fetch demande le repo distant pour tous les commits que d'autres ont faits mais que vous n'avez pas sur votre repo local. Récupérez les téléchargements ces propagations et les ajoute au dépôt local.

Git Merge

vous pouvez appliquer les modifications téléchargées par fetch en utilisant la commande merge. Fusion prendra les commits extrait de chercher et d'essayer de les ajouter à votre succursale locale. La fusion conservera l'historique de propagation de vos modifications locales de sorte que lorsque vous partagez votre branche avec push, Git saura comment d'autres peuvent fusionner vos modifications.

Git Pull

Extraction et de fusion de courir ensemble, assez souvent qu'une commande qui combine les deux, pull, a été créé. Pull effectue un fetch puis une fusion pour ajouter les propagations téléchargées dans votre de la succursale locale.

la seule différence entre git pull et git fetch est que:

git pull tire d'une branche éloignée et la fusionne.

git fetch ne prend que la branche distante mais ne fusionne pas

c'est à dire la commande git pull = git fetch + git merge ...

Git permet d'appliquer des commits chronologiquement plus anciens après des commits plus récents. Pour cette raison, le transfert de commits entre les dépôts se fait en deux étapes:

1. Copie de nouveaux commits de branche distante de copie de cette branche à distance à l'intérieur des locaux des pensions.

   (opération de mise en pension) master@remote >> remote/origin/master@local

2. l'Intégration de nouveaux commits de la branche locale

   (opération inside-repo) remote/origin/master@local >> master@local

Il y a deux façons de faire l'étape 2. Vous pouvez:

1. bifurque branche locale après le dernier ancêtre commun et ajoute de nouvelles propagations parallèles aux propagations qui sont uniques au dépôt local, finalisées par fusion de commit, fermant la bifurcation.
2. insérer nouvelles commits après le dernier ancêtre commun et réappliquer commits unique à local référentiel.

Dans git de la terminologie, l'étape 1 est git fetch , l'étape 2 est git merge ou git rebase

git pull est git fetch et git merge

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

Pour comprendre cela, il faut d'abord comprendre que votre git local maintient non seulement votre dépôt local, mais elle conserve également une copie locale du dépôt distant.

git fetch met à jour votre copie locale du dépôt distant. Par exemple, si votre dépôt distant est GitHub - vous pouvez récupérer toutes les modifications apportées dans le dépôt distant vers votre copie locale du dépôt distant. Cela vous permettra d'effectuer des opérations de comparaison ou de fusion.

git pull d'un autre côté ramènera les changements dans le dépôt distant à l'endroit où vous conservez votre propre code. Typiquement, git pull va faire un git fetch d'abord pour mettre à jour la copie locale du dépôt distant, puis il va fusionner les modifications dans votre propre dépôt de code et peut-être 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 distance locale, mais il ne fusionnent 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 origin à partir de la branche principale de remote to origin. Et puis compare le branche principale locale et branche principale d'origine. Enfin, la fusion.

2. git pull: Git va obtenir la dernière version à partir de la télécommande et fusionner dans le local.

       git pull origin master

   la commande ci-dessus est l'équivalent de git fetch et git merge . En pratique, git fetch peut-être plus sûr parce qu'avant la Fusion, nous pouvons voir les changements et décider de fusionner.

git pull = = (git fetch + git merge)

git fetch ne modifie pas les branches locales.

si vous avez déjà un dépôt local avec une télécommande configurée pour le projet désiré, vous pouvez saisir toutes les branches et étiquettes pour la télécommande existante en utilisant git fetch . ... Fetch n'apporte aucun changement aux branches locales, vous devrez donc fusionner une branche distante avec une branche locale appariée pour incorporer les nouveaux changements fetch. de github

J'essaie d'être clair et simple.

la commande git pull est en fait une commande shortcut pour git fetch suivie de la commande git merge ou de la commande git rebase selon votre configuration. Vous pouvez configurer votre dépôt Git de sorte que git pull soit un fetch suivi d'un rebase.

en fait Git maintient une copie de votre propre code et le dépôt distant.

la commande git fetch met à jour votre copie locale en obtenant des données du dépôt distant. La raison pour laquelle nous avons besoin de cela est parce que quelqu'un d'autre pourrait avoir fait quelques changements au code et vous voulez garder vous-même mis à jour.

la commande git pull apporte les modifications du dépôt distant à l'endroit où vous conservez votre propre code. Normalement, git pull fait cela en faisant un ‘git fetch’ d'abord pour mettre à jour la copie locale du dépôt distant, puis il fusionne les modifications dans votre propre dépôt de code et éventuellement votre copie de travail.

git pull = git fetch + git merge 

une représentation graphique simple pour les débutants,

ici,

git pull  

récupérera le code du dépôt et rebasera avec votre local... dans git pull il y a la possibilité de créer de nouveaux commits.

mais dans la ,

git fetch

récupérera le code du dépôt et nous devons rebasez-le manuellement en utilisant git rebase

eg: je vais aller chercher à server master et le rebaser dans mon master local.

1) la commande git pull ( cela se fait automatiquement):

git pull origin master

ici origine est votre distance repo maître est votre branche

2) git fetch (besoin de rebase manuellement):

git fetch origin master

il va chercher les modifications du serveur d'origine. et il sera dans vos locaux jusqu'à ce que vous rebase sur votre propre. nous devons régler les conflits manuellement en vérifiant les codes.

git rebase origin/master

ceci va réécrire le code en local. avant cela assurez-vous que vous êtes dans la bonne branche.