¿Por qué usar el módulo path en lugar de concatenar strings?

Question

Accepted Answer

El módulo integrado **`path`** construye y manipula rutas de archivos **correctamente entre sistemas operativos**. Concatenar manualmente strings de rutas con `/` se rompe en Windows (que usa `\`) y maneja mal los casos límite — `path` se encarga de todo eso de forma confiable.

## El problema de concatenar strings

```js
// ❌ frágil, dependiente del SO, propenso a errores
const filePath = baseDir + "/" + "sub" + "/" + fileName;
// se rompe en Windows (\), duplica barras si baseDir termina en /, etc.
```

## La solución: path.join

```js
import path from "path";

// ✅ usa el separador correcto para el SO, normaliza las barras
const filePath = path.join(baseDir, "sub", fileName);
// Linux/Mac: baseDir/sub/file.txt   Windows: baseDir\sub\file.txt
```

`path.join` inserta el separador correcto, colapsa las barras duplicadas/finales y resuelve los segmentos `..`/`.`.

## Otras funciones esenciales de path

```js
path.resolve("src", "app.js");  // → ruta ABSOLUTA desde el 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;                         // "/" o "\" según el SO
```

## Obtener el directorio del archivo actual

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

// Módulos ES — __dirname no existe; derívalo de import.meta.url
import { fileURLToPath } from "url";
const __dirname = path.dirname(fileURLToPath(import.meta.url));
```

Construir rutas relativas al archivo actual (con `__dirname`, o su equivalente en ESM) es la forma segura de referenciar archivos — independiente de dónde se inició el proceso.

## join vs resolve

```text
path.join    → solo une segmentos (lo relativo sigue siendo relativo)
path.resolve → produce una ruta ABSOLUTA (resuelve desde el cwd / de derecha a izquierda)
```

## Por qué es importante

Usar `path` en lugar de concatenar strings hace que el código de manejo de archivos sea **multiplataforma y robusto** — una fuente frecuente de bugs cuando código escrito en Mac/Linux se rompe en Windows, o cuando la concatenación produce rutas mal formadas.

Es un pequeño hábito con beneficios de fiabilidad desproporcionados, y conocer `join` vs `resolve`, además de cómo obtener `__dirname` en ESM, cubre las necesidades cotidianas de rutas en cualquier proyecto de Node que toque el sistema de archivos.