Diferencia entre git pull y git pull --rebase

A veces tenemos un upstream que rebasa/rebobina una rama de la que dependemos. Esto puede ser un gran problema causing causando conflictos desordenados para nosotros si estamos río abajo.

La magia es git pull --rebase

Un git pull normal es, vagamente hablando, algo como esto (usaremos un control remoto llamado origin y una rama llamada foo en todos estos ejemplos):

# assume current checked out branch is "foo"
git fetch origin
git merge origin/foo

A primera vista, podrías pensar que un git pull reb rebase hace precisamente esto:

git fetch origin
git rebase origin/foo

Pero eso no ayudará si la rebase de upstream implicó algún "squashing" (lo que significa que los patch-id de las confirmaciones cambiaron, no solo su orden).

Lo que significa que git pull reb rebase tiene que hacer un poco más que eso. Aquí hay una explicación de lo que hace y cómo.

Digamos que tu punto de partida es este:

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

El tiempo pasa, y has hecho algunos commits encima de tu propio "foo":{[11]]}

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

Mientras tanto, en un ataque de rabia antisocial, el el mantenedor de upstream no solo ha rebasado su "foo", sino que incluso ha usado una o dos squash. Su cadena de commit ahora se ve así:

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

Un tirón de git en este punto resultaría en caos. Incluso un git fetch; git rebase origin / foo no lo cortaría, porque las confirmaciones "b" y "c" por un lado, y las confirmaciones "b+c" por el otro, entrarían en conflicto. (Y de manera similar con d, e y d + e).

Lo que git pull --rebase hace, en este caso, es:

git fetch origin
git rebase --onto origin/foo e foo

Esto te da:

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

Todavía puede tener conflictos, pero serán conflictos genuinos (entre p/q/r y a/b+c/d+e/f), y no conflictos causados por b/c que entran en conflicto con b+c, etc.

Respuesta tomada de (y ligeramente modificada):
http://gitolite.com/git-pull--rebase

Supongamos que tienes dos confirmaciones en la rama local:

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

Después de "git pull", será:

      D--------E  
     /          \
A---B---C---F----G   master, origin/master

Después de "git pull reb rebase", no habrá punto de fusión G. Tenga en cuenta que D y E se convierten en confirmaciones diferentes:

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

En el caso más simple de no colisiones

• con rebase: rebases sus commits locales en la parte superior de la CABEZA remota y no no crear una merge / merge commit
• sin/normal: fusiona y crea una confirmación de fusión

Véase también:

man git-pull

Más precisamente, git pull ejecuta git fetch con los parámetros dados y llama a git merge para fusionar los jefes de rama recuperados en el Sucursal. Con reb rebase, se ejecuta git rebase en lugar de git merge.

Ver también:
Cuando debo usar git pull --rebase?
http://git-scm.com/book/en/Git-Branching-Rebasing

Para esto es importante entender la diferencia entre Fusionar y Rebase.

Las rebases son cómo los cambios deben pasar de la parte superior de la jerarquía hacia abajo y las fusiones son la forma en que fluyen hacia arriba.

Para más detalles, consulte - http://www.derekgourlay.com/archives/428