¿Cuál es la forma más eficiente de cambiar al último maestro de código con git?

Supongamos que he estado trabajando en una twig de corrección de errores durante aproximadamente un día, en la twig Bug123. Ahora quiero fusionar esto para dominar. Creo que la práctica estándar es hacer esto:

git checkout master git pull --tags git merge Bug123 

Esto está bien, pero lo que sucede detrás de las escenas antes de la fusión real es este:

  1. Comienzo con la base de código de directory de trabajo apuntando a Bug123
  2. Me cambio a la base de código que apunta a mi copy del maestro desde mi última extracción, por ejemplo, hace un día.
  3. Me cambio a la base de código donde el origen / maestro es ahora

Así que cambiaré la base de código dos veces. De hecho, no tengo ningún uso para la base de código en el paso 2. Realmente no me importa qué maestro fue hace un día, sin embargo, estoy cambiando mi base de código.

Lo que encontré más eficiente es esto:

(De nuevo, supongamos que estoy en la twig Bug123)

 git fetch --tags git checkout origin/master git checkout -B master git merge Bug123 

Al hacer esto, estoy cambiando la base de código solo una vez, y nunca volveré al estado anterior del maestro.

[actualización] @ max630 sugirió fusionar las dos líneas medias en una sola:

 git checkout -B master origin/master 

[/actualizar]

También encontré que esta técnica es útil en el caso en que tengo una base de código local muy antigua. Voy a eso, solo hago:

 git checkout master git pull --tags 

Y tengo un montón de conflictos de fusión. No quiero hacer ninguna fusión. Solo quiero la última base de código. Entonces, en cambio, hago lo mismo:

 git fetch --tags git checkout origin/master git checkout -B master 

Esto funciona. Pero no estoy seguro de que este sea el path correcto. Quiero decir, creo que mis casos de uso son extremadamente main-stream, por lo que se siente extraño tener que hacer cosas raras como "git checkout -B". Me parece hackoso. ¿Hay una mejor manera?

Para mantener esta pregunta constructiva, no estoy buscando opiniones subjetivas. Una respuesta aceptable será una alternativa a la anterior que logre el mismo resultado, que es que networkinguce el número de veces que se cambia la base de código en comparación con el flujo de trabajo original en la parte superior de esta pregunta.

Tenga en count que esta pregunta es diferente de " Cómo fusionar la twig actual en otra twig ". Esa pregunta tiene que ver con la networkingucción del número de commands. No estoy preocupado por la cantidad de commands que debo emitir. Mi preocupación es intercambiar innecesariamente el directory de trabajo. Y ninguna de las respuestas en esa pregunta aborda el problema que planteé aquí.

Puedes hacer esto con rebase , aquí hay un ejemplo:

 # you are in branch Bug123 git fetch origin git rebase origin/master git checkout -B master 

Está haciendo todo de una manera sin cambiar a la base de código dos veces, solo tome los últimos cambios del master remoto, agréguelos a la bifurcación actual Bug123 y mueva el resultado (últimos cambios del master remoto con cambios de Bug123 ) a master .

Una posible solución para evitar cambiar dos veces es golpear:

 git fetch origin master:master git checkout master git merge Bug123 

La primera búsqueda actualizará su master sucursal local.