récupérer - Réinitialiser ou rétablir un fichier spécifique en une révision spécifique en utilisant Git?




git récupérer un fichier (20)

J'ai apporté des modifications à un fichier qui a été validé à quelques reprises en tant que partie d'un groupe de fichiers, mais je souhaite maintenant réinitialiser / rétablir les modifications sur une version précédente.

J'ai fait un git log avec un git diff pour trouver la révision dont j'ai besoin, mais je ne sais pas du tout comment rétablir le fichier dans son état antérieur.


git-aliases, awk et les fonctions shell à la rescousse!

git prevision <N> <filename>

<N> est le nombre de révisions du fichier à restaurer pour le fichier <filename> .
Par exemple, pour extraire la révision précédente immédiate d’un seul fichier x/y/zc , exécutez

git prevision -1 x/y/z.c

Comment fonctionne la prévision git?

Ajoutez ce qui suit à votre gitconfig

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

La commande essentiellement

  • effectue un git log sur le fichier spécifié et
  • choisit le commit-id approprié dans l'historique du fichier et
  • exécute une git checkout sur le commit-id pour le fichier spécifié.

Essentiellement, tout ce que l’on ferait manuellement dans cette situation,
enveloppé dans un beau et efficace git-alias - git-prevision


Beaucoup de réponses ici prétendent utiliser git reset ... <file> ou git checkout ... <file> mais ce faisant, vous perdrez toutes les modifications apportées sur <file> validées après la validation que vous souhaitez annuler.

Si vous voulez annuler les modifications d'un commit sur un seul fichier, tout comme git revert ferait, mais seulement pour un fichier (ou un sous-ensemble des fichiers commit), je suggère d'utiliser à la fois git diff et git apply avec <sha> = le hachage du commit que vous voulez annuler):

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

En gros, il commence par générer un correctif correspondant aux modifications que vous souhaitez annuler, puis à appliquer le correctif en sens inverse pour supprimer ces modifications.

Bien sûr, cela ne fonctionnera pas si les lignes annulées ont été modifiées par un commit entre <sha1> et HEAD (conflit).


Cela a fonctionné pour moi:

git checkout <commit hash> file

Puis commettez le changement:

git commit -a

Dans le cas où vous souhaitez restaurer un fichier avec une validation précédente (et le fichier que vous souhaitez restaurer déjà validé), vous pouvez utiliser

git checkout HEAD^1 path/to/file

ou

git checkout HEAD~1 path/to/file

Ensuite, mettez en scène et validez la "nouvelle" version.

Sachant qu’un commit peut avoir deux parents en cas de fusion, vous devez savoir que HEAD ^ 1 est le premier parent et HEAD ~ 1 est le deuxième parent.

L'un ou l'autre fonctionnera s'il n'y a qu'un seul parent dans l'arbre.


En supposant que le hachage du commit que vous voulez est c5f567 :

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

La page de manuel de git checkout donne plus d’informations.

Si vous souhaitez revenir au commit avant c5f567 , ajoutez ~1 (fonctionne avec n’importe quel numéro):

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

En passant, cette commande a toujours été inconfortable, car elle est utilisée à la fois pour des tâches ordinaires (changement de branche) et des tâches inhabituelles et destructrices (suppression des modifications dans le répertoire de travail).


Et pour revenir à la dernière version validée, qui est le plus souvent utilisée, vous pouvez utiliser cette commande plus simple.

git checkout HEAD file/to/restore

J'ai eu le même problème tout à l'heure et j'ai trouvé cette réponse plus facile à comprendre ( commit-ref est la valeur SHA de la modification dans le journal vers lequel vous souhaitez revenir):

git checkout [commit-ref] [filename]

Cela mettra cette ancienne version dans votre répertoire de travail et à partir de là, vous pourrez la commettre si vous le souhaitez.



Notez cependant que git checkout ./foo et git checkout HEAD ./foo ne sont pas exactement la même chose; Exemple:

$ 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

(Le deuxième add met le fichier dans l'index, mais il n'est pas validé.)

Git checkout ./foo signifie revenir chemin ./foo partir de l' index ; ajouter HEAD indique à Git de rétablir ce chemin dans l'index vers sa révision HEAD avant de le faire.


Pour accéder à une version de validation précédente du fichier, obtenez le numéro de validation, dites eb917a1 puis

git checkout eb917a1 YourFileName

Si vous avez juste besoin de revenir à la dernière version validée

git reset HEAD YourFileName
git checkout YourFileName

Cela vous mènera simplement au dernier état commis du fichier


Première réinitialisation de la tête pour le fichier cible

git reset HEAD path_to_file

Deuxième extraction de ce fichier

git checkout -- path_to_file

Si vous savez combien d’engagements vous devez revenir en arrière, vous pouvez utiliser:

git checkout master~5 image.png

Cela suppose que vous êtes sur la branche master et que la version souhaitée est de 5 commits.


Si vous validez un fichier erroné lors de vos derniers commits, suivez les instructions:

  1. arborescence open source, passez à ce commit

  1. changer les lignes et trouver votre commit que le mauvais fichier envoyé en commit

  1. vous pouvez voir la liste de vos modifications dans ce commit
  2. sélectionnez-le puis cliquez sur ... les boutons à droite ... cliquez sur le fichier inversé
  3. alors vous pouvez le voir sur l'onglet statut du fichier en bas à gauche puis cliquez sur unstage:

  1. ouvrez votre code visual studio et revenez en arrière en validant les fichiers supprimés
  2. après tout, vous pouvez voir les résultats dans votre dernier commit dans l'arbre source


Utilisez git log pour obtenir la clé de hachage pour une version spécifique, puis utilisez git checkout <hashkey>

Remarque: N'oubliez pas de taper le hachage avant le dernier. Le dernier hash indique votre position actuelle (HEAD) et ne change rien.


Voici mon chemin.

a) Dans Android Studio, ouvrez le fichier.

b) git -> Show History, trouvez le commit précédent auquel je veux revenir. Récupère le commit_id (c'est-à-dire le hachage de commit).

c) git checkout commit_id file_path


Vous devez faire attention quand vous dites "rollback". Si vous utilisiez une version d’un fichier dans commit $ A, puis que vous apportiez ensuite deux modifications à deux commits distincts $ B et $ C (vous voyez donc la troisième itération du fichier), et si vous dites " Je veux revenir à la première ", tu le penses vraiment?

Si vous souhaitez vous débarrasser des modifications à la fois de la deuxième et de la troisième itérations, c'est très simple:

$ git checkout $A file

et ensuite vous commettez le résultat. La commande demande "Je veux extraire le fichier de l'état enregistré par le commit $ A".

De l’autre côté, vous vouliez supprimer le changement apporté par la deuxième itération (c’est-à-dire commit $ B), tout en conservant ce que commit $ C avait fait pour le fichier, vous voudriez restaurer $ B

$ git revert $B

Notez que celui qui a créé commit $ B n’est peut-être pas très discipliné et a peut-être commis des modifications totalement non liées dans le même commit, et cette annulation peut toucher des fichiers autres que ceux dont vous voyez les modifications offensantes. Vous pouvez donc vérifier soigneusement le résultat alors.


Vous pouvez utiliser n'importe quelle référence à un commit git, y compris SHA-1 si cela vous convient le mieux. Le fait est que la commande ressemble à ceci:

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


git checkout réf | commitHash - cheminFichier

par exemple

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

git checkout -- foo

Cela réinitialisera foo en HEAD. Vous pouvez également:

git checkout HEAD^ foo

pour une révision en arrière, etc.


git revert <hash>

Va annuler un commit donné. Il semble que vous pensiez que git revert n'affecte que le dernier commit.

Cela ne résout pas votre problème si vous souhaitez annuler une modification dans un fichier spécifique et que la validation a changé plus que ce fichier.





version-control