Obtenga cambios de maestro a rama en Git

En mi repositorio tengo una rama llamada en la aqque estoy trabajando.

Luego cometí nuevos trabajos y errores master.

¿Cuál es la mejor manera de llevar esos commits a la aqsucursal? ¿Crear otra nueva rama mastery fusionarla con aq?

Echa un vistazo a la aqrama y rebase de master.

git checkout aq
git rebase master

Debería poder hacerlo solo git merge origin/mastercuando esté en su sucursal aq.

git checkout aq
git merge origin/master

Primero echa un vistazo a master:

git checkout master

Haz todos los cambios, revisa y confirma y empuja a tu maestro.

Regrese a su rama, 'aq', y combine master en ella:

git checkout aq
git merge master

Su sucursal estará actualizada con master. Un buen y básico ejemplo de fusión es 3.2 Git Branching - Ramificación y fusión básica .

No hay garantía de que las correcciones de errores maestros no estén entre otras confirmaciones, por lo tanto, no puede simplemente fusionarse. Hacer

git checkout aq
git cherry-pick commit1
git cherry-pick commit2
git cherry-pick commit3
...

asumiendo que esas confirmaciones representan las correcciones de errores.

Sin embargo, a partir de ahora, mantenga las correcciones de errores en una rama separada. Podrás simplemente

git merge hotfixes

cuando quieras pasarlos todos a la rama de desarrollo regular.

O bien cherry-picklos commits relevantes en branch aqo fusionan branch masteren branch aq.

Fusionarlo con aq

git checkout master
git pull
git checkout aq
git merge --no-ff master
git push

Camino fácil

# 1. Create a new remote branch A base on last master
# 2. Checkout A
# 3. Merge aq to A

Para mí, ya tenía cambios y quería lo último de la rama base. No pude hacerlo rebase, y me cherry-pickhubiera llevado una eternidad, así que hice lo siguiente:

git fetch origin <base branch name>  
git merge FETCH_HEAD

entonces en este caso:

git fetch origin master  
git merge FETCH_HEAD

Esto ( desde aquí ) funcionó para mí:

git checkout aq
git pull origin master
...
git push

Citando:

git pull origin masterrecupera y combina el contenido de la rama maestra con su rama y crea una confirmación de fusión. Si hay conflictos de fusión, se le notificará en esta etapa y debe resolver los compromisos de fusión antes de continuar . Cuando esté listo para enviar sus confirmaciones locales, incluida su nueva confirmación de fusión, al servidor remoto, ejecute git push.

Usted tiene un par de opciones. git rebase master aqen la rama que mantendrá los nombres de confirmación, pero NO REEMBOLSAR si se trata de una rama remota. Puede git merge master aqhacerlo si no le importa mantener los nombres de confirmación. Si desea mantener los nombres de confirmación y es una rama remota, git cherry-pick <commit hash>las confirmaciones en su rama.

También puede hacerlo ejecutando una sola línea.
git merge aq master

Esto es equivalente a

git checkout aq
git merge master

EDITAR:

Mi respuesta a continuación documenta una forma de fusión masteren aqdonde si ver los detalles de la fusión que enumera los cambios realizados en aqantes de la fusión, no los cambios realizados en master. Me he dado cuenta de que probablemente eso no sea lo que quieres, ¡incluso si crees que lo es!

Sólo:

git checkout aq
git merge master

está bien.

Sí, esta combinación simple mostrará que los cambios masterse realizaron aqen ese punto, no al revés; pero eso está bien, ¡ya que eso es lo que sucedió! Más tarde, cuando finalmente fusiona su rama master, es cuando una fusión finalmente mostrará todos sus cambios realizados master(que es exactamente lo que desea, y es el compromiso donde la gente esperará encontrar esa información de todos modos).

Lo he verificado y el enfoque a continuación también muestra exactamente los mismos cambios (todos los cambios realizados aqdesde la división original entre aqy master) que el enfoque normal anterior, cuando finalmente fusiona todo de nuevo master. Por lo tanto, creo que su única desventaja real (además de ser demasiado complejo y no estándar ...: - /) es que si revierte los cambios recientes git reset --hard HEAD~<n>y esto va más allá de la fusión, entonces la versión a continuación retrocede. rama 'incorrecta', que debe arreglar a mano (por ejemplo, con git reflog& git reset --hard [sha]).

[Entonces, lo que antes pensaba era que:]

Hay un problema con:

git checkout aq
git merge master

porque los cambios que se muestran en la confirmación de fusión (por ejemplo, si mira ahora o más tarde en Github, Bitbucket o su visor de historial de git local favorito) son los cambios realizados en master, que bien pueden no ser lo que desea.

Por otra parte

git checkout master
git merge aq

muestra los cambios realizados en aq, que probablemente es lo que desea. (¡O, al menos, a menudo es lo que quiero!) ¡Pero la combinación que muestra los cambios correctos está en la rama incorrecta!

¡¿Como hacer frente?!

El proceso completo, que termina con una confirmación de fusión que muestra los cambios realizados en aq (según la segunda fusión anterior), pero con la fusión que afecta a la rama aq, es:

git checkout master
git merge aq
git checkout aq
git merge master
git checkout master
git reset --hard HEAD~1
git checkout aq

Esto: combina aq en master, avanza rápidamente esa misma combinación en aq, lo deshace en master y lo vuelve a poner en aq nuevamente.

Siento que me estoy perdiendo algo, esto parece ser algo que obviamente querrías y algo que es difícil de hacer.

Además, rebase NO es equivalente. Pierde las marcas de tiempo y la identidad de las confirmaciones realizadas en aq, que tampoco es lo que quiero.

Escenario:

• Creé una rama de master say branch-1 y la llevé a mi local.
• Mi amigo creó una rama de master say branch-2.
• Él cometió algunos cambios de código para master.
• Ahora quiero llevar esos cambios de la rama maestra a mi rama local.

Solución

git stash // to save all existing changes in local branch
git checkout master // Switch to master branch from branch-1
git pull // take changes from the master
git checkout branch-1 // switchback to your own branch
git rebase master // merge all the changes and move you git head  forward
git stash apply // reapply all you saved changes 

Puede encontrar conflictos en su archivo después de ejecutar "git stash apply". Necesita arreglarlo manualmente y ahora está listo para presionar.