Réinitialiser ou retourner un fichier spécifique à une révision spécifique en utilisant Git?

J'ai apporté des modifications au fichier qui a été transféré à plusieurs reprises en tant que partie d'un groupe de fichiers, mais je souhaite maintenant rétablir / rétablir les modifications apportées à la version précédente.

J'ai créé git log avec git diff pour trouver l'option dont j'avais besoin, mais je ne sais pas comment récupérer le fichier par le passé.

3786
19 окт. set Hates_ 19 oct. 2008-10-19 02:34 08 à 02h34 2008-10-19 02:34
ответ 31 réponses
  • 1
  • 2

En supposant que le hash de 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 à commit sur c5f567 , ajoutez ~1 (fonctionne avec n’importe quel nombre):

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

En guise de remarque, cette commande me mettait toujours mal à l'aise, car elle était utilisée à la fois pour des choses ordinaires (commutation entre branches) et pour des choses inhabituelles et destructrices (à l'exclusion des modifications dans le répertoire de travail).

5117
19 окт. réponse donnée par Greg Hewgill le 19 octobre 2008-10-19 02:39 '08 à 2:39 2008-10-19 02:39

Vous pouvez rapidement consulter les modifications apportées à un fichier à l'aide de la commande diff:

 git diff <commit hash> <filename> 

Ensuite, pour renvoyer un fichier spécifique à ce fixateur, utilisez la commande de réinitialisation:

 git reset <commit hash> <filename> 

Vous devrez peut-être utiliser l'option --hard si vous avez des modifications locales.

border=0

Un bon flux de documents pour gérer vos points de passage consiste à utiliser des balises pour que les points de votre chronologie restent propres. Je ne peux pas comprendre votre dernière phrase, mais vous aurez peut-être besoin de la divergence de la branche par rapport au point précédent. Pour ce faire, utilisez la commande de vérification pratique:

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

Vous pouvez ensuite le réinstaller par rapport à votre ligne principale lorsque vous êtes prêt à fusionner ces modifications:

 git checkout <my branch> git rebase master git checkout master git merge <my branch> 
541
17 дек. Réponse donnée par Chris Lloyd le 17 décembre 2008-12-17 09:59 '08 à 9:59 2008-12-17 09:59

Vous pouvez utiliser n’importe quel lien pour git commit, y compris SHA-1, si cela vous convient le mieux. Le fait est que l'équipe ressemble à ceci:

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

319
08 апр. la réponse est donnée foxxtrot 08 avr. 2009-04-08 00:48 '09 à 0:48 2009-04-08 00:48
 git checkout -- foo 

Ce sera un reset foo pour HEAD. Vous pouvez aussi:

 git checkout HEAD^ foo 

pour une révision, etc.

256
29 авг. réponse donnée par Greg Hewgill le 29 août 2008-08-29 23:56 2008 à 23h56 2008-08-29 23h56

Et pour revenir à la dernière version complète, qui est le plus souvent nécessaire, vous pouvez utiliser cette commande plus simple.

 git checkout HEAD file/to/restore 
114
14 янв. la réponse est donnée au CDR le 14 janvier. 2012-01-14 09:15 '12 à 9:15 2012-01-14 09:15

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

 git checkout [commit-ref] [filename] 

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

102
27 мая '09 в 20:52 2009-05-27 20:52 la réponse est donnée par bbrown le 27 mai 09 à 20:52 2009-05-27 20:52

Si vous savez combien de commits vous devez retourner, vous pouvez utiliser:

 git checkout master~5 image.png 

On suppose que vous êtes dans la branche master et que la version souhaitée est 5.

88
07 апр. La réponse est donnée par Ron DeVera 07 avril 2009-04-07 17:03 '09 à 17h03 2009-04-07 17:03

Je pense avoir trouvé ... de http://www-cs-students.stanford.edu/~blynn/gitmagic/ch02.html

Parfois, vous voulez simplement revenir en arrière et oublier tous les changements pour un certain point, car ils ont tous tort.

Commencez avec:

$ git log

qui vous montre une liste des commits récents et leur hachage SHA1.

Puis entrez:

$ git reset --hard SHA1_HASH

restaurer l'état d'un commit et effacer pour toujours toutes les nouvelles entrées de l'enregistrement.

78
17 дек. la réponse est donnée jdee 17 déc. 2008-12-17 09:53 '08 à 9:53 2008-12-17 09:53

Cela a fonctionné pour moi:

 git checkout <commit hash> file 

Puis commettez le changement:

 git commit -a 
61
26 авг. la réponse est donnée v2k 26 août. 2011-08-26 01:12 '11 à 1:12 2011-08-26 01:12

Vous devez faire attention quand vous dites "rollback". Si vous avez utilisé une version du fichier dans commit $ A, puis apporté deux modifications à deux commits distincts $ B et $ C (vous voyez donc que ceci est la troisième itération du fichier), et si vous dites "je veux revenir à la première", vraiment le dire?

Si vous souhaitez vous débarrasser des modifications des deuxième et troisième itérations, la procédure est très simple:

 $ git checkout $A file 

et ensuite vous corrigez le résultat. La commande demande "Je veux vérifier le fichier à partir de l'état écrit par le $ A commit".

Par contre, vous vouliez vous débarrasser de la deuxième modification d’itération (c’est-à-dire, gagner $ B), tout en maintenant que vous avez corrigé le fichier $ C dans le fichier, vous souhaitez renvoyer $ B

 $ git revert $B 

Remarque: celui qui commet $ B n’a peut-être pas été très discipliné et pourrait apporter des modifications totalement indépendantes à la même validation, et ce retour peut concerner des fichiers autres que le fichier que vous voyez, des modifications offensantes. peut vérifier le résultat soigneusement après cela.

54
11 янв. la réponse est donnée par gitster le 11 janvier . 2009-01-11 11:13 '09 à 11:13 2009-01-11 11:13

Fait intéressant, 'git checkout foo' ne fonctionnera pas si la copie de travail se trouve dans un répertoire nommé foo; Cependant, comme "w20> checkout HEAD foo" et "git checkout./foo", ce serait:

 $ pwd /Users/aaron/Documents/work/foo $ git checkout foo D foo Already on "foo" $ git checkout ./foo $ git checkout HEAD foo 
36
30 авг. la réponse est donnée par Aaron Maenpaa 30 août. 2008-08-30 00:26 '08 à 0:26 am 2008-08-30 00:26

Ici la rebase fonctionne:

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

Supposons que vous ayez

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

Les deux premières équipes ... font un assistant de réinstallation git checkout

... cochez la branche des modifications que vous souhaitez appliquer à la branche principale. La commande rebase prend les commits de <my branch> (qui ne se trouvent pas dans le master ) et les rebase à l'en-tête du master . En d'autres termes, l'élément parent de la première validation dans <my branch> n'est plus le fixateur précédent dans l'historique principal, mais l'en-tête master actuel. Deux équipes sont les mêmes que:

 git rebase master <my branch> 

Il serait peut-être plus facile de retenir cette commande, car les branches "base" et "modify" sont explicites.

. Le résultat final:

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

Les deux dernières équipes ...

 git checkout master git merge <my branch> 

... effectuez une fusion rapide pour appliquer toutes les modifications de <my branch> à master . Sans cette étape, une validation de base n'est pas ajoutée au master . Le résultat final:

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

master et <my branch> tous deux des références B' . En outre, à partir de ce point, vous pouvez supprimer en toute sécurité le lien <my branch> .

 git branch -d <my branch> 
32
24 февр. La réponse est donnée par cmcginty le 24 février. 2009-02-24 12:43 '09 à 12:43 2009-02-24 12:43

git aliases, awk et fonctions shell pour le salut!

 git prevision <N> <filename> 

<N> est le nombre de correctifs de fichier pour l'annulation du fichier <filename> .
Par exemple, pour vérifier la révision précédente immédiate d’un seul fichier x/y/zc , exécutez

 git prevision -1 x/y/zc 

Comment fonctionne la prédiction git?

Ajouter à votre gitconfig

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

Équipe fondamentalement

  • exécute le git log dans le fichier spécifié et
  • sélectionne l'ID de validation correspondant dans l'historique du fichier et
  • effectue l'identifiant de validation de git checkout pour le fichier spécifié.

Essentiellement, tout ce qui pourrait être fait manuellement dans cette situation
enveloppé dans un beau et efficace git-alias - git-prevision

21
01 мая '15 в 4:46 2015-05-01 04:46 la réponse est donnée par TheCodeArtist le 01 mai '15 à 4:46 2015-05-01 04:46

J'ai besoin de connecter EasyGit ici, qui est un wrapper permettant de rendre git plus accessible aux débutants sans dérouter les utilisateurs expérimentés. Une des choses qu'il fait est de donner plus de valeurs git revert . Dans ce cas, vous dites simplement:

eg revert foo/bar foo/baz

20
19 окт. la réponse est donnée à Aristote Pagaltzis le 19 oct. 2008-10-19 03:16 '08 à 3:16 am 2008-10-19 03:16

Si vous voulez retourner le fichier à la précédente validation (et que le fichier que vous voulez retourner est déjà fixé), vous pouvez utiliser

 git checkout HEAD^1 path/to/file 

ou

 git checkout HEAD~1 path/to/file 

Ensuite, effectuez simplement l’étape et corrigez la «nouvelle» version.

Sachant que dans le cas d'une fusion, un commit peut avoir deux parents, vous devez savoir que HEAD ^ 1 est le premier parent et HEAD ~ 1 est le deuxième parent.

Ou cela fonctionnera s'il n'y a qu'un seul parent dans l'arbre.

20
11 янв. La réponse est donnée par ModernIncantations le 11 janvier. 2014-01-11 03:29 '14 à 3:29 2014-01-11 03:29

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

 git reset HEAD path_to_file 

La deuxième vérification de ce fichier

 git checkout -- path_to_file 
19
04 апр. la réponse est donnée par Gulshan Maurya 04 avr. 2017-04-04 13:25 '17 à 13h25 2017-04-04 13:25

Notez que git checkout ./foo et git checkout HEAD ./foo ne git checkout HEAD ./foo 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 traite le fichier dans l'index, mais il n'est pas validé.)

git checkout ./foo signifie retourner le chemin ./foo à l'index ; l'ajout d'un HEAD indique à Git de renvoyer ce chemin d'index à son HEAD avant cela.

19
31 авг. La réponse est donnée par Damien Diederen le 31 août. 2008-08-31 14:54 2008 à 14h54: 2008-08-31 14:54

Il y a beaucoup de suggestions ici, la plupart dans l'esprit de git checkout $revision -- $file . Quelques alternatives obscures:

 git show $revision:$file > $file 

Et aussi, je l'utilise souvent seulement pour voir temporairement une version spécifique:

 git show $revision:$file 

ou

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

(OBS: le $file doit commencer par le préfixe ./ s'il s'agit d'un chemin relatif pour git show $revision:$file doit fonctionner)

Et d'autant plus étrange

 git archive $revision $file | tar -x0 > $file 
14
08 янв. Réponse de Peter V. Mørch Jan 08 2016-01-08 01:19 '16 à 1:19 2016-01-08 01:19

Pour aller à la version précédente du fichier de validation, obtenez le numéro de validation, par exemple, eb917a1 puis

 git checkout eb917a1 YourFileName 

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

 git reset HEAD YourFileName git checkout YourFileName 

Cela vous mènera au dernier état enregistré du fichier.

11
25 февр. la réponse est donnée shah1988 le 25 février 2014-02-25 17:01 '14 à 17:01 2014-02-25 17:01

Pour moi, aucune réponse ne m'a semblé très claire, c'est pourquoi j'aimerais ajouter la mienne, qui semble très simple.

J'ai un commit abc1 et après j'ai créé plusieurs (ou une modification) fichier file.txt .

Dites-moi maintenant que j'ai foiré quelque chose dans le fichier file.txt et que je veux revenir au commit précédent abc1 .

1. git checkout file.txt : cela supprimera les modifications locales si vous n'en avez pas besoin.

2. git checkout abc1 file.txt : cela conduira votre fichier à la version souhaitée

3. git commit -m "Restored file.txt to version abc1" : cela entraînera votre réversion.

  1. git push : cela va tout mettre dans un dépôt distant

Entre les étapes 2 et 3, bien sûr, vous pouvez git status pour comprendre ce qui se passe. D'habitude, vous devriez voir que le file.txt a déjà été ajouté, et donc il n'y a pas besoin de git add .

10
23 марта '17 в 0:33 2017-03-23 00:33 La réponse est donnée par kalmanIsAGameChanger le 23 mars 2017 à 0:33 2017-03-23 ​​00:33

git checkout ref | commitHash - filePath

par exemple.

 git checkout HEAD~5 -- foo.bar or git checkout 048ee28 -- foo.bar 
10
26 сент. La réponse est donnée à Amos Folarin 26 sep . 2013-09-26 20:04 13 à 20:04 2013-09-26 20:04

Beaucoup des réponses ici nécessitent que vous git reset ... <file> ou git checkout ... <file> , mais vous perdrez toutes les modifications apportées à <file> après la validation que vous souhaitez renvoyer.

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

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

En principe, il génère d'abord un correctif correspondant aux modifications que vous souhaitez renvoyer, puis annule l'application du correctif pour ignorer ces modifications.

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

8
07 дек. la réponse est donnée Vince 07 déc. 2016-12-07 17:43 '16 à 17h43 2016-12-07 17:43

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

Note N'oubliez pas d'entrer le hash avant le dernier. Le dernier dièse indique la position actuelle (HEAD) et ne change rien.

8
05 дек. la réponse est donnée à mustafakyr 05 déc. 2011-12-05 23:09 '11 à 23:09 2011-12-05 23:09

De toute évidence, quelqu'un doit écrire un livre clair sur git ou git pour mieux l'expliquer dans la documentation. Face au même problème, j'ai deviné que

 cd <working copy> git revert master 

annule le dernier commit, ce qui semble être le cas.

Ian

7
16 дек. La réponse est donnée par Ian Davis le 16 décembre. 2011-12-16 06:03 '11 à 6:03 2011-12-16 06:03

Si vous créez un fichier incorrect dans vos commits récents, suivez les instructions:

  1. arborescence open source, modifiez ce commit

2019

23 авг. réponse donnée par sabre tabatabaee yazdi 23 août. 2018-08-23 12:53 '18 à 12:53 2018-08-23 12:53

Vous pouvez le faire en 4 étapes:

  1. annuler l'intégralité du commit avec le fichier que vous souhaitez spécifiquement annuler - cela créera un nouveau commit dans votre thread
  2. réinitialisation logicielle qui valide - supprime la validation et déplace les modifications vers l'espace de travail
  3. sélectionner manuellement les fichiers à retourner et les verrouiller
  4. déposer tous les autres fichiers dans votre espace de travail

Ce que vous devez appeler sur votre 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.

bonne chance

4
08 мая '18 в 13:26 2018-05-08 13:26 la réponse est donnée par Nir M. le 08 mai '18 à 13h26. 2018-05-08 13:26
 git revert <hash> 

Retourne le commit spécifié. Vous semblez penser que le git revert n'affecte que le dernier commit.

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

4
17 дек. Otto répondit le 17 décembre 2008-12-17 21:56 08 à 21h56 2008-12-17 21h56

Voici mon chemin.

a) Dans Android Studio, ouvrez le fichier.

b) git → Afficher l'historique, trouver le commit précédent auquel je veux revenir. Récupère commit_id (c'est-à-dire commit hachage).

c) git checkout commit_id file_path

1
13 марта '17 в 11:10 2017-03-13 11:10 la réponse est donnée par Francis Bacon le 13 mars 17 à 11:10 2017-03-13 11:10

Si vous utilisez Git Extensions et souhaitez retourner au commit parent du fichier, vous pouvez sélectionner le commit contenant les modifications à renvoyer, puis sélectionner l'onglet "Diff" en détail, cliquer avec le bouton droit de la souris sur le fichier que vous voulez renvoyer, puis Réinitialiser le fichier à " .... ", puis" A "(parent)

1
26 сент. réponse donnée par johnny le 26 sept. 2017-09-26 04:48 '17 à 4:48 2017-09-26 04:48

C'est une étape très simple. Extrayez le fichier avec l’ID de validation que nous voulons, en l’occurrence, un ID de validation auparavant, puis exécutez simplement la commande git commitmend, et le tour est joué.

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

C'est très pratique. Si nous voulons sortir n'importe quel fichier avec n'importe quel identifiant de la précédente validation en haut de la validation, nous pouvons le faire facilement.

1
24 янв. Réponse donnée par Abhishek Dwivedi le 24 janvier 2019-01-24 20:21 '19 à 20h21 le 20 janvier 2019 20h21
  • 1
  • 2

Autres questions sur balises ou Poser une question