Formations — 1 037 leçons en français

Accueil › Node.js › L'asynchrone côté serveur

L'asynchrone côté serveur — entretien Node.js

12 questions posées en entretien sur 6 sujets, avec la bonne réponse et son explication.

Concurrence

Trois appels indépendants attendus l'un après l'autre coûtent combien ?

  1. La somme des trois latences ✓
  2. Le maximum des trois latences
  3. La moyenne des trois latences
  4. La latence du premier appel seulement

Pourquoi : Un `await` suspend la fonction : le deuxième appel n'est pas encore parti quand le premier attend. Node est non bloquant pour les autres requêtes, pas pour la vôtre. La formulation qui fait bonne impression en entretien est la règle de décision : deux `await` consécutifs ne se justifient que si le second utilise le résultat du premier.

Niveau junior

Pourquoi borner la concurrence plutôt que passer toute la liste à `Promise.all` ?

  1. Parce que le pool de connexions ne détient qu'une dizaine de jetons : au-delà, les requêtes attendent puis expirent ✓
  2. Parce que `Promise.all` ralentit au-delà de cent promesses
  3. Parce que Node limite le nombre de promesses simultanées
  4. Parce que l'ordre des résultats n'est plus garanti sur de grandes listes

Pourquoi : `map` crée toutes les promesses d'un coup, donc tous les travaux sont déjà lancés. Le symptôme trompe : l'erreur parle d'acquisition de connexion et laisse croire à une panne de la base. Le détail qui montre l'expérience est le choix de la limite — on la règle sur la taille du pool ou sur la limite de débit annoncée par l'API tierce, pas au hasard.

Niveau confirme

Combinateurs

Dans quel ordre `Promise.all` rend-elle ses résultats ?

  1. Dans l'ordre des promesses passées en entrée, quel que soit l'ordre d'achèvement ✓
  2. Dans l'ordre d'achèvement, la plus rapide en premier
  3. Dans un ordre non spécifié
  4. Dans l'ordre inverse des entrées

Pourquoi : L'ordre d'entrée est garanti, et c'est ce qui permet la déstructuration en trois constantes nommées. L'erreur fréquente consiste à croire l'inverse et à trier le résultat soi-même, ou à ajouter un identifiant dans chaque réponse pour la réapparier. `allSettled` conserve la même garantie d'ordre.

Niveau junior

Quatre-vingt-dix-neuf courriels sur cent partent, le centième échoue. Quel combinateur ?

  1. `Promise.allSettled`, puis traitement explicite des échecs ✓
  2. `Promise.all` dans un try/catch
  3. `Promise.any`, puisqu'un succès suffit
  4. `Promise.race`, pour ne pas attendre le plus lent

Pourquoi : `all` rejetterait au premier échec, et vous ne sauriez plus lesquels des cent envois ont abouti. `allSettled` attend tout le monde et rend un statut par élément. Attention à la suite : `allSettled` ne dispense pas de traiter les échecs, elle permet de les traiter après. Un filtre sur `status === "rejected"` qui se contente de journaliser perd les destinataires concernés.

Niveau confirme

Annulation

À quoi sert `AbortSignal.timeout(2000)` ?

  1. Il rend un signal qui s'avorte seul après deux secondes, ce qui fait échouer l'opération et ferme la connexion ✓
  2. Il retarde le départ de la requête de deux secondes
  3. Il réessaie la requête au bout de deux secondes
  4. Il limite la durée totale du processus

Pourquoi : L'opération rejette avec une erreur dont `name` vaut `TimeoutError`, et la connexion sous-jacente est réellement fermée. C'est la différence avec un `Promise.race` contre un `setTimeout`, qui libère l'appelant mais laisse la requête continuer dans le vide. Autre avantage pratique : son minuteur n'empêche pas le processus de sortir.

Niveau junior

Un client abandonne sa requête au bout d'une seconde. Que devient le travail en cours côté serveur ?

  1. Il continue jusqu'au bout, sauf si votre code écoute la fermeture de la connexion et avorte ✓
  2. Node interrompt automatiquement les appels sortants
  3. Il est interrompu à la première écriture dans la réponse
  4. Il est suspendu puis reprend si le client revient

Pourquoi : Node signale la fermeture, il n'en tire aucune conséquence lui-même. Sans annulation, un client qui réessaie trois fois vous fait faire quatre fois le travail pour une seule réponse utile — c'est le mécanisme par lequel un ralentissement devient une panne. On écoute `close` sur la requête, et on combine le signal obtenu avec un délai par `AbortSignal.any`.

Niveau confirme

Comment traiter une erreur dont `name` vaut `AbortError` dans un gestionnaire de requête ?

  1. Sortir sans écrire de réponse, et compter l'abandon séparément des erreurs serveur ✓
  2. Renvoyer un `500` avec le message de l'erreur
  3. Renvoyer un `504` comme pour un délai écoulé
  4. La relancer pour que le gestionnaire global la journalise en erreur

Pourquoi : La connexion est déjà fermée : écrire dans la réponse ne sert à rien. Et compter ces abandons comme des erreurs serveur fait du taux d'erreur de votre service une mesure de la qualité du réseau mobile de vos utilisateurs — le jour d'un vrai incident, le seuil d'alerte est déjà insensible. On distingue `AbortError`, qui est un abandon, de `TimeoutError`, qui justifie un `504`.

Niveau senior

Disjoncteur

Quels sont les trois états d'un disjoncteur et qu'arrive-t-il en état ouvert ?

  1. Fermé, ouvert, entrouvert — en état ouvert l'appel échoue immédiatement sans être émis ✓
  2. Fermé, ouvert, entrouvert — en état ouvert l'appel est mis en file jusqu'au réarmement
  3. Actif, dégradé, coupé — en état coupé l'appel part avec un délai réduit
  4. Fermé, ouvert — il n'y a que deux états, le réarmement est immédiat

Pourquoi : Le double bénéfice est à nommer : l'appelant obtient sa réponse en une microseconde au lieu d'attendre le délai d'expiration, et le service en difficulté cesse de recevoir la charge qui l'empêche de se rétablir. Mettre en file ferait l'inverse — on accumulerait des requêtes pour les lâcher toutes au réarmement, ce qui recouche le service aussitôt.

Niveau confirme

Boucle d'événements

Dans une boucle de traitement longue, comment rendre réellement la main à la boucle d'événements ?

  1. `await new Promise((ok) => setImmediate(ok))` ✓
  2. `await Promise.resolve()`
  3. `await new Promise((ok) => process.nextTick(ok))`
  4. `queueMicrotask(() => {})`

Pourquoi : Les microtâches sont vidées avant que la boucle n'avance d'une phase : céder à `Promise.resolve()` ne laisse traiter aucune entrée-sortie, et la boucle reste bloquée. `setImmediate` place le rappel à la phase de vérification, donc la phase de sondage est traversée entre-temps et les requêtes en attente sont servies. `nextTick` est encore pire que la microtâche, puisque sa file passe avant elle.

Niveau confirme

Qu'affiche ce code ?

setTimeout(() => console.log("minuteur"), 0);
setImmediate(() => console.log("immediat"));
Promise.resolve().then(() => console.log("promesse"));
process.nextTick(() => console.log("tick"));
  1. tick, promesse, minuteur, immediat ✓
  2. promesse, tick, minuteur, immediat
  3. tick, promesse, immediat, minuteur
  4. minuteur, immediat, tick, promesse

Pourquoi : La file `nextTick` est vidée avant celle des microtâches de promesse, et les deux avant que la boucle n'avance d'une phase. Vient ensuite la phase des minuteurs, puis la phase de vérification où vit `setImmediate`. La précision qui distingue une bonne réponse : depuis un rappel d'entrée-sortie, l'ordre des deux derniers s'inverse, parce que la phase de vérification suit immédiatement le sondage.

Niveau senior

Une fonction s'appelle elle-même par `process.nextTick`. Quel est le symptôme ?

  1. Le processus consomme un cœur entier et ne sert plus aucune requête, sans dépassement de pile ✓
  2. Un dépassement de pile au bout de quelques milliers d'appels
  3. La réserve de fils de libuv se sature
  4. Rien : Node interrompt la file au bout de mille rappels

Pourquoi : La file `nextTick` est vidée entièrement avant que la boucle n'avance, et Node ne limite pas le nombre de rappels traités d'affilée : la file se remplit aussi vite qu'elle se vide. Aucune pile ne grandit puisque les appels ne s'imbriquent pas, ce qui rend le diagnostic très difficile sans la métrique de retard de boucle. La même récursion en `setImmediate` laisse chaque tour traiter les entrées-sorties.

Niveau senior

Délais

Trois appels à deux secondes de délai chacun, pour un client qui abandonne à trois secondes. Que corriger ?

  1. Partager un seul signal de délai pour toute la requête, au lieu de délais indépendants qui s'additionnent ✓
  2. Réduire chaque délai à une seconde
  3. Augmenter le délai du client à six secondes
  4. Supprimer les délais et compter sur la déconnexion du client

Pourquoi : Des délais réglés appel par appel donnent un pire cas égal à leur somme, qui ne correspond à rien de ce que le client attend. Un budget unique, créé en tête de requête et transmis à toutes les opérations, fait du délai une propriété de la requête plutôt que la somme accidentelle des réglages de chaque client HTTP. Réduire chaque délai réglerait l'arithmétique et échouerait des appels qui allaient aboutir.

Niveau senior

S'entraîner sur ces questions, chronométré →