tipos - Actualizar las ramas de Git desde el maestro

git ver archivos modificados

Question

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

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

¿Cómo actualizo todas las otras sucursales con el código de la rama master ?

Answer 1

@cmaster hizo la respuesta mejor 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 volver a escribir el historial de sucursales, en lugar de mantenerlos en el estado real para futuras referencias. Al fusionarse con el maestro, crea un compromiso adicional, pero eso es barato. Los compromisos no cuestan.

Answer 2

Para actualizar otras ramas como (copia de seguridad) con su copia de rama maestra. Puedes hacer lo siguiente (rebase o fusionar) ...

1. Hacer rebase (no se realizará ningún compromiso adicional en la rama de respaldo).

2. Fusionar ramas (habrá un compromiso adicional automáticamente en la rama de respaldo).

   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 las hay, como backup2 y etc.,)

git checkout backup
git rebase master
git push

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

Answer 3

Puede fusionar, o puede aplicar confirmaciones individuales a través de las ramas utilizando git cherry-pick .

Answer 4

Si ha estado trabajando en una sucursal de vez en cuando, o han ocurrido lotes en otras sucursales mientras ha estado trabajando en algo, es mejor cambiar la base de su sucursal al maestro. 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 modifiques las ramas en las que has colaborado con otros.
• Debería volver a basarse en la rama a la que se fusionará, que puede no ser siempre el principal.

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

Answer 5

Tienes básicamente dos opciones:

1. Te fusionas. Eso es en realidad bastante simple, y una operación perfectamente local:

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

   Esto deja el historial exactamente como sucedió: se bifurcó de maestro, hizo cambios en todas las ramas y finalmente incorporó los cambios de maestro en las tres ramas.

   git puede manejar esta situación realmente bien, está diseñado para que las combinaciones ocurran en todas las direcciones, al mismo tiempo. Puede confiar en que podrá juntar todos los hilos correctamente. Simplemente no le importa si la rama b1 fusiona el master , o si el master combina la b1 , la combinación de combinaciones parece lo mismo para git. La única diferencia es que la rama termina apuntando a este compromiso de fusión.

2. Usted rebase. Las personas con un SVN, o antecedentes similares, encuentran esto más intuitivo. Los comandos son análogos al caso de combinación:

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

   A las personas les gusta este enfoque porque conserva una historia lineal en todas las ramas. Sin embargo, esta historia lineal es una mentira, y debes ser consciente de que lo es. Considera este gráfico de compromiso:

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

   Los resultados de la fusión en la historia verdadera:

   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 las comillas E'' , F'' y G'' nunca existieron realmente, y probablemente nunca hayan sido probadas. Ni siquiera pueden compilar. En realidad, es bastante fácil crear confirmaciones sin sentido a través de una rebase, especialmente cuando los cambios en el master son importantes para el desarrollo en b1 .

   La consecuencia de esto puede ser que no puede distinguir cuál de los tres cometer E , F y G introdujo realmente una regresión, lo que disminuye el valor de git bisect .

   No estoy diciendo que no git rebase usar git rebase . Tiene sus usos. Pero siempre que lo use, debe estar consciente del hecho de que miente sobre la historia. Y al menos deberías compilar las nuevas confirmaciones.

Answer 6

Tienes dos opciones:

La primera es una combinación, pero esto crea una confirmación adicional para la combinación.

Comprobación de cada rama:

git checkout b1

Luego fusionar:

git merge origin/master

Luego presiona:

git push origin b1

Alternativamente, puedes hacer un rebase:

git fetch
git rebase origin/master

Answer 7

git rebase master es la forma correcta de hacer esto. La fusión significaría que se crearía un compromiso para la fusión, mientras que la reorganización no.