41 Pregunta: ¿Cómo puedo revertir un repositorio Git a un commit anterior?

pregunta creada en Mon, Jun 10, 2019 12:00 AM

¿Cómo vuelvo de mi estado actual a una instantánea realizada en una confirmación determinada?

Si hago git log, obtengo el siguiente resultado:

 
$ git log
commit a867b4af366350be2e7c21b8de9cc6504678a61b`
Author: Me <me@me.com>
Date:   Thu Nov 4 18:59:41 2010 -0400

blah blah blah...

commit 25eee4caef46ae64aa08e8ab3f988bc917ee1ce4
Author: Me <me@me.com>
Date:   Thu Nov 4 05:13:39 2010 -0400

more blah blah blah...

commit 0766c053c0ea2035e90f504928f8df3c9363b8bd
Author: Me <me@me.com>
Date:   Thu Nov 4 00:55:06 2010 -0400

And yet more blah blah...

commit 0d1d7fc32e5a947fbd92ee598033d85bfc445a50
Author: Me <me@me.com>
Date:   Wed Nov 3 23:56:08 2010 -0400

Yep, more blah blah.

¿Cómo volver al compromiso desde el 3 de noviembre, es decir, comprometer 0d1d7fc?

    
6891
  1. Relacionado ¿Cómo deshacer el último compromiso de Git? .
    2014-05-23 17: 57: 12Z
  2. Aquí está una publicación muy clara y completa sobre deshacer cosas en git, directamente de Github.
    2015-06-08 19: 41: 52Z
  3. Relacionado: Restaurar a un antiguo Git commit en un repositorio público . Tenga en cuenta que esa pregunta agrega una restricción de que el repositorio es público.
    2015-10-19 09: 51: 42Z
  4. Me encanta git, pero el hecho de que haya 35 respuestas a algo que debería ser increíblemente simple expone un gran problema con git. ¿O son los documentos?
    2018-01-03 22: 26: 59Z
  5. Podrían agregar una funcionalidad de botón para eso como SVN en la historia
    2018-12-13 18: 29: 31Z
  6. 30 Respuestas                              30                         

    Esto depende mucho de lo que quieres decir con "revertir".

    Cambiar temporalmente a una confirmación diferente

    Si quieres volver temporalmente a ello, tontear, luego volver a donde estás, todo lo que tienes que hacer es revisar el compromiso deseado:

     
    # This will detach your HEAD, that is, leave you with no branch checked out:
    git checkout 0d1d7fc32
    

    O si quieres hacer confirmaciones mientras estás allí, sigue adelante y crea una nueva sucursal mientras estás en ello:

     
    git checkout -b old-state 0d1d7fc32
    

    Para volver al lugar donde estaba, solo revise la rama en la que estaba nuevamente. (Si ha realizado cambios, como siempre al cambiar de sucursal, tendrá que tratar con ellos según corresponda. Podría reiniciar para desecharlos; podría esconder, retirar y guardar para llevarlos consigo; podría cometer a una rama allí si quieres una rama allí.)

    Eliminar errores no publicados

    Si, por otro lado, quieres realmente deshacerte de todo lo que has hecho desde entonces, hay dos posibilidades. Una, si no ha publicado ninguno de estos compromisos, simplemente reinicie:

     
    # 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.
    

    Si te equivocas, ya has desechado tus cambios locales, pero al menos puedes volver a donde estabas antes restableciendo nuevamente.

    Deshacer confirmaciones publicadas con nuevas confirmaciones

    Por otra parte, si ha publicado el trabajo, es probable que no desee restablecer la rama, ya que eso es efectivamente reescribir el historial. En ese caso, efectivamente podría revertir las confirmaciones. Con Git, revertir tiene un significado muy específico: crear una confirmación con el parche inverso para cancelarla. De esta manera no reescribirás ninguna historia.

     
    # This will create three separate revert commits:
    git revert a867b4af 25eee4ca 0766c053
    
    # It also takes ranges. This will revert the last two commits:
    git revert HEAD~2..HEAD
    
    #Similarly, you can revert a range of commits using commit hashes:
    git revert a867b4af..0766c053 
    
    # Reverting a merge commit
    git revert -m 1 <merge_commit_sha>
    
    # To get just one, you could use `rebase -i` to squash them afterwards
    # Or, you could do it manually (be sure to do this at top level of the repo)
    # get your index and work tree into the desired state, without changing HEAD:
    git checkout 0d1d7fc32 .
    
    # Then commit. Be sure and write a good message describing what you just did
    git commit
    

    La página de manual git-revert cubre mucho de esto en su descripción. Otro enlace útil es esta sección de git-scm.com que trata sobre git -revertir .

    Si decide que no desea revertir después de todo, puede revertir la reversión (como se describe aquí) o restablecerla antes de la reversión (consulte la sección anterior).

    También puede encontrar útil esta respuesta en este caso:
    ¿Cómo mover HEAD de nuevo a una ubicación anterior? (Cabeza separada)

        
    8799
    2018-04-04 17: 54: 07Z
    1. @ comentario de Rod en git revert HEAD~3 como el mejor wat para revertir 3 confirmaciones es una convención importante.
      2012-08-22 15: 16: 45Z
    2. ¿Podrías escribir el número entero? como: git reset --hard 0d1d7fc32e5a947fbd92ee598033d85bfc445a50
      2012-12-04 13: 58: 13Z
    3. @ MathiasMadsenStav Sí, por supuesto, puede especificar confirmaciones por el SHA1 completo. Usé hashes abreviados para que la respuesta fuera más legible, y también tiendes a usarlos si estás escribiendo. Si estás copiando y pegando, por todos los medios utiliza el hash completo. Consulte Especificación de revisiones en man git rev- parse para obtener una descripción completa de cómo puede asignar un nombre a las confirmaciones.
      2012-12-04 16: 55: 52Z
    4. Para volver al estado actual, el comando es 'git checkout master'
      2013-01-18 00: 33: 26Z
    5. Puedes usar git revert --no-commit hash1 hash2 ... y después de esto solo cometer cada revertir en un solo commit git commit -m "Message"
      2013-09-24 12: 12: 16Z

    Rogue Coder?

    ¿Trabajando por tu cuenta y solo quieres que funcione? Siga estas instrucciones a continuación, han trabajado de manera confiable para mí y para muchos otros durante años.

    ¿Trabajar con otros? Git es complicado. Lea los comentarios debajo de esta respuesta antes de hacer algo precipitado.

    Revertir copia de trabajo a la confirmación más reciente

    Para volver a una confirmación anterior, ignorando cualquier cambio:

     
    git reset --hard HEAD
    

    donde HEAD es la última confirmación en su rama actual

    Revertir la copia de trabajo a una confirmación anterior

    Para volver a una confirmación anterior a la confirmación más reciente:

     
    # Resets index to former commit; replace '56e05fced' with your commit code
    git reset 56e05fced 
    
    # Moves pointer back to previous HEAD
    git reset --soft HEAD@{1}
    
    git commit -m "Revert to 56e05fced"
    
    # Updates working copy to reflect the new commit
    git reset --hard
    

    Los créditos van a una pregunta similar de desbordamiento de pila, Revertir a un compromiso por un hash SHA en Git? .

        
    1465
    2019-06-13 02: 36: 39Z
    1. Hice eso, pero luego no pude comprometerme y enviar al repositorio remoto. Quiero un compromiso mayor específico para convertirse en HEAD ...
      2012-09-24 18: 17: 28Z
    2. Significa que ya has introducido los compromisos que quieres revertir. Puede crear muchos problemas para las personas que verificaron su código y trabajaron en él. Ya que no pueden aplicar su cometido sin problemas sobre el de ellos. En tal caso es mejor hacer un git revertir. Si eres el único que usa el repositorio. Haz un git push -f (pero piénsalo dos veces antes de hacer eso)
      2012-12-05 04: 51: 51Z
    3. Advertencia obligatoria: no reinicie el sistema si está compartiendo su sucursal con otras personas que tienen copias de las confirmaciones anteriores, porque usa Un restablecimiento completo como este los obligará a tener que volver a sincronizar su trabajo con la rama que se acaba de restablecer. Sin embargo, el reinicio por software es seguro, así como las últimas soluciones en esta respuesta .
      2014-06-28 20: 06: 00Z
    4. También quiero señalar que, alternativamente, para la solución de reinicio por software, en lugar de hacer un reinicio mixto primero y un reinicio por hardware en último lugar, realmente puede hacer lo difícil. restablece primero, como sigue: git reset --hard 56e05fc; git reset --soft HEAD@{1}; git commit.
      2014-06-29 00: 20: 29Z
    5. @ nuton linus pauling, el creador de git, lo criticó por ser demasiado complicado. Según consta, dijo que estaba "sorprendido" porque git se volvió tan popular debido a su complejidad
      2015-05-18 23: 56: 00Z

    Muchas respuestas complicadas y peligrosas aquí, pero en realidad es fácil:

     
    git revert --no-commit 0766c053..HEAD
    git commit
    

    Esto revertirá todo, desde el HEAD de nuevo al hash de confirmación, lo que significa que volverá a crear ese estado de confirmación en el árbol de trabajo como si todas las confirmaciones se hayan devuelto. A continuación, puede confirmar el árbol actual, y creará un nuevo compromiso esencialmente equivalente al compromiso al que usted "revertió".

    (El indicador --no-commit le permite a git revertir todas las confirmaciones a la vez; de lo contrario, se le pedirá un mensaje para cada confirmación en el rango, ensuciando su historial con nuevas confirmaciones innecesarias).

    Esta es una forma segura y fácil de regresar a un estado anterior . No se destruye ningún historial, por lo que se puede utilizar para confirmaciones que ya se han hecho públicas.

        
    1458
    2014-06-28 20: 12: 34Z
    1. Si realmente quieres tener confirmaciones individuales (en lugar de revertir todo con una única confirmación grande), puedes pasar --no-edit en lugar de --no-commit, para que no Tiene que editar un mensaje de confirmación para cada reversión.
      2014-06-28 20: 11: 40Z
    2. Si una de las confirmaciones entre 0766c053..HEAD es una combinación, aparecerá un error (no se especifica -m especificado). Esto puede ayudar a los que se encuentren con que: stackoverflow.com/questions/5970889/…
      2014-11-21 11: 55: 43Z
    3. Para ver las diferencias antes de confirmar el uso git diff --cached.
      2015-11-06 18: 35: 20Z
    4. $ git revert --no-commit 53742ae..HEAD devuelve fatal: empty commit set passed
      2016-08-01 20: 30: 18Z
    5. @ AlexG, porque debe ingresar el hash uno anterior al que desea volver. En mi caso, los hashes eran como: 81bcc9e HEAD{0}; e475924 HEAD{1}, ... (de git reflog), y quería deshacer lo que hice en 81bcc9e, luego tuve que hacer git revert e475924..HEAD
      2017-04-16 14: 22: 51Z

    La mejor opción para mí y probablemente otras es la opción de restablecimiento de Git:

     
    git reset --hard <commidId> && git clean -f
    

    ¡Esta ha sido la mejor opción para mí! ¡Es simple, rápido y efectivo!


    Nota: Como se menciona en los comentarios, no hagas esto si estás compartiendo tu sucursal con otras personas que tienen copias de los antiguos compromisos

    También de los comentarios, si quisieras un método menos agresivo, podrías usarlo

    git clean -i

        
    184
    2015-07-16 15: 31: 10Z
    1. Advertencia obligatoria: no hagas esto si estás compartiendo tu sucursal con otras personas que tienen copias de las confirmaciones anteriores, porque usas Un restablecimiento completo como este los obligará a tener que volver a sincronizar su trabajo con la rama que se acaba de restablecer. Para obtener una solución que explique en detalle cómo revertir de manera segura los compromisos sin perder el trabajo con un restablecimiento completo, vea esta respuesta .
      2014-06-28 20: 03: 54Z
    2. Segundo, la advertencia de @ Cupcake ... sé muy consciente de las consecuencias. Sin embargo, tenga en cuenta que si su necesidad es hacer que esas confirmaciones desaparezcan del historial para siempre, este método de restablecimiento + limpieza lo hará, y necesitará que force empuje sus ramas modificadas de nuevo a cualquiera y todos los mandos a distancia.
      2014-10-29 14: 46: 25Z
    3. git clean -f PELIGRO PELIGRO
      2015-07-16 14: 59: 20Z
    4. Esto establece el encabezado de mi copia local en el commit deseado. Pero entonces no puedo impulsar ningún cambio porque está detrás del control remoto. Y si saco el control remoto, vuelve a estar donde estaba en la última confirmación en la rama remota. ¿Cómo borro completamente (de todas partes) varias confirmaciones en mi copia local que se han enviado?
      2017-10-22 11: 47: 32Z
    5. @ Ade .. Puede usar el indicador git push -f .. Pero tenga cuidado, anulará el control remoto .. Asegúrese de saber lo que quiere hacer ...
      2017-10-23 09: 02: 57Z

    Antes de responder, agreguemos algunos antecedentes, explicando qué es este HEAD.

    First of all what is HEAD?

    HEAD es simplemente una referencia al compromiso actual (más reciente) en la rama actual. Solo puede haber un HEAD en un momento dado (excluyendo git worktree).

    El contenido de HEAD se almacena dentro de .git/HEAD, y contiene los 40 bytes SHA-1 de la confirmación actual.


    detached HEAD

    Si no está en la última confirmación, lo que significa que HEAD apunta a una confirmación anterior en el historial, se llama detached HEAD .

     Introduzca la descripción de la imagen aquí

    En la línea de comandos se verá así: SHA-1 en lugar del nombre de la rama ya que el HEAD no apunta a la punta de la rama actual:

     Introduzca la descripción de la imagen aquí


    Algunas opciones sobre cómo recuperarse de un HEAD separado:


    git checkout

     
    git checkout <commit_id>
    git checkout -b <new branch> <commit_id>
    git checkout HEAD~X // x is the number of commits t go back
    

    Esto comprobará la nueva rama que apunta a la confirmación deseada. Este comando realizará el checkout a un commit dado.

    En este punto, puede crear una rama y comenzar a trabajar desde este punto en:

     
    # Checkout a given commit.
    # Doing so will result in a `detached HEAD` which mean that the `HEAD`
    # is not pointing to the latest so you will need to checkout branch
    # in order to be able to update the code.
    git checkout <commit-id>
    
    # Create a new branch forked to the given commit
    git checkout -b <branch name>
    

    git reflog

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

    Cada vez que se modifique el HEAD, habrá una nueva entrada en el reflog

     
    git reflog
    git checkout HEAD@{...}
    

    Esto te llevará de vuelta a la confirmación deseada

     Introduzca la descripción de la imagen aquí


    git reset HEAD --hard <commit_id>

    "Mueve" tu cabeza hacia atrás hasta la confirmación deseada.

     
    # 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.
    
    • Nota: ( Desde Git 2.7 ) También puede usar el git rebase --no-autostash también.

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

     Introduzca la descripción de la imagen aquí

        
    143
    2018-07-04 19: 25: 17Z
    1. Excelente sugerencia para git reflog, eso es exactamente lo que necesitaba
      2016-03-13 21: 25: 01Z
    2. ¡Ouch! Todo esto parece terriblemente complicado ... ¿no hay un comando simple que te lleve un paso atrás en el proceso? ¿Te gusta pasar de la versión 1.1 en tu proyecto a la versión 1.0? Esperaría algo como: git stepback_one_commit o algo ...
      2016-03-20 14: 35: 15Z
    3. hay: git reset HEAD^ --hard`
      2016-03-20 14: 38: 43Z
    4. @ Kokodoko Sí, es horriblemente complicado ... y un ejemplo perfecto de cuán poca consideración tienen los expertos para las personas que recién están comenzando. Por favor, consulte mi respuesta aquí, y también el libro que recomiendo. Git NO es algo que puedes captar intuitivamente. Y puedo estar absolutamente seguro de que CodeWizard no lo hizo.
      2016-08-29 17: 17: 51Z

    Si desea "descomprimir", borrar el último mensaje de confirmación y volver a poner los archivos modificados en la preparación, debe usar el comando:

     
    git reset --soft HEAD~1
    
    •  --soft indica que los archivos no confirmados deben conservarse como archivos de trabajo en lugar de --hard que los descartarán.
    •  HEAD~1 es el último commit. Si desea deshacer 3 confirmaciones puede usar HEAD~3. Si desea revertir a un número de revisión específico, también puede hacerlo utilizando su hash SHA.

    Este es un comando extremadamente útil en situaciones en las que cometiste algo incorrecto y deseas deshacer el último compromiso.

    Fuente: http://nakkaya.com/2009/09/24/git- delete-last-commit /

        
    125
    2014-03-04 17: 25: 52Z
    1. Esto es suave y delicado: sin riesgos si no has impulsado tu trabajo
      2017-01-18 10: 04: 18Z

    He intentado muchas formas de revertir los cambios locales en Git, y parece que esto funciona mejor si solo quieres revertir al estado de confirmación más reciente.

     
    git add . && git checkout master -f
    

    Breve descripción:

    • NO creará ninguna confirmación como lo hace git revert.
    • NO se separará de tu CABEZA como lo hace el git checkout <commithashcode>.
    • Anulará todos los cambios locales y BORRARÁ todos los archivos agregados desde la última confirmación en la rama.
    • Funciona solo con los nombres de las sucursales, por lo que solo puede revertir a la última confirmación en la sucursal de esta manera.

    Encontré una manera mucho más conveniente y sencilla de lograr los resultados anteriores:

     
    git add . && git reset --hard HEAD
    

    donde HEAD apunta a la última confirmación en tu rama actual.

    Es el mismo código que sugiere boulder_ruby, pero agregué git add . antes de git reset --hard HEAD para borrar todos los archivos nuevos creados desde la última confirmación, ya que esto es lo que la mayoría de la gente espera al volver a la última confirmación.

        
    105
    2014-06-24 20: 08: 20Z

    Puedes hacerlo mediante los siguientes dos comandos:

     
    git reset --hard [previous Commit SHA id here]
    git push origin [branch Name] -f
    

    Se eliminará tu anterior compromiso Git.

    Si desea mantener los cambios, también puede usar:

     
    git reset --soft [previous Commit SHA id here]
    

    Luego guardará tus cambios.

        
    99
    2016-07-03 06: 30: 27Z
    1. Intenté 1/2 docena de respuestas en este post hasta que llegué a este ... todos esos otros, mi configuración de git me dio un error al intentar empujar. Esta respuesta funcionó. ¡Gracias!
      2016-09-16 19: 47: 15Z
    2. Un detalle para mí fue que perdí las diferencias ... que quería seguir para ver lo que había hecho en el compromiso que no funcionó. Entonces, la próxima vez, solo guardaré los datos antes de ejecutar este comando de reinicio
      2016-09-16 19: 49: 36Z
    3. Esta fue la única manera de deshacer una fusión incorrecta, ya que revertir no funcionó en ese caso. ¡Gracias!
      2017-01-19 20: 07: 19Z

    OK, volver a la confirmación anterior en git es bastante fácil ...

    Revertir sin mantener los cambios:

     
    git reset --hard <commit>
    

    Revertir manteniendo los cambios:

     
    git reset --soft <commit>
    

    Explique: usando git reset, puede restablecer a un estado específico, es común usarlo con un hash de confirmación como se ve arriba.

    Pero como ve la diferencia, está usando las dos banderas --soft y --hard, por defecto git reset usando la bandera --soft, pero es una buena práctica usar la bandera siempre, explico cada bandera:


    --soft

    El indicador predeterminado tal como se explica, no es necesario que lo proporcione, no cambia el árbol de trabajo, pero agrega todos los archivos de cambios listos para confirmar, por lo que regresa al estado de confirmación que los cambios en los archivos quedan sin programar.


    --hard

    ¡Ten cuidado con esta bandera, restablece el árbol de trabajo y todos los cambios a los archivos rastreados y todo desaparecerá!


    También creé la siguiente imagen que puede suceder en una vida real al trabajar con git:

     git resetea un commit

        
    65
    2019-02-05 13: 24: 37Z

    Aquí nada me funcionó aparte de esta combinación exacta:

     
    git reset --hard <commit_hash>
    git push origin <branch_name> --force
    

    La clave aquí es forzar la inserción, no hay mensajes adicionales de confirmación /confirmación, etc.

        
    59
    2018-04-23 01: 47: 59Z
    1. Esto funcionó para mí, pero debes tener cuidado porque todo el historial de confirmación después del restablecimiento completo se pierde y esta acción es irreversible. Debes estar seguro de lo que estás haciendo.
      2018-04-19 19: 34: 15Z

    Supongamos que tiene las siguientes confirmaciones en un archivo de texto llamado ~/commits-to-revert.txt (usé git log --pretty=oneline para obtenerlas)

     
    fe60adeba6436ed8f4cc5f5c0b20df7ac9d93219
    0c27ecfdab3cbb08a448659aa61764ad80533a1b
    f85007f35a23a7f29fa14b3b47c8b2ef3803d542
    e9ec660ba9c06317888f901e3a5ad833d4963283
    6a80768d44ccc2107ce410c4e28c7147b382cd8f
    9cf6c21f5adfac3732c76c1194bbe6a330fb83e3
    fff2336bf8690fbfb2b4890a96549dc58bf548a5
    1f7082f3f52880cb49bc37c40531fc478823b4f5
    e9b317d36a9d1db88bd34831a32de327244df36a
    f6ea0e7208cf22fba17952fb162a01afb26de806
    137a681351037a2204f088a8d8f0db6e1f9179ca
    

    Crea un script de shell Bash para revertir cada uno de ellos:

     
    #!/bin/bash
    cd /path/to/working/copy
    for i in `cat ~/commits-to-revert.txt`
    do
        git revert $i --no-commit
    done
    

    Esto hace que todo vuelva al estado anterior, incluidas las creaciones de archivos y directorios, y las eliminaciones, confirme en su rama y retenga el historial, pero lo ha vuelto a la misma estructura de archivos. Por qué Git no tiene un git revert --to <hash> está más allá de mí.

        
    57
    2014-06-29 00: 13: 03Z
    1. Puedes hacer un git revert HEAD~3 para eliminar las últimas 3 confirmaciones
      2012-02-19 18: 59: 22Z
    2. @ Rod: No, eso no es correcto. Ese comando revertirá el compromiso que es el tercer abuelo de HEAD (no los últimos tres compromisos).
      2012-09-11 22: 13: 05Z
    3. @ kflorence Ok, gracias por la información. ¿Funcionaría git revert -n master~3..master~1? (Visto por kernel.org/pub/software/scm /git /docs /git-revert.html )
      2012-09-12 01: 59: 58Z
    4. @ Rod: Eso suena bien, seguro que es una sintaxis fea, ¿no es así? Siempre me ha parecido verificar el compromiso al que quiero "revertir" y luego cometerlo de manera más intuitiva.
      2012-10-01 01: 12: 03Z
    5. Hay una forma mucho más fácil de hacer esto ahora que con un script como este, solo use git revert --no-commit <start>..<end>, porque git revert acepta un rango de confirmación en el nuevo (¿o todas?) versiones de Git. Tenga en cuenta que el inicio del rango no está incluido en la reversión.
      2014-06-28 20: 02: 39Z

    Alternativas adicionales a las soluciones de Jefromi's

    Las soluciones de Jefromi's son definitivamente las mejores, y definitivamente debes usarlas. Sin embargo, en aras de la integridad, también quería mostrar estas otras soluciones alternativas que también se pueden usar para revertir un compromiso (en el sentido de que crea un nuevo compromiso que deshace los cambios en el compromiso anterior , justo como lo hace git revert).

    Para ser claros, estas alternativas no son la mejor manera de revertir los compromisos , Las soluciones de Jefromi son , pero solo quiero señalar que también puede utilizar estos otros métodos para lograr lo mismo que git revert.

    Alternativa 1: reinicios de hardware y software

    Esta es una versión muy ligeramente modificada de la solución de Charles Bailey para ¿Volver a un commit por un hash SHA en Git? :

     
    # Reset the index to the desired commit
    git reset --hard <commit>
    
    # Move the branch pointer back to the previous HEAD
    git reset --soft HEAD@{1}
    
    # Commit the changes
    git commit -m "Revert to <commit>"
    

    Esto básicamente funciona utilizando el hecho de que los reinicios por software dejarán el estado de la confirmación previa en el índice /área de almacenamiento, que luego puede confirmar.

    Alternativa 2: eliminar el árbol actual y reemplazarlo por uno nuevo

    Esta solución proviene de la solución de svick para Compruebe el compromiso antiguo y conviértalo en un nuevo compromiso :

     
    git rm -r .
    git checkout <commit> .
    git commit
    

    De manera similar a la alternativa # 1, esto reproduce el estado de <commit> en la copia de trabajo actual. Es necesario hacer git rm primero porque git checkout no eliminará los archivos que se han agregado desde <commit>.

        
    56
    2017-05-23 11: 47: 32Z
    1. Acerca de la Alternativa 1, una pregunta rápida: al hacerlo, no perdemos entre comillas, ¿no?
      2014-12-02 10: 14: 33Z
    2. en la Alternativa 2, los puntos representan qué hay en esos comandos?
      2014-12-02 10: 21: 40Z
    3. @ Bogac: los puntos indican una ruta de archivo, en este caso el directorio actual, por lo que se supone que lo está ejecutando desde la raíz de su copia de trabajo.
      2014-12-02 19: 06: 38Z
    4. La advertencia se repite varias veces en la respuesta, pero ¿podría alguien agregar por qué ? no es la mejor manera - comparado, a algo así como git revert HEAD~2..HEAD de la solución vinculada de @ Cascabel (@ Jefromi's). No estoy viendo el problema.
      2018-12-28 02: 16: 08Z

    Suponiendo que está hablando de maestro y de esa rama respectiva (dicho esto, podría ser cualquier rama de trabajo que le interese):

     
    # Reset local master branch to November 3rd commit ID
    git reset --hard 0d1d7fc32e5a947fbd92ee598033d85bfc445a50
    
    # Reset remote master branch to November 3rd commit ID
    git push -f origin 0d1d7fc32e5a947fbd92ee598033d85bfc445a50:master
    

    Encontré la respuesta en una publicación de blog (ahora ya no existe)

    Tenga en cuenta que esto es Restablecer y forzar el cambio en el control remoto, de modo que si otros miembros de su equipo ya lo han intentado, le causarán problemas. Estás destruyendo el historial de cambios, lo cual es una razón importante por la que la gente usa git en primer lugar.

    Es mejor usar revertir (ver otras respuestas) que restablecer. Si eres un equipo de un solo hombre, entonces probablemente no importa.

        
    56
    2019-04-28 19: 59: 43Z
    1. ¿En qué se diferencia esta respuesta de la miríada de otras personas?
      2016-05-10 17: 46: 51Z
    2. El enlace está roto.
      2016-07-03 10: 59: 27Z
    3. Eso es desafortunado. Le envié un correo electrónico al blogger, ¡espero que aún lo tenga!
      2016-07-04 19: 29: 37Z
    4. 2016-09-01 17: 51: 49Z
    5. Falta la sintaxis de inserción en la mayoría de las otras sugerencias sobre cómo solucionar esto. Funcionó muy bien.
      2017-03-24 16: 20: 56Z

    Aquí hay una forma mucho más sencilla de volver a un compromiso anterior (y tenerlo en un estado no comprometido, para hacerlo con lo que quieras):

     
    git reset HEAD~1
    

    Por lo tanto, no hay necesidad de ID de confirmación, etc. :)

        
    51
    2016-07-03 10: 56: 38Z
    1. no funcionó, un tirón de git después de este resultado: error: Sus cambios locales en los siguientes archivos se sobrescribirían con merge:
      2016-11-05 00: 21: 33Z
    2. @ malhal Eso se debe a que has tenido cambios sin compromiso. Guárdelas /reinicie y luego funcionará sin ese error.
      2017-01-22 13: 37: 38Z

    Después de todos los cambios, cuando presiona todos estos comandos, es posible que tenga que usar:

     
    git push -f ...
    

    Y no solo git push.

        
    34
    2013-09-28 19: 07: 07Z
    1. Advertencia obligatoria: no hagas esto si estás compartiendo tu sucursal con otras personas que tienen copias de las confirmaciones anteriores, porque usas un empuje de fuerza como este los obligará a tener que volver a sincronizar su trabajo. Para obtener una solución que explique en detalle cómo revertir de manera segura los compromisos sin perder el trabajo con un impulso forzado, vea esta respuesta .
      2014-06-28 20: 00: 19Z
    2. A veces esto es lo que quieres. Ejemplo: confirmó y empujó varios confirmaciones a la rama incorrecta (rama A). Después de seleccionar a la rama B, quiero que se eliminen estos compromisos de la rama A. No querría revertir, ya que la reversa se aplicaría más adelante cuando las ramas A y B se fusionen. Haciendo un reinicio --hard < commitId > en la rama A, seguido de un impulso de fuerza, se eliminan estos compromisos de la rama y se conservan en la rama B. Puedo evitarlo porque sé que nadie más se está desarrollando en la rama A.
      2014-10-22 20: 44: 19Z
    3. ¡Gracias! No pude averiguar cómo hacer que la sucursal remota coincida con mi sucursal local, solo necesitaba hacer un impulso de fuerza.
      2017-02-06 12: 49: 58Z

    Hay un comando (no es una parte del núcleo Git, pero está en el paquete git-extras ) específicamente para revertir y poner en escena los compromisos viejos:

     
    git back
    

    Según la página de manual , también se puede utilizar como tal:

     
    # Remove the latest three commits
    git back 3
    
        
    34
    2014-06-28 20: 19: 45Z

    Puedes completar todos estos pasos iniciales tú mismo y push de vuelta a git repo.

    1. Extraiga la última versión de su repositorio de Bitbucket usando el  Comando git pull --all.

    2. Ejecuta el comando git log con -n 4 desde tu terminal. El número después de -n determina el número de confirmaciones en el registro a partir de la confirmación más reciente en su historial local.

      $ git log -n 4

    3. Restablece el encabezado del historial de tu repositorio usando el git reset --hard HEAD~N, donde N es el número de confirmaciones que quieres devolver. En el siguiente ejemplo la cabeza se retrasaría una commit, hasta el último commit en el historial del repositorio:

    4. Empuje el cambio a git repo usando git push --force para forzar empuje el cambio.

    Si desea que git repository sea un commit anterior

     
    git pull --all
    git reset --hard HEAD~1
    git push --force
    
        
    29
    2018-07-05 20: 56: 59Z

    Vuelva al más reciente confirmando e ignorando todos los cambios locales:

     
    git reset --hard HEAD
    
        
    27
    2018-07-04 19: 28: 44Z

    Seleccione su confirmación requerida y verifíquela por

     
    git show HEAD
    git show HEAD~1
    git show HEAD~2 
    

    hasta que obtenga el commit requerido. Para que la CABEZA apunte a eso, hazlo

     
    git reset --hard HEAD~1
    

    o git reset --hard HEAD~2 o lo que sea.

        
    26
    2014-06-28 19: 51: 32Z
    1. Advertencia obligatoria: no hagas esto si estás compartiendo tu sucursal con otras personas que tienen copias de las confirmaciones anteriores, porque usas Un restablecimiento completo como este los obligará a tener que volver a sincronizar su trabajo con la rama que se acaba de restablecer. Para obtener una solución que explique en detalle cómo revertir de manera segura los compromisos sin perder el trabajo con un restablecimiento completo, vea esta respuesta .
      2014-06-28 19: 57: 00Z
    2. Además, para ser claro, git show HEAD es equivalente a usar git log HEAD -1.
      2014-06-28 19: 58: 54Z

    Para mantener los cambios de la confirmación anterior a HEAD y pasar a la confirmación anterior, haga:

     
    git reset <SHA>
    

    Si no se requieren cambios de la confirmación anterior a HEAD y simplemente descarta todos los cambios, haz:

     
    git reset --hard <SHA>
    
        
    20
    2016-07-03 10: 21: 53Z

    Para limpiar completamente el directorio de un codificador de algunos cambios accidentales, utilizamos:

     
    git add -A .
    git reset --hard HEAD
    

    Solo el git reset --hard HEAD eliminará las modificaciones, pero no eliminará los archivos "nuevos". En su caso, accidentalmente arrastraron una carpeta importante a algún lugar, y todos esos archivos fueron tratados como nuevos por Git, por lo que un reset --hard no lo solucionó. Al ejecutar el git add -A . de antemano, los rastreó explícitamente a todos con git, que se eliminará con el reinicio.

        
    20
    2016-07-03 10: 55: 25Z

    Esta es una forma más de restablecer directamente a un compromiso reciente

     
    git stash
    git stash clear
    

    Borra directamente todos los cambios que has estado realizando desde la última confirmación.

    PS: tiene un pequeño problema; también elimina todos los cambios de almacenamiento almacenados recientemente. Lo que supongo que en la mayoría de los casos no debería importar.

        
    20
    2016-07-03 10: 57: 18Z
    1. NOTA: Los archivos nuevos que no se agregaron en el índice no se ocultan. Tienes tambienAgrégalos o elimínalos manualmente.
      2016-12-08 14: 08: 46Z
    2. ¿Por qué, oh, por qué eliminar el alijo? Además de no ser una solución, esto es realmente dañino. La lectura de la primera oración de la pregunta invalida inmediatamente la solución de ocultación (que podría ser útil SOLAMENTE para restablecer el último compromiso).
      2019-03-07 07: 35: 51Z

    Creo que algunas personas pueden llegar a esta pregunta queriendo saber cómo deshacer los cambios comprometidos que han hecho en su maestro, es decir, deshacerse de todo y volver al origen /maestro, en cuyo caso, haga esto:

     
    git reset --hard origin/master
    

    https://superuser.com/questions/273172/how-to -reset-master-to-origin-master

        
    19
    2017-03-20 10: 18: 20Z

    Revertir es el comando para deshacer las confirmaciones.

     
    git revert <commit1> <commit2> 
    

    Sample:

    git revert 2h3h23233

    Es capaz de tomar rango desde la CABEZA como a continuación. Aquí 1 dice "revertir último compromiso".

    git revert HEAD~1..HEAD

    y luego hacer git push

        
    16
    2016-05-27 06: 05: 57Z

    Revertir el compromiso más reciente:

     
    git reset --hard HEAD
    

    HEAD es simplemente una referencia al compromiso actual (más reciente) en la rama actual. Solo puede haber un HEAD en un momento dado.

    Volver a un compromiso anterior: La forma más rápida de restaurar una versión anterior es usar el comando reset:

     
    # Resets index to former commit
    git reset 56e05fced 
    
    # Moves pointer back to previous HEAD
    git reset --soft HEAD@{1}
    
    # Updates working copy to reflect the new commit
    git reset --hard
    

    Esto rebobinará su rama HEAD a la versión especificada. Todas las confirmaciones que vinieron después de esta versión se deshacen efectivamente; su proyecto es exactamente como era en ese momento.

    El comando de reinicio viene con un par de opciones, una de las más interesantes es la bandera --soft. Si lo usa en lugar de --hard, Git mantendrá todos los cambios en esos compromisos "no hechos" como modificaciones locales.

    Restaurar una revisión en Nueva sucursal local

    Como se dijo, el uso del comando de reinicio en su rama HEAD es una acción bastante drástica: eliminará cualquier confirmación (en esta rama) que vino después de la revisión especificada. Si está seguro de que esto es lo que quiere, todo está bien.

    Sin embargo, también hay una forma más segura en caso de que prefieras dejar tu rama HEAD actual sin tocar. Dado que las "sucursales" son tan baratas y fáciles en Git, podemos crear fácilmente una nueva sucursal que comience en esa antigua revisión:

     
    git checkout -b old-project-state 0ad5a7a6
    

    Normalmente, el comando de pago se usa para cambiar de rama. Sin embargo, al proporcionar el parámetro -b, también puede dejar que cree una nueva rama (denominada old-project-state en este ejemplo). Si no desea que comience en la revisión HEAD actual, también debe proporcionar un hash de confirmación: la revisión del proyecto anterior que queremos restaurar.

    Ahora tiene una nueva sucursal llamada old-project-state que refleja la versión anterior de su proyecto, sin tocar ni eliminar ninguna otra confirmación o rama.

        
    16
    2018-08-31 11: 08: 13Z

    Si la situación es urgente y solo desea hacer lo que el interlocutor le preguntó de manera rápida y sucia , suponiendo que su proyecto se encuentra en el directorio "mi proyecto ":

    1. Copie todo el directorio y llámelo de otra manera, como "mi proyecto - copiar"

    2. Haz:

       
      git reset --hard [first-4-letters&numbers-of-commit's-SHA]
      

    Luego tiene dos versiones en su sistema ... puede examinar o copiar o modificar archivos de interés, o lo que sea, de la confirmación anterior. Puede descartar completamente los archivos en "mi proyecto - copiar", si ha decidido que el nuevo trabajo no iría a ninguna parte ...

    Lo obvio si desea continuar con el estado del proyecto sin realmente discaEjecutar el trabajo ya que esta confirmación recuperada es renombrar su directorio nuevamente: elimine el proyecto que contiene la confirmación recuperada (o asigne un nombre temporal) y cambie el nombre de su directorio "mi proyecto - copiar" a "mi proyecto". Entonces probablemente hagas otro compromiso bastante pronto.

    Git es una creación brillante, pero no puedes simplemente "recogerlo sobre la marcha": también las personas que intentan explicarlo con demasiada frecuencia asumen el conocimiento previo de otros VCS [Sistemas de control de versiones ] y ahondar demasiado profundo demasiado pronto, y cometer otros delitos, como usar términos intercambiables para "verificar", en formas que a veces parecen casi calculadas para confundir a un principiante.

    Para ahorrarte mucho estrés, debes leer un libro sobre Git. Recomendaría " Control de versiones con Git ". Y si puedes confiar en mí (o más bien en mis cicatrices) cuando digo "tengo que hacerlo", se deduce que también puedes hacerlo NOW . Gran parte de la complejidad de Git proviene de la ramificación y luego de la fusión. Pero a partir de tu pregunta no hay ninguna razón por la que las personas deberían cegarte con la ciencia .

    ¡Especialmente si, por ejemplo, esta es una situación desesperada y eres un novato con Git!

    PS: Otra idea: es (ahora) bastante simple mantener el repositorio Git ("repo") en un directorio diferente al que contiene los archivos de trabajo. Esto significaría que no tendría que copiar todo el repositorio de Git utilizando el comando rápido & solución sucia Vea la respuesta de Fryer usando --separate-git-dir aquí . Tenga cuidado , sin embargo: si tiene un repositorio de "directorio separado" que no copia, y realiza un restablecimiento completo, todas las versiones posteriores a la confirmación de restablecimiento se perderán para siempre, a menos que he hecho, como absolutamente debería, hacer una copia de seguridad de su repositorio, preferiblemente en la nube (por ejemplo, Google Drive ) entre otros lugares.

        
    13
    2017-05-23 11: 55: 13Z

    Intente restablecer el compromiso deseado -

    git reset <COMMIT_ID>

    (para verificar COMMIT_ID use git log)

    Esto restablecerá todos los archivos modificados al estado sin agregar.

    Ahora puedes checkout todos los archivos sin agregar por

    git checkout .

    Marque git log para verificar sus cambios.

    ACTUALIZAR

    Si tienes uno y solo confirmación en tu repositorio, prueba

    git update-ref -d HEAD

        
    13
    2018-04-17 10: 02: 40Z

    A medida que sus confirmaciones se empujan de forma remota, debe eliminarlas. Déjame asumir que tu rama está desarrollada y que está sobre el origen.

    Primero debes eliminar el desarrollo desde el origen:

     
    git push origin :develop (note the colon)
    

    Entonces necesitas desarrollarte al estado que deseas, déjame asumir que el hash de confirmación es EFGHIJK:

     
    git reset --hard EFGHIJK
    

    Por último, presiona desarrollar nuevamente:

     
    git push origin develop
    
        
    11
    2017-04-19 07: 18: 34Z
      

    ¡Precaución! Este comando puede hacer que se pierda el historial de confirmación, si el usuario coloca la confirmación errónea por error. Siempre tiene una copia de seguridad adicional de su git algunos   donde más, en caso de cometer errores, entonces es un poco más seguro.   :)

    He tenido un problema similar y quise volver al Commit anterior. En mi caso, no fui designado para mantener la confirmación más reciente, por lo tanto, utilicé Hard.

    Así es como lo hice:

     
    git reset --hard CommitId && git clean -f
    

    Esto se revertirá en el repositorio local, aquí después de usar git push -f se actualizará el repositorio remoto.

     
    git push -f
    
        
    11
    2018-02-02 13: 51: 57Z

    Si desea corregir algún error en la última confirmación, una buena alternativa seríaestar usando el comando git commit --amend . Si la última confirmación no es señalada por ninguna referencia, esto hará el truco, ya que creará una confirmación con el mismo padre que la última confirmación. Si no hay ninguna referencia al último compromiso, simplemente se descartará y este compromiso será el último compromiso. Esta es una buena manera de corregir las confirmaciones sin revertir las confirmaciones. Sin embargo tiene sus propias limitaciones.

        
    10
    2015-07-01 11: 35: 54Z
fuente colocada aquí