¿Restablecer o revertir un archivo específico a una revisión específica usando Git?

StackOverflow https://stackoverflow.com/questions/215718

Pregunta

He realizado algunos cambios en un archivo que se ha confirmado varias veces como parte de un grupo de archivos, pero ahora quiero restablecer/revertir los cambios a una versión anterior.

he hecho un git log junto con un git diff para encontrar la revisión que necesito, pero no tengo idea de cómo hacer que el archivo vuelva a su estado anterior.

¿Fue útil?

Solución

Suponiendo que el hash de la confirmación que desea es c5f567: 

git checkout c5f567 -- file1/to/restore file2/to/restore

La página del manual git checkout ofrece más información.

Si desea volver a la confirmación antes de ~1, agregue <=> (funciona con cualquier número): 

git checkout c5f567~1 -- file1/to/restore file2/to/restore

Como nota al margen, siempre me he sentido incómodo con este comando porque se usa tanto para cosas comunes (cambio entre ramas) como para cosas inusuales y destructivas (descartando cambios en el directorio de trabajo).

Otros consejos

Puede revisar rápidamente los cambios realizados en un archivo utilizando el comando diff: 

git diff <commit hash> <filename>

Luego, para revertir un archivo específico a ese commit, use el comando reset: 

git reset <commit hash> <filename>

Puede que necesite usar la opción --hard si tiene modificaciones locales.

Un buen flujo de trabajo para administrar puntos de referencia es usar etiquetas para marcar puntos en su línea de tiempo. No puedo entender tu última oración, pero lo que puedes desear es divergir una rama de un punto anterior en el tiempo. Para hacer esto, use el útil comando de pago: 

git checkout <commit hash>
git checkout -b <new branch name>

A continuación, puede volver a redactar eso en su línea principal cuando esté listo para combinar esos cambios: 

git checkout <my branch>
git rebase master
git checkout master
git merge <my branch>

Puede usar cualquier referencia a un git commit, incluido el SHA-1 si es más conveniente. El punto es que el comando se ve así:

git checkout [commit-ref] -- [filename] 

git checkout -- foo

Eso restablecerá foo a HEAD. También puedes: 

git checkout HEAD^ foo

para una revisión, etc.

Y para volver a la última versión confirmada, que se necesita con mayor frecuencia, puede usar este comando más simple. 

git checkout HEAD file/to/restore

Tuve el mismo problema en este momento y encontré esta respuesta más fácil de entender (commit-ref es el valor SHA del cambio en el registro al que desea volver): 

git checkout [commit-ref] [filename]

Esto colocará esa versión anterior en su directorio de trabajo y desde allí puede confirmarla si lo desea.

Si sabe cuántas confirmaciones necesita volver, puede usar: 

git checkout master~5 image.png

Esto supone que está en la rama master, y la versión que desea es 5 confirmaciones.

Creo que lo he encontrado ... de http : //www-cs-students.stanford.edu/~blynn/gitmagic/ch02.html

A veces solo quieres regresar y olvidarte de cada cambio pasado un cierto punto porque todos están equivocados.

Comience con:

$ git log

que le muestra una lista de confirmaciones recientes y sus hashes SHA1.

A continuación, escriba:

$ git reset --hard SHA1_HASH

para restaurar el estado a una confirmación determinada y borrar todas las confirmaciones más nuevas del registro de forma permanente.

Esto funcionó para mí: 

git checkout <commit hash> file

Luego confirma el cambio: 

git commit -a

Debe tener cuidado al decir " rollback " ;. Si solía tener una versión de un archivo en commit $ A, y luego realizó dos cambios en dos commits separados $ B y $ C (entonces lo que está viendo es la tercera iteración del archivo), y si dice < !> quot; Quiero volver al primero " ;, ¿lo dices en serio?

Si desea deshacerse de los cambios tanto en la segunda como en la tercera iteración, es muy simple: 

$ git checkout $A file

y luego confirmas el resultado. El comando pregunta & Quot; Quiero verificar el archivo del estado registrado por el commit $ A & Quot ;.

Por otro lado, lo que quiso decir es deshacerse del cambio que introdujo la segunda iteración (es decir, commit $ B), mientras mantiene lo que commit $ C hizo en el archivo, querrá revertir $ B 

$ git revert $B

Tenga en cuenta que cualquiera que haya creado commit $ B puede no haber sido muy disciplinado y haber cometido cambios totalmente no relacionados en el mismo commit, y esta reversión puede tocar archivos que no sean file y verá cambios ofensivos, por lo que es posible que desee verificar el resultado cuidadosamente después de hacerlo.

Divertidamente, git checkout foo no funcionará si la copia de trabajo está en un directorio llamado foo; sin embargo, tanto git checkout HEAD foo como git checkout ./foo: 

$ pwd
/Users/aaron/Documents/work/foo
$ git checkout foo
D   foo
Already on "foo"
$ git checkout ./foo
$ git checkout HEAD foo

Así es cómo rebase obras:

git checkout <my branch>
git rebase master
git checkout master
git merge <my branch>

Supongamos que tienes

---o----o----o----o  master
    \---A----B       <my branch>

Los dos primeros comandos...cometer git checkout git Rebase Master

...consulte la rama de cambios que desea aplicar al master rama.El rebase El comando toma las confirmaciones de <my branch> (que no se encuentran en master) y los vuelve a aplicar al jefe de master.En otras palabras, el padre del primer compromiso en <my branch> ya no es un compromiso anterior en el master historia, pero el actual jefe de master.Los dos comandos son iguales a:

git rebase master <my branch>

Puede que sea más fácil recordar este comando ya que tanto la rama "base" como la "modificación" son explícitas.

.El resultado final de la historia es:

---o----o----o----o   master
                   \----A'----B'  <my branch>

Los dos últimos comandos...

git checkout master
git merge <my branch>

...hacer una fusión rápida para aplicar todo <my branch> cambia a master.Sin este paso, la confirmación de rebase no se agrega a master.El resultado final es:

---o----o----o----o----A'----B'  master, <my branch>

master y <my branch> ambas referencias B'.Además, desde este punto es seguro eliminar el <my branch> referencia.

git branch -d <my branch>

Primero restablecer la cabeza para el archivo de destino 

git reset HEAD path_to_file

Segunda comprobación de ese archivo 

git checkout -- path_to_file
  ¡

git-aliases, awk y funciones de shell al rescate! 

git prevision <N> <filename>

donde <N> es el número de revisiones del archivo a revertir para el archivo <filename>.
Por ejemplo, para pagar la revisión previa inmediata de un solo archivo x/y/z.c, ejecute 

git prevision -1 x/y/z.c

¿Cómo funciona la previsión git?

Agregue lo siguiente a su gitconfig 

[alias]
        prevision = "!f() { git checkout `git log --oneline $2 |  awk -v commit="$1" 'FNR == -commit+1 {print $1}'` $2;} ;f"
  

El comando básicamente

     
      
  • realiza un git log en el archivo especificado y
    •   
  • selecciona el id de confirmación apropiado en el historial del archivo y
    •   
  • ejecuta un git checkout al commit-id para el archivo especificado.
    •   

Esencialmente, todo lo que uno haría manualmente en esta situación,
envuelto en un hermoso y eficiente git-alias - git-prevision

Tengo que conectar EasyGit aquí, que es un envoltorio para hacer que git sea más accesible para principiantes sin confundir a los usuarios experimentados. Una de las cosas que hace es da más significados a git revert . En este caso, simplemente diría:

eg revert foo/bar foo/baz

En el caso de que desee revertir un archivo a una confirmación previa (y el archivo que desea revertir ya confirmado) puede usar 

git checkout HEAD^1 path/to/file

o 

git checkout HEAD~1 path/to/file

Luego simplemente ponga en escena y confirme el " new " versión.

Armado con el conocimiento de que un commit puede tener dos padres en el caso de una fusión, debe saber que HEAD ^ 1 es el primer padre y HEAD ~ 1 es el segundo padre.

Cualquiera funcionará si solo hay un padre en el árbol.

Tenga en cuenta, sin embargo, que git checkout ./foo y git checkout HEAD ./foono son exactamente la misma cosa;caso en punto:

$ echo A > foo
$ git add foo
$ git commit -m 'A' foo
Created commit a1f085f: A
1 files changed, 1 insertions(+), 0 deletions(-)
create mode 100644 foo
$ echo B >> foo
$ git add foo
$ echo C >> foo
$ cat foo
A
B
C
$ git checkout ./foo
$ cat foo
A
B
$ git checkout HEAD ./foo
$ cat foo
A

(El segundo add coloca el archivo en el índice, pero lo hace no comprometerse.)

Git checkout ./foo significa revertir el camino ./foo desde el índice;agregando HEAD le indica a Git que revierta esa ruta en el índice a suHEAD revisión antes de hacerlo.

Muchas sugerencias aquí, la mayoría en la línea de git checkout $revision -- $file. Un par de alternativas oscuras: 

git show $revision:$file > $file

Y también, lo uso mucho solo para ver una versión particular temporalmente: 

git show $revision:$file

o 

git show $revision:$file | vim -R -

(OBS: $file necesita tener el prefijo ./ si es una ruta relativa para que git show $revision:$file funcione)

Y lo más extraño: 

git archive $revision $file | tar -x0 > $file

Para mí, ninguna de las respuestas me pareció muy clara y, por lo tanto, me gustaría agregar la mía, que parece súper fácil.

tengo un compromiso abc1 y después he hecho varias (o una modificación) a un archivo file.txt.

Ahora di que estropeé algo en el archivo. file.txt y quiero volver a un compromiso anterior abc1.

1.git checkout file.txt :esto eliminará los cambios locales, si no los necesita

2.git checkout abc1 file.txt :esto traerá su archivo a su buscado versión

3.git commit -m "Restored file.txt to version abc1" :esto comprometerá su reversión.

  1. git push :esto empujará todo en el repositorio remoto

Entre el paso 2 y 3 por supuesto que puedes hacer git status para entender lo que está pasando.Normalmente deberías ver el file.txt ya agregado y es por eso que no hay necesidad de un git add.

Para ir a una versión de confirmación anterior del archivo, obtenga el número de confirmación, diga eb917a1 entonces 

git checkout eb917a1 YourFileName

Si solo necesita volver a la última versión confirmada 

git reset HEAD YourFileName
git checkout YourFileName

Esto simplemente lo llevará al último estado confirmado del archivo

git checkout ref | commitHash - filePath

p. 

git checkout HEAD~5 -- foo.bar
or 
git checkout 048ee28 -- foo.bar

Use git log para obtener la clave hash para una versión específica y luego use git checkout <hashkey>

Nota: No olvides escribir el hash antes del último. El último hash señala tu posición actual (HEAD) y no cambia nada.

Muchas respuestas aquí afirman usar git reset ... <file> o git checkout ... <file> pero al hacerlo, perderá todas las modificaciones en <file> comprometido después del compromiso que desea revertir.

Si desea revertir los cambios de una confirmación en un solo archivo, tal como git revert funcionaría, pero solo para un archivo (o digamos un subconjunto de los archivos de confirmación), sugiero usar ambos git diff y git apply así (con <sha> = el hash de la confirmación que desea revertir):

git diff <sha>^ <sha> path/to/file.ext | git apply -R

Básicamente, primero generará un parche correspondiente a los cambios que desea revertir y luego aplicará el parche de manera inversa para eliminar esos cambios.

Por supuesto, no funcionará si las líneas revertidas han sido modificadas por cualquier confirmación entre <sha1> y HEAD (conflicto).

Obviamente, alguien necesita escribir un libro inteligible sobre git o git necesita ser mejor explicado en la documentación. Ante este mismo problema, supuse que 

cd <working copy>
git revert master

deshacería la última confirmación que parece hacer.

Ian

si confirma un archivo incorrecto en sus últimas confirmaciones, siga las instrucciones:

  1. árbol de código abierto, cambie a esta confirmación

árbol de código abierto

  1. cambie las líneas y encuentre su confirmación de que el archivo incorrecto se envió como confirmación

ingrese la descripción de la imagen aquí

  1. puede ver la lista de sus cambios en esa confirmación lista de archivos en el árbol de origen
  2. selecciónelo y luego haga clic en ... botones del lado derecho ... haga clic en el archivo inverso
  3. entonces puede verlo en la pestaña de estado del archivo en la parte inferior izquierda luego haga clic en unstage:

pestaña de estado del archivo

  1. abra su código visual de estudio y vuelva atrás al confirmar los archivos eliminados
  2. después de todos, puede ver los resultados en su última confirmación en el árbol de origen

ingrese la descripción de la imagen aquí

Este es un paso muy simple. Revise el archivo para la identificación de confirmación que queremos, aquí hay una identificación de confirmación antes, y luego solo git commitmend y hemos terminado. 

# git checkout <previous commit_id> <file_name>
# git commit --amend

Esto es muy útil. Si queremos llevar cualquier archivo a cualquier ID de confirmación anterior en la parte superior de la confirmación, podemos hacerlo fácilmente.

  1. Git revierte el archivo a una confirmación específica
  

git checkout Last_Stable_commit_Number - fileName

2.Git revierte el archivo a una rama específica 

git checkout branchName_Which_Has_stable_Commit fileName

git revert <hash>

Revertirá una confirmación dada. Parece que cree que git revert solo afecta la confirmación más reciente.

Eso no resuelve su problema, si desea revertir un cambio en un archivo específico y esa confirmación cambió más que ese archivo.

Puede hacerlo en 4 pasos:

  1. revierte todo el commit con el archivo que deseas revertir específicamente: creará un nuevo commit en tu rama
  2. restablecimiento parcial de esa confirmación: elimina la confirmación y mueve los cambios al área de trabajo
  3. seleccione manualmente los archivos para revertirlos y confirmarlos
  4. suelte todos los demás archivos en su área de trabajo

Lo que necesita escribir en su terminal :

  1. git revert <commit_hash>
  2. git reset HEAD~1
  3. git add <file_i_want_to_revert> & amp; & amp; git commit -m 'reverting file'
  4. git checkout .

buena suerte

Aquí está mi camino.

a) En Android Studio, abra el archivo.

b) git - > Mostrar historial, buscar el compromiso anterior al que quiero volver. Obtenga commit_id (es decir, commit hash).

c) git checkout commit_id file_path

Licenciado bajo: CC-BY-SA con atribución
No afiliado a StackOverflow
scroll top