Les flux — entretien Node.js
8 questions posées en entretien sur 3 sujets, avec la bonne réponse et son explication.
Consommer
Comment consomme-t-on un flux lisible en JavaScript moderne ?
- Avec for await, tout flux lisible étant un itérateur asynchrone ✓
- Avec un écouteur data et un écouteur end, il n'y a pas d'autre moyen
- En appelant read() dans une boucle while jusqu'à null
- En l'enveloppant dans une promesse avec Promise.all
Pourquoi : Les flux lisibles implémentent `Symbol.asyncIterator`, donc `for await` fonctionne directement. Ce n'est pas qu'une question de style : la boucle ne redemande rien avant d'avoir fini le tour courant, ce qui respecte la contre-pression sans y penser, là où un écouteur `data` laisse les morceaux arriver quoi qu'il arrive. Les erreurs remontent aussi naturellement dans un `try`/`catch`.
Niveau junior
Pourquoi un écouteur on("data") ne peut-il pas ralentir la source ?
- Parce qu'un écouteur n'a pas de valeur de retour : le flux ne sait pas qu'il est en retard ✓
- Parce que les écouteurs sont exécutés dans un autre fil
- Parce que l'événement data est émis avant la lecture réelle du morceau
- Parce que data contourne volontairement le tampon interne
Pourquoi : Attacher un écouteur `data` met le flux en mode coulant : les morceaux arrivent dès qu'ils sont disponibles, et un traitement asynchrone lancé sans être attendu s'accumule derrière. Les deux corrections sont `pause()`/`resume()` à la main, ou un `for await` qui ne redemande rien avant la fin du tour courant. La seconde est préférable parce qu'elle ne peut pas être oubliée sur un chemin d'erreur.
Niveau senior
Composer
Pourquoi utiliser pipeline de node:stream/promises plutôt qu'une chaîne de .pipe() ?
- Parce que pipeline propage les erreurs et détruit tous les flux de la chaîne ✓
- Parce que .pipe() ne respecte pas la contre-pression
- Parce que .pipe() ne fonctionne pas en mode objet
- Parce que pipeline transfère les morceaux par blocs plus gros
Pourquoi : Répondre « parce que `.pipe()` ignore la contre-pression » est l'erreur classique sur cette question : `.pipe()` la respecte parfaitement. Ce qu'il ne fait pas, c'est propager une erreur et nettoyer — la destination reste ouverte, le fichier de sortie reste tronqué, le descripteur fuit, et un `error` sans écouteur fait tomber le processus. `pipeline` rend une promesse, propage, et appelle `destroy` partout.
Niveau confirme
Que se passe-t-il si la source échoue dans source.pipe(destination) sans écouteur error ?
- Le flux émet error sans écouteur, ce qui fait tomber le processus par exception non interceptée ✓
- La destination reçoit l'erreur et la relaie à son propre écouteur
- La chaîne s'arrête silencieusement et la destination se ferme proprement
- Node réessaie automatiquement la lecture une fois
Pourquoi : Un `EventEmitter` qui émet `error` sans écouteur lève l'erreur, et dans un contexte asynchrone cela devient une exception non interceptée qui termine le processus. C'est pourquoi une chaîne de trois `.pipe()` correcte exige trois écouteurs `error` et trois appels à `destroy`. Écrire cela à la main est précisément le code que `pipeline` remplace.
Niveau confirme
Que fait pipeline aux autres flux de la chaîne quand une étape échoue ?
- Il appelle destroy sur toutes les étapes, source comprise ✓
- Il ne détruit que les étapes situées après celle qui a échoué
- Il laisse la source finir sa lecture puis jette les morceaux restants
- Il relance la chaîne entière une fois avant d'abandonner
Pourquoi : Le nettoyage remonte et descend. Sans cela, une écriture échouée sur un disque plein laisserait la lecture du fichier d'entrée se poursuivre pour rien, descripteur ouvert — c'est l'origine la plus fréquente d'un `EMFILE` sur un service qui tourne depuis plusieurs jours. Une étape qui ignore son `destroy` est dite « fuyante », et c'est le défaut que `pipeline` ne peut pas corriger à votre place.
Niveau senior
Transformer
À quoi sert flush dans un Transform ?
- À émettre ce qui restait en réserve après le dernier morceau entrant ✓
- À vider le tampon d'écriture dès qu'il dépasse le seuil
- À forcer l'envoi sur le réseau des morceaux déjà poussés
- À réinitialiser l'état interne entre deux appels à transform
Pourquoi : C'est le dernier moment où un `Transform` peut encore pousser : un découpeur y émet la dernière ligne dépourvue de retour à la ligne, un agrégateur y émet ses totaux. L'oublier produit un bogue très caractéristique — tout est juste sauf le dernier enregistrement, et seulement sur les fichiers qui ne finissent pas par un retour à la ligne.
Niveau confirme
Pourquoi ne peut-on pas traiter chaque morceau d'un flux de texte comme une suite de lignes complètes ?
- Parce qu'un morceau est un découpage arbitraire d'octets : il coupe au milieu d'une ligne ✓
- Parce que les morceaux arrivent dans un ordre non garanti
- Parce que le flux ne conserve pas les retours à la ligne
- Parce qu'un morceau contient toujours exactement une ligne
Pourquoi : La taille d'un morceau est fixée par `highWaterMark` et par ce que le système a rendu, jamais par le contenu : la coupure tombe où elle tombe, y compris au milieu d'un caractère UTF-8 si aucun encodage n'est fixé. Tout traitement qui a une notion d'enregistrement doit donc conserver un reste d'un morceau sur l'autre. L'ordre, lui, est garanti.
Niveau confirme
De quoi dépend la mémoire d'une agrégation par clé réalisée en flux ?
- Du nombre de clés distinctes, pas du nombre de lignes lues ✓
- Du nombre de lignes, comme un group-by sur tableau
- De la taille du plus gros morceau reçu
- Du produit du nombre de clés par le nombre de lignes
Pourquoi : On ne retient que l'accumulateur de chaque clé : un million de ventes sur douze régions tiennent dans douze compteurs. La nuance qu'un entretien attend est la limite de la méthode — si la clé est de cardinalité comparable au nombre de lignes, par exemple un identifiant de commande, l'agrégation en flux ne gagne plus rien et il faut trier en amont ou laisser la base faire le regroupement.
Niveau senior