Node.js 22+ features die het verschil maken

Node.js 22 is sinds oktober 2024 een LTS-release en brengt features die echt het verschil maken in je dagelijkse workflow. Van een volwassen native test runner tot een ingebouwde WebSocket client, een permission model en de handige node --run scripts: de laatste twee jaar heeft het platform enorme stappen gezet.

In dit artikel loop ik door de belangrijkste verbeteringen van Node.js 22 en nieuwer, met praktische voorbeelden. Je ziet wat je direct kunt gebruiken, wat nog experimenteel is en waar je op moet letten bij een upgrade.

Waarom Node.js 22 de moeite waard is

Node.js 22 kreeg in oktober 2024 de LTS-status onder de codenaam "Jod". Support loopt door tot april 2027. De release bundelt een V8-update naar versie 12.4, Maglev als standaard tier compiler op 64-bit systemen en een groot aantal ingebouwde tools die voorheen losse dependencies vereisten.

Voor teams betekent dat minder externe packages, minder maintenance en vaak betere performance. Als je nog op Node.js 18 of eerder zit, wordt het tijd om te plannen, want Node.js 18 is eind april 2025 end-of-life gegaan.

Native test runner: eindelijk volwassen

De node:test module is er al sinds Node.js 18, maar pas in 22 voelt hij echt productie-klaar. Je hebt nu geen Jest, Vitest of Mocha meer nodig voor veel projecten.

import { test, describe, before } from 'node:test'
import assert from 'node:assert/strict'
import { createUser } from './users.js'

describe('users', () => {
  before(() => {
    // setup
  })

  test('maakt een gebruiker aan', async () => {
    const user = await createUser({ email: '[email protected]' })
    assert.equal(user.email, '[email protected]')
    assert.ok(user.id)
  })
})

Je draait dit met node --test of met het nieuwe node --test --watch voor test-watch mode. De runner ondersteunt nu ook coverage via --experimental-test-coverage, mocks via mock.fn() en filterbare tests met --test-name-pattern.

Wat je ermee bespaart: geen extra build step, geen Babel, geen Jest-config en een snellere startup. Voor meer context over teststrategieën lees je testing strategieën in Node.js.

node --run: vergeet npm run

Als je ooit hebt opgemerkt hoe traag npm run script soms is, dan waardeer je node --run. Deze nieuwe builtin leest scripts uit je package.json en draait ze direct, zonder de overhead van npm.

# Oud
npm run build

# Nieuw, tot 2x sneller op startup
node --run build

Let op: node --run is bewust minimalistisch. Het ondersteunt geen pre/post scripts en draait niet automatisch node_modules/.bin in PATH. Voor de meeste scripts is dat prima, voor complexere workflows blijf je bij npm of een task runner.

Ingebouwde WebSocket client

Node.js 22 heeft een WebSocket client ingebouwd, geïmplementeerd via undici. Geen ws of isomorphic-ws meer nodig voor de client-zijde.

const ws = new WebSocket('wss://echo.websocket.org')

ws.addEventListener('open', () => {
  ws.send('hallo')
})

ws.addEventListener('message', (event) => {
  console.log('ontvangen:', event.data)
})

De API is identiek aan die van de browser, wat code delen tussen frontend en backend makkelijker maakt. Voor servers blijf je ws of Socket.IO gebruiken. Meer over realtime architectuur lees je in WebSockets en realtime apps.

fetch, undici en request pooling

De globale fetch is in Node.js 22 stabiel en volledig ondersteund. Onder de motorkap draait undici, de HTTP/1.1 client die speciaal voor Node.js ontwikkeld is.

const response = await fetch('https://api.example.com/users', {
  headers: { 'Authorization': `Bearer ${token}` }
})

if (!response.ok) {
  throw new Error(`HTTP ${response.status}`)
}

const users = await response.json()

Voor geavanceerde use cases zoals connection pooling, retries of interceptors gebruik je undici direct. Voor rate limiting en defensieve clients kijk je ook naar rate limiting en API security.

Watch mode zonder nodemon

Je kunt sinds Node.js 22 stabiel gebruik maken van node --watch. Het herstart je applicatie automatisch bij file changes, en sinds 22 is het ook stabiel voor productie-achtige dev workflows.

node --watch server.js

Combineer met --env-file=.env om environment variables in te laden zonder dotenv, en je hebt een zeer lichte dev setup zonder nodemon of dotenv.

node --watch --env-file=.env server.js

TypeScript zonder build step

Vanaf Node.js 22.6 kun je TypeScript-bestanden experimenteel direct draaien met --experimental-strip-types. In Node.js 22.18+ is dit stabieler en in versie 23 zelfs standaard aan.

node --experimental-strip-types server.ts

Belangrijk: Node voert geen type checking uit. Types worden simpelweg weggestript voor uitvoering. Voor echte type safety heb je nog steeds tsc --noEmit in je pipeline nodig. Meer hierover in TypeScript in Node.js projecten.

Features zoals enums, namespaces of decorators werken niet standaard, daarvoor blijf je bij tsc of tsx. Voor een groot deel van moderne TypeScript-code is strip-types echter een gamechanger.

Het permission model

Een van de meer ambitieuze features: een ingebouwd permission model waarmee je processen kunt beperken tot specifieke bestanden, directories of capabilities.

node --experimental-permission \
     --allow-fs-read=./data \
     --allow-fs-write=./logs \
     app.js

Je script kan nu alleen lezen uit ./data en schrijven naar ./logs. Probeert het iets anders, dan krijg je een ERR_ACCESS_DENIED. Er is ook --allow-child-process en --allow-worker voor process-scheiding.

Het is nog experimenteel en heeft edge cases, maar voor untrusted scripts, plugins of CI-pipelines is het nu al interessant. Voor productie security combineer je dit met containerisatie, zoals beschreven in Node.js in Docker best practices.

Glob zonder externe dependencies

Je hoeft glob of fast-glob niet meer te installeren voor eenvoudige file matching. Node.js 22 brengt fs.glob en de synchrone variant mee.

import { glob } from 'node:fs/promises'

for await (const file of glob('src/**/*.js')) {
  console.log(file)
}

Het ondersteunt standaard glob-patronen en werkt prima voor CLI-tools, migration scripts of build-hulpjes. Voor zeer complexe matching blijven gespecialiseerde libraries sneller.

V8 upgrade en performance wins

De V8-engine in Node.js 22 is versie 12.4. Dat brengt Maglev als standaard tier compiler mee voor 64-bit platforms, wat vooral CLI-tools en korte processen aanzienlijk sneller maakt.

Verdere verbeteringen:

• Snellere Array.prototype.toSorted en andere immutable array methods
• WeakRef en FinalizationRegistry stabiel, handig voor caches
• Intl.Segmenter voor tekst-segmentatie in meerdere talen
• Betere performance van structuredClone voor diepe kopieën

In benchmarks zien veel teams 10-20% verbetering op CPU-gebonden workloads vergeleken met Node.js 18. Voor concrete tuning tips zie performance tuning Node.js.

Stabiele require(esm)

Een van de grootste pijnpunten van de afgelopen jaren: je kon geen ESM-modules requiren vanuit CommonJS. In Node.js 22.12 is require(esm) stabiel geworden achter een vlag, en sinds versie 23 standaard aan.

// CommonJS bestand
const { someFunction } = require('./pure-esm-module.mjs')

Dit betekent dat je legacy CJS-codebases stap voor stap kunt moderniseren zonder alles in één keer om te bouwen. Niet elke ESM-module werkt, vooral die met top-level await niet, maar het opent deuren die jarenlang dicht zaten.

Wat dit betekent voor je stack

De trend is duidelijk: Node.js integreert steeds meer tools die voorheen extern waren. Dat heeft concrete gevolgen voor je project:

• Minder dependencies betekent minder supply chain risk en snellere installs
• Snellere startup door minder modules en Maglev scheelt in CI en serverless
• Betere developer experience met watch, test runner en env-file ingebouwd
• Security as a feature via het permission model en betere defaults

Tegelijk moet je kritisch blijven. Niet elke ingebouwde feature verslaat een gespecialiseerde library. Vitest heeft meer features dan node:test, fast-glob is sneller dan fs.glob op grote filesystemen, en Express' middleware-ecosysteem is niet te evenaren.

Migratie: praktische tips

Upgraden van Node.js 18 of 20 naar 22 is doorgaans straightforward. Let op:

• Check je dependencies met npm outdated en test op een feature branch
• Update je Dockerfile naar node:22-alpine of node:22-slim
• Vervang dotenv door --env-file=.env waar mogelijk
• Experimenteer met node:test op nieuwe test files, niet direct op bestaande Jest suites
• Monitor je app na deploy, de V8-update kan edge cases in memory usage onthullen

Voor meer over productie-voorbereiding lees je de production readiness checklist voor Node.js apps.

De officiële release notes en de Node.js 22 announcement geven de complete lijst. Ook de Node.js changelogs op GitHub zijn een goudmijn voor details per minor release.

Veelgestelde vragen

Is Node.js 22 een LTS-versie?

Ja, Node.js 22 werd in oktober 2024 een LTS-versie (Long Term Support) onder de codenaam "Jod". Dat betekent dat je tot april 2027 op security fixes en bugfixes kunt rekenen, wat het een veilige keuze maakt voor productie.

Kan ik nu al zonder ts-node TypeScript draaien in Node.js?

Vanaf Node.js 22.6 kun je TypeScript experimenteel direct draaien via de --experimental-strip-types vlag. In Node.js 23 is dit standaard aan, en in LTS 22.18+ werkt het stabieler. Voor type checking heb je nog steeds tsc nodig.

Wat is het verschil tussen fetch in Node.js en undici?

De ingebouwde fetch in Node.js 22 gebruikt intern undici als HTTP-client. Voor de meeste use cases voldoet fetch prima, maar als je geavanceerde features nodig hebt zoals connection pooling of interceptors, gebruik je undici direct.

Moet ik migreren van Node.js 20 naar 22?

Als je op Node.js 20 zit, is een upgrade naar 22 meestal laagdrempelig. De V8 engine update levert performance wins op en features zoals --run en de stabiele watch mode besparen tijd in development. Test wel je dependencies.

Werkt het permission model al productie-ready?

Het permission model in Node.js 22 is nog experimenteel. Het is interessant voor niet-kritieke workloads en tooling, maar voor productie waar security cruciaal is, combineer je het beter met containerisatie en OS-level isolatie.