¿Cómo deshago los commits locales más recientes en Git?

Deshacer un commit es un poco de miedo si no sabes cómo funciona. Pero en realidad es increíblemente fácil si lo entiendes.

Digamos que tiene esto, donde C es su HEAD y (F) es el estado de sus archivos.

   (F)
A-B-C
    ↑
  master

Desea nuke commit C y nunca más lo veas . Tu hiciste esto:

git reset --hard HEAD~1

El resultado es:

 (F)
A-B
  ↑
master

Ahora B es la CABEZA. Debido a que usó --hard, sus archivos se restablecen a su estado en la confirmación B.

Ah, pero supongamos que cometer C no fue un desastre, sino solo un poco. Desea deshacer la confirmación pero mantener sus cambios para un poco de edición antes de realizar una mejor confirmación. Empezando de nuevo desde aquí, con C como tu CABEZA:

   (F)
A-B-C
    ↑
  master

Puedes hacer esto, dejando fuera el --hard:

git reset HEAD~1

En este caso el resultado es:

   (F)
A-B-C
  ↑
master

En ambos casos, HEAD es solo un puntero a la última confirmación. Cuando haces un git reset HEAD~1, le dices a Git que mueva el HEAD puntero hacia atrás una confirmación. Pero (a menos que use --hard) deja sus archivos como estaban. Así que ahora git status muestra los cambios que ha registrado en C. ¡No ha perdido nada!

Para el toque más ligero, puede incluso deshacer su confirmación pero dejar sus archivos y su index:

git reset --soft HEAD~1

Esto no solo deja sus archivos solos, sino que también deja su índice solo. Cuando hagas git status, verás que los mismos archivos están en el índice que antes. De hecho, justo después de este comando, podrías hacer git commit y estarías rehaciendo la misma confirmación que acabas de tener.

Una cosa más: Supongamos que destruyes un commit como en el primer ejemplo, pero luego descubres que lo necesitabas después de todo ? Mala suerte, ¿verdad?

No, hay todavía una forma de recuperarlo. Escriba git reflog y verá una lista de commit (parcial) shas (es decir, hashes) en los que se ha movido. Encuentre el commit que destruyó y haga esto:

git checkout -b someNewBranchName shaYouDestroyed

Ahora has resucitado ese compromiso. Los compromisos en realidad no se destruyen en Git durante unos 90 días, por lo que generalmente puede regresar y rescatar uno que no quería deshacerse de él.

Esto me tomó un tiempo entenderlo, así que quizás esto ayude a alguien ...

Hay dos formas de "deshacer" su último compromiso, dependiendo de si ya ha hecho público su compromiso (enviado a su repositorio remoto):

Cómo deshacer un commit local

Digamos que me comprometí localmente, pero ahora quiero eliminar ese compromiso.

git log
    commit 101: bad commit    # latest commit, this would be called 'HEAD'
    commit 100: good commit   # second to last commit, this is the one we want

Para restaurar todo de nuevo a la forma en que estaba antes de la última confirmación, necesitamos reset para la confirmación antes de HEAD:

git reset --soft HEAD^     # use --soft if you want to keep your changes
git reset --hard HEAD^     # use --hard if you don't care about keeping the changes you made

Ahora git log mostrará que nuestra última confirmación ha sido eliminada.

Cómo deshacer un compromiso público.

Si ya ha hecho públicos sus confirmaciones, deseará crear una nueva confirmación que "revertirá" los cambios realizados en su confirmación anterior (HEAD actual).

git revert HEAD

Sus cambios ahora serán revertidos y listos para que los cometa:

git commit -m 'restoring the file I removed by accident'
git log
    commit 102: restoring the file I removed by accident
    commit 101: removing a file we don't need
    commit 100: adding a file that we need

Para obtener más información, consulte Conceptos básicos de Git - Cómo deshacer cosas

Agrega/elimina archivos para obtener las cosas de la manera que deseas:

git rm classdir
git add sourcedir

Luego enmendar el compromiso:

git commit --amend

La confirmación errónea anterior se editará para reflejar el nuevo estado del índice; en otras palabras, será como si nunca hubiera cometido el error en primer lugar.

Tenga en cuenta que solo debe hacer esto si aún no ha empujado. Si ha presionado, entonces solo tendrá que confirmar un arreglo normalmente.

git rm yourfiles/*.class
git commit -a -m "deleted all class files in folder 'yourfiles'"

o

git reset --hard HEAD~1

Advertencia: el comando anterior eliminará permanentemente las modificaciones a los archivos .Java (y cualquier otro archivo) que quisiera confirmar.

El hard reset a HEAD-1 establecerá su copia de trabajo en el estado de la confirmación antes de su confirmación incorrecta.

Para cambiar el ultimo commit

Reemplace los archivos en el índice:

git rm --cached *.class
git add *.Java

Entonces, si es una rama privada, enmendar la confirmación:

git commit --amend

O, si se trata de una rama compartida, haga un nuevo compromiso:

git commit -m 'Replace .class files with .Java files'

( para cambiar una confirmación anterior , usa la impresionante rebase interactiva )

ProTip ™: agregue *.class a un gitignore para evitar que esto vuelva a suceder.

Para revertir un commit

Modificar una confirmación es la solución ideal si necesita cambiar la última confirmación, pero una solución más general es reset.

Puedes reiniciar git a cualquier commit con:

git reset @~N

Donde N es el número de confirmaciones antes de HEAD, y @~ se reinicia a la confirmación anterior.

Entonces, en lugar de enmendar el compromiso, podrías usar:

git reset @~
git add *.Java
git commit -m "Add .Java files"

Echa un vistazo a git help reset, específicamente las secciones en --soft--mixed y --hard, para una mejor comprensión de lo que hace esto.

Reflog

Si te equivocas, siempre puedes usar el reflog para encontrar confirmaciones eliminadas:

$ git reset @~
$ git reflog
c4f708b [email protected]{0}: reset: moving to @~
2c52489 [email protected]{1}: commit: added some .class files
$ git reset 2c52489
... and you're back where you started

Utilice git revert <commit-id>

Para obtener el ID de confirmación, simplemente use git log

Si planea deshacer un compromiso local por completo, lo que haya cambiado lo hizo en el compromiso, y si no se preocupa por eso, simplemente ejecute el siguiente comando.

git reset --hard HEAD^1

(Este comando ignorará su compromiso completo y sus cambios se perderán completamente de su árbol de trabajo local). Si desea deshacer su confirmación, pero desea que se realicen cambios en el área de preparación (antes de la confirmación, como después de git add), ejecute el siguiente comando.

git reset --soft HEAD^1

Ahora sus archivos comprometidos entran en el área de preparación. Supongamos que si desea subir el escenario de los archivos, ya que necesita editar algún contenido incorrecto, realice el siguiente comando

git reset HEAD

Ahora los archivos comprometidos deben provenir del área apilada al área sin apilar. Ahora los archivos están listos para editar, así que, independientemente de lo que cambie, desea editarlo y agregarlo, y realizar un nuevo/nuevo compromiso.

Más

Si tiene Git Extras instalado, puede ejecutar git undo para deshacer la última confirmación. git undo 3 deshará las últimas 3 confirmaciones.

Quería deshacer las últimas 5 confirmaciones en nuestro repositorio compartido. Busqué el ID de revisión al que quería revertir. Entonces escribí lo siguiente.

Prompt> git reset --hard 5a7404742c85
HEAD is now at 5a74047 Added one more page to catalogue
Prompt> git Push Origin master --force
Total 0 (delta 0), reused 0 (delta 0)
remote: bb/acl: neoneye is allowed. accepted payload.
To [email protected]:thecompany/prometheus.git
 + 09a6480...5a74047 master -> master (forced update)
Prompt>

Prefiero usar git rebase -i para este trabajo, porque aparece una lista de Niza donde puedo elegir los compromisos para eliminar. Puede que no sea tan directo como algunas otras respuestas aquí, pero simplemente se siente bien .

Elija la cantidad de confirmaciones que desea enumerar, luego invoque de esta manera (para enlistar las últimas tres)

git rebase -i HEAD~3

Lista de muestra

pick aa28ba7 Sanity check for RtmpSrv port
pick c26c541 RtmpSrv version option
pick 58d6909 Better URL decoding support

Luego, Git eliminará las confirmaciones para cualquier línea que elimines.

Cómo arreglar el compromiso local anterior

Use git-gui (o similar) para realizar un git commit --amend. Desde la GUI puede agregar o eliminar archivos individuales de la confirmación. También puede modificar el mensaje de confirmación. 

Cómo deshacer el compromiso local anterior.

Simplemente restablezca su sucursal a la ubicación anterior (por ejemplo, usando gitk o git rebase). Luego vuelva a aplicar los cambios de una copia guardada. Después de la recolección de basura en su repositorio local, será como si el compromiso no deseado nunca hubiera ocurrido. Para hacer todo eso en un solo comando, use git reset HEAD~1.

Palabra de advertencia : El uso descuidado de git reset es una buena manera de poner su copia de trabajo en un estado confuso. Recomiendo que los novatos de Git eviten esto si pueden.

Cómo deshacer un compromiso público.

Realice un retroceso pick pick ( git-revert ) para deshacer los cambios.

Si aún no ha introducido otros cambios en su rama, simplemente puede hacer ...

git revert --no-edit HEAD

Luego presiona tu rama actualizada al repositorio compartido.

El historial de confirmaciones mostrará ambas confirmaciones, por separado.

Avanzado: Corrección de la rama private en el repositorio público

Esto puede ser peligroso - asegúrese de tener una copia local de la sucursal para repush.

También tenga en cuenta: no quiere hacer esto si alguien más está trabajando en la sucursal.

git Push --delete (branch_name) ## remove public version of branch

Limpia tu rama localmente luego repush ...

git Push Origin (branch_name)

En el caso normal, es probable que no deba preocuparse de que su historial de confirmación de sucursal privada sea prístino. Simplemente presione una confirmación de seguimiento (vea 'Cómo deshacer una confirmación pública' más arriba), y más adelante, haga un squash-merge para ocultar el historial.

Si has cometido chatarra pero no has empujado,

git reset --soft HEAD~1

HEAD ~ 1 es una abreviatura de cometer antes de head. Alternativamente, puede consultar el SHA-1 del hash si desea restablecerlo. --soft option eliminará la confirmación pero dejará todos los archivos modificados "Cambios por confirmar", como lo pondría el estado de git.

Si desea deshacerse de cualquier cambio en los archivos rastreados en el árbol de trabajo, ya que la confirmación antes del encabezado use " --hard ".

OR

Si ya presionaste y alguien tiró, lo que generalmente es mi caso, no puedes usar git reset . Sin embargo, puedes hacer un git revert ,

git revert HEAD

Esto creará un nuevo compromiso que revierte todo lo introducido por el compromiso accidental.

Si desea deshacerlo permanentemente y ha clonado algún repositorio 

El ID de confirmación puede ser visto por 

git log 

Entonces puedes hacer ...

git reset --hard <commit_id>

git Push Origin <branch_name> -f

En SourceTree (GUI para GitHub), puede hacer clic con el botón derecho en la confirmación y hacer una 'Confirmación inversa'. Esto debería deshacer tus cambios.

En la terminal:

También puede utilizar:

git revert

O:

git reset --soft HEAD^ # Use --soft if you want to keep your changes.
git reset --hard HEAD^ # Use --hard if you don't care about keeping your changes.

Un solo comando:

git reset --soft 'HEAD^' 

¡Funciona muy bien deshacer el último commit local!

Simplemente reinicie el comando a continuación usando git:

git reset --soft HEAD~1

Explique: lo que git reset hace, es básicamente reset a cualquier confirmación a la que le gustaría regresar, entonces si lo combina con la tecla --soft, volverá, pero mantenga los cambios en su archivo (s) ), para volver a la etapa en la que se acaba de agregar el archivo, HEAD es el jefe de la rama y si se combina con ~1 (en este caso, también usa HEAD^), retrocederá solo una confirmación que desea ...

Creo los pasos en la imagen a continuación con más detalles, incluidos todos los pasos que pueden suceder en situaciones reales y confirmando el código:

¿Cómo deshacer el último commit de Git?

Para restaurar todo a la forma en que estaba antes de la última confirmación, debemos restablecer la confirmación antes de HEAD.

1. Si no quieres mantener los cambios que hiciste:

   git reset --hard HEAD^
   

2. Si quieres mantener tus cambios:

   git reset --soft HEAD^
   

Ahora revisa tu registro de git. Mostrará que nuestro último commit ha sido eliminado.

Usa reflog para encontrar un estado correcto

git reflog

REEMBOLSO ANTES DE RESTABLECER

Seleccione el reflog correcto (f3cb6e2 en mi caso) y escriba 

git reset --hard f3cb6e2

Después de eso, el repositorio HEAD se restablecerá a ese HEADid REGISTRO DESPUÉS DEL REAJUSTE

Finalmente el reflog se parece a la imagen de abajo.

REFLOG FINAL

"Restablecer el árbol de trabajo a la última confirmación"

git reset --hard HEAD^ 

"Limpiar archivos desconocidos del árbol de trabajo"

git clean    

ver - Referencia rápida de Git

NOTA: Este comando eliminará su confirmación anterior, así que use con precaución. git reset --hard es más seguro -

Primer intento: 

git reflog

Le mostrará todas las acciones posibles que ha realizado en su repositorio, por ejemplo, cometer, fusionar, extraer, etc.

Entonces hazlo:

git reset --hard ActionIdFromRefLog

Deshacer última confirmación:

git reset --soft HEAD^ o git reset --soft HEAD~

Esto deshará la última confirmación.

Aquí --soft significa restablecer en la puesta en escena.

HEAD~ o HEAD^ significa moverse para confirmar antes de HEAD.

Reemplace la última confirmación para la nueva confirmación:

git commit --amend -m "message"

Reemplazará la última confirmación con la nueva confirmación.

De otra manera:

Verifique la sucursal que desea revertir, luego restablezca su copia de trabajo local a la confirmación que desea que sea la más reciente en el servidor remoto (todo después de que se irá adiós). Para hacer esto, en SourceTree, hice clic derecho en y seleccioné "Restablecer BRANCHNAME para este compromiso".

Luego navegue al directorio local de su repositorio y ejecute este comando:

git -c diff.mnemonicprefix=false -c core.quotepath=false Push -v -f --tags REPOSITORY_NAME BRANCHNAME:BRANCHNAME

Esto borrará todas las confirmaciones después de la actual en su repositorio local, pero solo para esa rama.

Escriba git log y encuentre el último código hash de confirmación y luego ingrese:

git reset <the previous co>

En mi caso, accidentalmente cometí algunos archivos que no quería. Así que hice lo siguiente y funcionó:

git reset --soft HEAD^
git rm --cached [files you do not need]
git add [files you need]
git commit -c ORIG_HEAD

Verifique los resultados con gitk o git log --stat

Utilice SourceTree (herramienta gráfica para Git) para ver sus confirmaciones y el árbol. Puede restablecerlo manualmente directamente haciendo clic derecho.

Simple, ejecuta esto en tu línea de comando:

git reset --soft HEAD~ 

Para restablecer la revisión anterior, elimine permanentemente todos los cambios no confirmados: 

git reset --hard HEAD~1

Hay dos escenarios principales

Aún no has presionado el commit

Si el problema fueron los archivos adicionales que comprometió (y no quiere que estén en el repositorio), puede eliminarlos usando git rm y luego cometer con --amend

git rm <pathToFile>

También puede eliminar directorios completos con -r, o incluso combinar con otros Bash comandos

git rm -r <pathToDirectory>
git rm $(find -name '*.class')

Después de eliminar los archivos, puede confirmar, con --amend option

git commit --amend -C HEAD # the -C option is to use the same commit message

Esto reescribirá su reciente confirmación local eliminando los archivos adicionales, por lo tanto, estos archivos nunca se enviarán en Push y también serán eliminados de su repositorio local .git por GC.

Ya presionaste el commit

Puede aplicar la misma solución del otro escenario y luego hacer git Push con la opción -f, pero es no recomendado ya que sobrescribe el historial remoto con un cambio divergente (puede desordenar su repositorio).

En su lugar, debe realizar la confirmación sin --amend (recuerde esto acerca de -amend`: esa opción reescribe el historial de la última confirmación).

Hay muchas maneras de hacerlo:

Git comando para deshacer la última confirmación/confirmaciones anteriores:

Advertencia: No use --hard si no sabe lo que está haciendo. - hard es demasiado peligroso , y podría eliminar sus archivos.

El comando básico para revertir la confirmación en Git es:

$ git reset --hard <COMMIT -ID>

o

$ git reset --hard HEAD~<n>

COMMIT-ID : ID para la confirmación

n: es el número de las últimas confirmaciones que desea revertir

Puede obtener el ID de confirmación como se muestra a continuación:

$ **git log --oneline**

d81d3f1 function to subtract two numbers

be20eb8 function to add two numbers

bedgfgg function to mulitply two numbers

donde d81d3f1 y be20eb8 son ID de confirmación.

Ahora veamos algunos casos:

Supongamos que desea revertir la última confirmación 'd81d3f1'. Aquí hay dos opciones:

$ git reset --hard d81d3f1

o

$ git reset --hard HEAD~1

Suponga que desea revertir la confirmación 'be20eb8':

$ git reset --hard be20eb8

Para obtener información más detallada, puede consultar y probar algunos otros comandos también para restablecer la cabeza a un estado específico:

$ git reset --help

Para un compromiso local.

git reset --soft HEAD~1

o si no recuerda exactamente en qué cometer está, puede usar

git rm --cached <file>

Para un commit empujado

La forma correcta de eliminar archivos del historial del repositorio es usar git filter-branch. Es decir,

git filter-branch --index-filter 'git rm --cached <file>' HEAD

Pero te recomiendo que uses este comando con cuidado. Lea más engit-filter-branch (1) Página de manual.

¿QUÉ UTILIZAR, reset --soft o reset --hard?

Solo estoy agregando dos centavos por la respuesta de @ Kyralessa:

Si no está seguro de qué usar, vaya por --soft (utilicé esta convención para recordarlo - s oft por seguridad).

Por qué ?

Si elige --hard por error,PERDERÁsus cambios como no lo estaba antes. Si elige --soft por error, puede lograr los mismos resultados de --hard mediante la aplicación de comandos adicionales

git reset HEAD file.html
git checkout -- file.html

Ejemplo completo

echo "some changes..." > file.html
git add file.html
git commit -m "wrong commit"

# I need to reset
git reset --hard HEAD~1 (cancel changes)
# OR
git reset --soft HEAD~1 # Back to staging
git reset HEAD file.html # back to working directory
git checkout -- file.html # cancel changes

Los créditos van para @Kyralessa.

Puedes usar:

git reset [email protected]{1}

Este comando eliminará su confirmación errónea sin un registro de Git.

Piensa que tenemoscode.txtarchivo. Hacemos algunos cambios y confirmamos. Podemos deshacer este compromiso de tres maneras , pero primero debe saber qué es el archivo en etapas ... Un archivo en etapas es un archivo que está listo para cometer y si ejecuta git status, este archivo se mostrará con un color verde y si no lo está La puesta en escena de la confirmación se mostrará en color rojo:

Significa que si confirma su cambio, sus cambios en este archivo no se guardan. Puede agregar este archivo en su escenario con git add code.txt y luego confirmar su cambio:

Deshacer última confirmación:

1. Ahora, si solo queremos deshacer la confirmación sin ningún otro cambio, podemos usar

   git reset --soft HEAD^ 

    

2. Si queremos deshacer la confirmación y sus cambios (ESTE IS PELIGROSO, porque su cambio se perderá), podemos usar

   git reset --hard HEAD^

    

3. Y si queremos deshacer la confirmación y eliminar los cambios de la etapa, podemos usar

   git reset --mixed HEAD^ o en una forma corta git reset HEAD^

    

Por lo general, usted quiere deshacer cometer porque cometió un error y quiere corregirlo, esencialmente lo que hizo el OP cuando hizo la pregunta. Así que realmente, realmente quieres rehacer a confirmar.

La mayoría de las respuestas aquí se centran en la línea de comandos. Si bien la línea de comandos es la mejor manera de usar Git cuando te sientes cómodo con ella, es probable que sea un poco extraño para los que vienen de otros sistemas de control de versiones de Git. 

Aquí es cómo hacerlo utilizando una GUI. Si tiene Git instalado, ya tiene todo lo que necesita para seguir estas instrucciones.

NOTA: Supondré aquí que se dio cuenta de que la confirmación fue incorrecta antes de empujarla. Si no sabe qué es empujar, probablemente no lo haya hecho, así que continúe con las instrucciones. Si ha presionado el compromiso defectuoso, la forma menos riesgosa es simplemente seguir el compromiso defectuoso con un nuevo compromiso que corrige las cosas, como lo haría en un sistema de control de versiones que no le permite reescribir el historial. 

Dicho esto, aquí le indicamos cómo solucionar su error más reciente mediante una GUI:

1. Navegue a su repositorio en la línea de comandos y comience la interfaz gráfica de usuario con git gui
2. Seleccione "Modificar último compromiso". Verá su último mensaje de confirmación, los archivos almacenados y los archivos que no.
3. Ahora cambie las cosas a cómo desea que se vean y haga clic en Confirmar. 

Solo deshacer el último commit: 

git reset --soft HEAD~

O deshacer el tiempo anterior a cometer: 

git reset --soft HEAD~2

O deshacer cualquier confirmación previa: 

git reset --soft <commitID>

(puede obtener el commitID usando git reflog)

Cuando deshaga un compromiso anterior, recuerde limpiar el lugar de trabajo con

git clean

Más detalles se pueden encontrar en los documentos: git-reset

Si está trabajando conSourceTree, esto le ayudará.

Haga clic con el botón derecho en la confirmación luego seleccione "Restablecer (rama actual)/maestro para esta confirmación" y la última seleccione " Reinicio suave.

Deshacer la última confirmación

Hay toneladas de situaciones en las que realmente desea deshacer la última confirmación en su código. P.ej. porque le gustaría reestructurarlo ampliamente, o incluso descartarlo por completo.

En estos casos, el comando "restablecer" es tu mejor amigo:

$ git reset --soft HEAD~1

El comando anterior (restablecer) rebobinará su rama HEAD actual a la revisión especificada. En nuestro ejemplo anterior, nos gustaría volver al anterior a la revisión actual: hacer que nuestro último compromiso se deshaga.

Tenga en cuenta el indicador --soft: esto garantiza que se conserven los cambios en las revisiones no realizadas. Después de ejecutar el comando, encontrará los cambios como modificaciones locales no confirmadas en su copia de trabajo.

Si no desea mantener estos cambios, simplemente use la marca --hard. Asegúrese de hacer esto solo cuando esté seguro de que ya no necesita estos cambios.

$ git reset --hard HEAD~1

Para deshacer su confirmación local, utilice git reset <commit>. También ese tutorial es muy útil para mostrarte cómo funciona.

Alternativamente, puede usar git revert <commit>: revertir debe usarse cuando desea agregar otro compromiso que revierte los cambios (pero los mantiene en el historial del proyecto).

Un típico ciclo de Git

Al hablar de los comandos relacionados con Git en las respuestas anteriores, me gustaría compartir mis ciclos de Git típicos con todos los lectores, lo que puede ser útil. Así es como trabajo con Git,

1. Clonando la primera vez desde el servidor remoto.

   git clone $project

2. Tirando desde el control remoto (cuando no tengo un compromiso local pendiente para Push)

   git pull

3. Agregar un nuevo archivo local1 en $ to_be_committed_list (imagina que $ to_be_committed_list significa staged area)

   git add $file1

4. Eliminar el archivo2 agregado erróneamente de $ to_be_committed_list (suponga que el archivo2 se agrega como el paso 3, que no quería)

   git reset $file2

5. Confirmando archivo1 que está en $ to_be_committed_list

   git commit -m "commit message description"

6. Sincronización de la confirmación local con el repositorio remoto antes de empujar

   git pull --rebase

7. Resolución cuando se produce un conflicto requisito previo para configurar mergetool

   git mergetool #resolve merging here, also can manually merge

8. Agregando archivos de resolución de conflictos, digamos file1:

   git add $file1

9. Continuando mi comando de rebase anterior

   git rebase --continue

10. Empujando listo y ya sincronizado último compromiso local

    git Push Origin head:refs/for/$branch # branch = master, dev, etc.

En mi caso me comprometí y fui a la rama equivocada, así que lo que quería era recuperar todos mis cambios para poder enviarlos a una nueva rama correcta, así que hice esto:

En la misma rama que confirmó y presionó, si escribe "git status" no verá nada nuevo porque confirmó y presionó, ahora escriba:

git reset --soft HEAD~1

Esto hará que todos los cambios (archivos) vuelvan a estar en el área del escenario, ahora para recuperarlos en el directorio de trabajo (sin escenario) que acaba de escribir:

git reset FILE

Donde "Archivo" es el archivo que desea confirmar nuevamente. Ahora este ARCHIVO debería estar en el directorio de trabajo (sin organizar) con todos los cambios que hizo. Ahora puede cambiar a la rama que desee y confirmar los cambios en esa rama. Espero que esto ayude a otras personas que cometieron el mismo error que yo. Por supuesto, la sucursal inicial que confirmó todavía está allí con todos los cambios, pero en mi caso estuvo bien, si no es para usted, puede buscar formas de revertir ese compromiso en esa sucursal.

USUARIOS DE VISUAL STUDIO (2015, etc.)

Si no puede sincronizar en Visual Studio, ya que no se le permite ingresar a una rama como "desarrollo", tanto como lo intenté, en Visual Studio NI elREVERTIRNOR elRESET(hard o soft) funcionaría.

Por la respuesta con TONELADAS DE VOTOS:

Use esto en el comando Solicitud de la raíz de su proyecto para detener cualquier cosa que intente ser empujada:

git reset --hard HEAD~1

Realice una copia de seguridad de sus archivos o guárdelos en un archivo Zip en caso de que no desee perder ningún trabajo, etc.

Obtuve el ID de confirmación de bitbucket y luego hice:

git checkout commitID .

Ejemplo:

git checkout 7991072 .

Y lo revertió a esa copia de trabajo de ese compromiso.

Supongamos que cometió una confirmación errónea localmente y la colocó en un repositorio remoto. Puedes deshacer el desorden con estos dos comandos:

Primero, debemos corregir nuestro repositorio local volviendo al compromiso que deseamos:

git reset --hard <previous good commit id where you want the local repository  to go>

Ahora presionamos con fuerza este buen compromiso en el repositorio remoto usando este comando:

git Push --force-with-lease

La versión 'con-arrendamiento' de la opción de fuerza evitará la eliminación accidental de nuevas confirmaciones que no conoce (es decir, que provienen de otra fuente desde su última extracción).

Deshacer el último commit:

git reset --soft HEAD^ or git reset --soft HEAD~

Esto deshará la última confirmación.

Aquí --soft significa restablecer en la puesta en escena.

HEAD~ or HEAD^ significa moverse para confirmar antes de HEAD.

Reemplace la última confirmación para la nueva confirmación:

git commit --amend -m "message"

Reemplazará la última confirmación con la nueva confirmación.

Necesitas hacer lo fácil y rápido.

    git commit --amend

si es una rama privada o

    git commit -m 'Replace .class files with .Java files'

si es una sucursal compartida o pública.

Tienes varias opciones para deshacer tu último commit. Estas son algunas de sus opciones resumidas en una sola respuesta con fragmentos de código

En primer lugar, debe averiguar cuáles son las confirmaciones "incorrectas" que desea descartar. Usaremos git reflog para encontrarlo.

git reflog

Siempre puedes usar la reflog también.
git reflog mostrará cualquier cambio que actualice la HEAD y al revisar la entrada de búsqueda deseada, la HEAD volverá a esta confirmación. 

Cada vez que se modifique HEAD habrá una nueva entrada en la reflog.
La reflog es similar al comando de historial de Unix y se mantiene localmente en su máquina.

git reflog
git checkout [email protected]{...}
# or
git checkout <sha-1>

Usando el proceso de pago puede volver a cualquier confirmación deseada y puede crear una rama o cualquier otra opción que git checkout le permita hacer.

git reset HEAD --hard <commit_id>

"Mueve" tu cabeza hacia atrás hasta la confirmación deseada.
Git reset verificará el contenido de confirmación deseado en su área de preparación y/o en su directorio de trabajo según el valor --hard/--soft/--mixed que elija. --hard actualizará el área de la etapa y el directorio de trabajo con el contenido dado y "separará" cualquier otra confirmación más allá de este punto en su sucursal local. 

Si esos compromisos no forman parte de ninguna otra rama, se convertirán en "cuelga".
contenido "colgado" significa que hay un contenido inaccesible en su repositorio local que no forma parte de ninguna otra rama y puede eliminarse o lo eliminará gc.

# This will destroy any local modifications.
# Don't do it if you have uncommitted work you want to keep.
git reset --hard 0d1d7fc32

# Alternatively, if there's work to keep:
git stash
git reset --hard 0d1d7fc32
git stash pop
# This saves the modifications, then reapplies that patch after resetting.
# You could get merge conflicts, if you've modified things which were
# changed since the commit you reset to.

Este esquema ilustra qué comando hace qué.
Como puede ver, reset && checkout modifica HEAD.

Utilice este comando:

git checkout -b old-state number_commit

Usa este comando

git checkout -b old-state 0d1d7fc32

Eliminar un compromiso incorrecto que ya se ha enviado a Github

git Push Origin +(previous good commit id):(branch name)

Por favor, especifique el último ID de confirmación que desea restablecer en Github.

Por ejemplo. Si el último ID de confirmación es incorrecto, especifique el ID de confirmación anterior en el comando git anterior con nombre de rama. 

Puede obtener el ID de confirmación anterior utilizando git log

Para deshacerse de (todos los cambios en) la última confirmación, las últimas 2 confirmaciones y las últimas n confirmaciones:

git reset --hard HEAD~1
git reset --hard HEAD~2
...
git reset --hard HEAD~n

Y, para deshacerse de cualquier cosa después de un compromiso específico:

git reset --hard <commit sha>

p.ej., 

git reset --hard 0d12345

PD:
1- Tenga cuidado, debido a la opción "difícil", elimina los cambios locales En su repositorio también y vuelve a la confirmación mencionada anteriormente. Usted Debe ejecutar esto si está seguro de haber cometido un error en su último (s) compromiso (s) Y le gustaría volver al pasado. 

2- Por lo general, 7 letras de "commit sha" son suficientes, pero en proyectos Más grandes, es posible que necesite hasta 12 letras para garantizar que sea único. Usted También puede mencionar las 40 letras enteras sha.

3- Los comandos anteriores también funcionan en Github para Windows.

Siempre puede hacer un git checkout <SHA code> de la versión anterior y luego confirmar nuevamente con el nuevo código.

Puedes deshacer tus confirmaciones de Git de dos maneras: Primero, puedes usar git revert, si quieres mantener tu historial de confirmaciones:

git revert HEAD~3
git revert <hashcode of commit>

En segundo lugar, puede usar git reset, que eliminaría todo su historial de confirmaciones y llevaría a su cabeza a comprometerse donde lo desee.

git reset <hashcode of commit>
git reset HEAD~3

También puede usar la palabra clave --hard si cualquiera de ellas comienza a comportarse de otra manera. Pero, solo lo recomendaría hasta que sea extremadamente necesario.

Referencia: ¿Cómo deshacer el último commit en Git?

Si tiene Git Extensions instalado, puede deshacer/revertir fácilmente cualquier confirmación (puede descargar extensiones de git desde aquí ).

Abra Git Extensions, haga clic con el botón derecho en la confirmación que desea revertir y luego seleccione "Revertir confirmación". 

Se abrirá una ventana emergente (vea la captura de pantalla a continuación)

Seleccione "Crear automáticamente un compromiso" si desea confirmar directamente los cambios revertidos o si desea confirmar manualmente los cambios revertidos mantenga la casilla sin seleccionar y haga clic en el botón "Revertir este compromiso".

Simplemente use git reset --hard <last good SHA> para restablecer sus cambios y dar un nuevo compromiso. También puedes usar git checkout -- <bad filename>.

He encontrado este sitio que describe cómo deshacer las cosas que ha confirmado en el repositorio.

Algunos comandos:

git commit --amend        # Change last commit
git reset HEAD~1 --soft   # Undo last commit

Aquí está el sitio: Oh shit, git! .

Aquí hay muchas recetas de cómo deshacer cosas en Git. Algunos:

¡Oh, mierda, necesito cambiar el mensaje en mi última confirmación!

git commit --amend
# follow prompts to change the commit message

¡Oh, mierda, accidentalmente cometí algo para dominar que debería haber estado en una nueva sucursal!

# Create a new branch from the current state of master
git branch some-new-branch-name
# Remove the commit from the master branch
git reset HEAD~ --hard
git checkout some-new-branch-name
# Your commit lives in this branch now :)

Puedes deshacer tus confirmaciones desde el repositorio local. Por favor, siga el siguiente escenario.

En la imagen de abajo, reviso la rama 'test' (usando el comando Git git checkout -b test) como un estado local y verifico (usando el comando Git git status) de la rama local que no hay nada que cometer.

En la siguiente imagen de la imagen que puede ver aquí, hice algunos cambios en Filter1.txt y agregué ese archivo al área de preparación y luego confirmé mis cambios con algún mensaje (usando el comando Git git commit -m "Doing commit to test revert back").

"-m es para el mensaje de confirmación"

En la siguiente imagen puede ver su registro de confirmaciones, independientemente de lo que haya realizado (utilizando el comando Git git log).

Así que en la imagen anterior puede ver el ID de confirmación con cada confirmación y con su mensaje de confirmación ahora cualquier confirmación que desee revertir o deshacer copie esa identificación de confirmación y presione el comando Git a continuación, git revert {"paste your commit id"}. Ejemplo:

git revert 9ca304ed12b991f8251496b4ea452857b34353e7

He devuelto mi último compromiso. Ahora, si verifica el estado de su Git, puede ver el archivo modificado que es Filter1.txt y aún se debe confirmar.

La forma más sencilla de deshacer el último commit es

git reset HEAD^

Esto traerá el estado del proyecto antes de que haya realizado el compromiso.

En IntelliJ IDEA simplemente puede abrir el registro del repositorio Git presionando Alt+9, haga clic con el botón derecho del ratón en alguna etiqueta de la lista de confirmaciones, y seleccione: "Restablecer rama actual aquí ...".

CABEZA:

Antes de reiniciar la confirmación, debemos conocer HEAD ... HEAD no es más que su estado actual en su directorio de trabajo. Está representado por un número de confirmación.

Git commit:

Cada cambio asignado en una confirmación que está representada por una etiqueta única. Los compromisos no se pueden eliminar. Entonces, si desea su último compromiso, puede simplemente sumergirse en él usando git reset.

Puedes sumergirte en el último commit usando dos métodos:

Método 1: (si no conoce el número de confirmación, pero desea pasar al primero)

git reset HEAD~1  # It will move your head to last commit

Método 2: (si conoce la confirmación, simplemente la restablece en su confirmación conocida)

git reset 0xab3 # Número de compromiso

Nota: si desea conocer un intento de confirmación reciente git log -p -1

Aquí está la representación gráfica:

La diferencia entre git reset --mixed, --soft y --hard

Requisito previo: cuando se realiza una modificación a un archivo existente en su repositorio , Este cambio se considera inicialmente como no organizado. Para confirmar los cambios, es necesario que se establezca, lo que significa agregándolo al índice usando git add. Durante una operación de confirmación, los archivos Que se almacenan en etapas se agregan a un índice.

Tomemos un ejemplo: 

- A - B - C (master)

HEAD apunta a C y el índice coincide con C.

--suave

• Cuando ejecutamos git reset --soft B con la intención de eliminando el commit C y apuntando el master/HEAD a B. 
• El maestro/HEAD ahora apuntará a B, pero el el índice aún ha cambiado de C. 
• Al ejecutar git status podría ver los archivos indexados en commit C como puesta en escena. 
• La ejecución de un git commit en este punto creará un nuevo commit con los mismos cambios que C

--mezclado

• Ejecuta git reset --mixed B. 
• En la ejecución, master/HEAD apuntará a B y el el índice también se modifica para que coincida con B debido a la marca mixta utilizada. 
• Si ejecutamos git commit en este punto, no ocurrirá nada ya que el índice coincide con HEAD.
• Todavía tenemos los cambios en el directorio de trabajo, pero como no están en el índice, el estado de git los muestra como no estadificados. 
• Para cometerlos, debe hacer git add y luego cometer como de costumbre.

--difícil

• Ejecutar git reset --hard B
• En la ejecución, master/HEAD apuntará a B y modifica su directorio de trabajo
• Los cambios agregados en C y todos los cambios no confirmados serán eliminados.
• Los archivos en la copia de trabajo coincidirán con la confirmación B, esto resultará en la pérdida permanente de todos los cambios realizados en la confirmación C más los cambios no confirmados

Espero que esta comparación de banderas disponibles para usar con el comando git reset ayude a alguien a usarlas sabiamente. Consulte estos para obtener más detalles link1 & link2

La conversión de puntos y rechazo son los mejores cuando se desea mantener el historial limpio Útil al proponer parches a una sucursal pública, etc.

Si tiene que eliminar la confirmación superior, la siguiente línea de ayuda le ayuda

git rebase --onto HEAD~1 HEAD

Pero si quieres soltar 1 de muchos cometidos dijiste

a -> b -> c -> d -> maestro

y quieres soltar el commit 'c'

git rebase --onto b c

Esto hará que 'b' sea la nueva base de 'd' que elimina 'c'.

Encuentre el último código hash de confirmación viendo el registro por:

git log

Entonces

git reset <the previous co>

En aras de la exhaustividad, daré el único método obvio que las respuestas anteriores pasaron por alto.

Dado que el compromiso no se empujó, el control remoto no se modificó, por lo que:

1. Eliminar el repositorio local.
2. Clona el repositorio remoto.

Esto a veces es necesario si su cliente Git de lujo se despide. (por ejemplo, errores non-fast-forward)

No te olvides de volver a confirmar tus cambios guardados desde el último Push.

Suponiendo que está trabajando en Visual Studio, si ingresa a su historial de sucursales y observa todas sus confirmaciones, simplemente seleccione el evento antes de la confirmación que desea deshacer, haga clic con el botón derecho y seleccione Revert. Tan fácil como eso.

Si desea eliminar los archivos incorrectos debe hacer 

git reset --soft <your_last_good_commit_hash_here> Aquí, si lo hace git status, verá los archivos en el área de preparación. Puede seleccionar los archivos incorrectos y eliminarlos del área de preparación.

Como los siguientes.

git reset wrongFile1 wrongFile2 wrongFile3

Ahora puede simplemente agregar los archivos que necesita para Push,

git add goodFile1 goodFile2

cometerlos 

git commit -v o git commit -am "Message"

y empujar

git Push Origin master

Sin embargo, si no le importan los archivos modificados, puede restablecer a la buena confirmación anterior y enviar todo al servidor.

por 

git reset --hard <your_last_good_commit_hash_here>

git Push Origin master

Si ya ha publicado sus archivos incorrectos en el servidor, puede usar el indicador --force para enviar al servidor y editar el historial.

git Push --force Origin master

Intente esto, reinicie por completo la confirmación anterior donde no se agregaron esos archivos, luego:

git reset --hard <commit_hash>

Asegúrate de tener una copia de seguridad de tus cambios por si acaso, ya que es un restablecimiento completo, lo que significa que se perderán (a menos que hayas escondido antes)

git reset --soft HEAD~1

Restablecer rebobinará su rama HEAD actual a la revisión especificada. Nota el indicador --soft: esto garantiza que se conserven los cambios en las revisiones deshechas. Después de ejecutar el comando, encontrará los cambios como modificaciones locales no confirmadas en su copia de trabajo.

Si no desea mantener estos cambios, simplemente use la marca --hard. Asegúrese de hacer esto solo cuando esté seguro de que ya no necesita estos cambios.

 git reset --hard HEAD~1

Deshacer múltiples confirmaciones

git reset --hard 0ad5a7a6

tenga en cuenta, sin embargo, que el uso del comando reset deshace todas las confirmaciones que vinieron después de la que devolvió a:

Lo que hago cada vez que necesito deshacer un commit/commit es:

1. git reset HEAD~<n> // el número de las últimas confirmaciones que necesito deshacer

2. git status // opcional. Todos los archivos están ahora en rojo (sin etapas).

3. Ahora, puedo agregar y confirmar solo los archivos que necesito:

   • git add <file names> & git commit -m "message" -m "details"
4. Opcional: Puedo revertir los cambios de los archivos de descanso, si los necesito, a su condición anterior, con la verificación:
   • git checkout <filename>
5. si ya lo había empujado a Origen remoto, anteriormente:
   • git Push Origin <branch name> -f // usa -f para forzar el Push.

Si quieres deshacer el primer commit en tu repo

Te encontrarás con este problema:

$ git reset HEAD~
fatal: ambiguous argument 'HEAD~': unknown revision or path not in the working tree.
Use '--' to separate paths from revisions, like this:
'git <command> [<revision>...] -- [<file>...]'

El error se produce porque si la última confirmación es la confirmación inicial (o no los padres) del repositorio, no hay HEAD ~.

Solución

Si desea restablecer la única confirmación en la rama "maestra"

$ git update-ref -d HEAD
$ git rm --cached -r .

Obtenga el último ID de confirmación usando este comando (en el registro uno en la parte superior es el más reciente):

git log

Obtenga el ID de confirmación (GUID) y ejecute este comando:

git revert <commit_id>

Cómo editar una confirmación anterior

En general, no quiero deshacer un montón de confirmaciones, sino más bien editar una confirmación anterior de cómo desearía haberla cometido en primer lugar.

Me encontré arreglando un compromiso pasado con la frecuencia suficiente para que escribiera un script para él.

Aquí está el flujo de trabajo:

1. git commit-edit <commit-hash>
   

   Esto te dejará en la confirmación que deseas editar.

   Los cambios de la confirmación serán un staged, listos para ser ejecutados como desee que fuera la primera vez.

2. Arregle y ponga en escena el compromiso como deseara, en primer lugar.

   (Es posible que desee utilizar git stash save --keep-index para guardar cualquier archivo que no esté confirmando)

3. Rehacer la confirmación con --amend, por ejemplo:

   git commit --amend
   

4. Completa la rebase:

   git rebase --continue
   

Llame a este siguiente git-commit-edit y póngalo en su $PATH:

#!/bin/bash

# Do an automatic git rebase --interactive, editing the specified commit
# Revert the index and working tree to the point before the commit was staged
# https://stackoverflow.com/a/52324605/5353461

set -euo pipefail

script_name=${0##*/}

warn () { printf '%s: %s\n' "$script_name" "$*" >&2; }
die () { warn "[email protected]"; exit 1; }

[[ $# -ge 2 ]] && die "Expected single commit to edit. Defaults to HEAD~"

# Default to editing the parent of the most recent commit
# The most recent commit can be edited with `git commit --amend`
commit=$(git rev-parse --short "${1:-HEAD~}")

# Be able to show what commit we're editing to the user
if git config --get alias.print-commit-1 &>/dev/null; then
  message=$(git print-commit-1 "$commit")
else
  message=$(git log -1 --format='%h %s' "$commit")
fi

if [[ $OSTYPE =~ ^darwin ]]; then
  sed_inplace=(sed -Ei "")
else
  sed_inplace=(sed -Ei)
fi

export GIT_SEQUENCE_EDITOR="${sed_inplace[*]} "' "s/^pick ('"$commit"' .*)/edit \\1/"'
git rebase --quiet --interactive --autostash --autosquash "$commit"~
git reset --quiet @~ "$(git rev-parse --show-toplevel)"  # Reset the cache of the toplevel directory to the previous commit
git commit --quiet --amend --no-edit --allow-empty  #  Commit an empty commit so that that cache diffs are un-reversed

echo
echo "Editing commit: $message" >&2
echo

Si simplemente desea desechar todos sus cambios/confirmaciones locales y hacer que su sucursal local se vea como la sucursal de Origin desde la que comenzó ...

git reset --hard Origin/branch-name

git revert commit

Esto generará los cambios opuestos a partir de la confirmación que desea revertir, y luego solo confirmará los cambios. Creo que esta es la forma más sencilla.

https://git-scm.com/docs/git-revert

reemplace su versión local, incluidos sus cambios con la versión del servidor, estas dos líneas de código obligarán a git a extraer y sobrescribir la local. Abra el indicador de comando y navegue a la raíz del proyecto git. Si usa VS, haga clic en Equipo, Sincronizar y haga clic en "Abrir indicador de comando" (vea la imagen) a continuación. 

Una vez en Cmd Prompt, siga adelante con las siguientes dos instrucciones. 

git fetch --all

entonces haces

git reset --hard Origin/master

esto sobrescribirá la versión local existente con la del servidor git

git Push --delete (branch_name) //this will be removing the public version of your branch

git Push Origin (branch_name) //This will add the previous version back