# Overal node_modules: zo vind je ze, ruim je ze op en krijg je ze terug

> Vind elke node_modules-map op je Mac met de grootte erbij, verwijder wat je niet nodig hebt, installeer opnieuw vanuit de lockfile en wis de pakketcaches.

- URL: https://moreroom.app/nl/learn/node-modules-cleanup
- Published: 2026-10-17
- Updated: 2026-10-17
- Publisher: MoreRoom (Yando Pte. Ltd.) — https://moreroom.app

## TL;DR

- node_modules verwijderen is veilig zolang je package.json en de lockfile bewaart; npm ci of pnpm install zet exact dezelfde versies terug.
- find met -prune toont elke node_modules-map in je thuismap met de grootte erbij, zonder in geneste mappen af te dalen.
- Met npx npkill blader je door node_modules-mappen en verwijder je ze interactief, maar meteen en zonder prullenmand.
- Met pnpm zijn de bestanden in node_modules klonen of harde links van een gedeelde opslag, dus verwijderen levert weinig op totdat je pnpm store prune uitvoert.
- Buildmappen zoals .next, .turbo, .nuxt, .svelte-kit en .parcel-cache worden automatisch opnieuw opgebouwd en mogen ook veilig weg.

Een [node_modules](https://moreroom.app/glossary#node-modules)-map bevat de afhankelijkheden die voor één JavaScript- of TypeScript-project zijn geïnstalleerd, en is doorgaans een paar honderd megabyte groot. Met tientallen oude projecten loopt dat makkelijk op tot tientallen gigabytes. **Je kunt ze veilig verwijderen zolang je `package.json` en de lockfile bewaart**: je pakketbeheerder installeert dezelfde versies opnieuw zodra je naar het project terugkeert.

## Vind elke node_modules-map en de grootte ervan

Deze opdracht doorzoekt je thuismap, slaat `~/Library` en de prullenmand over en toont elke `node_modules`-map met de grootte, met de grootste onderaan:

```sh
find ~ \( -path "$HOME/Library" -o -path "$HOME/.Trash" \) -prune -o -type d -name node_modules -prune -print0 2>/dev/null | xargs -0 du -sh 2>/dev/null | sort -h
```

Zo werkt het: de eerste `-prune` slaat de twee uitgesloten mappen over, `-type d -name node_modules` vindt de mappen, en de tweede `-prune` zorgt dat `find` er niet in afdaalt, zodat geneste `node_modules` één keer worden meegeteld, binnen hun bovenliggende map. `du -sh` meet elke map en `sort -h` sorteert de lijst. De opdracht leest alleen. Bij een grote thuismap kan het een paar minuten duren, en Terminal kan om toegang vragen tot Documenten, Bureaublad of Downloads.

Negeer resultaten in mappen van tools zoals `~/.nvm`, `~/.vscode` of `~/.cursor`. Die horen bij geïnstalleerde tools en editorextensies, niet bij je projecten.

Gebruiken je projecten pnpm, dan zijn de getoonde groottes groter dan wat je terugkrijgt. Verderop lees je waarom.

## Verwijder de mappen die je niet nodig hebt

Open voordat je iets verwijdert de projectmap en controleer of er een lockfile in staat: `package-lock.json` (npm), `pnpm-lock.yaml` (pnpm), `yarn.lock` (Yarn) of `bun.lock` / `bun.lockb` (Bun). Bewaar die, en bewaar ook `package.json`.

De veiligste manier om te verwijderen is `node_modules` in de Finder naar de prullenmand te slepen. Zolang je de prullenmand niet leegt, kun je nog van gedachten veranderen. Met veel kleine bestanden duurt het verplaatsen naar de prullenmand even.

Vanuit Terminal, in één projectmap:

```sh
cd ~/Projects/old-app
rm -rf node_modules
```

`rm -rf` verwijdert definitief, zonder prullenmand. Controleer eerst met `pwd` in welke map je staat, en gebruik het nooit met een jokerteken of een lege variabele.

### npkill: een interactief alternatief

[npkill](https://github.com/voidcosmos/npkill) toont `node_modules`-mappen met hun grootte en laat je ze met één toetsaanslag tegelijk verwijderen:

```sh
npx npkill -d ~/Projects
```

`-d` bepaalt waar de zoektocht begint; zonder die optie begint npkill in de huidige map. Navigeer met de pijltoetsen en druk op de spatiebalk of Del om de geselecteerde map te verwijderen. npkill verwijdert meteen, zonder prullenmand. Mappen die apps nodig hebben om te werken, markeert het met ⚠️; laat die met rust. Met `--dry-run` simuleer je het verwijderen als je het eerst wilt uitproberen.

## Opnieuw installeren als je terugkeert naar een project

Gebruik de opdracht die precies installeert wat in de lockfile staat:

| Pakketbeheerder | Lockfile | Opnieuw installeren |
|---|---|---|
| npm | `package-lock.json` | `npm ci` |
| pnpm | `pnpm-lock.yaml` | `pnpm install --frozen-lockfile` |
| Yarn (Berry) | `yarn.lock` | `yarn install --immutable` |
| Yarn Classic | `yarn.lock` | `yarn install --frozen-lockfile` |
| Bun | `bun.lock` | `bun install --frozen-lockfile` |

[`npm ci`](https://docs.npmjs.com/cli/v11/commands/npm-ci) vereist een lockfile, verwijdert eerst een eventuele bestaande `node_modules` en wijzigt nooit `package.json` of de lockfile. Een gewone `npm install` werkt ook, maar kan de lockfile bijwerken.

## Andere mappen die zichzelf opnieuw opbouwen

Frameworks en buildtools bewaren caches en uitvoer naast `node_modules`. In projecten die je niet draait, kun je ze veilig verwijderen; de volgende build of devserver maakt ze opnieuw aan.

| Map | Aangemaakt door |
|---|---|
| `.next` | Next.js |
| `.nuxt` | Nuxt |
| `.svelte-kit` | SvelteKit |
| `.turbo` | Turborepo |
| `.parcel-cache` | Parcel |
| `.angular` | Angular CLI |

`dist` en `build` bevatten meestal ook builduitvoer, maar de namen zijn algemeen. Sommige projecten committen daar bestanden of gebruiken ze voor iets anders, dus kijk erin voordat je ze verwijdert.

Zo toon je de frameworkcaches in een projectenmap:

```sh
find ~/Projects -type d \( -name .next -o -name .nuxt -o -name .svelte-kit -o -name .turbo -o -name .parcel-cache \) -prune -print0 | xargs -0 du -sh | sort -h
```

## De globale pakketcaches wissen

Elke pakketbeheerder houdt daarnaast een downloadcache bij die alle projecten delen. Die wissen is definitief, maar onschuldig: pakketten worden opnieuw gedownload als dat nodig is.

```sh
npm cache clean --force
pnpm store prune
yarn cache clean
bun pm cache rm
```

- **npm** bewaart zijn cache in `~/.npm/_cacache`. De [documentatie van npm cache](https://docs.npmjs.com/cli/v11/commands/npm-cache) legt uit waarom `clean` `--force` nodig heeft en vermeldt dat `npm cache verify` opruimt zonder alles te legen. Pakketten die `npx` ophaalt, staan in `~/.npm/_npx`.
- **pnpm** bewaart zijn opslag op macOS in `~/Library/pnpm/store` (`pnpm store path` toont die van jou). [`pnpm store prune`](https://pnpm.io/cli/store) verwijdert alleen pakketten waarnaar geen project verwijst, en de documentatie van pnpm raadt aan het af en toe uit te voeren, niet voortdurend.
- **Yarn Classic** cachet in `~/Library/Caches/Yarn`. Bij Yarn Berry leegt `yarn cache clean --mirror` de globale cache in `~/.yarn/berry/cache`.
- **Bun** cachet in `~/.bun/install/cache`; `bun pm cache rm` maakt die leeg.

Ook oude Node.js-versies die je met nvm hebt geïnstalleerd, tellen op in `~/.nvm/versions/node`; met `nvm uninstall <version>` verwijder je een versie die je niet meer nodig hebt.

## Waarom pnpm minder vrijmaakt dan du aangeeft

npm en Yarn Classic kopiëren elk pakket naar de `node_modules` van elk project. pnpm bewaart elk pakket één keer, in een [content-addressable store](https://pnpm.io/motivation), en linkt de bestanden in elk project dat het pakket gebruikt. Op macOS probeert de standaardinstelling [`packageImportMethod`](https://pnpm.io/settings/node-modules) van pnpm eerst APFS-klonen en daarna [harde links](https://moreroom.app/glossary#hard-link).

![npm kopieert pakketten naar elk project, terwijl pnpm één opslag deelt via klonen of harde links](https://moreroom.app/learn/img/node-modules-cleanup-pnpm-store.svg)

Hoe dan ook worden de bytes gedeeld. `du` telt in elk project toch de volledige grootte, dus de `node_modules` van een pnpm-project verwijderen levert meestal veel minder op dan werd aangegeven. De ruimte komt terug wanneer `pnpm store prune` pakketten verwijdert die geen overgebleven project meer gebruikt. Daarvoor moet de opslag op dezelfde schijf staan als het project; projecten op een externe schijf krijgen daar een eigen opslag.

## Hoe MoreRoom helpt

De gratis versie van MoreRoom vindt `node_modules`-mappen in projecten die een lockfile hebben en 30 dagen niet zijn aangeraakt, plus frameworkcaches zoals `.next` en `.turbo`, en labelt ze als “Veilig te verwijderen”. Het slaat `~/Library` over, net als mappen van tools zoals `~/.nvm` en `~/.vscode`. Je verplaatst onderdelen één voor één naar de prullenmand, met Herstel. Voor de npm-cache en de pnpm-opslag voert MoreRoom `npm cache clean --force` en `pnpm store prune` uit; die opdrachten zijn definitief en worden ook zo gelabeld.

MoreRoom Pro voegt Projectwinterslaap toe: inactieve projecten laten mappen vallen die opnieuw kunnen worden opgebouwd, zoals `node_modules` en builduitvoer, en worden met één klik weer wakker zodra je terugkeert. Pro bevat ook de Verzamelaar en Doelmodus.

## FAQ

### Is het veilig om node_modules te verwijderen?

Ja. De map bevat alleen geïnstalleerde afhankelijkheden, die je pakketbeheerder opnieuw kan installeren vanuit package.json en de lockfile. Verwijder hem alleen bij projecten die je nu niet draait, en bewaar de lockfile.

### Moet ik package-lock.json ook verwijderen?

Nee. De lockfile legt de exacte versies vast die werkten. Bewaar hem, zodat npm ci, pnpm install of yarn install later dezelfde node_modules kan aanmaken.

### Waarom levert het verwijderen van node_modules in een pnpm-project zo weinig ruimte op?

pnpm bewaart één kopie van elk pakket in een gedeelde opslag en kloont of hardlinkt die bestanden in elk project. Verwijder je de node_modules van een project, dan verdwijnen alleen de links; pnpm store prune verwijdert daarna de pakketten die geen enkel project gebruikt.

### Is npm cache clean --force veilig?

Ja. Het leegt de downloadcache van npm in ~/.npm/_cacache, en npm downloadt pakketten opnieuw als dat nodig is. Volgens de documentatie van npm is de cache wissen alleen nuttig om schijfruimte terug te winnen.

### Verplaatst npkill mappen naar de prullenmand?

Nee. npkill verwijdert de geselecteerde mappen meteen. Gebruik de optie --dry-run om te oefenen, en de Finder als je de prullenmand als vangnet wilt.