Comment réinitialiser ou rétablir un fichier dans une révision spécifique?

J'ai apporté quelques modifications à un fichier qui a été validé plusieurs fois dans le cadre d'un groupe de fichiers, mais je souhaite maintenant réinitialiser / rétablir les modifications qu'il contient dans une version précédente.

J'ai fait un git logavec un git diffpour trouver la révision dont j'ai besoin, mais je n'ai aucune idée de comment ramener le fichier à son ancien état dans le passé.

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 git checkout donne plus d'informations.

Si vous souhaitez revenir à la validation avant c5f567, ajoutez ~1(où 1 est le nombre de validations que vous souhaitez revenir en arrière, cela peut être n'importe quoi):

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

En guise de remarque, j'ai toujours été mal à l'aise avec cette commande car elle est utilisée à la fois pour les choses ordinaires (changement entre les branches) et pour les choses inhabituelles et destructrices (suppression des modifications dans le répertoire de travail).

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

git diff <commit hash> <filename>

Ensuite, pour rétablir un fichier spécifique à ce commit, utilisez la commande reset:

git reset <commit hash> <filename>

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

Un bon flux de travail pour gérer les points de cheminement consiste à utiliser des balises pour marquer proprement les points de votre chronologie. Je ne comprends pas très bien votre dernière phrase, mais ce que vous voudrez peut-être, c'est de diverger d'une branche d'un point dans le temps. Pour ce faire, utilisez la commande de paiement pratique:

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

Vous pouvez ensuite rebaser cela sur 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>

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

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

git checkout -- foo

Cela sera réinitialisé foosur HEAD. Vous pouvez également:

git checkout HEAD^ foo

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

Et pour revenir à la dernière version validée, qui est le plus souvent nécessaire, 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-refest la valeur SHA de la modification dans le journal que vous souhaitez revenir):

git checkout [commit-ref] [filename]

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

Si vous savez combien de commits vous devez revenir en arrière, vous pouvez utiliser:

git checkout master~5 image.png

Cela suppose que vous êtes sur la masterbranche, et la version que vous souhaitez est 5 validée.

Je pense que je l'ai trouvé .... sur http://www-cs-students.stanford.edu/~blynn/gitmagic/ch02.html

Parfois, vous voulez simplement revenir en arrière et oublier chaque changement après un certain point, car ils ont tous tort.

Commencer avec:

$ git log

qui affiche une liste des validations récentes et leurs hachages SHA1.

Ensuite, saisissez:

$ git reset --hard SHA1_HASH

pour restaurer l'état d'une validation donnée et effacer définitivement toutes les nouvelles validations de l'enregistrement.

Cela a fonctionné pour moi:

git checkout <commit hash> file

Validez ensuite le changement:

git commit -a

Vous devez être prudent lorsque vous dites "rollback". Si vous aviez auparavant une version d'un fichier dans la validation $ A, puis que vous avez ensuite apporté deux modifications dans deux validations distinctes $ B et $ C (vous voyez donc la troisième itération du fichier), et si vous dites " Je veux revenir au premier ", tu le penses vraiment?

Si vous voulez vous débarrasser des changements à la fois la deuxième et la troisième itération, c'est très simple:

$ git checkout $A file

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

D'un autre côté, vous vouliez vous débarrasser du changement apporté par la deuxième itération (c'est-à-dire commit $ B), tout en conservant ce que $ C a fait dans le fichier, vous voudriez revenir sur $ B

$ git revert $B

Notez que celui qui a créé le commit $ B peut ne pas avoir été très discipliné et avoir commis des modifications totalement indépendantes dans le même commit, et cette annulation peut toucher des fichiers autres que le fichier que vous voyez des changements offensants, vous pouvez donc vouloir vérifier soigneusement le résultat après avoir fait donc.

Curieusement, git checkout foocela ne fonctionnera pas si la copie de travail se trouve dans un répertoire nommé foo; Cependant, à la fois git checkout HEAD fooet git checkout ./foosera:

$ pwd
/Users/aaron/Documents/work/foo
$ git checkout foo
D   foo
Already on "foo"
$ git checkout ./foo
$ git checkout HEAD foo

Voici comment ça rebasemarche:

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 commandes ... commit git checkout git rebase master

... consultez la branche des modifications que vous souhaitez appliquer à la masterbranche. La rebasecommande prend les validations de <my branch>(qui ne se trouvent pas dans master) et les réapplique au chef de master. En d'autres termes, le parent du premier commit dans <my branch>n'est plus un commit précédent dans l' masterhistorique, mais le responsable actuel de master. Les deux commandes sont les mêmes que:

git rebase master <my branch>

Il pourrait être plus facile de se souvenir de cette commande car les branches "base" et "modify" sont explicites.

. Le résultat final de l'historique est:

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

Les deux dernières commandes ...

git checkout master
git merge <my branch>

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

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

masteret les <my branch>deux références B'. De plus, à partir de ce moment, il est possible de supprimer la <my branch>référence.

git branch -d <my branch>

Depuis git v2.23.0, il existe une nouvelle méthode de restauration git qui est supposée assumer une partie de ce qui git checkoutétait responsable (même la réponse acceptée mentionne ce qui git checkoutest assez déroutant). Voir les faits saillants des changements sur le blog github .

Le comportement par défaut de cette commande est de restaurer l'état d'une arborescence de travail avec le contenu provenant de la source paramètre (qui dans votre cas sera un hachage de validation).

Donc, selon la réponse de Greg Hewgill (en supposant que le hachage de validation est c5f567), la commande ressemblerait à ceci:

git restore --source=c5f567 file1/to/restore file2/to/restore

Ou si vous souhaitez restaurer le contenu d'un commit avant c5f567:

git restore --source=c5f567~1 file1/to/restore file2/to/restore

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

git reset HEAD path_to_file

Deuxième extraction de ce fichier

git checkout -- path_to_file

git-alias, awk et shell-fonctions à la rescousse!

git prevision <N> <filename>

où <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/z.c, exécutez

git prevision -1 x/y/z.c

Comment fonctionne git prevision?

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 une git log sur le fichier spécifié et
• sélectionne le commit-id approprié dans l'historique du fichier et
• exécute un git checkoutà l'ID de validation 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

Je dois brancher EasyGit ici, qui est un wrapper pour rendre git plus accessible aux novices sans dérouter les utilisateurs chevronnés. L'une des choses qu'il fait est de donner plus de sens àgit revert . Dans ce cas, vous diriez simplement:

eg revert foo/bar foo/baz

Dans le cas où vous souhaitez restaurer un fichier à une validation précédente (et le fichier que vous souhaitez rétablir 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.

Armé de la connaissance qu'un commit peut avoir deux parents dans le cas d'une 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.

De nombreuses suggestions ici, la plupart dans le sens de git checkout $revision -- $file. Quelques alternatives obscures:

git show $revision:$file > $file

Et aussi, je l'utilise beaucoup juste pour voir temporairement une version particulière:

git show $revision:$file

ou

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

(OBS: $filedoit être préfixé ./s'il s'agit d'un chemin relatif pourgit show $revision:$file travailler)

Et le plus étrange encore:

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

Notez toutefois que git checkout ./fooet git checkout HEAD ./foo ne sont pas exactement la même chose; cas d'espèce:

$ 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

(La deuxième addétape du fichier dans l'index, mais il n'est pas validé.)

Git checkout ./foosignifie revenir au chemin ./foode l' index ; l'ajout HEADindique à Git de rétablir ce chemin dans l'index à sa HEADrévision avant de le faire.

Pour moi, aucune des réponses ne semblait vraiment claire et je voudrais donc ajouter la mienne qui semble super facile.

J'ai un commit abc1et après cela j'ai fait plusieurs (ou une modification) dans un fichier file.txt.

Maintenant, disons que j'ai foiré quelque chose dans le fichier file.txtet que je veux revenir à un 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 amènera votre fichier à votre recherche version

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

4. git push : cela poussera tout sur le référentiel distant

Entre les étapes 2 et 3, bien sûr, vous pouvez faire git statuspour comprendre ce qui se passe. Habituellement, vous devriez voir le file.txtdéjà ajouté et c'est pourquoi il n'y a pas besoin d'un git add.

1. Git revert file to a specific commit

git checkout Last_Stable_commit_Number -- fileName

2.Git restaurer le fichier dans une branche spécifique

git checkout branchName_Which_Has_stable_Commit fileName

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 amènera simplement au dernier état validé du fichier

git checkout ref | commitHash - filePath

par exemple

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

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

Si vous souhaitez annuler les modifications d'un commit sur un seul fichier, comme vous le git revertferiez mais pour un seul fichier (ou dire un sous-ensemble des fichiers de commit), je suggère d'utiliser les deux git diffet git applycomme ça (avec <sha>= le hachage du vous vous engagez à revenir):

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

Fondamentalement, il générera d'abord un patch correspondant aux modifications que vous souhaitez annuler, puis appliquera le patch à l'envers pour supprimer ces modifications.

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

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

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

De toute évidence, quelqu'un doit soit écrire un livre intelligible sur git, soit git doit être mieux expliqué dans la documentation. Face à ce même problème j'ai deviné que

cd <working copy>
git revert master

annulerait le dernier commit qui semble le faire.

Ian

Vous pouvez le faire en 4 étapes:

1. annuler la validation entière avec le fichier que vous souhaitez restaurer spécifiquement - cela créera une nouvelle validation sur votre branche
2. réinitialisation logicielle qui valide - supprime la validation et déplace les modifications dans la zone de travail
3. sélectionner les fichiers à la main pour les restaurer et les valider
4. déposez tous les autres fichiers dans votre zone de travail

Ce que vous devez saisir dans 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

Il s'agit d'une étape très simple. Extraire le fichier de l'ID de validation que nous voulons, ici un ID de validation avant, puis juste git commit modifier et nous avons terminé.

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

C'est très pratique. Si nous voulons apporter n'importe quel fichier à n'importe quel ID de validation précédent en haut de la validation, nous pouvons facilement le faire.

git revert <hash>

Annulera un commit donné. Il semble que vous git revertn'affectiez que le commit le plus récent.

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.

si vous validez un mauvais fichier lors de vos dernières validations, suivez les instructions:

1. arborescence open source, passez à ce commit

2. changer les lignes et trouver votre commit que le mauvais fichier envoyé comme commit

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

6. ouvrez votre code Visual Studio et revenez en arrière en validant vos fichiers supprimés
7. après tous, vous pouvez voir les résultats de votre dernier commit dans l'arborescence source