Actualizar ramas de Git desde master

Soy nuevo en Git, y ahora estoy en esta situación:

• Tengo cuatro ramas (master, b1, b2 y b3).
• Después de trabajar en b1-b3, me di cuenta de que tenía algo que cambiar en la rama maestra que debería estar en todas las demás ramas.
• Cambié lo que necesitaba mastery ... aquí está mi problema:

¿Cómo actualizo todas las demás sucursales con mastercódigo de sucursal?

Tienes dos opciones:

El primero es una fusión, pero esto crea una confirmación adicional para la fusión.

Verifique cada sucursal:

git checkout b1

Luego fusionar:

git merge origin/master

Luego presione:

git push origin b1

Alternativamente, puedes hacer un rebase:

git fetch
git rebase origin/master

Básicamente tienes dos opciones:

1. Te unes. Eso es realmente bastante simple y una operación perfectamente local:

   git checkout b1
   git merge master
   # repeat for b2 and b3
   

   Esto deja la historia exactamente como sucedió: bifurcaste de master, hiciste cambios en todas las ramas y finalmente incorporaste los cambios de master en las tres ramas.

   gitpuede manejar esta situación realmente bien, está diseñado para fusiones que ocurren en todas las direcciones, al mismo tiempo Puede confiar en que podrá juntar todos los hilos correctamente. Simplemente no le importa si la b1fusión de ramas mastero las masterfusiones b1, la confirmación de fusión se ve igual que git. La única diferencia es, qué rama termina apuntando a esta confirmación de fusión.

2. Usted rebase. Las personas con un SVN o un fondo similar encuentran esto más intuitivo. Los comandos son análogos al caso de fusión:

   git checkout b1
   git rebase master
   # repeat for b2 and b3
   

   A la gente le gusta este enfoque porque conserva un historial lineal en todas las ramas. Sin embargo, esta historia lineal es una mentira, y debe saber que lo es. Considere este gráfico de compromiso:

   A --- B --- C --- D <-- master
    \
     \-- E --- F --- G <-- b1
   

   La fusión da como resultado la verdadera historia:

   A --- B --- C --- D <-- master
    \                 \
     \-- E --- F --- G +-- H <-- b1
   

   El rebase, sin embargo, te da esta historia:

   A --- B --- C --- D <-- master
                      \
                       \-- E' --- F' --- G' <-- b1
   

   El punto es que los commits E', F'y G'nunca existieron realmente, y probablemente nunca hayan sido probados. Puede que ni siquiera compilen. En realidad, es bastante fácil crear confirmaciones sin sentido a través de un rebase, especialmente cuando los cambios masterson importantes para el desarrollo b1.

   La consecuencia de esto puede ser, que no se puede distinguir cuál de las tres confirmaciones E, Fy Gen realidad introdujo una regresión, disminuyendo el valor de git bisect.

   No estoy diciendo que no debas usar git rebase. Tiene sus usos. Pero siempre que lo use, debe ser consciente del hecho de que está mintiendo sobre la historia. Y al menos deberías compilar probar los nuevos commits.

git rebase masteres la forma correcta de hacer esto. Fusionar significaría que se crearía un commit para la fusión, mientras que rebase no.

Si ha estado trabajando de vez en cuando en una sucursal, o han sucedido muchas cosas en otras sucursales mientras ha estado trabajando en algo, es mejor volver a armar su sucursal en maestra. Esto mantiene la historia ordenada y hace que las cosas sean mucho más fáciles de seguir.

git checkout master
git pull
git checkout local_branch_name
git rebase master
git push --force # force required if you've already pushed

Notas:

• No rebajas las ramas en las que has colaborado con otros.
• Debes volver a basar en la rama a la que te unirás, que no siempre será maestra.

Hay un capítulo sobre rebase en http://git-scm.com/book/ch3-6.html , y muchos otros recursos disponibles en la web.

@cmaster hizo la mejor respuesta elaborada. En breve:

git checkout master #
git pull # update local master from remote master
git checkout <your_branch>
git merge master # solve merge conflicts if you have`

No debe reescribir el historial de la rama sino mantenerlos en estado real para futuras referencias. Mientras se fusiona para dominar, crea una confirmación adicional, pero eso es barato. Los compromisos no cuestan.

Para actualizar otras ramas como (copia de seguridad) con su copia de rama maestra. Puede seguirlo de cualquier manera (rebase o fusión) ...

1. Realice un rebase (no se realizará ninguna confirmación adicional en la rama de respaldo).

2. Fusionar ramas (habrá una confirmación adicional automáticamente en la rama de copia de seguridad).

   Nota: Rebase no es más que establecer una nueva base (una nueva copia)

git checkout backup
git merge master
git push

(Repita para otras ramas si hay alguna como backup2 y etc.,)

git checkout backup
git rebase master
git push

(Repita para otras ramas si hay alguna como backup2 y etc.,)

Puede fusionar, o puede aplicar confirmaciones individuales a través de ramas mediante el uso de git cherry-pick .

Hay dos opciones para este problema.

1) git rebase

2) git merge

Solo difiere con los anteriores en caso de fusión, tendrá un compromiso adicional en la historia

1) rama de pago de git (b1, b2, b3)

2) git rebase origin / master (en caso de conflictos, resuelva localmente haciendo git rebase - continúe)

3) empuje git

Alternativamente, la opción git merge es una moda similar

1) git checkout "your_branch" (b1, b2, b3)

2) git merge master

3) empuje git

para actualizar su sucursal desde el maestro:

  git checkout master
  git pull
  git checkout your_branch
  git merge master