Juillet 2026 · Guide Mac pour développeurs

Supprimer node_modules dans tous vos projets sur Mac

Chaque projet que vous avez lancé garde sa propre copie de node_modules, et l'ensemble finit par peser des dizaines de gigaoctets oubliés. Voici comment les trouver tous, voir leur taille, les supprimer sans risque, puis réinstaller dès que vous revenez au projet.

Par Ram Velmurugan · Founder & Lead Developer, 1dot.ai

Terminal et interface graphique·Nettoyage sûr et réversible·9 min de lecture
En bref

Depuis votre dossier de projets, listez chaque node_modules avec sa taille grâce à find . -type d -name node_modules -prune -exec du -sh {} + | sort -hr, puis supprimez-les tous avec find . -type d -name node_modules -prune -exec rm -rf {} +. Vous préférez vérifier visuellement ? Lancez npx npkill et supprimez les dossiers un par un.

C'est sans risque, car node_modules est généré, pas écrit à la main. Tant que le projet conserve son package.json et son lockfile, npm install le reconstruit exactement comme avant.

Ouvrez « À propos de ce Mac », cliquez sur Stockage, et regardez cet énorme bloc Données système ou Développeur, impossible à explorer d'un clic. Si vous écrivez du JavaScript, une bonne partie de ce bloc est très probablement node_modules : le dossier de dépendances que npm, Yarn et pnpm déposent dans chaque projet où vous avez lancé une installation.

Le problème ne vient d'aucun de ces dossiers pris isolément. Une app React ou Next.js transporte 200 à 500 Mo dans node_modules, ce qui paraît raisonnable tant que vous travaillez dessus. Le problème, c'est que vous en avez une vingtaine éparpillés entre de vieux projets perso, des missions client terminées l'an dernier et des tutoriels clonés une fois puis jamais rouverts. Chacun garde sa copie complète sur le disque. Personne ne les supprime, parce que personne ne se souvient qu'ils sont là.

Ce guide montre comment les faire apparaître tous d'un coup, voir exactement l'espace occupé par chacun et supprimer ceux dont vous n'avez pas besoin, sans toucher à une seule ligne de votre vrai code.

Pourquoi node_modules remplit votre disque sans bruit

node_modules est l'endroit où votre gestionnaire de paquets installe chaque bibliothèque dont dépend votre projet, plus chaque bibliothèque dont celles-ci dépendent, et ainsi de suite jusqu'en bas. Un projet front-end moderne embarque ainsi des centaines de paquets, et l'arbre est stocké sous forme de dizaines de milliers de minuscules fichiers. Trois facteurs le font grossir plus vite que prévu.

  • Rien n'est partagé entre les projets. Avec npm et Yarn classique, chaque projet reçoit sa propre copie complète de chaque dépendance. Dix projets qui utilisent React stockent React dix fois.
  • Il est invisible dans le Finder par défaut. On ne parcourt pas node_modules, il n'apparaît donc jamais quand vous cherchez de l'espace. macOS range l'essentiel dans les Données système, que vous ne pouvez pas explorer.
  • Les anciens projets ne sont jamais nettoyés. Vous terminez un projet, passez à autre chose, et son node_modules reste aussi lourd que le jour où vous avez lancé npm install pour la dernière fois. Il n'a pas de date d'expiration.

Au total, un Mac de développeur en activité transporte couramment 5 à 30 Go de dossiers node_modules, parfois bien davantage. La bonne nouvelle, c'est que presque rien de tout cela ne mérite d'être gardé, car chaque octet peut être reconstruit à la demande.

Pourquoi le supprimer est sans risque (et réversible)

Voici l'idée clé qui rend tout le nettoyage peu risqué : node_modules est généré, pas écrit à la main. Vous n'y écrivez jamais de code. Il est produit entièrement à partir de deux fichiers qui vivent dans votre projet et sont versionnés dans Git :

  • package.json liste les dépendances que demande votre projet.
  • Le lockfile (package-lock.json pour npm, yarn.lock pour Yarn ou pnpm-lock.yaml pour pnpm) consigne les versions exactes qui ont été installées.

Lancez npm install, yarn ou pnpm install : le gestionnaire de paquets lit ces deux fichiers et reconstruit node_modules dans exactement le même état. C'est aussi pour cela que presque tous les projets listent node_modules dans leur .gitignore : il est jetable par nature, il n'est donc jamais versionné dans le dépôt. Supprimer le dossier ne change rien à votre dépôt, à votre historique ni à votre code source.

La seule chose à vérifier
Un projet ne peut être nettoyé sans risque que s'il a un lockfile. Si vous tombez sur un vieux dossier avec un package.json mais sans lockfile, lancez une fois npm install et versionnez le lockfile généré avant de faire le ménage. Vous serez ainsi certain de pouvoir retrouver les mêmes versions plus tard.

Trouver chaque node_modules et sa taille

Ne supprimez jamais avant d'avoir regardé. La première commande trouve chaque node_modules sous un dossier et affiche sa taille, du plus gros au plus petit, pour que vous sachiez à quoi vous avez affaire. Pointez-la vers l'endroit où vous rangez votre code. Beaucoup de développeurs utilisent ~/Developer, mais chez vous ce sera peut-être ~/Projects, ~/code ou plusieurs emplacements différents.

find ~/Developer -type d -name node_modules -prune -exec du -sh {} + | sort -hr

Voici le rôle de chaque partie :

  • -type d -name node_modules cible les dossiers nommés node_modules.
  • -prune indique à find de ne pas descendre dans un node_modules une fois qu'il en a trouvé un. C'est important, car les dépendances ont leurs propres node_modules imbriqués : sans prune, vous les compteriez deux fois et perdriez du temps à parcourir des millions de fichiers.
  • -exec du -sh {} + affiche une taille lisible pour chaque résultat.
  • sort -hr place les plus gros dossiers en tête.

Le résultat ressemble à ceci, et les pires gloutons sautent aux yeux immédiatement :

482M  /Users/you/Developer/old-client-dashboard/node_modules
417M  /Users/you/Developer/nextjs-experiment/node_modules
361M  /Users/you/Developer/react-native-app/node_modules
298M  /Users/you/Developer/gatsby-blog-2023/node_modules
 96M  /Users/you/Developer/cli-tool/node_modules

Pour voir le total cumulé, additionnez les tailles lors d'un second passage. Cette commande affiche un seul total général, pour savoir combien d'espace est en jeu :

find ~/Developer -type d -name node_modules -prune -exec du -sk {} + | awk '{sum += $1} END {printf "%.1f GB total\n", sum/1024/1024}'

Vous avez maintenant un vrai chiffre et une liste. Si les vieux projets perso et les missions client terminées en représentent l'essentiel, vous pouvez récupérer la plus grande partie de cet espace sans jamais toucher à ce sur quoi vous travaillez.

La suppression en une ligne, et le rôle de -prune

Une fois la liste vérifiée et si vous êtes à l'aise, la suppression reprend la même commande avec rm -rf à la place de du. Lancez-la depuis votre dossier de projets, ou indiquez-lui le dossier explicitement :

# depuis votre dossier de projets
find . -type d -name node_modules -prune -exec rm -rf {} +

L'option -prune fait ici un vrai travail, elle ne sert pas seulement à gagner du temps. Quand find trouve un node_modules de premier niveau et l'élague, il le supprime en entier sans d'abord descendre dans les node_modules imbriqués de chaque dépendance. L'opération reste rapide, et find n'essaie pas de descendre dans des répertoires que rm -rf est en train d'effacer sous ses pieds.

Avant de lancer rm -rf
rm -rf ne passe pas par la Corbeille et ne peut pas être annulé. Lancez d'abord la version du de la commande et lisez la liste. Vérifiez que vous êtes bien dans votre dossier de projets, et non dans votre dossier personnel ou à la racine du disque, pour que la recherche ne s'aventure jamais dans des bundles d'apps ou des caches de Library. En cas de doute, utilisez plutôt npkill, qui vous montre chaque dossier avant de le supprimer.

Si vous voulez seulement supprimer les dépendances d'un projet, find est inutile. Placez-vous dans ce projet et lancez rm -rf node_modules. Réinstallez avec votre gestionnaire de paquets quand vous y revenez.

npkill : la méthode interactive

Si une suppression globale à l'aveugle vous inquiète, npkill est l'option la plus rassurante. Cet outil gratuit en ligne de commande recherche les dossiers node_modules et vous laisse les supprimer un par un depuis une liste triable, mise à jour en direct. Rien à installer de façon permanente, lancez-le avec npx :

npx npkill

Il analyse à partir du dossier où vous le lancez, affiche chaque node_modules trouvé avec sa taille et sa date de dernière modification, et vous laisse parcourir la liste avec les flèches du clavier. Appuyez sur la touche Suppr sur un dossier pour l'effacer. Vous voyez chacun disparaître et l'espace revenir en temps réel.

La raison de le préférer à une commande brute, c'est la sécurité. Certaines apps installées, dont Spotify et Discord, embarquent leur propre node_modules et en ont réellement besoin pour fonctionner. npkill signale ces dossiers par un avertissement, pour que vous ne supprimiez pas quelque chose qui casserait une app. Un simple balayage rm -rf lancé de trop haut les effacerait sans prévenir.

Astuce
Triez la liste de npkill par taille et commencez par le haut. Une poignée des plus gros dossiers représente en général l'essentiel de l'espace : vous pouvez récupérer des dizaines de gigaoctets en quelques minutes sans faire défiler chaque entrée.

Quelle méthode choisir

Les trois approches suppriment les mêmes dossiers. Elles diffèrent par le niveau de contrôle qu'elles vous donnent et par la confiance que vous vous accordez face à une suppression avec caractères génériques.

MéthodeIdéal pourContrôleVitesse
find + du (mesure)Avoir une vue d'ensemble avant d'agirLecture seuleRapide
find + rm -rfTout vider sous un dossier en un seul passageTout ou rienLe plus rapide
npkillVérifier et supprimer dossier par dossierPar dossier, avec avertissementsRapide
rm -rf node_modulesNettoyer un seul projetUn projetInstantané
System Cleaner (app)Aussi les caches hors Node, en un passage vérifiéPar élément, avec vérificationRapide

Un bon réflexe par défaut : lancez la commande find + du pour voir la liste, puis supprimez les gros dossiers avec npkill en gardant un œil sur chacun. Ne sortez la ligne find + rm -rf que si vous êtes certain que tout le dossier peut être vidé, par exemple un répertoire d'archives de projets terminés.

Trouvez chaque node_modules de votre Mac

System Cleaner liste node_modules à côté des caches Xcode, des dossiers de build Flutter et des caches Gradle en un seul passage, et ne supprime que les dossiers que vous cochez. Le nettoyeur est entièrement gratuit.

macOS 12 or later. 25 free AI renames, no account needed.

Les points de vigilance

Le nettoyage de node_modules peut mal tourner de deux façons précises, toutes deux faciles à éviter.

  • Lancer la suppression de trop haut. Si vous lancez la commande find depuis votre dossier personnel ou la racine du disque, elle peut atteindre des bundles d'apps et des dossiers Library qui contiennent leur propre node_modules. Restez dans votre répertoire de projets, ou laissez npkill signaler pour vous les dossiers qui appartiennent à des apps.
  • Nettoyer un projet sans lockfile. Sans lockfile versionné, une réinstallation peut récupérer des versions plus récentes et légèrement différentes de vos dépendances. Pour un projet actif, cela compte. Générez et versionnez d'abord un lockfile, puis nettoyez.

Pour tout le reste, allez-y. Vous ne pouvez pas perdre de code source de cette manière, car votre code ne vit jamais dans node_modules. Dans le pire des cas réaliste, une erreur vous coûte une réinstallation en une ligne.

Remettre un projet en route

Quand vous revenez à un projet dont vous avez vidé le node_modules, une seule commande lancée dans le dossier du projet suffit pour le restaurer. Utilisez le gestionnaire de paquets du projet, que vous reconnaîtrez à son lockfile :

npm install     # package-lock.json
yarn            # yarn.lock
pnpm install    # pnpm-lock.yaml

Le gestionnaire de paquets lit le lockfile et réinstalle exactement les versions que vous aviez. Pour un projet typique, cela prend de quelques secondes à quelques minutes, selon votre connexion et selon que les paquets sont encore ou non dans le cache local du gestionnaire. Voilà tout l'échange : un peu de temps de réinstallation contre des gigaoctets d'espace récupéré sur des projets auxquels vous ne touchez pas aujourd'hui.

Éviter que tout se remplisse à nouveau

Vider node_modules une fois est satisfaisant, mais le dossier repousse à la prochaine installation. Quelques habitudes l'empêchent de remonter un jour à des dizaines de gigaoctets.

  • Passer à pnpm. pnpm stocke chaque version de paquet une seule fois dans un magasin global adressé par contenu, puis la lie par lien physique dans chaque projet. Dix projets qui utilisent la même version de React partagent une seule copie sur le disque au lieu d'en garder dix. Si vous jonglez entre plusieurs projets, c'est la correction structurelle la plus efficace.
  • Nettoyer au fil de l'eau. Dès que vous bouclez une mission client ou mettez un projet perso de côté, supprimez son node_modules. Le lockfile reste dans Git : rien n'est perdu, et le dossier se reconstruit si vous rouvrez un jour le projet.
  • Contrôler les tailles tous les deux ou trois mois. Lancez la commande find + du à intervalles réguliers. À 8 Go, c'est un nettoyage de deux minutes. À 40 Go, c'est la panique quand le disque se remplit en plein build.
  • Purger aussi le cache du gestionnaire de paquets. Le cache global de téléchargement grossit indépendamment de node_modules. npm cache clean --force, yarn cache clean et pnpm store prune récupèrent cet espace quand il devient important.

node_modules est rarement le seul à alourdir un Mac de développeur. Xcode DerivedData, les simulateurs iOS, les images Docker et les anciens résultats de build s'accumulent en parallèle. Si le disque reste à l'étroit après avoir vidé node_modules, c'est là qu'il faut regarder ensuite. Notre guide pour vider le cache Xcode traite le plus gros d'entre eux.

Quand un outil de nettoyage se justifie

Les commandes ci-dessus sont le bon outil si vous vivez dans le terminal et ne vous souciez que de node_modules. Une app dédiée devient utile quand vous préférez voir tous les caches de développement de votre Mac d'un seul coup d'œil, et quand node_modules n'est qu'une partie du problème.

Files Magic AI inclut un System Cleaner avec une vue dédiée aux caches de développement. Elle fait apparaître les dossiers node_modules, Xcode DerivedData et les autres caches de build de tout le Mac dans une seule liste, affiche leur taille et les supprime après vérification, sans que rien ne parte sans votre accord. Il s'ajoute au rangement de fichiers par IA sur l'appareil et à Magic Rename, qui fonctionne sur l'appareil par défaut, autour desquels l'app est construite. Récupérer de l'espace devient ainsi une partie de l'entretien de la machine, et non une corvée à part avec un outil à part.

Rien de tout cela ne remplace find ou npkill. Si vous aimez la ligne de commande, continuez à l'utiliser. L'app s'adresse aux développeurs qui préfèrent jeter un œil à une liste, cocher les dossiers inutiles et attraper dans le même passage les caches qui ne viennent pas de Node.


Questions fréquentes

Peut-on supprimer node_modules sans risque ?
Oui, tant que le projet a toujours son package.json et un lockfile. node_modules est un dossier de build rempli de dépendances téléchargées, pas votre code source. Lancez npm install, yarn ou pnpm install et il revient exactement comme avant. Le seul cas où il faut s'arrêter est un projet sans lockfile : réinstallez et versionnez un lockfile avant de nettoyer.
Comment trouver tous les dossiers node_modules sur mon Mac ?
Pointez find vers votre dossier de projets et listez chaque résultat avec sa taille : find ~/Developer -type d -name node_modules -prune -exec du -sh {} + | sort -hr. L'option -prune empêche find de descendre dans les node_modules imbriqués, ce qui le rend rapide et évite de compter deux fois. Remplacez ~/Developer par l'endroit où vous rangez votre code.
Comment supprimer tous les dossiers node_modules d'un coup ?
Depuis votre dossier de projets, lancez find . -type d -name node_modules -prune -exec rm -rf {} +. La commande trouve chaque node_modules, ignore ceux qui sont imbriqués à l'intérieur et les supprime en un seul passage. Lancez toujours d'abord la même commande avec du, pour voir exactement ce qui sera supprimé.
Qu'est-ce que npkill et comment fonctionne-t-il ?
npkill est un outil gratuit en ligne de commande que vous lancez avec npx npkill. Il analyse à partir du dossier courant, liste chaque node_modules trié par taille et vous laisse supprimer celui de votre choix avec les flèches et la touche Suppr. Il signale par un avertissement les dossiers qui appartiennent à des apps installées comme Spotify ou Discord, ce qui le rend plus sûr qu'une commande qui supprime tout à l'aveugle.
Pourquoi node_modules est-il si volumineux ?
Les gestionnaires de paquets installent tout l'arbre de dépendances à plat sur le disque, si bien qu'une seule app React ou Next.js occupe souvent 200 à 500 Mo répartis sur des dizaines de milliers de petits fichiers. Avec npm et Yarn classique, rien n'est partagé entre les projets : chacun garde sa propre copie complète. Dix à vingt projets peuvent ainsi totaliser 5 à 30 Go, rangés pour l'essentiel dans les Données système, où vous ne les voyez jamais.
Faut-il ajouter node_modules au .gitignore ?
Oui, et presque tous les projets le font déjà. node_modules est généré à partir du package.json et du lockfile, il ne doit donc jamais être versionné. Comme Git l'ignore, le supprimer ne touche en rien votre dépôt : le dossier se reconstruit à partir de votre manifeste versionné à la prochaine installation, et c'est précisément pour cela que le vider est sans risque.
Comment éviter que node_modules remplisse à nouveau mon disque ?
Passez à pnpm, qui stocke chaque paquet une seule fois dans un magasin global et le lie par lien physique dans chaque projet : dix copies d'une dépendance occupent la place d'une seule. Supprimez node_modules des projets que vous n'avez pas ouverts depuis des mois, puisqu'ils se réinstallent en quelques secondes quand vous y revenez. Et faites un rapide contrôle des tailles avec find tous les deux ou trois mois, pour que rien ne s'accumule à nouveau.

Vous voulez une vue d'ensemble du stockage Mac au-delà de node_modules ? Notre guide pour libérer de l'espace disque sur Mac traite des doublons, des DMG et d'autres caches de développement, le guide du cache Xcode s'occupe de l'autre gros consommateur d'une machine de développeur, et notre comparatif des meilleures apps de nettoyage pour Mac classe les outils qui automatisent tout cela.

Publié le 14 juillet 2026 · Plus de guides · Files Magic AI

Une liste plutôt qu'une commande find

npkill et find font tous deux le travail. Si vous voulez que les restes de Gradle, Flutter et Xcode soient attrapés dans le même passage, le nettoyeur de Files Magic AI les affiche ensemble, avec une vérification préalable.

macOS 12 or later. 25 free AI renames, no account needed.