La différence entre la commande git pull et git pull --rebase

J'ai commencé à utiliser git parfois en arrière et de ne pas bien comprendre les subtilités. Ma question de base ici est de savoir la différence entre un git pull et git pull --rebase , depuis l'ajout de la --rebase option ne semble pas faire quelque chose de très différent : il suffit de ne un pull.

S'il vous plaît aidez-moi à comprendre la différence.

Connexes: Quand dois-je utiliser git pull --rebase?.
Double Possible de git pull VS git fetch git rebase
Lien utile: atlassian.com/git/tutorials/rewriting-history/git-rebase

InformationsquelleAutor Rndm | 2013-09-21

git git-pull

290

git pull = git fetch + git merge à l'encontre de suivi en amont de la branche

git pull --rebase = git fetch + git rebase à l'encontre de suivi en amont de la branche

Si vous voulez savoir comment git merge et git rebase diffèrent, lire ce.
- Il est intéressant de noter que le fait de dire git pull --rebase est le même que git fetch et git rebase est fondamentalement la façon dont il est, mais ce n'est pas exactement sémantiquement équivalentes. Il y a quelques différences, dont certaines sont expliquées ici. gitolite.com/git-pull--rebase
- C'est ce que j'appellerais une "pratique mensonge", pour reprendre l'expression de Scott Meyers. C'est une bonne façon de l'expliquer, peu importe.
InformationsquelleAutor mvp
225
Parfois, nous avons un amont qui relocalisée/remonter une branche nous sommes des selon les. Cela peut être un gros problème, causant un désordre conflits pour nous si nous sommes en aval.

La magie est git pull --rebase

Normale git pull est, grosso modo, quelque chose comme ceci (nous allons utiliser une distance appelée origine et une branche appelée foo dans tous ces exemples):
```
# assume current checked out branch is "foo"
git fetch origin
git merge origin/foo
```
À première vue, vous pourriez penser qu'un git pull --rebase fait juste cela:
```
git fetch origin
git rebase origin/foo
```
Mais cela ne l'aidera pas si, en amont, rebase impliqués "écraser" (ce qui signifie que le patch id de la commet changé, et pas seulement leur ordre).

Qui signifie git pull --rebase a faire un peu plus que cela. Voici une explication de ce qu'il fait et comment.

Disons-votre point de départ est: est-ce
```
a---b---c---d---e  (origin/foo) (also your local "foo")
```
Le temps passe, et que vous avez fait certains s'engage sur le dessus de votre propre "foo":
```
a---b---c---d---e---p---q---r (foo)
```
Pendant ce temps, dans un ajustement de l'anti-social de la rage, de la responsable amont n'a pas seulement relocalisée son "toto", il a même utilisé un squash ou deux. Son commit de la chaîne d'ressemble maintenant à ceci:
```
a---b+c---d+e---f  (origin/foo)
```
Un git pull à ce stade, le résultat serait le chaos. Même un git fetch; git rebase origine/foo ne serait pas le couper, parce que s'engage "b" et "c" sur une face, et de s'engager "b+c" sur l'autre, serait en conflit. (Et de même avec d, e et d+e).

Ce git pull --rebase fait, dans ce cas, est:
```
git fetch origin
git rebase --onto origin/foo e foo
```
Cela vous donne:
```
 a---b+c---d+e---f---p'---q'---r' (foo)
```
Vous pouvez toujours obtenir les conflits, mais ils seront de véritables conflits (entre p/q/r et a/b+c/d+e/f), et pas de conflits causés par les b/c en conflit avec b+c, etc.

Répondre prises à partir de (et légèrement modifié):

http://gitolite.com/git-pull--rebase
- C'est la meilleure réponse. Vous souhaiterez peut-être modifier le résultat final de a---b+c---d+e---f---p'---q'---r' (foo) depuis rebase les changements de valeurs de hachage.
- Changé, merci pour cette remarque @Bastien
- Cette réponse a été copié et collé verbatim à partir de gitolite.com/git-pull--rebase, et devraient inclure l'attribution par la licence sur cette page.
- C'est une bonne explication. Mais j'ai eu une situation où j'ai dû commettre A, et j'ai envoyé un PR à l'amont des pensions qui a été accepté. Puis, quand je n'ai git pull --rebase contre l'amont repo, je n'ai pas de nouvelles A' s'engager sur le dessus de l'tiré en amont des pensions. En fait, pas de A' existait. Est-ce parce que A a été fusionné dans le système? Ou est-ce parce qu'il n'y a pas de différence entre l'amont et mon relocalisée sur la version?
- Je suis en train de passer par le Git et le tutoriel a été l'aide de cette réponse pour mieux comprendre un git pull --rebase. Mais une chose qui me confond dans cette situation hypothétique est que le responsable amont a changé de projet de l'histoire qui a déjà été tiré dans les locaux du développeur dépôts. N'est-ce pas juste une mauvaise pratique en général? S'il voulait l'écraser s'engage/réécrire l'histoire, il doit avoir été effectué avant de l'intégrer dans le référentiel central pour éviter ce type de conflits.
InformationsquelleAutor Mauri Lopez
37

Supposons que vous avez deux s'engage dans les locaux de la direction de la
```
      D---E master
     /
A---B---C---F origin/master
```
Après "git pull", sera:
```
      D--------E  
     /         \
A---B---C---F----G   master, origin/master
```
Après "git pull --rebase", il n'y aura pas de fusion point G. Remarque que le D et le E devient différente s'engage à:
```
A---B---C---F---D'---E'   master, origin/master
```
- n'est-il pas Un---B---C---D---E'--F ?
- oui, Vous avez raison @prgmrDev
- Pourquoi serait-D et E être inséré avant la F?
InformationsquelleAutor Deqing
10

Dans la plupart des cas simple de pas de collisions
- avec rebase: rebases votre local s'engage ontop de distance de la TÊTE et de ne pas créer une fusion/fusion de commettre
- sans/normal: fusionne et crée une fusion de commettre
Voir aussi:

man git-pull

Plus précisément, la commande git pull fonctionne git fetch avec les paramètres donnés et
appels git merge pour fusionner l'extrait chefs de direction dans le courant de
de la branche. Avec --rebase, il exécute la commande git rebase au lieu de git merge.

Voir aussi:

Quand dois-je utiliser git pull --rebase?

http://git-scm.com/book/en/Git-Branching-Rebasing
- Et en cas de collisions ?
- Vous serez invité à les résoudre manuellement, et puis continuer avec rebase:git sdd modified-file; git rebase --continue ou de fusion:git add modified-file; git commit; où modified-file est votre local de fichier que vous avez modifié manuellement/mergetool
InformationsquelleAutor drahnr
7

Pour ce qui est important de comprendre la différence entre Fusion et Rebase.

Rebases sont comment les changements doivent passer par le haut de la hiérarchie vers le bas
et les fusions sont comment ils reviennent vers le haut.

Pour des détails, reportez - http://www.derekgourlay.com/archives/428
- Je pense que votre réponse propose une explication beaucoup plus simple qui n'est pas évident sur le reste des réponses ci-dessus. Merci.
InformationsquelleAutor Sagar Mody

Vous devez vous connecter pour publier un commentaire.