Hvorfor bruke path-modulen i stedet for strengkonkatenering?

Question

IT Interview Practice · Accepted Answer

Den innebygde **`path`**-modulen bygger og manipulerer filbaner **korrekt på tvers av operativsystemer**. Manuell konkatenering av batstringer med `/` fungerer ikke på Windows (som bruker `\`) og håndterer ikke edge cases – `path` håndterer alt pålitelig.

## Problemet med strengkonkatenering

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

## Løsningen: 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` setter inn riktig separator, fjerner duplikate/etterfølgende skråstreker, og løser `..`/`.` segmenter.

## Andre essensielle path-funksjoner

```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
```

## Få gjeldende fils katalog

```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));
```

Å bygge baner relativt til gjeldende fil (med `__dirname`, eller ekvivalenten i ESM) er den sikre måten å referere til filer på – uavhengig av hvor prosessen ble startet.

## join vs resolve

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

## Hvorfor det betyr noe

Å bruke `path` i stedet for strengkonkatenering gjør filhåndteringskode **plattformuavhengig og robust** – en hyppig kilde til bugs når kode skrevet på Mac/Linux slutter å fungere på Windows, eller når konkatenering produserer malformerte baner.

Det er en liten vane med stor påvirkning på påliteligheten, og å kjenne `join` vs `resolve`, pluss hvordan man får `__dirname` i ESM, dekker de daglige batbehovet i ethvert Node-prosjekt som arbeider med filsystemet.

Problemet med strengkonkatenering

Løsningen: path.join

Andre essensielle path-funksjoner

Få gjeldende fils katalog

join vs resolve

Hvorfor det betyr noe

Relaterte spørsmål