Disons que je suis dans un référentiel Git. Je supprime un fichier et valide cette modification. Je continue de travailler et je fais encore plus de commits. Ensuite, je trouve que je dois restaurer ce fichier.

Je sais que je peux extraire un fichier en utilisant git checkout HEAD^ foo.bar, mais je ne sais pas vraiment quand ce fichier a été supprimé.

1. Quel serait le moyen le plus rapide de trouver le commit qui a supprimé un nom de fichier donné?
2. Quelle serait la façon la plus simple de remettre ce fichier dans ma copie de travail?

J'espère que je n'ai pas à parcourir manuellement mes journaux, à extraire l'intégralité du projet pour un SHA donné, puis à copier manuellement ce fichier dans mon extraction de projet d'origine.

Trouvez le dernier commit qui a affecté le chemin donné. Comme le fichier n'est pas dans la validation HEAD, cette validation doit l'avoir supprimé.

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

Ensuite, extrayez la version lors de la validation avant, en utilisant le ^symbole caret ( ):

git checkout <deleting_commit>^ -- <file_path>

Ou dans une commande, si $filec'est le fichier en question.

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

Si vous utilisez zsh et que l'option EXTENDED_GLOB est activée, le symbole caret ne fonctionnera pas. Vous pouvez utiliser à la ~1place.

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

1. Utilisation git log --diff-filter=D --summary pour obtenir tous les commits qui ont supprimé des fichiers et les fichiers supprimés;
2. Utilisez git checkout $commit~1 path/to/file.extpour restaurer le fichier supprimé.

Où $commitest la valeur du commit que vous avez trouvé à l'étape 1, par exemplee4cf499627

Pour restaurer tous ces fichiers supprimés dans un dossier, entrez la commande suivante.

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

Je suis venu à cette question en cherchant à restaurer un fichier que je viens de supprimer mais je n'avais pas encore validé la modification. Au cas où vous vous trouveriez dans cette situation, tout ce que vous devez faire est le suivant:

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

Si vous êtes fou, utilisez git-bisect. Voici quoi faire:

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

Il est maintenant temps d'exécuter le test automatisé. La commande shell '[ -e foo.bar ]'retournera 0 si elle foo.barexiste et 1 sinon. La commande "run" de git-bisectutilisera la recherche binaire pour trouver automatiquement le premier commit où le test échoue. Il commence à mi-chemin dans la plage donnée (de bon à mauvais) et le coupe de moitié en fonction du résultat du test spécifié.

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

Vous êtes maintenant au commit qui l'a supprimé. À partir d'ici, vous pouvez revenir vers le futur et utiliser git-revertpour annuler le changement,

git bisect reset
git revert <the offending commit>

ou vous pouvez revenir en arrière d'un commit et inspecter manuellement les dommages:

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

Mon nouvel alias préféré, basé sur bonyiii s » réponse (upvoted), et ma réponse au sujet de « passer un argument à une commande 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'

J'ai perdu un fichier, supprimé par erreur il y a quelques commits?
Rapide:

git restore my_deleted_file

Crise évitée.

Attention, avec Git 2.23 (Q3 2019) vient la commande expérimentale nommée git restore(!).
Renommez donc cet alias (comme indiqué ci-dessous).

Robert Dailey propose dans les commentaires l'alias suivant:

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

Et jegan ajoute dans les commentaires :

Pour définir l'alias à partir de la ligne de commande, j'ai utilisé cette commande:

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

Si vous connaissez le nom de fichier, c'est un moyen simple avec les commandes de base:

Liste tous les commits pour ce fichier.

git log -- path/to/file

Le dernier commit (le plus haut) est celui qui a supprimé le fichier. Vous devez donc restaurer l'avant-dernier commit.

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

Pour restaurer un fichier supprimé et validé:

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

Il a été testé sur Git version 1.7.5.4.

Si vous avez seulement apporté des modifications et supprimé un fichier, mais pas le valider, et maintenant vous avez rompu avec vos modifications

git checkout -- .

mais vos fichiers supprimés ne sont pas revenus, vous exécutez simplement la commande suivante:

git checkout <file_path>

Et hop, votre dossier est de retour.

J'ai cette solution .

1. Obtenez l'id du commit où le fichier a été supprimé en utilisant l'une des méthodes ci-dessous.

   • git log --grep=*word*
   • git log -Sword
   • git log | grep --context=5 *word*
   • git log --stat | grep --context=5 *word* # recommandé si vous ne vous souvenez de rien

2. Vous devriez obtenir quelque chose comme:

commit bfe68bd117e1091c96d2976c99b3bcc8310bebe7 Auteur: Alexander Orlov Date: jeu 12 mai 23:44:27 2011 +0200

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

commit 3ea4e3af253ac6fd1691ff6bb89c964f54802302 Auteur: Alexander Orlov Date: jeu 12 mai 22:10:22 2011 +0200

3 . Maintenant, en utilisant l'ID de validation bfe68bd117e1091c96d2976c99b3bcc8310bebe7, procédez comme suit:

git checkout bfe68bd117e1091c96d2976c99b3bcc8310bebe7^1 yourDeletedFile.java

Comme l'ID de validation fait référence à la validation où le fichier a déjà été supprimé, vous devez référencer la validation juste avant bfe68b, ce que vous pouvez faire en ajoutant ^1. Cela signifie: donnez-moi le commit juste avant bfe68b.

git checkout /path/to/deleted.file

git undelete path/to/file.ext

1. Mettez ceci dans votre .bash_profile(ou tout autre fichier pertinent qui se charge lorsque vous ouvrez un shell de commande):

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

2. Utilisez ensuite:

   git undelete path/to/file.ext
   

Cet alias vérifie d'abord pour trouver le dernier commit où ce fichier existait, puis effectue une extraction Git de ce chemin de fichier à partir du dernier commit où ce fichier existait. Source .

Dans de nombreux cas, il peut être utile d'utiliser des coreutils (grep, sed, etc.) en conjonction avec Git. Je connais déjà assez bien ces outils, mais Git l'est moins. Si je voulais faire une recherche pour un fichier supprimé, je ferais ce qui suit:

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

Quand je trouve la révision / commit:

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

Tout comme d'autres l'ont dit avant moi.

Le fichier sera maintenant restauré dans son état antérieur à sa suppression. N'oubliez pas de le réengager dans l'arborescence de travail si vous souhaitez le conserver.

J'ai dû restaurer un tas de fichiers supprimés à partir d'un commit spécifique, et je l'ai géré avec deux commandes:

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 

(Notez l'espace de fin à la fin de chaque commande.)

Les fichiers ont été ajoutés au fichier .gitignore puis effacés avec git rm. J'avais besoin de restaurer les fichiers, mais de les décompresser. J'avais des centaines de fichiers à restaurer, et taper des choses manuellement pour chaque fichier comme dans les autres exemples allait être beaucoup trop lent.

En fait, cette question concerne directement Git, mais quelqu'un comme moi travaille avec des outils GUI comme WebStorm VCS part connaître les commandes CLI de Git.

Je fais un clic droit sur le chemin qui contient le fichier supprimé, puis je vais dans Git, puis je clique sur Afficher l'historique .

Les outils VCS montrent toutes les révisions et je peux voir tous les commits et les changements de chacun d'eux.

Ensuite, je sélectionne les commits que mon ami supprime le PostAd.jsfichier. voir maintenant ci-dessous:

Et maintenant, je peux voir mon fichier supprimé de désir. Je viens de double-cliquer sur le nom du fichier et il récupère.

Je sais que ma réponse n'est pas les commandes Git, mais elle est rapide, fiable et facile pour les développeurs débutants et professionnels. Les outils WebStorm VCS sont géniaux et parfaits pour travailler avec Git et ne nécessitent aucun autre plugin ou outil.

J'avais la même question. Sans le savoir, j'avais créé un commit pendant .

Liste des validations pendantes

git fsck --lost-found

Inspectez chaque commit pendant

git reset --hard <commit id>

Mes fichiers ont réapparu lorsque je suis passé au commit suspendu.

git status pour la raison:

“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

Restaurez le fichier supprimé:

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 vous connaissez le commit qui a supprimé le ou les fichiers, exécutez cette commande où <SHA1_deletion>est le commit qui a supprimé le fichier:

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

La partie avant le canal répertorie tous les fichiers qui ont été supprimés dans la validation; ils sont tous extraits de la validation précédente pour les restaurer.

Recherchez le commit qui a supprimé votre fichier:

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

Exemple de sortie:

4711174

Depuis Git 2.23, il existe en fait une restorecommande. C'est encore expérimental mais pour restaurer quelque chose que vous avez supprimé dans un commit (4711174 dans ce cas) vous pouvez alors taper:

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

Notez le ^ après l'ID de validation car nous voulons restaurer quelque chose à partir du commit avant celui qui a supprimé le fichier.

L' --sourceargument indique aurestore commande où chercher le ou les fichiers à restaurer et il peut s'agir de n'importe quel commit et même de l'index.

Voir: doc git-restore pour git 2.23.0

Dans notre cas, nous avons accidentellement supprimé des fichiers dans un commit et certains commits plus tard, nous avons réalisé notre erreur et voulions récupérer tous les fichiers qui ont été supprimés, mais pas ceux qui ont été modifiés.

Basé sur l'excellente réponse de Charles Bailey, voici mon one-liner:

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 et précis-

Tout d'abord, obtenez un dernier commit stable dans lequel vous avez ce fichier par -

git log 

Supposons que vous trouviez $ commitid 1234567 ..., puis

git checkout <$commitid> $fileName

Cela restaurera la version du fichier qui était dans ce commit.

Pour la meilleure façon de le faire, essayez-le.

Tout d'abord, recherchez l'ID de validation du commit qui a supprimé votre fichier. Il vous donnera un résumé des validations qui ont supprimé les fichiers.

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

git checkout 84sdhfddbdddf ~ 1

Remarque: 84sdhfddbdddest votrecommit id

Grâce à cela, vous pouvez facilement récupérer tous les fichiers supprimés.

Vous pouvez toujours git revertvotre commit qui a supprimé le fichier. ( Cela suppose que la suppression était le seul changement dans la validation. )

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

    deleted readme.md

Et si vous avez poursuivi le travail et réalisé plus tard que vous ne vouliez pas valider ce commit de suppression, vous pouvez le rétablir en utilisant:

> git revert 2994bd

git logMontre maintenant :

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

    Revert "deleted readme"

    This reverts commit 2994bda49cd97ce49099953fc3f76f7d3c35d1d3.

Et readme.mda été restauré dans le référentiel.

J'ai également ce problème en utilisant le code ci-dessous pour récupérer un fichier précédent dans un répertoire local:

git checkout <file path with name>

L'exemple ci-dessous fonctionne pour moi:

git checkout resources/views/usaSchools.blade.php

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

Si la suppression n'a pas été validée, la commande ci-dessous restaurera le fichier supprimé dans l'arborescence de travail.

$ git checkout -- <file>

Vous pouvez obtenir une liste de tous les fichiers supprimés dans l'arborescence de travail à l'aide de la commande ci-dessous.

$ git ls-files --deleted

Si la suppression a été validée, recherchez la validation à l'endroit où elle s'est produite, puis récupérez le fichier à partir de cette validation.

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

Dans le cas où vous recherchez le chemin du fichier à récupérer, la commande suivante affichera un résumé de tous les fichiers supprimés.

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

Afin de restaurer tous les fichiers supprimés avec Git, vous pouvez également faire:

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

Où git ls-files --deletedrépertorie tous les fichiers supprimés et git checkout $(git command)restaure la liste des fichiers dans un paramètre.