Comment supprimer des fichiers d’un dépôt Git sans casser votre projet

Supprimer des fichiers avec Git n’est pas toujours aussi simple qu’il y paraît. Vous supprimez un fichier sur votre système, mais cela ne signifie pas qu’il a disparu du dépôt. Il peut encore exister dans l’historique, ou pire, être ajouté par erreur au prochain commit, comme un fichier de configuration ou une clé API.

Dans ce guide, vous allez apprendre à retirer des fichiers de Git. Nous commencerons par les commandes de base comme git rm, puis nous verrons des méthodes plus avancées, comme le nettoyage des fichiers non suivis et l’édition de l’historique des commits.

Prérequis

Avant de supprimer des fichiers avec Git, vérifions que tout est en place.

D’abord, vérifiez si Git est installé. Ouvrez votre terminal et exécutez :

git --versionPropulsé par

Si vous voyez un numéro de version, vous êtes prêt.

Si vous voyez un numéro de version, vous êtes prêt.

Vous pouvez aussi installer une interface graphique Git comme GitHub Desktop, Sourcetree ou GitKraken si vous préférez un mode visuel. Mais dans ce guide, j’utiliserai la ligne de commande (Git Bash).

Assurez-vous d’avoir les droits pour modifier le dépôt, surtout si vous travaillez en équipe ou avec un dépôt distant comme GitHub ou GitLab.

Note : certaines suppressions sont irréversibles. Il est donc conseillé de sauvegarder votre projet ou au minimum de vérifier l’état de votre dépôt avant d’exécuter des commandes qui suppriment des fichiers.

Une fois cela fait, allons-y.

Suppression de fichiers basique avec Git

Il existe plusieurs façons de supprimer des fichiers dans Git, selon votre objectif. Voici les options les plus courantes :

Utiliser git rm

La commande git rm supprime des fichiers de votre dépôt Git. Quand vous l’exécutez, il se passe deux choses :

• Git retire le fichier de votre répertoire de travail
• Il prépare cette suppression pour le prochain commit

Mais Git ne se contente pas de supprimer le fichier. Il enregistre la suppression dans l’historique. Une fois que vous validez (commit), le fichier est officiellement retiré du projet.

git rm file1.txtPropulsé par

Vous pouvez supprimer un fichier, plusieurs fichiers, ou un ensemble avec des jokers.

Par exemple, pour supprimer tous les fichiers de logs :

git rm *.logPropulsé par

Cela indique à Git de supprimer tous les fichiers du dossier qui se terminent par .log. Vous pouvez confirmer le changement avec :

git statusPropulsé par

Supprimez plusieurs fichiers avec une seule commande git rm. Image par l’auteur.

Vous voulez supprimer tous les fichiers d’un dossier sans supprimer le dossier lui-même ? Utilisez :

git rm temp/*Propulsé par

Cela supprime tous les fichiers à l’intérieur du dossier temp sans supprimer le dossier.

Git ajoute aussi des garde-fous. Si un fichier contient des modifications non validées, Git ne le supprimera pas sauf si vous forcez. À utiliser seulement si vous êtes certain de pouvoir jeter ces changements :

git rm -fPropulsé par

Pour supprimer un dossier entier et son contenu, ajoutez l’option -r :

git rm -r testfolderPropulsé par

Cela supprime testfolder et tous les fichiers qu’il contient.

Ensuite, validez la modification avec :

git commit -m "removed log files”Propulsé par

Options clés de git rm

Voici les options les plus courantes avec git rm :

1. <filename>

C’est l’usage de base. Listez simplement les fichiers à supprimer :

git rm file1.txt file2.txtPropulsé par

Vous pouvez aussi utiliser un joker pour supprimer plusieurs fichiers du même type. Par exemple, pour supprimer tous les fichiers .txt :

git rm *.txtPropulsé par

(Ici, * signifie « tout ». Il correspond à tout nom de fichier qui se termine par .txt.)

2. --cached

Cette option supprime le fichier du dépôt mais le conserve sur votre ordinateur. Disons que j’ai ajouté par erreur un fichier sensible comme config.env. Je ne veux pas qu’il soit dans le dépôt, mais j’en ai besoin localement. J’exécuterais donc :

git rm --cached config.envPropulsé par

Ici, git rm le supprimerait du dépôt et du répertoire de travail. Et --cached arrête son suivi par Git (il ne sera pas poussé), tout en le laissant physiquement en place.

Pour éviter qu’il ne soit réajouté, ajoutez-le à .gitignore :

echo config.env >> .gitignorePropulsé par

3. -r

Signifie récursif. Au lieu d’un fichier, supprime le dossier et son contenu de manière récursive. Sans cela, Git renverra une erreur si vous tentez de supprimer un dossier.

git rm -r <folder-name>Propulsé par

Ici, j’ai créé un dossier nommé testfolder avec deux fichiers : a.txt et b.txt. Ensuite, j’exécute :

git rm -r testfolderPropulsé par

Cela supprime le dossier ainsi que tout son contenu.

4. --dry-run

Si vous n’êtes pas sûr de l’impact d’une suppression, utilisez git rm avec l’option --dry-run comme ceci :

git rm --dry-run <filename>Propulsé par

C’est une façon sûre d’apercevoir ce qui sera supprimé.

Ou si vous nettoyez des fichiers non suivis et voulez vérifier ce qui sera supprimé, utilisez :

git clean -nPropulsé par

Cela affichera uniquement ce que la commande supprimerait.

Analyse comparative des workflows

Il y a plusieurs façons de supprimer un fichier dans Git. Elles peuvent sembler similaires, mais leur comportement diffère.

git rm vs suppression manuelle

Prenons un fichier nommé file.txt. Disons que je n’en ai plus besoin.

Une façon de le supprimer est de l’effacer directement du système.

Sur Linux, macOS ou Git Bash :

rm file.txtPropulsé par

Sur Windows (invite de commandes) :

del file.txtPropulsé par

Cela supprime le fichier de votre dossier. Mais Git ne le sait pas encore. Vous devez donc indiquer à Git que le fichier a été supprimé :

git add file.txtPropulsé par

Cela prépare la suppression pour qu’elle soit incluse dans le prochain commit.

Si vous avez supprimé plusieurs fichiers et ne vous souvenez plus de tous, exécutez :

git add -uPropulsé par

Cela prépare tous les fichiers suivis modifiés ou supprimés. Il n’inclut pas les fichiers non suivis.

Validez maintenant le changement :

git commit -m "Remove file.txt"Propulsé par

Si vous utilisez git rm, tout est géré en une seule étape. Le fichier est supprimé et la modification est immédiatement indexée :

git rm file.txtgit commit -m "Remove file.txt"Propulsé par

Inutile d’exécuter git add séparément. C’est plus propre et vous n’oublierez pas d’indexer la suppression.

En bref :

• La suppression manuelle nécessite des étapes supplémentaires pour que Git prenne en compte le changement.
• Si vous oubliez d’indexer la suppression, Git pensera que le fichier existe toujours, ce qui peut provoquer de la confusion dans les commits ou les fusions.
• git rm est plus propre et plus sûr quand vous supprimez intentionnellement des fichiers suivis.

Restaurer des fichiers supprimés dans Git

Et si vous supprimez un fichier puis réalisez ensuite qu’il vous est encore utile ? Pas de souci. Git propose plusieurs façons de le récupérer selon le moment où vous détectez l’erreur.

Si vous n’avez pas encore validé (commit) :

Disons que vous avez supprimé le fichier sans encore valider la modification. Vous pouvez le restaurer depuis le dernier commit comme ceci :

git restore file.txtPropulsé par

Cela rétablit le fichier dans votre répertoire de travail depuis le dernier commit.

Si vous avez déjà validé la suppression :

Pas de problème non plus. D’abord, trouvez le dernier commit où le fichier existait encore :

git log -- file.txtPropulsé par

Parcourez le journal et copiez le hash du commit où le fichier était présent. Puis exécutez :

git checkout <commit hash> -- file.txtPropulsé par

Dans les anciennes versions de Git, vous pouviez utiliser la commande ci-dessus. Elle restaure un fichier depuis un commit précis, mais pouvait aussi changer de branche.

Depuis Git 2.23, cela a été séparé en deux commandes plus claires :

• git switch (pour changer de branche)
• git restore (pour restaurer des fichiers)

Si vous souhaitez uniquement restaurer un fichier depuis un commit, utilisez :

git restore --source=<commit-hash> --file.txtPropulsé par

Cela récupère le fichier depuis ce commit et le remet dans votre répertoire de travail.

Si vous ne savez pas quand le fichier a été supprimé :

Peut-être avez-vous fait de nombreux changements et ne vous souvenez plus à quel moment le fichier a disparu. Dans ce cas, utilisez git reflog ou journal des références :

git reflogPropulsé par

Cela affiche l’historique complet de vos commits, checkouts, resets, etc.

Mais git reflog est local uniquement et ne fonctionne pas sur les dépôts distants. Si vous travaillez avec un dépôt distant, il vaut mieux utiliser git log -- file.txt pour suivre l’historique de ce fichier.

Une fois le point identifié, restaurez le fichier avec git checkout ou git restore comme précédemment.

Corriger les fichiers manquants dans Git

Parfois, des fichiers sont supprimés directement du système — via l’explorateur, une commande rm en terminal, ou par accident. Dans ce cas, Git ne nettoie pas automatiquement. Il marque ces fichiers comme manquants et attend que vous gériez correctement la suppression.

Voyons comment traiter cette situation, étape par étape.

Étape 1 : repérer les fichiers manquants

Exécutez ceci dans le dossier du projet :

git statusPropulsé par

Si Git indique qu’un fichier est supprimé, cela signifie qu’il a disparu de votre système, mais que le changement n’a pas encore été indexé.

Étape 2 : indexer la suppression

Pour demander à Git d’indexer tous les changements (y compris les suppressions), exécutez :

git add -APropulsé par

• git add -A = indexer tous les changements (nouveaux, modifiés, supprimés).
• git add -u = indexer modifiés + supprimés, mais pas les nouveaux.

Cela indexe toutes les modifications : nouveaux, modifiés et supprimés. Puis validez :

git commit -m "Removed missing files"Propulsé par

C’est la méthode la plus sûre pour tout nettoyer en une fois.

Étape 3 : pousser sur le dépôt distant

Si vous travaillez avec un dépôt distant, poussez le commit :

git push origin <branch-name>Propulsé par

Remplacez <branch-name> par la branche de travail, comme main ou dev.

Étape 4 : alternative

Disons que vous avez supprimé manuellement un lot de fichiers, par accident ou lors d’un ménage. Git pense toujours que ces fichiers existent jusqu’à ce que vous l’informiez du contraire.

Si vous ne souhaitez pas tous les retirer un par un avec git rm, il existe un moyen plus rapide de nettoyer.

Exécutez cette commande dans votre terminal :

git ls-files --deleted -z | xargs -0 git rmPropulsé par

Voici ce qu’elle fait :

• git ls-files --deleted liste tous les fichiers suivis par Git qui manquent désormais sur le disque.
• xargs -0 git rm transmet ces noms de fichiers à git rm et les supprime de l’index de Git.

Très utile sur un gros projet pour accélérer le nettoyage.

Note : j’ai obtenu ce message car aucun fichier suivi n’est actuellement manquant sur votre disque.

Suppression avancée de fichiers avec Git

Maintenant que nous avons vu les bases, passons à des situations plus avancées où retirer un fichier de Git ne se résume pas à exécuter git rm. Ce sont des cas où des données sensibles sont en jeu ou où il faut nettoyer prudemment des fichiers non suivis.

Retirer des données sensibles de Git

Il arrive qu’un fichier contenant des données privées, comme des clés API ou des mots de passe, soit commité par erreur. Le supprimer « normalement » ne suffit pas. Comme Git conserve l’historique complet, le fichier existe encore dans les commits antérieurs.

Pour l’effacer totalement, utilisez la commande git filter-repo : git filter-repo (recommandé)

C’est une alternative plus récente et meilleure que filter-branch. Plus rapide, plus sûre et plus simple.

Commencez par l’installer (vous aurez besoin de Python et pip) :

pip install git-filter-repoPropulsé par

Puis exécutez :

git filter-repo --path hide.txt --invert-pathsPropulsé par

Cela supprime le fichier hide.txt de tous les commits de l’historique du dépôt.

Pour vérifier, exécutez :

git log --all -- supersecrets.txtPropulsé par

Si le fichier a disparu, ajoutez-le à .gitignore pour éviter qu’il ne soit de nouveau suivi :

echo hide.txt >> .gitignorePropulsé par

Si vous travaillez en équipe, nettoyez l’historique réécrit et poussez en force :

git push origin --force --allPropulsé par

Prévenez ensuite vos collègues. Ils devront re-cloner ou réinitialiser leurs copies locales pour éviter les erreurs.

Nettoyer les fichiers non suivis avec git clean

Faisons le point :

• Les fichiers suivis figurent dans l’historique de Git. Pour les retirer, utilisez git rm, puis validez.
• Les fichiers non suivis ne sont pas dans Git. Ils peuvent s’accumuler et encombrer votre projet.

Pour supprimer des fichiers ou dossiers non suivis, utilisez git clean.

Voici les options les plus utiles :

git clean -n     # Affiche les fichiers non suivis qui seraient supprimésgit clean -nd    # Affiche les dossiers non suivis qui seraient supprimésgit clean -fd    # Supprime tous les fichiers et dossiers non suivis. Destructif.Propulsé par

Ici :

• -n signifie aperçu uniquement.
• -f force la suppression.
• -d inclut les dossiers dans le nettoyage.

Note : git clean n’affecte pas les fichiers suivis. Mais il supprimera tout ce qui n’est pas suivi, y compris des fichiers que vous souhaitiez garder. Utilisez donc toujours -n d’abord pour prévisualiser.

Suppression de fichiers dans GitHub et outils GUI

La plupart de ce que nous avons vu se fait en ligne de commande. Mais tout le monde ne travaille pas ainsi, et c’est très bien. Certain·e·s développeurs utilisent des outils visuels ou travaillent directement dans GitHub.

Voyons comment la suppression fonctionne dans l’interface web de GitHub et dans d’autres outils GUI, et comment cela se compare à la ligne de commande.

Supprimer des fichiers sur le site GitHub

Si vous travaillez dans l’interface navigateur de GitHub, vous pouvez supprimer des fichiers sans terminal.

Voici comment cela fonctionne dans l’interface 2025 :

1. Ouvrez le fichier à supprimer.
2. Cliquez sur les trois points en haut à droite.
3. Choisissez Delete file dans le menu déroulant.

GitHub affiche alors une zone de message de commit. Ajoutez un court message, par exemple :

Delete practice.pyPropulsé par

Vous pouvez aussi écrire une description optionnelle.

Ensuite, choisissez comment enregistrer la modification :

• Valider directement sur la branche main
• Ou créer une nouvelle branche et ouvrir une pull request (recommandé en équipe)

Cliquez sur Commit changes, et GitHub supprimera le fichier et enregistrera la suppression dans un commit, comme le fait git rm en ligne de commande.

Supprimer des fichiers avec des outils Git GUI

Si vous utilisez une interface Git comme GitHub Desktop, Sourcetree ou Tower, le processus est également simple :

1. Supprimez le fichier dans votre explorateur ou depuis l’application.
2. L’application affiche la suppression sous « Changes » ou « File Status ».
3. Vérifiez, indexez et validez la modification.

Chaque outil a son look, mais le workflow est similaire : vous suivez les changements visuellement et vous validez quand vous êtes prêt.

Bonnes pratiques par plateforme

Aperçu rapide du fonctionnement de la suppression selon les plateformes, et quand les utiliser :

• GitHub (Web) : idéal pour des corrections rapides et petites mises à jour. À éviter pour des grands nettoyages ou des fichiers sensibles.
• Outils Git GUI : parfaits au quotidien. Vision claire des changements et commits sécurisés.
• Ligne de commande : la plus flexible et la plus utile. Idéale pour les tâches avancées, les modifications en masse ou les réécritures d’historique.

Bonnes pratiques pour la suppression de fichiers avec Git

Supprimer des fichiers avec Git semble simple, mais une erreur peut casser votre code. Voici des conseils pratiques que j’applique pour sécuriser les suppressions, surtout sur des projets partagés ou de long terme.

Toujours vérifier avant de supprimer

Avant de supprimer, prenez une minute pour confirmer ce que fait le fichier :

• Exécutez git status pour voir s’il est indexé ou modifié.
• Utilisez git log -- <filename> pour consulter son historique de commits.

Ce rapide contrôle m’évite des heures de récupération plus tard.

Faire des commits atomiques

Un commit atomique correspond à une unité logique de changement par commit.

Par exemple, si je supprime des fichiers inutilisés, je ne commite que ces suppressions, séparément de mes modifications de code.

Pourquoi c’est utile :

• Le débogage est plus simple. Des outils comme git bisect fonctionnent mieux avec des commits petits et ciblés.
• L’historique reste clair et lisible.
• Les revues de code vont plus vite.

Collaborer prudemment lors d’une réécriture d’historique

Réécrire l’historique avec des outils comme git filter-repo impacte toute l’équipe. Pour éviter le chaos :

• Communiquez avant de réécrire des branches partagées.
• Utilisez git push --force avec précaution, car cela réécrit l’historique distant.
• Demandez aux collègues de re-cloner ou de réinitialiser leurs dépôts locaux ensuite.

Utiliser --dry-run avant toute commande destructive

Avant d’exécuter une commande qui supprime des fichiers, testez-la :

git clean -nPropulsé par

Cette commande montre ce qui serait supprimé sans rien effacer. Voici pourquoi vous devriez toujours le faire :

• Évite de supprimer des fichiers que vous vouliez garder.
• Agit comme filet de sécurité, surtout sur de gros projets où une erreur peut effacer journaux ou fichiers générés.

Combiner git rm --cached et .gitignore

Si vous avez commité par mégarde quelque chose qui ne devrait pas être dans le dépôt (fichier de config, logs), corrigez en deux étapes :

1. Arrêter le suivi du fichier :```git rm --cached <filename>

git rm --cached <filename>Propulsé par

Cela indique à Git d’arrêter de suivre le fichier, tout en le laissant sur votre machine.

1. L’ajouter à .gitignore :

echo <filename> >> .gitignorePropulsé par

Pourquoi c’est utile :

• Garde les fichiers sensibles ou locaux (comme .env, .log ou node_modules) hors du dépôt.
• Évite d’encombrer l’historique Git.
• Les futures modifications de ces fichiers ne déclencheront plus de changements dans Git.

Cas limites Git : indexation et dossiers vides

Parfois, la suppression ne se déroule pas comme prévu. Vous pouvez indexer le mauvais fichier ou rencontrer des problèmes avec des dossiers vides.

Voici comment je gère ces cas fréquents.

Désindexer un fichier sans perdre vos modifications

Supposons que j’exécute git add . et que j’indexe par erreur un fichier. Je ne veux pas perdre mes changements — je veux seulement le désindexer.

Pour corriger ça, j’exécute :

git reset HEAD <filename>Propulsé par

Cela retire le fichier de l’index, tout en conservant les modifications.

Pour vérifier, j’utilise :

git statusPropulsé par

Le fichier doit maintenant apparaître comme « modified » et non plus « staged ».

Conserver des dossiers vides dans le dépôt

Par défaut, Git ignore les dossiers vides. Si je tente de valider un dossier sans fichier, Git l’ignore.

Mais il m’arrive de vouloir garder ce dossier pour de futurs journaux ou imports. L’astuce consiste à ajouter un fichier « placeholder » appelé .gitkeep.

Voici comment faire :

touch logs/.gitkeepgit add logs/.gitkeepgit commit -m "Keep logs folder in the repo"Propulsé par

Cela rend le dossier « non vide » et Git le suit.

Note : .gitkeep n’est pas une fonctionnalité Git. C’est une convention. Vous pouvez nommer le fichier comme vous voulez, mais .gitkeep indique clairement son utilité.

Dépannage de la suppression de fichiers Git

Voici quelques problèmes courants rencontrés lors de suppressions dans Git, et comment les résoudre.

Le fichier apparaît encore sur le dépôt distant

Vous avez supprimé le fichier, validé la modification, mais il est toujours sur le dépôt distant. Peut-être avez-vous oublié de pousser.

Assurez-vous donc d’exécuter :

git push origin <branch-name>Propulsé par

Vérifiez aussi :

• Êtes-vous sur la bonne branche ?
• Votre commit inclut-il bien la suppression du fichier ?

Problèmes avec les sous-modules

Les sous-modules sont des dépôts Git à l’intérieur d’autres dépôts Git. Ils ne se comportent pas comme des dossiers normaux.

Si vous supprimez des fichiers dans un sous-module :

• Entrez dans le dossier du sous-module
• Validez et poussez les changements depuis le sous-module

Si vous retirez entièrement le sous-module :

• Supprimez le dossier du sous-module
• Retirez les références dans .gitmodules et .git/config

État HEAD détaché (detached HEAD)

Dans Git, HEAD pointe généralement vers la branche courante. Mais parfois il pointe vers un commit spécifique : c’est l’état « detached HEAD ».

Cela arrive si vous :

• Faites un checkout d’un commit par son hash
• Passez sur un tag
• Faites un checkout d’une branche distante sans la configurer en suivi

Vérifiez votre statut :

git statusPropulsé par

Si vous voyez :

HEAD detached at <commit-hash>Propulsé par

Vous n’êtes pas sur une branche et tout nouveau changement peut être perdu lorsque vous en changez.

Voici comment corriger la situation :

Si vous avez fait des changements et souhaitez les conserver, exécutez :

git checkout -b <new-branch-name>Propulsé par

Cela place votre travail sur une nouvelle branche et le sauvegarde.

Si vous avez déjà commité les changements et voulez les déplacer plus tard vers une autre branche, faites :

git checkout -b temp-branch          # from detached HEADgit checkout main                    # or another target branchgit merge temp-branchPropulsé par

Si vous n’avez fait aucun changement et souhaitez simplement sortir du mode detached HEAD, exécutez :

git checkout <branch-name> Propulsé par

Et voilà. Votre HEAD est réattaché et tout revient à la normale.

Erreurs de permissions ou d’état

Parfois Git refuse de supprimer un fichier, notamment sous Windows. Cela peut arriver si :

• Le fichier est ouvert dans une autre application
• Git n’a pas les permissions pour le modifier

Pour corriger :

• Fermez toute application utilisant le fichier
• Redémarrez le terminal en mode Administrateur (Windows)

Problèmes de merge ou de rebase

Si vous voyez des erreurs telles que :

• you are not currently on a branch
• merge conflict

Vous êtes probablement au milieu d’un merge ou d’un rebase.

Pour terminer un rebase après résolution des conflits :

git rebase --continuePropulsé par

Pour annuler complètement le rebase ou le merge :

git reset --mergePropulsé par

Cela restaure votre dépôt à l’état antérieur au début du merge.

Vous voulez jeter tous les changements locaux et réinitialiser votre répertoire de travail ?

Essayez :

git restore .Propulsé par

Cela remet tous les fichiers dans l’état du dernier commit.

Dernières réflexions

Quand vous supprimez des fichiers avec Git, l’erreur est vite arrivée si vous n’êtes pas attentif. Un petit faux pas peut entraîner de gros problèmes : code cassé, travail perdu, incompréhensions dans l’équipe. D’où l’intérêt de prendre quelques secondes pour vérifier ce que vous faites.

Utilisez la bonne commande pour la situation. Si vous n’êtes pas sûr de l’effet d’une action, testez d’abord en dry run. Et si vous travaillez à plusieurs, assurez-vous que tout le monde est aligné.

Git sait faire bien plus que supprimer des fichiers. Vous pouvez supprimer des branches, annuler des erreurs avec reset et revert, ou voir précisément ce qui a changé avec git diff. Plus vous apprenez, plus votre workflow gagne en fluidité.

Avancez étape par étape. C’est ainsi qu’on progresse.