Digamos que estoy en un repositorio Git. Elimino un archivo y confirmo ese cambio. Sigo trabajando y hago algunos compromisos más. Entonces, encuentro que necesito restaurar ese archivo.

Sé que puedo retirar un archivo usando git checkout HEAD^ foo.bar, pero realmente no sé cuándo se eliminó ese archivo.

1. ¿Cuál sería la forma más rápida de encontrar la confirmación que eliminó un nombre de archivo dado?
2. ¿Cuál sería la forma más fácil de recuperar ese archivo en mi copia de trabajo?

Espero no tener que buscar manualmente mis registros, pagar el proyecto completo para un SHA determinado y luego copiar manualmente ese archivo en mi pago original del proyecto.

Encuentra el último commit que afectó la ruta dada. Como el archivo no está en la confirmación HEAD, esta confirmación debe haberlo eliminado.

git rev-list -n 1 HEAD -- <file_path>

Luego revise la versión en el commit antes, usando el cursor (^ símbolo ):

git checkout <deleting_commit>^ -- <file_path>

O en un comando, si $filees el archivo en cuestión.

git checkout $(git rev-list -n 1 HEAD -- "$file")^ -- "$file"

Si está utilizando zsh y tiene habilitada la opción EXTENDED_GLOB, el símbolo de intercalación no funcionará. Puedes usar ~1en su lugar.

git checkout $(git rev-list -n 1 HEAD -- "$file")~1 -- "$file"

1. Utilizar git log --diff-filter=D --summary para obtener todos los commits que han eliminado archivos y los archivos eliminados;
2. Use git checkout $commit~1 path/to/file.extpara restaurar el archivo eliminado.

¿Dónde $commitestá el valor de la confirmación que has encontrado en el paso 1, por ejemplo,e4cf499627

Para restaurar todos esos archivos eliminados en una carpeta, ingrese el siguiente comando.

git ls-files -d | xargs git checkout --

Llegué a esta pregunta buscando restaurar un archivo que acabo de eliminar pero aún no había confirmado el cambio. En caso de que se encuentre en esta situación, todo lo que necesita hacer es lo siguiente:

git checkout HEAD -- path/to/file.ext

Si estás loco, úsalo git-bisect. Esto es lo que debes hacer:

git bisect start
git bisect bad
git bisect good <some commit where you know the file existed>

Ahora es el momento de ejecutar la prueba automatizada. El comando de shell '[ -e foo.bar ]'devolverá 0 si foo.barexiste, y 1 de lo contrario. El comando "ejecutar" git-bisectutilizará la búsqueda binaria para encontrar automáticamente la primera confirmación donde falla la prueba. Comienza a la mitad del rango dado (de bueno a malo) y lo reduce a la mitad según el resultado de la prueba especificada.

git bisect run '[ -e foo.bar ]'

Ahora estás en el commit que lo eliminó. Desde aquí, puede volver al futuro y usar git-revertpara deshacer el cambio,

git bisect reset
git revert <the offending commit>

o podría retroceder un commit e inspeccionar manualmente el daño:

git checkout HEAD^
cp foo.bar /tmp
git bisect reset
cp /tmp/foo.bar .

Mi nuevo alias favorito, basado en bonyiii 's respuesta (upvoted), y mi propia respuesta acerca de ' pasar un argumento a un comando de alias Git ':

git config alias.restore '!f() { git checkout $(git rev-list -n 1 HEAD -- $1)~1 -- $(git diff --name-status $(git rev-list -n 1 HEAD -- $1)~1 | grep '^D' | cut -f 2); }; f'

¿Perdí un archivo, lo borré por error hace algunos commits?
Rápido:

git restore my_deleted_file

Crisis evitada.

Advertencia, con Git 2.23 (Q3 2019) viene el comando experimental llamado git restore(!).
Así que cambie el nombre de este alias (como se muestra a continuación).

Robert Dailey propone en los comentarios el siguiente alias:

restore-file = !git checkout $(git rev-list -n 1 HEAD -- "$1")^ -- "$1"

Y jegan agrega en los comentarios :

Para configurar el alias desde la línea de comando, utilicé este comando:

git config --global alias.restore "\!git checkout \$(git rev-list -n 1 HEAD -- \"\$1\")^ -- \"\$1\"" 

Si conoce el nombre de archivo, esta es una manera fácil con comandos básicos:

Enumere todas las confirmaciones para ese archivo.

git log -- path/to/file

La última confirmación (la más alta) es la que eliminó el archivo. Por lo tanto, debe restaurar la penúltima confirmación.

git checkout {second to last commit} -- path/to/file

Para restaurar un archivo borrado y comprometido:

git reset HEAD some/path
git checkout -- some/path

Fue probado en Git versión 1.7.5.4.

Si solo realizó cambios y eliminó un archivo, pero no lo confirmó, y ahora rompió con sus cambios

git checkout -- .

pero sus archivos borrados no regresaron, simplemente ejecuta el siguiente comando:

git checkout <file_path>

Y listo, tu archivo está de vuelta.

Tengo esta solución .

1. Obtenga la identificación de la confirmación donde se eliminó el archivo utilizando una de las siguientes formas.

   • git log --grep=*word*
   • git log -Sword
   • git log | grep --context=5 *word*
   • git log --stat | grep --context=5 *word* # recomendado si apenas recuerda algo

2. Deberías obtener algo como:

commit bfe68bd117e1091c96d2976c99b3bcc8310bebe7 Autor: Alexander Orlov Fecha: jue 12 de mayo 23:44:27 2011 +0200

replaced deprecated GWT class
- gwtI18nKeySync.sh, an outdated (?, replaced by a Maven goal) I18n generation script

commit 3ea4e3af253ac6fd1691ff6bb89c964f54802302 Autor: Alexander Orlov Fecha: jue 12 de mayo 22:10:22 2011 +0200

3 . Ahora, usando el commit id bfe68bd117e1091c96d2976c99b3bcc8310bebe7 do:

git checkout bfe68bd117e1091c96d2976c99b3bcc8310bebe7^1 yourDeletedFile.java

Como el ID de confirmación hace referencia a la confirmación donde ya se eliminó el archivo, debe hacer referencia a la confirmación justo antes de bfe68b, lo que puede hacer agregando ^1. Esto significa: dame el commit justo antes de bfe68b.

git checkout /path/to/deleted.file

git undelete path/to/file.ext

1. Ponga esto en su .bash_profile(u otro archivo relevante que se carga cuando abre un shell de comandos):

   git config --global alias.undelete '!sh -c "git checkout $(git rev-list -n 1 HEAD -- $1)^ -- $1" -'
   

2. Luego use:

   git undelete path/to/file.ext
   

Este alias primero comprueba para encontrar la última confirmación donde existió este archivo, y luego realiza un pago Git de esa ruta de archivo desde la última confirmación donde existió este archivo. Fuente .

En muchos casos, puede ser útil usar coreutils (grep, sed, etc.) junto con Git. Ya conozco estas herramientas bastante bien, pero Git no tanto. Si quisiera hacer una búsqueda de un archivo eliminado, haría lo siguiente:

git log --raw | grep -B 30 $'D\t.*deleted_file.c'

Cuando encuentro la revisión / commit:

git checkout <rev>^ -- path/to/refound/deleted_file.c

Al igual que otros han dicho antes que yo.

El archivo ahora se restaurará al estado que tenía antes de eliminarlo. Recuerde volver a confirmarlo en el árbol de trabajo si desea conservarlo.

Tuve que restaurar un montón de archivos eliminados de una confirmación específica, y lo logré con dos comandos:

git show <rev> --diff-filter=D --summary --name-only --no-commit-id | xargs git checkout <rev>^ -- 
git show <rev> --diff-filter=D --summary --name-only --no-commit-id | xargs git reset HEAD 

(Tenga en cuenta el espacio final al final de cada comando).

Los archivos se agregaron al archivo .gitignore y luego se borraron con git rm. Necesitaba restaurar los archivos, pero luego quitarlos del escenario. Tenía cientos de archivos para restaurar, y escribir cosas manualmente para cada archivo como en los otros ejemplos iba a ser demasiado lento.

En realidad, esta pregunta es directamente sobre Git, pero alguien como yo trabaja con herramientas de GUI como WebStorm VCS además de conocer los comandos de Git CLI.

Hago clic derecho en la ruta que contiene el archivo eliminado, y luego voy a Git y luego hago clic en Mostrar historial .

Las herramientas de VCS muestran el tren de todas las revisiones y puedo ver todos los compromisos y cambios de cada uno de ellos.

Luego selecciono las confirmaciones de que mi amigo elimine el PostAd.jsarchivo. ahora mira abajo:

Y ahora, puedo ver mi archivo de deseo eliminado. Simplemente hago doble clic en el nombre del archivo y se recupera.

Sé que mi respuesta no son comandos Git, pero es rápido, confiable y fácil para desarrolladores principiantes y profesionales. Las herramientas de WebStorm VCS son increíbles y perfectas para trabajar con Git y no necesita ningún otro complemento o herramientas.

Tenía la misma pregunta. Sin saberlo, había creado una confirmación pendiente .

Lista de confirmaciones pendientes

git fsck --lost-found

Inspeccione cada confirmación pendiente

git reset --hard <commit id>

Mis archivos reaparecieron cuando me mudé a la confirmación pendiente.

git status por la razón:

“HEAD detached from <commit id where it detached>”

user@bsd:~/work/git$ rm slides.tex
user@bsd:~/work/git$ git pull 
Already up-to-date.
user@bsd:~/work/git$ ls slides.tex
ls: slides.tex: No such file or directory

Restaurar el archivo eliminado:

user@bsd:~/work/git$ git checkout
D       .slides.tex.swp
D       slides.tex
user@bsd:~/work/git$ git checkout slides.tex 
user@bsd:~/work/git$ ls slides.tex
slides.tex

Si conoce la confirmación que eliminó los archivos, ejecute este comando donde <SHA1_deletion>está la confirmación que eliminó el archivo:

git diff --diff-filter=D --name-only <SHA1_deletion>~1 <SHA1_deletion> | xargs git checkout <SHA1_deletion>~1 --

La parte anterior a la tubería enumera todos los archivos que se eliminaron en la confirmación; todos son de pago de la confirmación anterior para restaurarlos.

Encuentra el commit que eliminó tu archivo:

git log --diff-filter=D --oneline -- path/to/file | cut -f -d ' '

Salida de muestra:

4711174

A partir de Git 2.23 en realidad hay un restorecomando. Todavía es experimental, pero para restaurar algo que eliminó en una confirmación (4711174 en este caso), puede escribir:

git restore --source=4711174^ path/to/file

Tenga en cuenta la ^ después de la identificación de confirmación, ya que queremos restaurar algo de la confirmación antes de la que eliminó el archivo.

El --sourceargumento le dice al restorecomando dónde buscar los archivos para restaurar y puede ser cualquier confirmación e incluso el índice.

Ver: git-restore doc para git 2.23.0

En nuestro caso, eliminamos accidentalmente archivos en una confirmación y algunas confirmaciones más tarde nos dimos cuenta de nuestro error y queríamos recuperar todos los archivos que se eliminaron, pero no los que se modificaron.

Basado en la excelente respuesta de Charles Bailey, aquí está mi frase:

git co $(git rev-list -n 1 HEAD -- <file_path>)~1 -- $(git diff --name-status $(git rev-list -n 1 HEAD -- <file_path>)~1 head | grep '^D' | cut -f 2)

Simple y preciso

En primer lugar, obtenga una última confirmación estable en la que tenga ese archivo:

git log 

Digamos que encuentra $ commitid 1234567 ..., entonces

git checkout <$commitid> $fileName

Esto restaurará la versión del archivo que estaba en esa confirmación.

Para la mejor manera de hacerlo, pruébalo.

Primero, encuentre el id de confirmación del compromiso que eliminó su archivo. Le dará un resumen de las confirmaciones que eliminaron archivos.

git log --diff-filter = D --summary

git checkout 84sdhfddbdddf ~ 1

Nota: 84sdhfddbdddes tucommit id

A través de esto, puede recuperar fácilmente todos los archivos eliminados.

Siempre podría git revertsu confirmación que eliminó el archivo. ( Esto supone que la eliminación fue el único cambio en la confirmación ) .

> git log
commit 2994bda49cd97ce49099953fc3f76f7d3c35d1d3
Author: Dave <dave@domain.com>
Date:   Thu May 9 11:11:06 2019 -0700

    deleted readme.md

Y si ha seguido trabajando y luego se dio cuenta de que no deseaba confirmar esa eliminación, puede revertirla usando:

> git revert 2994bd

Ahora git logmuestra:

> git log
Author: Dave <dave@domain.com>
Date:   Thu May 9 11:17:41 2019 -0700

    Revert "deleted readme"

    This reverts commit 2994bda49cd97ce49099953fc3f76f7d3c35d1d3.

Y readme.mdha sido restaurado en el repositorio.

También tengo este problema al usar el siguiente código para recuperar un archivo anterior en un directorio local:

git checkout <file path with name>

El siguiente ejemplo está funcionando para mí:

git checkout resources/views/usaSchools.blade.php

$ git log --diff-filter=D --summary  | grep "delete" | sort

Si no se ha confirmado la eliminación, el siguiente comando restaurará el archivo eliminado en el árbol de trabajo.

$ git checkout -- <file>

Puede obtener una lista de todos los archivos eliminados en el árbol de trabajo utilizando el siguiente comando.

$ git ls-files --deleted

Si la eliminación se ha confirmado, busque la confirmación donde sucedió y luego recupere el archivo de esta confirmación.

$ git rev-list -n 1 HEAD -- <file>
$ git checkout <commit>^ -- <file>

En caso de que esté buscando la ruta del archivo para recuperar, el siguiente comando mostrará un resumen de todos los archivos eliminados.

$ git log --diff-filter=D --summary

Para restaurar todos los archivos eliminados con Git, también puede hacer:

git checkout $(git ls-files --deleted)

Donde git ls-files --deletedenumera todos los archivos eliminados y git checkout $(git command)restaura la lista de archivos en un parámetro.