Pourquoi utiliser le module path au lieu de la concaténation de chaînes?

Question

IT Interview Practice · Accepted Answer

Le module **`path`** intégré construit et manipule les chemins de fichiers **correctement sur tous les systèmes d'exploitation**. Concaténer manuellement des chaînes de chemin avec `/` ne fonctionne pas sous Windows (qui utilise `\`) et gère mal les cas limites — `path` gère tout cela de manière fiable.

## Le problème avec la concaténation de chaînes

```js
// ❌ fragile, OS-dependent, error-prone
const filePath = baseDir + "/" + "sub" + "/" + fileName;
// breaks on Windows (\), doubles slashes if baseDir ends in /, etc.
```

## La solution : path.join

```js
import path from "path";

// ✅ uses the correct separator for the OS, normalizes slashes
const filePath = path.join(baseDir, "sub", fileName);
// Linux/Mac: baseDir/sub/file.txt   Windows: baseDir\sub\file.txt
```

`path.join` insère le bon séparateur, supprime les barres obliques dupliquées/finales et résout les segments `..`/`.`.

## Autres fonctions path essentielles

```js
path.resolve("src", "app.js");  // → ABSOLUTE path from the cwd
path.basename("/a/b/file.txt");  // "file.txt"
path.dirname("/a/b/file.txt");   // "/a/b"
path.extname("file.txt");        // ".txt"
path.parse("/a/b/file.txt");     // { dir, base, name, ext }
path.sep;                         // "/" or "\" depending on OS
```

## Obtenir le répertoire du fichier actuel

```js
// CommonJS — built-in globals
const configPath = path.join(__dirname, "config.json");

// ES Modules — __dirname doesn't exist; derive it from import.meta.url
import { fileURLToPath } from "url";
const __dirname = path.dirname(fileURLToPath(import.meta.url));
```

Constituire des chemins relatifs au fichier courant (avec `__dirname` ou son équivalent ESM) est la manière sûre de référencer des fichiers — quel que soit l'endroit où le processus a été démarré.

## join vs resolve

```text
path.join    → just joins segments (relative stays relative)
path.resolve → produces an ABSOLUTE path (resolves from cwd / right-to-left)
```

## Pourquoi c'est important

Utiliser `path` au lieu de la concaténation de chaînes rend le code de traitement des fichiers **cross-platform et robuste** — une source fréquente de bogues lorsque le code écrit sur Mac/Linux se casse sur Windows, ou lorsque la concaténation produit des chemins malformés.

C'est une petite habitude avec des bénéfices de fiabilité disproportionnés, et connaître `join` vs `resolve`, plus comment obtenir `__dirname` en ESM, couvre les besoins quotidiens de chemins dans tout projet Node qui touche au système de fichiers.

Le problème avec la concaténation de chaînes

La solution : path.join

Autres fonctions path essentielles

Obtenir le répertoire du fichier actuel

join vs resolve

Pourquoi c'est important

Questions connexes