web-dev-qa-db-fra.com

Différence entre git pull et git pull --rebase

J'ai commencé à utiliser git il y a quelque temps et je ne comprenais pas bien les subtilités. Ma question fondamentale ici est de trouver la différence entre un git pull et un git pull --rebase, car l’ajout de l’option --rebase ne semble pas faire quelque chose de très différent: ne fait que tirer.

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

gitgit-pull
280
Rndm

git pull = git fetch + git merge contre le suivi de la branche en amont

git pull --rebase = git fetch + git rebase contre le suivi de la branche en amont

Si vous voulez savoir en quoi _git merge_ et _git rebase_ diffèrent, lisez ceci .

295
mvp

Parfois, nous avons un processus en amont qui rebase/rembobine une branche sur laquelle nous comptons. Cela peut être un gros problème - causer des conflits en désordre pour nous si nous sommes en aval.

La magie c'est git pull --rebase

Un git pull normal est, en gros, quelque chose comme ceci (nous allons utiliser une télécommande appelée Origin 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 tir git --rebase ne fait que ceci:

git fetch Origin
git rebase Origin/foo

Mais cela n’aidera pas si la base amont impliquait un "écrasement" (ce qui signifie que les patch-ids des commits ont changé, pas seulement leur ordre).

Ce qui signifie que git pull --rebase doit faire un peu plus que cela. Voici une explication de ce que cela fait et comment.

Disons que votre point de départ est le suivant:

a---b---c---d---e  (Origin/foo) (also your local "foo")

Le temps passe et vous avez commis des commits en plus de votre propre "foo":

a---b---c---d---e---p---q---r (foo)

Pendant ce temps, dans un accès de rage anti-sociale, le responsable en amont n'a pas seulement rebasonné son "foo", il a même utilisé une courge ou deux. Sa chaîne de commit ressemble maintenant à ceci:

a---b+c---d+e---f  (Origin/foo)

Un coup de bâton à ce stade entraînerait le chaos. Même un git chercher; git rebase Origine/foo ne l'aurait pas coupé, car commet "b" et "c" d'un côté et commet "b + c" de l'autre serait en conflit. (Et pareillement avec d, e et d + e).

Dans ce cas, git pull --rebase:

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 avoir des conflits, mais il s'agira de véritables conflits (entre p/q/r et a/b + c/d + e/f), et non de conflits causés par un conflit entre b/c et b + c, etc.

Réponse prise de (et légèrement modifiée):
http://gitolite.com/git-pull--rebase

228
Mauri Lopez

Supposons que vous ayez deux commits dans la branche locale:

      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 plus de point de fusion G. Notez que D et E deviennent des commits différents:

A---B---C---F---D'---E'   master, Origin/master
38
Deqing

Dans le cas le plus simple d'absence de collision

  • with rebase: rebase vos commits locaux ontop de HEAD à distance et ne ( pas crée une validation de fusion/fusion
  • without/normal: fusionne et crée un commit de fusion

Voir également:

man git-pull

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 extraites dans la branche actuelle. Avec --rebase, il exécute git rebase au lieu de git merge.

Voir également:
Quand devrais-je utiliser git pull --rebase?
http://git-scm.com/book/en/Git-Branching-Rebasing

10
drahnr

Car il est important de comprendre la différence entre Merge et Rebase.

Les bases sont la façon dont les modifications doivent passer du haut de la hiérarchie vers le bas et les fusions sont la manière dont elles sont renvoyées vers le haut.

Pour plus de détails, consultez - http://www.derekgourlay.com/archives/428

7
Sagar Mody