Formations — 1 037 leçons en français

Accueil › Node.js › Fichiers et chemins

Fichiers et chemins — entretien Node.js

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

Codes d'erreur

Quel code porte l'erreur levée quand le fichier demandé n'existe pas ?

  1. ENOENT ✓
  2. EACCES
  3. ENOTFOUND
  4. EISDIR

Pourquoi : `ENOENT` signifie « no entry » et couvre aussi le cas d'un **répertoire** manquant dans le chemin, ce qui explique qu'on l'obtienne souvent en écrivant dans un dossier non créé. `ENOTFOUND` existe, mais c'est une erreur de résolution DNS : la confondre avec un problème de fichier fait chercher au mauvais endroit. On teste toujours `err.code`, jamais `err.message`.

Niveau junior

Pourquoi ne teste-t-on pas l'existence d'un fichier avant de l'ouvrir ?

  1. Parce que l'état peut changer entre le test et l'ouverture ✓
  2. Parce qu'aucune fonction d'existence n'est fournie par Node
  3. Parce que le test coûte plus cher que la lecture
  4. Parce que le test ne fonctionne pas sur les liens symboliques

Pourquoi : Entre les deux appels, un autre processus — ou un autre `await` du vôtre — peut créer ou supprimer le fichier : le test ne garantit rien. Et comme l'ouverture peut échouer de toute façon, vous avez écrit deux chemins de code au lieu d'un. La bonne forme est un `try`/`catch` qui décide sur `err.code === "ENOENT"`. Cette même fenêtre explique pourquoi un verrou s'obtient avec le drapeau `"wx"`, atomique par construction.

Niveau confirme

Traversée de répertoire

Quelle est la défense correcte contre la traversée de répertoire ?

  1. Résoudre le chemin complet, puis vérifier qu'il est sous la racine autorisée ✓
  2. Supprimer toutes les occurrences de `..` dans l'entrée
  3. Refuser les entrées contenant un séparateur
  4. Encoder l'entrée avant de la passer à `path.join`

Pourquoi : Un filtre raisonne sur l'**écriture** du chemin, la défense correcte raisonne sur sa **destination** — et c'est la destination que le système ouvrira. Supprimer les `..` est même dangereux : sur `....//`, une seule passe laisse `../`. Refuser les séparateurs est une défense valable uniquement si le paramètre est un simple nom de fichier, et alors `path.basename` l'exprime plus clairement.

Niveau confirme

Pourquoi `cible.startsWith(racine)` est-il une vérification insuffisante ?

const racine = "/srv/public";
const cible = "/srv/public-old/notes.txt";
console.log(cible.startsWith(racine));
  1. Parce qu'un répertoire voisin dont le nom commence pareil passe la vérification ✓
  2. Parce que `startsWith` ignore la casse
  3. Parce que `resolve` peut rendre un chemin relatif
  4. Parce que la comparaison échoue si la racine finit par un séparateur

Pourquoi : La comparaison est textuelle et ne connaît pas la frontière entre deux noms de répertoire. Il faut comparer à `racine + path.sep`, en traitant à part le cas où la cible **est** la racine. La forme souvent préférée passe par `path.relative(racine, cible)` : si le résultat commence par `..` ou est absolu, la cible est dehors — et ce test n'a pas de piège de préfixe à retenir.

Niveau senior

Pourquoi une vérification fondée sur `path.resolve` ne suffit-elle pas quand le contenu servi peut contenir des liens symboliques ?

  1. Parce que la normalisation est textuelle et ne suit aucun lien ✓
  2. Parce que `resolve` échoue sur un lien symbolique
  3. Parce que les liens symboliques sont toujours absolus
  4. Parce que `resolve` suit les liens, mais seulement sous Linux

Pourquoi : `node:path` ne consulte jamais le disque : un chemin peut rester sous votre racine en texte tout en désignant `/etc` sur le disque. La vérification doit alors porter sur `realpath`, qui résout réellement les liens. Deux conséquences à annoncer en entretien : un accès disque supplémentaire, et un `ENOENT` si le fichier n'existe pas — à traiter comme un `404`, pas comme un refus de sécurité.

Niveau senior

Atomicité

Où doit vivre le fichier temporaire d'une écriture atomique ?

  1. Dans le répertoire de la cible, pour rester sur le même système de fichiers ✓
  2. Dans le répertoire rendu par `os.tmpdir()`
  3. Dans un sous-répertoire caché du projet
  4. En mémoire, puis écrit d'un coup dans la cible

Pourquoi : `rename` n'est atomique que sur un même système de fichiers ; ailleurs il échoue avec `EXDEV`. Or `os.tmpdir()` est très souvent un volume distinct, parfois un disque en mémoire. La correction réflexe — copier puis supprimer — rouvre exactement la fenêtre que le motif voulait fermer, puisque la copie écrit dans la cible par morceaux. Garder le contenu en mémoire ne change rien : l'écriture finale tronque toujours.

Niveau confirme

À quoi sert `fileHandle.sync()` avant le renommage dans une écriture atomique ?

  1. À garantir que les octets sont sur le disque avant que le renommage les publie ✓
  2. À rendre le renommage atomique
  3. À libérer le descripteur de fichier
  4. À vider le cache de lecture du système

Pourquoi : Le renommage est déjà atomique ; ce qui ne l'est pas, c'est l'ordre dans lequel le contenu et l'entrée de répertoire atteignent le disque. Sans synchronisation, une coupure d'alimentation peut publier un nom qui désigne un contenu incomplet — pire qu'un fichier absent. Le prix est un accès disque bloquant, qu'on ne paie que pour les données qu'on ne peut pas régénérer.

Niveau senior

Quel risque fait courir un nom de fichier temporaire fixe comme `config.json.tmp` ?

  1. Deux processus écrivant en même temps publient un contenu mélangé ✓
  2. Le renommage échoue avec EEXIST
  3. Le fichier temporaire n'est jamais nettoyé
  4. Aucun : le renommage sérialise les écritures

Pourquoi : Les deux processus écrivent dans le même temporaire, puis le renomment chacun : la cible reçoit un contenu entrelacé, et aucune des deux écritures n'est intacte. Le renommage ne sérialise rien — il remplace la destination sans se plaindre, donc sans `EEXIST`. L'identifiant du processus et un suffixe aléatoire suffisent, et le balayage des temporaires orphelins reste nécessaire pour le cas d'un processus tué.

Niveau senior

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