Git : Restauration fichier ou version et correction d’erreur

Vous venez de supprimer un fichier important ? Une commande Git a mal tourné ? Ou peut-être avez-vous simplement modifié du code que vous souhaitez finalement annuler ? Pas de panique : dans la majorité des cas, Git permet de restaurer un fichier, récupérer une ancienne version ou corriger une erreur sans détruire tout votre projet.

Dans ce tutoriel, vous allez apprendre à utiliser les principales commandes de restauration Git de manière simple et progressive. Nous verrons comment revenir en arrière, annuler des modifications, récupérer des fichiers supprimés et éviter les erreurs les plus fréquentes, le tout avec des exemples concrets pensés pour les débutants.

• Récupérez facilement un fichier supprimé ou une version précédente de votre projet Git sans repartir de zéro.
• Comprenez enfin ce que font réellement les commandes de restauration pour corriger vos erreurs sans stress ni peur de “tout casser”.
• Adoptez les bons réflexes pour éviter les manipulations dangereuses et garder le contrôle sur votre historique Git.

Lorsque l’on débute avec Git, il y a un moment presque inévitable : celui où l’on pense avoir “cassé” son projet. Un fichier supprimé par erreur, un mauvais commit, une modification impossible à retrouver…

La bonne nouvelle, c’est que Git a été conçu pour gérer ce genre de situation. Dans la majorité des cas, vos fichiers ne sont pas réellement perdus. Il existe souvent une solution pour restaurer une version précédente, récupérer un fichier supprimé ou annuler une mauvaise manipulation.

Pourquoi Git sauve souvent votre projet

Avant même de taper la moindre commande, il est important de comprendre une chose essentielle : Git conserve un historique.

À chaque commit, Git crée une sorte de “photo” de votre projet. Cela signifie qu’au fil du temps, vous accumulez plusieurs états de votre application. Même si vous modifiez ou supprimez un fichier, Git peut souvent retrouver une ancienne version.

• C’est un peu comme un système de sauvegarde intelligent.

Imaginez un développeur qui travaille sur son site pendant trois heures avant de supprimer accidentellement son fichier style.css. Sans Git, ce serait probablement un moment très douloureux. Avec Git, cela peut parfois se régler en quelques secondes.

C’est précisément ce qui rend Git aussi précieux dans le développement web.

Comprendre l’état des fichiers avec Git

Avant de restaurer quoi que ce soit, il faut apprendre à observer l’état du projet.

Pour cela, la commande la plus importante est :

git status

Cette commande affiche :

• les fichiers modifiés ;
• les fichiers supprimés ;
• les nouveaux fichiers ;
• les fichiers prêts à être enregistrés dans un commit.

Résultat possible :

On branch main

Changes not staged for commit:
  modified: index.html
  deleted: style.css

Git vous indique ici que :

• index.html a été modifié ;
• style.css a été supprimé.

Avant toute restauration, prenez l’habitude d’utiliser git status. C’est un peu le tableau de bord de votre projet.

Restaurer un fichier modifié

Imaginons maintenant une situation très fréquente.

Vous travaillez sur votre fichier index.html. Vous testez plusieurs idées, vous modifiez du code… puis finalement, vous réalisez que tout était mieux avant.

Vous souhaitez simplement revenir à la dernière version enregistrée dans Git.

Voici la commande :

git restore index.html

Cette commande restaure le fichier dans son dernier état sauvegardé.

Autrement dit :

• toutes les modifications non enregistrées seront supprimées
• le fichier redeviendra exactement comme lors du dernier commit

C’est très pratique… mais aussi un peu dangereux.

Pourquoi ? Parce qu’une fois la restauration effectuée, les modifications récentes disparaissent définitivement.

Avant de lancer cette commande, assurez-vous donc de ne plus avoir besoin des changements en cours.

Restaurer plusieurs fichiers en même temps

Vous pouvez également restaurer plusieurs fichiers d’un coup :

git restore index.html style.css app.js

Git remettra ces trois fichiers dans leur dernière version enregistrée.

Et si vous voulez tout restaurer dans le projet :

git restore .

• Le point représente l’ensemble du dossier courant.

Cette commande est très utile lorsqu’un test tourne mal et que vous souhaitez repartir d’une base propre.

Restaurer un fichier supprimé par erreur

C’est probablement l’une des erreurs les plus fréquentes chez les débutants.

Vous supprimez un fichier :

rm style.css

Puis vous réalisez quelques secondes plus tard que ce fichier était important. Pas de panique. Si le fichier existait dans le dernier commit, Git peut le récupérer facilement :

git restore style.css

Le fichier réapparaîtra immédiatement.

C’est souvent à ce moment-là que les débutants commencent vraiment à aimer Git.

Quelle différence entre modification et commit ?

Pour bien comprendre la restauration avec Git, il faut distinguer deux situations.

Les changements non commités

Ce sont les modifications que vous avez faites récemment, mais que vous n’avez pas encore enregistrées avec un commit.

Dans ce cas :

• git restore fonctionne très bien ;
• Git revient simplement au dernier état connu.

Les changements déjà commités

Ici, c’est différent. Une fois qu’un commit existe, Git considère cette version comme faisant partie de l’historique officiel du projet.

Il faudra alors utiliser d’autres commandes pour revenir en arrière.

C’est ce que nous allons voir maintenant.

Afficher l’historique du projet

Pour voir les anciennes versions du projet, utilisez :

git log

• Git affiche alors la liste des commits.

Exemple :

commit a51d2f7
Author: Alban
Date: Tue May 12

Ajout du menu responsive

commit b74c9e1
Author: Alban
Date: Mon May 11

Correction du formulaire

Chaque commit possède un identifiant unique.

C’est grâce à ces identifiants que Git peut retrouver une ancienne version.

Revenir temporairement à une ancienne version

Supposons que vous vouliez revoir l’état du projet avant une grosse erreur.

Vous pouvez charger temporairement un ancien commit :

git checkout b74c9e1

Git replace alors votre projet dans l’état exact de ce commit.

C’est très utile pour :

• vérifier un ancien code ;
• comparer des versions ;
• récupérer un fichier précis.

Attention toutefois : vous êtes alors dans un état spécial appelé “HEAD détachée”. Pas besoin d’avoir peur de ce terme compliqué. Cela signifie simplement que vous consultez une ancienne version sans être réellement sur votre branche habituelle.

Pour revenir à votre branche principale :

git checkout main

👉 Pour aller plus loin : Tout comprendre aux branches Git.

Restaurer un fichier depuis un ancien commit

Parfois, vous ne voulez pas restaurer tout le projet. Vous souhaitez simplement récupérer une ancienne version d’un fichier précis.

Imaginons que votre fichier style.css fonctionnait parfaitement il y a trois commits. Vous pouvez le récupérer avec :

git restore --source=b74c9e1 style.css

Git prendra alors le fichier depuis cet ancien commit.

• C’est extrêmement pratique lorsqu’un seul fichier pose problème.

Annuler le dernier commit

Autre situation classique : vous avez créé un commit… puis vous réalisez immédiatement qu’il contient une erreur.

Git permet de revenir en arrière.

Garder les modifications

Si vous souhaitez supprimer le commit mais conserver les fichiers modifiés :

git reset --soft HEAD~1

• Le commit disparaît, mais votre code reste présent.

C’est idéal lorsqu’on a oublié un fichier ou écrit un mauvais message de commit.

Supprimer complètement le commit

Si vous voulez revenir totalement à l’état précédent :

git reset --hard HEAD~1

Cette commande est beaucoup plus radicale.

Elle supprime :

• le commit ;
• les modifications associées.

Autrement dit, Git efface réellement les changements récents. Voilà pourquoi il faut être prudent avec --hard.

Comprendre HEAD simplement

Le mot HEAD apparaît souvent dans Git. En réalité, c’est simplement un pointeur.

Git utilise HEAD pour savoir où vous vous trouvez dans l’historique.

Par exemple :

Des formations informatique pour tous !

Débutant ou curieux ? Apprenez le développement web, le référencement, le webmarketing, la bureautique, à maîtriser vos appareils Apple et bien plus encore…

Formateur indépendant, professionnel du web depuis 2006, je vous accompagne pas à pas et en cours particulier, que vous soyez débutant ou que vous souhaitiez progresser. En visio, à votre rythme, et toujours avec pédagogie.

Découvrez mes formations Qui suis-je ?

HEAD~1

signifie : “le commit juste avant le commit actuel”.

Et :

HEAD~2

signifie : “deux commits en arrière”.

Ce système permet de naviguer facilement dans les anciennes versions du projet.

Sauvegarder temporairement son travail avec stash

Parfois, vous voulez mettre vos modifications de côté sans créer de commit.

Git possède une fonctionnalité très pratique pour cela :

git stash

Git range alors vos modifications dans une sorte de tiroir temporaire. Votre projet redevient propre immédiatement.

Plus tard, vous pourrez récupérer votre travail :

git stash pop

C’est particulièrement utile lorsqu’on veut :

• tester autre chose rapidement ;
• changer de branche ;
• éviter de perdre des modifications incomplètes.

Beaucoup de développeurs utilisent stash quotidiennement.

Pour résumer, la commande git stash est comme un tiroir où vous pouvez ranger votre travail en cours pour libérer votre bureau sans rien perdre. Imaginez que vous êtes en train de modifier un fichier, mais que votre code n’est pas encore fini (il ne « marche » pas encore). Soudain, vous devez absolument corriger un bug urgent ailleurs. Au lieu de faire un « commit » brouillon ou de risquer de perdre vos changements, vous tapez git stash. Git prend toutes vos modifications non sauvegardées, les met dans une boîte à part, et remet votre projet dans l’état exact où il était lors du dernier commit. Votre espace de travail est à nouveau « propre ».

Une fois que vous avez fini votre tâche urgente, vous pouvez revenir à votre tiroir et dire à Git : « Redonne-moi ce que j’ai rangé tout à l’heure ».

Pour cela, on utilise la commande git stash pop.

Vos modifications reviennent exactement là où vous les aviez laissées, et vous pouvez reprendre votre code tranquillement. C’est l’outil parfait pour jongler entre plusieurs tâches sans vous emmêler les pinceaux et sans polluer l’historique de votre projet avec des versions incomplètes.

Stash vs Commit

La différence principale réside dans le côté définitif ou temporaire de l’action

Un commit est comme une photo officielle que vous collez dans l’album photo de votre projet ; c’est une étape terminée, nommée et sauvegardée de façon permanente dans l’historique.

À l’inverse, un stash est une simple note adhésive posée sur le coin de votre bureau que vous prévoyez d’utiliser plus tard ; il sert à mettre vos modifications inachevées de côté pour retrouver un espace de travail propre en un instant, sans pour autant créer une trace officielle dans l’historique de votre code.

En résumé, vous utilisez le commit pour enregistrer vos progrès accomplis et le stash pour mettre votre bazar actuel en pause.

Quand une erreur semble irréversible

Il existe un moment très particulier avec Git. Celui où l’on pense :

“C’est fini… j’ai tout perdu.”

Cela arrive souvent après :

• un mauvais reset --hard ;
• une mauvaise manipulation ;
• un commit supprimé.

Et pourtant… Git garde souvent une trace cachée.

Utiliser git reflog pour retrouver des commits perdus

Voici probablement l’une des commandes les plus impressionnantes de Git :

git reflog

Cette commande affiche les déplacements récents de HEAD.

Même des commits “supprimés” peuvent encore apparaître ici.

Exemple :

a51d2f7 HEAD@{0}: reset: moving to HEAD~1
f84b221 HEAD@{1}: commit: Ajout du footer

Imaginons que vous ayez supprimé accidentellement le commit Ajout du footer.

Grâce au reflog, vous pouvez encore le retrouver. Puis revenir dessus :

git checkout f84b221

Ou même restaurer complètement le projet :

git reset --hard f84b221

Pour beaucoup de développeurs, git reflog ressemble presque à de la magie.

Restaurer un projet depuis GitHub

Parfois, le projet local est devenu tellement chaotique qu’il vaut mieux repartir de zéro.

Dans ce cas, GitHub peut servir de sauvegarde.

Vous pouvez simplement re-cloner le dépôt :

git clone https://github.com/utilisateur/projet.git

Git téléchargera une copie propre du projet. C’est une solution très rassurante lorsqu’on débute.

D’ailleurs, beaucoup de développeurs expérimentés utilisent cette méthode lorsqu’un environnement local devient trop instable.

Les erreurs Git les plus fréquentes chez les débutants

Lorsque l’on apprend Git, certaines erreurs reviennent sans arrêt.

Modifier un mauvais fichier

On pense corriger style.css, mais on modifie accidentellement app.js.

Dans ce cas :

• git status aide énormément ;
• git restore permet souvent de corriger rapidement le problème.

Oublier un commit

On travaille longtemps… puis on ferme le terminal sans commit. Git ne peut malheureusement pas sauver un travail jamais enregistré.

• Voilà pourquoi il est conseillé de faire des commits réguliers.

Même de petits commits.

Utiliser reset –hard trop rapidement

C’est probablement l’erreur la plus douloureuse.

Certains débutants tapent :

git reset --hard

sans réellement comprendre les conséquences.

Résultat : leurs modifications disparaissent. Heureusement, git reflog peut parfois sauver la situation.

Une bonne méthode pour éviter la panique

Avec l’expérience, beaucoup de développeurs suivent une sorte de routine avant toute commande risquée.

Voici une méthode simple :

1. Vérifier l’état du projet :

git status

2. Consulter les commits récents :

git log --oneline

3. Sauvegarder temporairement si nécessaire :

git stash

4. Puis seulement ensuite :

• restaurer ;
• annuler ;
• revenir en arrière.

Cette habitude réduit énormément les erreurs.

Git n’est pas votre ennemi

Quand on débute, Git peut sembler intimidant.

Les commandes paraissent étranges, les messages d’erreur parfois incompréhensibles, et certaines manipulations donnent vraiment l’impression qu’un projet entier vient d’exploser.

Pourtant, avec un peu de pratique, on réalise quelque chose d’important : Git est là pour vous protéger.

La plupart des développeurs ont déjà :

• supprimé un fichier important ;
• annulé le mauvais commit ;
• cassé un projet local ;
• paniqué devant un terminal.

C’est presque un passage obligatoire.

La différence, avec l’expérience, c’est qu’on apprend progressivement à utiliser les outils de restauration sans stress.

Et honnêtement, le jour où vous récupérerez un projet “perdu” grâce à git reflog, vous aurez probablement l’impression d’être devenu magicien.

---

FAQ Restauration avec Git

---

Maîtriser la restauration dans Git change complètement la manière de travailler sur un projet. On ose davantage tester des idées, modifier du code ou expérimenter, parce qu’on sait qu’il existe souvent un moyen de revenir en arrière.

Au début, certaines commandes peuvent sembler un peu abstraites. C’est normal. Git est un outil puissant, et il demande un petit temps d’adaptation. Mais plus vous pratiquerez, plus ces manipulations deviendront naturelles.

Le meilleur conseil reste finalement le plus simple : testez. Créez un petit projet, modifiez des fichiers, faites des erreurs volontairement, puis essayez de les corriger avec les commandes vues dans ce tutoriel.

Car c’est souvent en “cassant” un projet que l’on apprend réellement à utiliser Git.