# Node.js 24 en 2026 : URLPattern, Permission Model et questions d'entretien

> Node.js 24 LTS apporte un Permission Model stable, URLPattern global, la gestion explicite des ressources avec using/await using et V8 13.6. Plongée dans les fonctionnalités qui comptent en production et en entretien.

- Published: 2026-05-31
- Updated: 2026-06-06
- Author: SharpSkill
- Tags: node.js, node.js 24, urlpattern, permissions, interview, v8, javascript
- Reading time: 10 min

---

Node.js 24, nom de code Krypton, est passé en statut LTS en octobre 2025 et reste la version de production recommandée en 2026. Cette version stabilise le Permission Model, promeut URLPattern au rang d'API globale, livre la gestion explicite des ressources via V8 13.6 et fait passer npm à la version 11. Ces évolutions touchent directement la façon dont les applications backend gèrent la sécurité, le routage et le cycle de vie des ressources.

> **Node.js 24 LTS en un coup d'œil**
>
> V8 13.6 avec `using`/`await using`, flag `--permission` stable qui remplace `--experimental-permission`, `URLPattern` global pour un routage sans framework, npm 11 et Undici 7 comme client HTTP par défaut. Le dernier correctif est la 24.16.0 (mai 2026).

## Le Permission Model : de l'expérimental au prêt pour la production

Node.js 20 avait introduit le Permission Model derrière `--experimental-permission`. Node.js 24 abandonne le préfixe `experimental`. Le flag devient simplement `--permission`, et le runtime restreint l'accès au système de fichiers, au réseau, aux processus enfants, aux addons natifs et aux variables d'environnement, sauf autorisation explicite.

L'enjeu concerne la sécurité de la chaîne d'approvisionnement. Une dépendance compromise ne peut ni exfiltrer des données sur le réseau ni lire des fichiers arbitraires si le processus s'exécute sous `--permission` avec des autorisations finement délimitées.

```bash
# launch-secure.sh
# Run an API server with minimal permissions
node --permission \
  --allow-fs-read=/app/src,/app/config \
  --allow-fs-write=/app/uploads \
  --allow-net=0.0.0.0:3000 \
  server.js
```

Le processus ci-dessus ne peut que lire les répertoires de sources et de configuration, écrire dans le dossier des uploads et écouter sur le port 3000. Toute tentative de lancer un processus enfant, de charger un addon natif ou d'accéder à des variables d'environnement hors du périmètre autorisé déclenche une erreur `ERR_ACCESS_DENIED`.

### Vérifications de permissions à l'exécution avec process.permission

La méthode `process.permission.has()` permet une introspection à l'exécution. Le code applicatif peut vérifier ses propres capacités avant de tenter une opération restreinte.

```javascript
// permission-check.js
// Verify permissions before performing restricted operations
function ensureWriteAccess(directory) {
  if (!process.permission.has('fs.write', directory)) {
    throw new Error(`No write permission for ${directory}`);
  }
}

function canSpawnProcesses() {
  return process.permission.has('child');
}

// Gracefully degrade when network access is restricted
function fetchWithFallback(url, cachedData) {
  if (!process.permission.has('net')) {
    console.warn('Network access denied, using cached data');
    return cachedData;
  }
  return fetch(url);
}
```

Ce schéma s'avère particulièrement utile pour les bibliothèques qui doivent fonctionner aussi bien en environnement sandboxé que sans restriction. Le [correctif de sécurité](https://nodejs.org/en/blog/vulnerability/march-2026-security-releases) de mars 2026 pour Node.js 24.14.1 a également corrigé un contournement dans `FileHandle.chmod()` et `FileHandle.chown()` qui ignorait les vérifications de permissions, ce qui souligne l'importance de maintenir le runtime à jour.

## URLPattern global : correspondance de routes native sans dépendances

Node.js 24 expose [URLPattern](https://developer.mozilla.org/en-US/docs/Web/API/URLPattern) dans la portée globale. Ce standard WHATWG offre une correspondance de motifs proche des expressions régulières, conçue spécifiquement pour les URL, avec groupes nommés, segments optionnels et contraintes de validation.

Aucun `import` ni `require` n'est nécessaire. L'API se comporte de façon identique dans les navigateurs, dans Cloudflare Workers et dans Deno, ce qui en fait une primitive de routage véritablement portable.

```javascript
// router.js
// Framework-free HTTP router using global URLPattern
const routes = [
  {
    pattern: new URLPattern({ pathname: '/api/users/:userId' }),
    handler: handleGetUser
  },
  {
    pattern: new URLPattern({ pathname: '/api/users/:userId/posts/:postId' }),
    handler: handleGetPost
  },
  {
    // Optional segment: matches /api/products and /api/products/:category
    pattern: new URLPattern({ pathname: '/api/products{/:category}?' }),
    handler: handleProducts
  }
];

function matchRoute(url) {
  for (const route of routes) {
    const result = route.pattern.exec(url);
    if (result) {
      return { handler: route.handler, params: result.pathname.groups };
    }
  }
  return null;
}

// Usage with Node.js HTTP server
import { createServer } from 'node:http';

const server = createServer((req, res) => {
  const url = new URL(req.url, `http://${req.headers.host}`);
  const match = matchRoute(url.href);

  if (match) {
    match.handler(req, res, match.params);
  } else {
    res.writeHead(404).end('Not Found');
  }
});

server.listen(3000);
```

### Validation de motifs et correspondance avancée

URLPattern prend en charge des contraintes regex en ligne sur les groupes nommés, la correspondance par protocole et le filtrage par nom d'hôte. La méthode `test()` renvoie un booléen pour des vérifications rapides, sans allouer d'objet de résultat.

```javascript
// url-validation.js
// Validate URL segments with inline regex constraints
const numericUser = new URLPattern({ pathname: '/users/:id([0-9]+)' });
numericUser.test('https://app.com/users/42');    // true
numericUser.test('https://app.com/users/alice'); // false

// Match by protocol and hostname
const secureApi = new URLPattern({
  protocol: 'https',
  hostname: 'api.example.com',
  pathname: '/v2/*'
});

// Service worker-style routing for static assets vs API calls
const staticAssets = new URLPattern({ pathname: '/static/*' });
const apiCalls = new URLPattern({ pathname: '/api/*' });
```

Côté performance, URLPattern n'a pas vocation à rivaliser en débit brut avec des routeurs optimisés comme [find-my-way](https://github.com/delvedor/find-my-way). Sa valeur tient à la portabilité entre runtimes et à une API standardisée qui élimine les bugs d'analyse de chemins.

## Gestion explicite des ressources : using et await using

V8 13.6 dans Node.js 24 livre la proposition TC39 [Explicit Resource Management](https://github.com/tc39/proposal-explicit-resource-management). Les déclarations `using` et `await using` remplacent les blocs `try/finally` pour le nettoyage déterministe des descripteurs de fichiers, des connexions de base de données, des verrous et de tout objet implémentant `Symbol.dispose` ou `Symbol.asyncDispose`.

Depuis Node.js 24.2.0, `Symbol.dispose` et `Symbol.asyncDispose` ne sont plus expérimentaux.

```javascript
// resource-management.js
// Automatic cleanup with using and await using
import { open } from 'node:fs/promises';

async function processCSV(path) {
  // File handle is automatically closed when scope exits
  await using file = await open(path, 'r');
  const content = await file.readFile({ encoding: 'utf8' });
  return content.split('\n').length;
  // file[Symbol.asyncDispose]() called here automatically
}

// Custom disposable resource
function createDatabasePool(connectionString) {
  const pool = new Pool(connectionString);
  return {
    pool,
    query: (sql, params) => pool.query(sql, params),
    [Symbol.asyncDispose]: async () => {
      await pool.end();
      console.log('Pool connections released');
    }
  };
}

async function runMigrations() {
  await using db = createDatabasePool(process.env.DB_URL);
  await db.query('CREATE TABLE IF NOT EXISTS migrations ...');
  // Pool automatically closed, no try/finally needed
}
```

### DisposableStack pour plusieurs ressources

`DisposableStack` et `AsyncDisposableStack` agrègent plusieurs ressources jetables. Lorsque la pile est libérée, les ressources sont relâchées dans l'ordre inverse, ce qui gère correctement les chaînes de dépendances.

```javascript
// disposable-stack.js
// Manage multiple resources with AsyncDisposableStack
async function processTransaction() {
  await using stack = new AsyncDisposableStack();

  const connection = stack.use(await getConnection());
  const transaction = stack.use(await connection.beginTransaction());
  const tempFile = stack.use(await createTempFile());

  await transaction.execute('INSERT INTO orders ...');
  await tempFile.write('backup data');

  // On scope exit: tempFile closed, transaction committed/rolled back,
  // connection returned to pool (reverse order)
}
```

Ce schéma élimine toute une catégorie de bugs de fuite de ressources. Le type `SuppressedError` traite le cas limite où la libération elle-même lève une exception, en préservant à la fois l'erreur d'origine et l'erreur de libération.

## V8 13.6 : fonctionnalités du moteur JavaScript à connaître

Au-delà de la gestion explicite des ressources, V8 13.6 introduit plusieurs fonctionnalités qui reviennent lors des [entretiens techniques Node.js](/technologies/node-nestjs).

**RegExp.escape** assainit les chaînes pour les intégrer sans danger dans une expression régulière :

```javascript
// regexp-escape.js
// Safely embed user input in regular expressions
const userInput = 'price: $9.99 (USD)';
const escaped = RegExp.escape(userInput);
// escaped: 'price\:\ \$9\.99\ \(USD\)'
const pattern = new RegExp(escaped);
```

**Float16Array** ajoute un tableau typé à virgule flottante 16 bits, qui divise par deux l'usage mémoire par rapport à `Float32Array` pour des charges comme l'inférence ML ou la préparation de buffers WebGL :

```javascript
// float16.js
// Half-precision floating point for memory-sensitive workloads
const weights = new Float16Array([0.5, -1.25, 3.14]);
console.log(weights.byteLength); // 6 bytes instead of 12 with Float32Array
```

**Error.isError** fournit une vérification de type fiable qui fonctionne entre realms (iframes, contextes vm, worker threads) :

```javascript
// error-check.js
// Cross-realm error detection
const err = new TypeError('invalid input');
Error.isError(err);           // true
Error.isError({ message: 'fake' }); // false
```

## Amélioration des performances d'AsyncLocalStorage

Node.js 24 fait basculer `AsyncLocalStorage` sur l'implémentation `AsyncContextFrame` par défaut. Les versions précédentes reposaient sur une approche à base de hooks qui ajoutait du surcoût à chaque opération asynchrone. La nouvelle implémentation s'intègre directement à la file de microtâches de V8, réduisant le coût de propagation du contexte dans les applications à forte concurrence.

Ce changement est transparent pour le code existant. Des bibliothèques comme [OpenTelemetry](https://opentelemetry.io/) et les frameworks de journalisation qui s'appuient sur `AsyncLocalStorage` pour un contexte propre à chaque requête bénéficient de gains de débit mesurables, sans modification du code.

```javascript
// async-context.js
// Request-scoped context with improved AsyncLocalStorage
import { AsyncLocalStorage } from 'node:async_hooks';

const requestContext = new AsyncLocalStorage();

function handleRequest(req, res) {
  const context = {
    requestId: crypto.randomUUID(),
    startTime: performance.now()
  };

  requestContext.run(context, async () => {
    // Context automatically propagated through all async operations
    const data = await fetchUserData(req.userId);
    const elapsed = performance.now() - requestContext.getStore().startTime;
    logger.info(`Request ${requestContext.getStore().requestId} completed in ${elapsed}ms`);
    res.json(data);
  });
}
```

## Questions d'entretien : édition Node.js 24

Ces questions reflètent les fonctionnalités et les schémas que les recruteurs ciblent en 2026. Chaque réponse démontre une compréhension de niveau production plutôt qu'une connaissance de surface.

**Q1 : En quoi le Permission Model de Node.js diffère-t-il du sandboxing au niveau de l'OS ?**

Le Permission Model opère au niveau du runtime Node.js, pas au niveau du noyau de l'OS. Il restreint l'accès aux API intégrées de Node.js (`fs`, `net`, `child_process`) selon les flags de la ligne de commande. Le sandboxing au niveau de l'OS (conteneurs, seccomp, AppArmor) opère sous le runtime et restreint les appels système. Le Permission Model complète le sandboxing OS en apportant une granularité applicative. Limitation majeure : il ne s'applique pas aux addons natifs qui contournent les API de Node.js, et les descripteurs de fichiers déjà ouverts avant la vérification de permission restent utilisables.

**Q2 : Dans quel cas URLPattern serait-il un mauvais choix face à un routeur dédié ?**

URLPattern n'offre ni middleware, ni routage par méthode (GET vs POST), ni garantie d'ordre des routes. Il effectue une correspondance linéaire lorsqu'on parcourt un tableau de motifs, alors que des routeurs comme [find-my-way](https://github.com/delvedor/find-my-way) utilisent des arbres radix pour des recherches en O(log n). URLPattern convient à la logique de validation partagée client-serveur, aux gestionnaires de fetch dans les service workers et aux prototypes. Les API HTTP de production comptant des centaines de routes tirent profit d'un routeur dédié.

**Q3 : Expliquer la différence entre `using` et `await using`. Quand utiliser l'un ou l'autre ?**

`using` appelle `[Symbol.dispose]()` de façon synchrone à la sortie du bloc. Cela convient aux ressources comme les mutex, les descripteurs de fichiers gérés par des addons C++ synchrones ou les caches en mémoire. `await using` appelle `[Symbol.asyncDispose]()` et attend le résultat, ce qui le rend nécessaire pour les connexions de base de données, les sessions HTTP ou tout nettoyage impliquant des E/S asynchrones. Utiliser un `using` synchrone pour une ressource asynchrone ignore silencieusement le nettoyage.

**Q4 : Comment `AsyncContextFrame` améliore-t-il les performances d'`AsyncLocalStorage` ?**

Les implémentations précédentes utilisaient des async hooks (`init`, `before`, `after`, `destroy`) pour propager le contexte, ajoutant du surcoût à chaque résolution de `Promise` et à chaque callback de timer. `AsyncContextFrame` stocke le contexte directement dans la chaîne de promesses interne de V8, supprimant le surcoût des hooks. Le gain est le plus marqué dans les charges à fort renouvellement de `Promise`, comme les serveurs HTTP traitant des milliers de requêtes concurrentes avec un traçage par requête.

**Q5 : Quelles limitations de sécurité existent dans le Permission Model ?**

Cinq limitations critiques : (1) les liens symboliques peuvent sortir des chemins autorisés ; (2) les addons natifs contournent entièrement les vérifications de permissions ; (3) les descripteurs de fichiers hérités d'un processus parent ou ouverts avant l'initialisation de `--permission` ne sont pas restreints ; (4) les flags `--env-file` et `--openssl-config` lisent des fichiers avant l'initialisation du Permission Model ; (5) les permissions des worker threads sont indépendantes et doivent être configurées séparément. Le correctif CVE de mars 2026 pour `FileHandle.chmod()`/`FileHandle.chown()` a montré que les nouvelles API doivent être auditées en continu pour garantir l'application des permissions.

## Conclusion

- **Chemin de mise à niveau** : Node.js 24 LTS (Krypton) est la version de production recommandée jusqu'en avril 2028. Le flag `--permission` n'exige aucune modification de code, seulement une configuration de déploiement
- **URLPattern** supprime les dépendances de routage légères pour du code multi-runtime. Réserver les routeurs dédiés aux API HTTP à fort débit dotées de chaînes de middleware complexes
- **`using`/`await using`** remplacent `try/finally` pour la gestion du cycle de vie des ressources. Commencer par ajouter `[Symbol.asyncDispose]` aux wrappers de pools de base de données et aux utilitaires de descripteurs de fichiers
- **AsyncLocalStorage** voit ses gains de performance s'appliquer automatiquement. Les vérifier en mesurant la journalisation et le traçage par requête sous charge
- **La préparation aux entretiens** doit couvrir les limites du Permission Model (liens symboliques, addons natifs, descripteurs de fichiers hérités), les compromis d'URLPattern face aux routeurs à arbre radix et la distinction entre libération synchrone et asynchrone
- S'exercer à implémenter des ressources jetables personnalisées et des vérifications de permissions à l'exécution permet de démontrer une maîtrise concrète des fonctionnalités de Node.js 24 lors des [sessions d'entretien backend](/technologies/node-nestjs/interview-questions/authentication-jwt)

---

Source: SharpSkill (https://sharpskill.dev), tech interview preparation for your real stack.
HTML version of this page: https://sharpskill.dev/fr/blog/node-nestjs/nodejs-24-urlpattern-permissions-interview-questions