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

J’ai apporté quelques modifications à un fichier qui a été commis à plusieurs resockets dans le cadre d’un groupe de fichiers, mais je souhaite maintenant réinitialiser / rétablir les modifications apscopes à 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 n’ai aucune idée de la manière de récupérer le fichier dans son état antérieur.

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 voulez revenir à la validation avant c5f567 , ajoutez ~1 (fonctionne avec n’importe quel nombre):

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

En parallèle, cette commande m’a toujours gêné car elle est utilisée à la fois pour les choses ordinaires (changement entre twigs) et pour les choses inhabituelles et destrucsortingces (suppression des modifications dans le répertoire de travail).

Vous pouvez rapidement examiner les modifications apscopes à un fichier à l’aide de la commande diff:

 git diff   

Ensuite, pour rétablir un fichier spécifique dans cette validation, utilisez la commande reset:

 git reset   

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

Un bon workflow pour gérer les waypoints consiste à utiliser des tags pour marquer proprement les points dans votre calendrier. Je ne peux pas tout à fait comprendre votre dernière phrase, mais ce que vous pouvez vouloir, c’est diverger une twig d’un point antérieur. Pour ce faire, utilisez la commande checkout pratique:

 git checkout  git checkout -b  

Vous pouvez alors le rebaser sur votre ligne principale lorsque vous êtes prêt à fusionner ces modifications:

 git checkout  git rebase master git checkout master git merge  

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

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

 git checkout -- foo 

Cela réinitialisera foo à HEAD. Vous pouvez aussi:

 git checkout HEAD^ foo 

pour une révision de retour, 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-ref est la valeur SHA du changement dans le journal sur lequel vous voulez revenir):

 git checkout [commit-ref] [filename] 

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

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

 git checkout master~5 image.png 

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

Je pense que je l’ai trouvé …. de 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 sont tous faux.

Commencer avec:

$ git log

qui vous montre une liste des commits récents et leurs hachages SHA1.

Ensuite, tapez:

$ git reset --hard SHA1_HASH

pour restaurer l’état à un commit donné et effacer définitivement tous les commits plus récents de l’enregistrement.

Cela a fonctionné pour moi:

 git checkout  file 

Puis commettez le changement:

 git commit -a 

Vous devez faire attention quand vous dites “rollback”. Si vous aviez l’habitude d’avoir une version d’un fichier dans commit $ A, puis deux modifications dans deux commits distincts $ B et $ C (ce que vous voyez est la troisième itération du fichier), et si vous dites ” Je veux revenir au premier “, est-ce que tu le penses vraiment?

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

 $ git checkout $A file 

et puis vous engagez le résultat. La commande demande “Je veux extraire le fichier de l’état enregistré par le commit $ A”.

En revanche, vous vouliez vous débarrasser de la modification apscope lors de la deuxième itération (ie commit $ B), tout en conservant ce que commit $ C sur le fichier, vous souhaiteriez revenir à $ B

 $ git revert $B 

Notez que quiconque a créé un commit $ B n’a peut-être pas été très discipliné et qu’il a commis des modifications totalement indépendantes du même commit, et que ce retour peut toucher des fichiers autres que les modifications incriminées. alors.

De manière amusante, “git checkout foo” ne fonctionnera pas si la copie de travail est dans un répertoire nommé foo; cependant, les deux commandes «git checkout HEAD foo» et «git checkout ./foo» vont:

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

Voici comment fonctionne rebase :

 git checkout  git rebase master git checkout master git merge  

Supposons que vous ayez

 ---o----o----o----o master \---A----B  

Les deux premières commandes … commettent git checkout git rebase master

… consultez la twig des modifications que vous souhaitez appliquer à la twig principale. La commande rebase prend les commits de (qui ne se trouvent pas dans master ) et les réapplique à la tête du master . En d’autres termes, le parent du premier commit dans n’est plus un commit précédent dans l’historique master , mais le responsable actuel du master . Les deux commandes sont les mêmes que:

 git rebase master  

Il peut être plus facile de se rappeler de cette commande car les twigs “base” et “modify” sont explicites.

. Le résultat final de l’histoire est:

 ---o----o----o----o master \----A'----B'  

Les deux dernières commandes …

 git checkout master git merge  

… faire une fusion rapide pour appliquer toutes les modifications sur master . Sans cette étape, le commit de rebase n’est pas ajouté à master . Le résultat final est:

 ---o----o----o----o----A'----B' master,  

master et tous deux référence B' . De plus, à partir de là, vous pouvez supprimer la référence .

 git branch -d  

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

 git prevision   

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

 git prevision -1 x/y/zc 

Comment git prevision fonctionne?

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 l’identifiant de validation approprié dans l’historique du fichier et
  • exécute une git checkout à l’identifiant de validation du fichier spécifié.

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

Je dois twigr EasyGit ici, qui sert à rendre git plus accessible aux novices sans confondre les utilisateurs chevronnés. 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 restaurer déjà validé), vous pouvez utiliser

 git checkout HEAD^1 path/to/file 

ou

 git checkout HEAD~1 path/to/file 

Il suffit ensuite de mettre en scène et de valider 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.

Notez cependant que git checkout ./foo et 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 

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

Git checkout ./foo signifie revenir au chemin ./foo de l’ index ; L’ajout de HEAD indique à Git de retourner ce chemin dans l’index à sa révision HEAD avant de le faire.

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

 git reset HEAD path_to_file 

Deuxième vérification de ce fichier

 git checkout -- path_to_file 

Beaucoup de suggestions ici, la plupart sur les lignes 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: $file doit être préfixé avec ./ s’il s’agit d’un chemin relatif pour git show $revision:$file to work)

Et le plus étrange encore:

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

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

 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 engagé du fichier

git checkout ref | commitHash – filePath

par exemple

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

Pour moi, aucune des réponses ne m’a semblé très claire et je voudrais donc append la mienne qui semble super facile.

J’ai un commit abc1 et après cela j’ai fait plusieurs (ou une modification) sur un fichier file.txt .

Maintenant, dis que j’ai raté quelque chose dans le fichier file.txt et 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 à la version voulue

3. git commit -m "Restored file.txt to version abc1" : cela va valider votre retour.

  1. git push : cela va tout pousser sur le repository distant

Entre les étapes 2 et 3, bien sûr, vous pouvez faire le point avec vos git status pour comprendre ce qui se passe. Habituellement, vous devriez voir le file.txt déjà ajouté et c’est pourquoi il n’ya pas besoin d’ git add .

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

Note: N’oubliez pas de taper le hash avant le dernier. Le dernier hachage pointe votre position actuelle (HEAD) et ne change rien.

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

 cd  git revert master 

annulerait le dernier commit qui semblait faire.

Ian

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

Si vous souhaitez annuler les modifications d’un seul engagement sur un seul fichier, tout comme git revert ferait pour un seul fichier (ou un sous-ensemble des fichiers de validation), je suggère d’utiliser git diff et git apply comme ça ( avec = le hachage du commit que vous voulez rétablir):

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

Fondamentalement, il générera d’abord un patch correspondant aux modifications que vous souhaitez rétablir, puis appliquera le patch pour supprimer ces modifications.

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

 git revert  

Va annuler un commit donné. Il semble que vous pensiez que git revert n’affecte que le plus récent 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.

Vous pouvez le faire en 4 étapes:

  1. annulez la validation complète avec le fichier que vous voulez restaurer spécifiquement – cela créera un nouvel commit sur votre twig
  2. réinitialisation logicielle qui valide – supprime la validation et déplace les modifications vers la zone de travail
  3. cueillir à la main les fichiers pour les restaurer et les valider
  4. supprimer tous les autres fichiers dans votre zone de travail

Ce que vous devez taper dans votre terminal :

  1. git revert
  2. git reset HEAD~1
  3. git add && git commit -m 'reverting file'
  4. git checkout .

bonne chance

Si vous commettez un mauvais fichier dans vos derniers commits, suivez les instructions:

  1. ouvrir l’arborescence des sources, modifier cette validation

arbre source ouvert

  1. changez les lignes et trouvez votre commit que le mauvais fichier envoyé en tant que commit

entrer la description de l'image ici

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

onglet d'état du fichier

  1. Ouvrez votre code visuel de studio et revenez en validant vos fichiers supprimés
  2. après tout, vous pouvez voir les résultats dans votre dernier commit dans l’arborescence source

entrer la description de l'image ici

Voici mon chemin

a) Dans Android Studio, ouvrez le fichier.

b) git -> Afficher l’historique, trouvez le précédent commit auquel je veux revenir. Récupère le commit_id (c’est-à-dire le hash de validation).

c) git checkout commit_id file_path

Si vous utilisez les extensions Git et que vous souhaitez uniquement revenir à la validation parent pour le fichier, vous pouvez sélectionner la validation qui contient les modifications à restaurer, puis sélectionner l’onglet “Diff” dans le volet d’informations, cliquer avec le bouton droit de la souris. le fichier que vous souhaitez restaurer, puis “Réinitialiser le (s) fichier (s)” à “…., puis” A “(le parent)