Revirtiendo la Copia de Trabajo a la Confirmación Más Reciente

Para volver a un commit anterior, ignorando cualquier cambio:

git reset --hard HEAD

Donde HEAD es la última confirmación en tu rama actual

Revirtiendo la Copia de Trabajo a una Confirmación Anterior

Para volver a un commit que es más antiguo que el commit 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 de desbordamiento de pila similar, ¿Revertir a un commit mediante un hash SHA en Git?.

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 back hasta el hash commit, lo que significa que recreará ese estado de commit en el árbol de trabajo como si cada commit desde entonces hubiera sido devuelto. Luego puede confirmar el árbol actual, y creará un nuevo commit esencialmente equivalente al commit al que" revirtió".

(La bandera --no-commit permite a git revertir todas las confirmaciones a la vez, de lo contrario se te pedirá un mensaje para cada confirmación en el rango, llenando tu historial con nuevas confirmaciones innecesarias.)

Esta es una manera segura y fácil de revertir a un estado anterior. Ningún historial es destruido, por lo que puede ser usado para commits que ya han sido hechos públicos.

La mejor opción para mí y probablemente para otros es la opción Git reset:

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 mencionó en los comentarios, no hagas esto si estás compartiendo tu rama con otras personas que tienen copias de las confirmaciones antiguas

También de los comentarios, si querías un método menos 'ballzy' podrías usar

git clean -i

Antes de responder vamos a añadir algunos antecedentes, explicando lo que esto HEAD es.

First of all what is HEAD?

HEAD es simplemente una referencia al commit actual (latest) en la rama actual. Solo puede haber un único 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 usted no está en el última confirmación-lo que significa que HEAD está apuntando a una confirmación anterior en la historia a la que se llama detached HEAD.

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

Algunas opciones sobre cómo recuperarse de una CABEZA separada:

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 se realizará nueva rama que apunta a la confirmación deseada. Este comando descargará a un commit dado.

En este punto puede crear una rama y comenzar a trabajar a partir de este punto:

# 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. git reflog mostrará cualquier cambio que actualice el HEAD y al revisar la entrada de reflog deseada, el HEAD volverá a esta confirmación.

Cada vez que se modifique la CABEZA habrá una nueva entrada en el reflog

git reflog
git checkout HEAD@{...}

Esto te devolverá a tu confirmación deseada

git reset HEAD --hard <commit_id>

"Mueve" tu cabeza hacia atrás a 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 puedes usar git rebase --no-autostash.

Este esquema ilustra qué comando hace qué. Como se puede ver allí reset && checkout modificar el HEAD.

Si desea "descomit", borrar el último mensaje de confirmación y volver a poner los archivos modificados en staging, usaría el comando:

git reset --soft HEAD~1

• --soft indica que los archivos no comprometidos deben conservarse como archivos de trabajo en lugar de --hard que los descartaría.
• HEAD~1 es la última confirmación. Si quieres revertir 3 confirmaciones puedes usar HEAD~3. Si desea revertir a un número de revisión específico, también podría hacerlo usando su hash SHA.

Esto es un comando extremadamente útil en situaciones en las que has cometido algo incorrecto y quieres deshacer ese último commit.

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

He intentado muchas maneras de revertir los cambios locales en Git, y parece que esto funciona mejor si solo desea revertir al último estado de confirmación.

git add . && git checkout master -f

Breve descripción:

• NO creará ninguna confirmación como lo hace git revert.
• NO te separará la CABEZA como lo hace git checkout <commithashcode>.
• Anulará todos sus cambios locales y ELIMINARÁ todos los archivos agregados desde la última confirmación en la rama.
• Solo funciona con nombres de ramas, por lo que puede revertir solo a la última confirmación en la rama 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 sugirió boulder_ruby, pero he agregado 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, creo cuando revierte a la última confirmación.

Puede hacer esto mediante los siguientes dos comandos:

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

Eliminará tu confirmación de Git anterior.

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

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

Entonces guardará sus cambios.

Digamos que tienes 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 devuelve todo al estado anterior, incluidas las creaciones de archivos y directorios, y las eliminaciones, lo confirma en su rama y conserva el historial, pero lo hace volver a la misma estructura de archivos. Por qué Git no tiene un git revert --to <hash> está más allá de mí.

Alternativas adicionales a las Soluciones de Jefromi

Las soluciones de Jefromi son definitivamente las mejores, y definitivamente deberías 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 commit (en el sentido de que crea un nuevo commit que deshace los cambios en el commit anterior, al igual que lo hace git revert).

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

Alternativa 1: Reinicios duros y blandos

Esta es una versión muy ligeramente modificada de la solución de Charles Bailey para Revertir 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 reseteos suaves dejarán el estado de la confirmación anterior en el estado index / staging-área, que luego puede confirmar.

Alternativa 2: Eliminar el Árbol Actual y Reemplazarlo por el Nuevo

Esta solución viene de la solución de svick para Checkout old commit y hacer que sea una nueva confirmación :

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

Aquí hay una mucho más simple manera de volver a un commit anterior (y tenerlo en un estado no comprometido, para hacer con él lo que quieras):

git reset HEAD~1

Por lo tanto, no hay necesidad de identificadores de confirmación y así sucesivamente:)

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>

Explain: usando git reset, puedes restablecer a un estado específico, es común usarlo con un hash de confirmación como ves arriba.

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

Soft suave

La bandera predeterminada como se ha explicado, no es necesario proporcionarla, no cambia el árbol de trabajo, sino que agrega todos los archivos de cambios listos para confirmar, por lo que vuelve al estado de confirmación, que los cambios en los archivos no se editan.

Hard duro

Tenga cuidado con esta bandera, se restablece el árbol de trabajo y todos los cambios a los archivos rastreados y todo se habrá ido!

También he creado la imagen de abajo que puede suceder en una vida real trabajando con git:

Asumiendo que estás hablando de master y en esa rama respectiva (dicho esto, esta podría ser cualquier rama de trabajo que te interese):

# Revert local master branch to November 3rd commit ID
git reset --hard 0d1d7fc32e5a947fbd92ee598033d85bfc445a50

# Revert remote master branch to November 3rd commit ID
git push -f origin 0d1d7fc32e5a947fbd92ee598033d85bfc445a50:master

Encontré la respuesta en la entrada del blogEliminar repositorio Git remoto a confirmación específica.

Nada aquí funcionó para mí aparte de esta combinación exacta:

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

La clave aquí es forzar el push, no hay confirmaciones adicionales / mensajes de confirmación, etc.

Después de todos los cambios, cuando presione todos estos comandos, puede que tenga que usar:

git push -f ...

Y no solo git push.

Hay un comando (no es parte del núcleo de Git, pero está en el paquete git-extras) específicamente para revertir y organizar confirmaciones antiguas:

git back

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

# Remove the latest three commits
git back 3

Seleccione su confirmación requerida, y compruébela por

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

Hasta que obtengas la confirmación requerida. Para hacer el punto PRINCIPAL a eso, haga

git reset --hard HEAD~1

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

Volver a más reciente confirmar e ignorar todos los cambios locales:

git reset --hard HEAD

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 descartar todos los cambios, haga:

git reset --hard <SHA>

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

git add -A .
git reset --hard HEAD

Solo git reset --hard HEAD se deshará de las modificaciones, pero no se deshará de los archivos "nuevos". En su caso, habían arrastrado accidentalmente una carpeta importante a algún lugar aleatorio, y todos esos archivos estaban siendo tratados como nuevos por Git, por lo que un reset --hard no lo arregló. Al ejecutar el git add -A . de antemano, los rastreó explícitamente con git, para ser eliminados por el reinicio.

Esta es una forma más de restablecer directamente a una confirmación reciente

git stash
git stash clear

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

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

Creo que algunas personas pueden llegar a esta pregunta queriendo saber cómo revertir los cambios confirmados que han hecho en su maestro, es decir, tirar todo y volver a origin / master, en cuyo caso, haga esto:

git reset --hard origin/master

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

Puedes completar todos estos pasos iniciales tú mismo y volver a git repo.

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

2. Ejecute el comando git log con-n 4 desde su 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 la cabecera del historial de tu repositorio usando git reset --hard HEAD~N donde N es el número de confirmaciones que desea recuperar la cabeza. En el ejemplo siguiente la cabeza sería puesta detrás uno commit, hasta el último commit en el historial del repositorio:

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

Si quieres que el repositorio git sea un commit anterior

git pull --all
git reset --hard HEAD~1
git push --force

Revert es el comando para revertir las confirmaciones.

git revert <commit1> <commit2> 

Muestra:

git revert 2h3h23233

Es capaz de tomar distancia desde la CABEZA como abajo. Aquí 1 dice " revertir la última confirmación."

git revert HEAD~1..HEAD

Y luego hacer git push

Si la situación es urgente , y solo desea hacer lo que el interlocutor pidió de una manera rápida y sucia , asumiendo que su proyecto está bajo el directorio "mi proyecto":

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

2. Do:

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

Entonces 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. Puedes deseche completamente los archivos bajo "mi proyecto-copiar", si ha decidido que el nuevo trabajo no iba a ninguna parte...

Lo obvio si desea continuar con el estado del proyecto sin descartar realmente el trabajo desde este commit recuperado es cambiar el nombre de su directorio de nuevo: Elimine el proyecto que contiene el commit recuperado (o darle un nombre temporal) y cambie el nombre de su directorio "mi proyecto - copiar" a "mi proyecto". Entonces probablemente hacer otro commit bastante pronto.

Git es una creación brillante, pero no se puede simplemente "recogerlo sobre la marcha": también las personas que tratan de explicarlo con demasiada frecuencia asumen el conocimiento previo de otros VCS [Sistemas de Control de Versiones] y profundizan demasiado, demasiado pronto, y cometen otros delitos, como el uso de términos intercambiables para "checking out", de maneras que a veces parecen casi calculadas para confundir a un principiante.

Para ahorrarte mucho estrés tienes que leer un libro sobre Git-I'd recomienda "Control de versiones con Git". Y si puedes confiar en mí (o más bien en mis cicatrices) cuando digo "tengo que", se deduce que también podrías hacerlo AHORA. Gran parte de la complejidad de Git proviene de la ramificación y luego la refundición. Pero de tu pregunta no hay ninguna razón por la cual la gente debería cegarte con la ciencia.

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

PS: otro pensamiento: es (ahora) en realidad es bastante simple mantener el repositorio Git ("repo") en un directorio que no sea el que tiene los archivos de trabajo. Esto significaría que no tendría que copiar todo el repositorio Git utilizando la solución quick & dirty anterior. Vea la respuesta de Fryer usando separate separate-git-dir aquí. Tenga en cuenta, sin embargo: Si tiene un repositorio "separate-directory" que no copia, y hace un reinicio completo, todas las versiones posteriores a la confirmación de reinicio se perderán para siempre, a menos que tener, como es absolutamente necesario, una copia de seguridad regular de su repositorio, preferiblemente en la nube (por ejemplo, Google Drive), entre otros lugares.

Intente restablecer la confirmación deseada -

git reset <COMMIT_ID>

(para comprobar COMMIT_ID use git log)

Esto restablecerá todos los archivos cambiados al estado no agregado.

Ahora puede checkout todos los archivos sin agregar por

git checkout .

Marque git log para verificar sus cambios.

UPDATE

Si tienes uno y solo commit en tu repositorio, prueba

git update-ref -d HEAD

Como tus commits se envían de forma remota, necesitas eliminarlos. Déjame asumir que tu rama es develop y es empujada sobre origin.

Primero debe eliminar el desarrollo del origen:

git push origin :develop (note the colon)

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

git reset --hard EFGHIJK

Por último, empuje desarrollar de nuevo:

git push origin develop

Si quieres corregir algún error en la última confirmación, una buena alternativa sería usar el comando git commit amend amend. Si el último commit no es apuntado por ninguna referencia, esto hará el truco, ya que crea un commit con el mismo padre que el último commit. Si no hay referencia a la última confirmación, simplemente será descartada y esta confirmación será la última confirmación. Esta es una buena manera de corregir commits sin revertir commits. Sin embargo tiene sus propias limitaciones.

Precaución! Este comando puede causar la pérdida del historial de confirmaciones, si el usuario pone la confirmación incorrecta por error. Siempre tener una copia de seguridad adicional de su git algunos ¿dónde más por si acaso si haces errores, que estás un poco más seguro. :)

He tenido un problema similar y quería volver a la confirmación anterior. En mi caso yo no estaba intetessered para mantener nuevos commit por lo tanto usé Hard.

Así es como lo hice:

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

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

git push -f

Primero, obtenga la cadena que identifica la confirmación en alguna fecha, haciendo:

git rev-list -n 1 --before="2009-07-27 13:37" origin/master

Imprime el identificador de confirmación, toma la cadena (por ejemplo XXXX) y haz:

git checkout XXXX