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

parfois, nous avons un amont qui rebasé/rebound une branche dont nous dépendons. Cela peut être un gros problème -- causer des conflits confus pour nous si nous sommes en aval.

la magie est git pull --rebase

une traction normale de gitan est, grosso modo, quelque chose comme ceci (nous utiliserons 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 on pourrait penser qu'un git pull --rebase fait justement ceci:

git fetch origin
git rebase origin/foo

mais cela n'aidera pas si le rebase en amont impliquait un" squash " (ce qui signifie que les patch-ids des commits ont changé, pas seulement leur ordre).

ce qui veut dire git pull --rebase doit faire un peu plus que ça. Voici une explication de ce qu'il 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 fait quelques 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 antisociale, le mainteneur amont n'a pas seulement rebasé son "foo", il a même utilisé un squash ou deux. Sa chaîne de commit ressemble maintenant à ceci:

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

un coup de git à ce point aboutirait au chaos. Même un git fetch; git rebase origin / foo ne le couperait pas, car il engage "b" et " c " d'un côté, et commettre "b+c" sur l'autre, serait en conflit. (Et de même avec d, e et d+e).

ce que 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 avoir des conflits, mais ils seront de véritables conflits (entre p/q/R et a/b+c/d+e/F), et non des conflits causés par B/C en conflit avec b+C, etc.

Réponse tirée de (et légèrement modifiée):

http://gitolite.com/git-pull--rebase

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 pas de point de fusion."

A---B---C---F---D'---E'   master, origin/master

dans le cas le plus simple d'absence de collision

• 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, git pull court git fetch avec le donné les paramètres et les 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.

voir aussi:

Quand dois-je utiliser git pull --rebase?

http://git-scm.com/book/en/Git-Branching-Rebasing

pour cela est important de comprendre la différence entre la 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 plus de détails, voir - http://www.derekgourlay.com/archives/428