restaurar - ignorar cambios git

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

Question

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 en él 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 devolver el archivo a su estado anterior en el pasado.

Answer 1

git-aliases, awk y funciones de shell para el rescate!

git prevision <N> <filename>

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

git prevision -1 x/y/z.c

¿Cómo funciona la previsión git?

Agrega lo siguiente a tu 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
• elige el ID de confirmación adecuado en el historial del archivo y
• ejecuta una git checkout en el ID de confirmación 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

Answer 2

Aquí está mi camino.

a) En Android Studio, abre el archivo.

b) git -> Mostrar historial, encuentra el compromiso anterior al que quiero volver. Obtener el commit_id (es decir, cometer hash).

c) git checkout commit_id file_path

Answer 3

Así es como funciona el rebase :

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

Asume que tienes

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

Los dos primeros comandos ... cometer git checkout git rebase master

... verifique la rama de cambios que desea aplicar a la rama master . El comando rebase toma las confirmaciones de <my branch> (que no se encuentran en el master ) y las vuelve a aplicar al jefe del master . En otras palabras, el padre de la primera confirmación en <my branch> ya no es una confirmación anterior en el historial master , sino el jefe de master actual. Los dos comandos son los mismos que:

git rebase master <my branch>

Podría ser más fácil recordar este comando, ya que tanto las ramas "base" como "modificar" son explícitas.

. El resultado final de la historia es:

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

Los últimos dos comandos ...

git checkout master
git merge <my branch>

... haga una combinación de avance rápido para aplicar todos los cambios de <my branch> en el master . Sin este paso, la confirmación de rebase no se agrega al master . El resultado final es:

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

master y <my branch> ambos hacen referencia a B'' . Además, desde este punto es seguro eliminar la referencia <my branch> .

git branch -d <my branch>

Answer 4

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

A veces, solo desea volver y olvidarse de cada cambio después de cierto punto porque todos están equivocados.

Empezar con:

$ git log

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

A continuación, escriba:

$ git reset --hard SHA1_HASH

para restaurar el estado a un compromiso dado y borrar permanentemente todos los compromisos nuevos del registro.

Answer 5

Curiosamente, ''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

Answer 6

En el caso de que desee revertir un archivo a una confirmación anterior (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

Entonces simplemente ponga en escena y cometa la "nueva" versión.

Con el conocimiento de que un compromiso 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 de los dos funcionará si solo hay un padre en el árbol.

Answer 7

Esto funcionó para mí:

git checkout <commit hash> file

Luego cometa el cambio:

git commit -a

Answer 8

Muchas respuestas aquí afirman usar git reset ... <file> o git checkout ... <file> pero al hacerlo, perderá todas las modificaciones en <file> confirmadas después de la confirmación que desea revertir.

Si desea revertir los cambios de una confirmación en un solo archivo, de la misma manera que git revert haría pero solo para un archivo (o diga un subconjunto de los archivos de confirmación), sugiero que use git diff y git apply esa manera ( 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 en reversa 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).

Answer 9

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 debe tener el prefijo ./ si es una ruta relativa para git show $revision:$file para que funcione)

Y lo más raro aún:

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

Answer 10

Obviamente, alguien necesita escribir un libro inteligible sobre git, o git debe explicarse mejor en la documentación. Ante este mismo problema adiviné que

cd <working copy>
git revert master

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

Ian

Answer 11

Para ir a una versión de confirmación anterior del archivo, obtenga el número de confirmación, digamos eb917a1 y luego

git checkout eb917a1 YourFileName

Si solo necesitas volver a la última versión comprometida.

git reset HEAD YourFileName
git checkout YourFileName

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

Answer 12

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

Tengo una confirmación abc1 y después de eso he hecho varias (o una modificación) a un archivo file.txt .

Ahora diga que he estropeado algo en el archivo file.txt y quiero volver a un commit anterior abc1 .

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

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

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

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

Entre los pasos 2 y 3, por supuesto, puedes hacer el git status para entender lo que está sucediendo. Por lo general, debería ver el file.txt ya agregado y es por eso que no hay necesidad de git add un git add .

Answer 13

Primer cabezal de reinicio para archivo de destino

git reset HEAD path_to_file

Segundo checkout ese archivo

git checkout -- path_to_file

Answer 14

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

git diff <commit hash> <filename>

Luego, para revertir un archivo específico para ese compromiso, use el comando de reinicio:

git reset <commit hash> <filename>

Es posible que deba usar la opción --hard si tiene modificaciones locales.

Un buen flujo de trabajo para administrar puntos de ruta es usar etiquetas para marcar puntos de manera limpia en su línea de tiempo. No entiendo muy bien tu última oración, pero lo que podrías querer es divergir una rama de un punto anterior en el tiempo. Para hacer esto, use el práctico comando de pago:

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

Luego, puede volver a utilizarlo 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>

Answer 15

Puede usar cualquier referencia para 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]

Answer 16

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

1. árbol de código abierto, cambiar a este commit

2. cambia las líneas y encuentra tu confirmación de que el archivo incorrecto se envió como confirmación

3. Puedes ver la lista de tus cambios en ese compromiso.
4. selecciónelo y luego haga clic en ... botones del lado derecho ... haga clic en archivo inverso
5. luego, puede verlo en la pestaña de estado del archivo en la parte inferior izquierda y luego hacer clic en unstage:

6. abra su código de estudio visual y vuelva a cometer los archivos eliminados
7. Después de todos ellos, puede ver los resultados de su último compromiso en el árbol de origen.

Answer 17

Si está utilizando Git Extensions y solo desea volver a la confirmación primaria para el archivo, puede seleccionar la confirmación que contiene los cambios que desea revertir, luego seleccionar la pestaña ''Dif.'' En el panel de detalles, haga clic derecho el archivo que desea revertir, luego ''Restablecer archivo (s) a'' ...., luego ''A'' (el padre)

Answer 18

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

git checkout master~5 image.png

Esto supone que estás en la rama master y que la versión que quieres es de 5 confirmaciones.

Answer 19

Sin embargo, git checkout ./foo que git checkout ./foo y git checkout HEAD ./foo no son exactamente lo mismo; 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 etapas al archivo en el índice, pero no se confirma).

Git checkout ./foo significa revertir la ruta ./foo desde el índice ; agregar HEAD indica a Git que revierta esa ruta en el índice a su revisión HEAD antes de hacerlo.

Answer 20

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

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

La página de manual de git checkout da más información.

Si desea volver a la confirmación antes de c5f567 , agregue ~1 (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 para cosas comunes (cambiar entre ramas) y cosas inusuales y destructivas (descartar cambios en el directorio de trabajo).

Answer 21

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

eg revert foo/bar foo/baz

Answer 22

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

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 se compromete el resultado. El comando pregunta "Quiero revisar el archivo del estado registrado por el commit $ A".

Por otra parte, lo que quiso decir es deshacerse del cambio de la segunda iteración (es decir, comprometer $ B), mientras mantiene el compromiso que $ C hizo en el archivo, usted querría revertir $ B

$ git revert $B

Tenga en cuenta que quien haya creado el commit $ B puede no haber sido muy disciplinado y puede haber cometido un cambio no relacionado en el mismo commit, y esta reversión puede tocar otros archivos además de los que usted ve que ofenden cambios, por lo que puede querer verificar el resultado cuidadosamente después de hacerlo. asi que.

Answer 23

Tuve el mismo problema en este momento y encontré que esta respuesta es 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 antigua en su directorio de trabajo y desde allí puede confirmarla si lo desea.

Answer 24

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

Nota: No te olvides de escribir el hash antes del último. El último hash apunta a su posición actual (HEAD) y no cambia nada.

Answer 25

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

git checkout HEAD file/to/restore

Answer 26

git checkout ref | commitHash - filePath

p.ej

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

Answer 27

Puede hacerlo en 4 pasos:

1. revertir la confirmación completa con el archivo que desea revertir específicamente: creará una nueva confirmación en su rama
2. reinicio por software que confirma: elimina la confirmación y mueve los cambios al área de trabajo
3. Escoge los archivos para revertir y cometerlos.
4. levantar todos los archivos en su área de trabajo

Lo que necesitas para escribir en tu terminal :

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

buena suerte

Answer 28

git checkout -- foo

Eso restablecerá foo a HEAD. Tú también puedes:

git checkout HEAD^ foo

para una revisión atrás, etc.

Answer 29

git revert <hash>

Revertirá un commit dado. Parece que piensas que git revert solo afecta al commit más reciente.

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