Acabo de hacer un compromiso perfectamente bueno con la rama equivocada. ¿Cómo deshago la última confirmación en mi rama maestra y luego tomo los mismos cambios y los incluyo en mi rama de actualización?

Si aún no ha presionado sus cambios, también puede hacer un restablecimiento parcial:

git reset --soft HEAD^

Esto revertirá la confirmación, pero volverá a colocar los cambios confirmados en su índice. Suponiendo que las ramas estén relativamente actualizadas entre sí, git le permitirá realizar un pago en la otra rama, con lo que simplemente puede comprometerse:

git checkout branch
git commit

La desventaja es que debe volver a ingresar su mensaje de confirmación.

4 años de retraso en el tema, pero esto podría ser útil para alguien.

Si olvidó crear una nueva rama antes de comprometerse y se comprometió todo en master, no importa cuántas confirmaciones haya hecho, el siguiente enfoque es más fácil:

git stash                       # skip if all changes are committed
git branch my_feature
git reset --hard origin/master
git checkout my_feature
git stash pop                   # skip if all changes were committed

Ahora tiene su rama maestra igual origin/mastery todas las nuevas confirmaciones están activadas my_feature. Tenga en cuenta que my_featurees una sucursal local, no remota.

Si tiene una copia de trabajo limpia (sin modificar)

Para revertir una confirmación (asegúrese de anotar el hash de la confirmación para el siguiente paso):

git reset --hard HEAD^

Para llevar esa confirmación a una rama diferente:

git checkout other-branch
git cherry-pick COMMIT-HASH

Si tiene cambios modificados o sin seguimiento

También tenga en cuenta que git reset --hardva a matar a cualquier cambio sin seguimiento y modificados que pueda tener, por lo que si usted tiene los es posible que prefiera:

git reset HEAD^
git checkout .

Si ya presionó sus cambios, deberá forzar su próximo empuje después de reiniciar el HEAD.

git reset --hard HEAD^
git merge COMMIT_SHA1
git push --force

Advertencia: un restablecimiento completo deshacerá cualquier modificación no confirmada en su copia de trabajo, mientras que un empuje forzado sobrescribirá completamente el estado de la rama remota con el estado actual de la rama local.

Por si acaso, en Windows (usando la línea de comando de Windows, no Bash) en realidad es cuatro en ^^^^lugar de uno, por lo que es

git reset --hard HEAD^^^^

Recientemente hice lo mismo, donde accidentalmente cometí un cambio en master, cuando debería haberme comprometido con otra rama. Pero no presioné nada.

Si acaba de comprometerse con la rama equivocada, y no ha cambiado nada desde entonces, y no ha enviado al repositorio, puede hacer lo siguiente:

// rewind master to point to the commit just before your most recent commit.
// this takes all changes in your most recent commit, and turns them into unstaged changes. 
git reset HEAD~1 

// temporarily save your unstaged changes as a commit that's not attached to any branch using git stash
// all temporary commits created with git stash are put into a stack of temporary commits.
git stash

// create other-branch (if the other branch doesn't already exist)
git branch other-branch

// checkout the other branch you should have committed to.
git checkout other-branch

// take the temporary commit you created, and apply all of those changes to the new branch. 
//This also deletes the temporary commit from the stack of temp commits.
git stash pop

// add the changes you want with git add...

// re-commit your changes onto other-branch
git commit -m "some message..."

NOTA: en el ejemplo anterior, estaba rebobinando 1 commit con git reset HEAD ~ 1. Pero si desea rebobinar n commits, puede hacer git reset HEAD ~ n.

Además, si terminó comprometiéndose con la rama incorrecta, y también terminó escribiendo más código antes de darse cuenta de que se comprometió con la rama incorrecta, entonces podría usar git stash para guardar su trabajo en progreso:

// save the not-ready-to-commit work you're in the middle of
git stash 

// rewind n commits
git reset HEAD~n 

// stash the committed changes as a single temp commit onto the stack. 
git stash 

// create other-branch (if it doesn't already exist)
git branch other-branch

// checkout the other branch you should have committed to.
git checkout other-branch

// apply all the committed changes to the new branch
git stash pop

// add the changes you want with git add...

// re-commit your changes onto the new branch as a single commit.
git commit -m "some message..."

// pop the changes you were in the middle of and continue coding
git stash pop

NOTA: Usé este sitio web como referencia https://www.clearvision-cm.com/blog/what-to-do-when-you-commit-to-the-wrong-git-branch/

Entonces, si su escenario es con el que se comprometió masterpero con el que se comprometió another-branch(que puede o no existir) pero aún no lo ha hecho, esto es bastante fácil de solucionar.

// if your branch doesn't exist, then add the -b argument 
git checkout -b another-branch
git branch --force master origin/master

Ahora todos tus compromisos masterestarán activos another-branch.

Fuente de amor de: http://haacked.com/archive/2015/06/29/git-migrate/

Para elaborar esta respuesta, en caso de que tenga varias confirmaciones para pasar de, por ejemplo, developa new_branch:

git checkout develop # You're probably there already
git reflog # Find LAST_GOOD, FIRST_NEW, LAST_NEW hashes
git checkout new_branch
git cherry-pick FIRST_NEW^..LAST_NEW # ^.. includes FIRST_NEW
git reflog # Confirm that your commits are safely home in their new branch!
git checkout develop
git reset --hard LAST_GOOD # develop is now back where it started

Si se encuentra con este problema y tiene Visual Studio, puede hacer lo siguiente:

Haga clic derecho en su rama y seleccione View History:

Haga clic derecho en commit al que desea volver. Y revertir o restablecer según sea necesario.

Para confirmaciones múltiples en la rama incorrecta

Si para usted, se trata solo de 1 commit, entonces hay muchas otras soluciones de restablecimiento más fáciles disponibles. Para mí, tuve alrededor de 10 confirmaciones hechas accidentalmente en masterlugar de, llamémoslo branch_xyz, y no quería perder el historial de confirmaciones.

Lo que podía hacer y lo que me salvó fue usar esta respuesta como referencia, usando un proceso de 4 pasos, que es:

1. Crear una nueva rama temporal desde master
2. Fusionarse en la rama originalmente destinada a confirmaciones, es decir branch_xyz
3. Deshacer se compromete en master
4. Eliminar la rama temporal.

Aquí están los pasos anteriores en detalles:

1. Crear una nueva rama desde master(donde accidentalmente cometí muchos cambios)

   git checkout -b temp_branch_xyz
   

   Nota: la -bbandera se usa para crear una nueva rama.
   Solo para verificar si lo hicimos bien, haría un rápido git branchpara asegurarme de que estamos en la temp_branch_xyzrama y una git logpara verificar si tenemos los compromisos correctos.

2. Combinar la rama temporal en la rama originalmente destinada para los commits, es decir branch_xyz.
   Primero, cambie a la rama original, es decir branch_xyz(es posible que deba hacerlo git fetchsi no lo ha hecho)

   git checkout branch_xyz
   

   Nota: Sin usar el -bindicador
   Ahora, fusionemos la rama temporal en la rama que tenemos actualmente retiradabranch_xyz

   git merge temp_branch_xyz
   

   Puede que tenga que ocuparse de algunos conflictos aquí, si los hay. Puede presionar (lo haría) o pasar a los siguientes pasos, después de fusionar con éxito.

3. Deshaga las confirmaciones accidentales al masterusar esta respuesta como referencia, primero cambie amaster

   git checkout master
   

   luego deshaga todo el camino para que coincida con el control remoto (o para confirmar en particular, si lo desea)

   git reset --hard origin/master
   

   Nuevamente, haría un git logantes y un después solo para asegurarme de que los cambios previstos surtieran efecto.

4. Borrar la evidencia, eso es borrar la rama temporal. Para esto, primero debe verificar la rama en la que se fusionó la temperatura, es decir branch_xyz(si permanece encendido mastery ejecuta el siguiente comando, puede obtener un error: The branch 'temp_branch_xyz' is not fully merged), así que vamos a

   git checkout branch_xyz
   

   y luego elimine la prueba de este contratiempo

   git branch -d temp_branch_xyz
   

Ahí tienes.

Si la rama a la que desea aplicar sus cambios ya existe ( desarrollo de la rama , por ejemplo), siga las instrucciones proporcionadas por fotanus a continuación, luego:

git checkout develop
git rebase develop my_feature # applies changes to correct branch
git checkout develop # 'cuz rebasing will leave you on my_feature
git merge develop my_feature # will be a fast-forward
git branch -d my_feature

Y, obviamente, podría usar tempbranch o cualquier otro nombre de rama en lugar de my_feature si lo desea.

Además, si corresponde, retrase el stash pop (aplicar) hasta que se haya fusionado en su rama de destino.

Para mí, esto se resolvió revirtiendo el compromiso que había presionado, y luego seleccionando ese compromiso para la otra rama.

git checkout branch_that_had_the_commit_originally
git revert COMMIT-HASH
git checkout branch_that_was_supposed_to_have_the_commit
git cherry pick COMMIT-HASH

Puede usar git logpara encontrar el hash correcto, ¡y puede impulsar estos cambios cuando lo desee!