El módulo path es uno de los módulos incorporados de casa en NodeJS y lo podemos usar para trabajar con rutas dentro del sistema de archivos. Es uno de los módulos más usados, sea cual sea el nivel de NodeJJ en el que estés y resulta básico para muchas aplicaciones basadas en Node.

En este artículo te explicaremos cómo usar el módulo path, específicamente para la práctica más común en las aplicaciones, que es lidiar con la diferencia entre rutas de aplicación con barras o contrabarras, en notaciones válidas para Windows o sistemas parecidos a Unix.

En el artículo dedicado al módulo path de NodeJS encuentras los siguientes apartados.

• Require de path
• Notación Windows o POSIX
• Métodos de interés en el módulo path
• Conclusión y código completo de los ejemplos con path

Require de path

Para poder usar el módulo path es necesario importarlo de manera explícita en nuestros programas, usando la sentencia require de Node, el código sería el siguiente:

const path = require('node:path');

Este código para hacer el require también lo encuentras habitualmente de esta manera y son equivalentes:

const path = require('path');

Notación Windows o POSIX

La mayor utilidad que le podemos extraer a este módulo es la de lidiar con rutas en dos notaciones distintas y construir rutas absolutas o relativas ficheros.

El tema de las notaciones es espcialmente importante ya que la sistemas Windows difiere de las de los sistemas operativos basados en Unix, como Linux o Mac, conocidos como POSIX.

El módulo path se encargará automáticamente de trabajar adecuadamente con el sistema de rutas que tengas en el sistema operativo donde se ejecutan los programas, por lo que te aisla de las complejidades de lidiar con las barras o contrabarras de manera condicional. Pero además, este módulo tiene métodos específicos para usar notaciones específicas de un sistema u otro.

Por ejemplo este es el método basename genérico:

path.basename('src/foo.js') // devuelve "foo.js"

Por usar el método genérico, en este caso basename() se encargará de usar el sistema operativo donde se está ejecutando el código. Si es Windows atenderás a rutas con contrabarras y si es Linux o Mac entenderá las rutas con barras inclinadas normales. Sin embargo, con estas otras alternativas de código conseguimos respuestas personalizadas para un sistema específico.

path.win32.basename('src\\foo.js') // devuelve "foo.js"
path.posix.basename('src\\foo.js') // devuelve "src\foo.js"

Métodos de interés en el módulo path

El módulo path tiene bastantes métodos para trabajar con rutas y lo mejor que puedes hacer para conocerlos todos es acudir a la documentación de node para path.

Aquí vamos solamente a poner algunos ejemplos sencillos, que te vendrán bien porque son de uso habitual. Si trabajas con Node posiblemente los hayas usado o visto usar ya.

Método path.join()

Este método sirve para juntar partes de una ruta y Node se encargará de hacerlo con el carácter correcto para el sistema donde estamos trabajando. Recibe un número indeterminado de argumentos, el número de partes de ruta que quieras concatenar.

const ruta = path.join('foo', 'var', 'module.js');

Si estamos en Linux o Mac, la variable ruta que se ha creado contendría el valor "foo/var/module.js" pero si estamos en Windows el resultado de este método nos daría las barras invertidas "foo\var\module.js".

Para verificar los distintos casos podríamos probar a ejecutar los métodos predeterminados de cada sistema:

const rutaWindows = path.win32.join('foo', 'var', 'module.js');
const rutaPosix = path.posix.join('foo', 'var', 'module.js');

Un uso muy típico para este método join es cuando juntamos el directorio actual con una ruta que tengamos en el sistema.

const absolute = path.join(__dirname, 'modules', 'file.js')

Esto te entregará la ruta absoluta del archivo "file.js" que está en la carpeta "modules" que cuelga del directorio actual donde estás trabajando. La salida por supuesto dependerá de dónde tienes el archivo que se está ejecutando, pero podría ser algo como "/Users/midesweb/manuales/node/modules/file.js" en un sistema MacOS.

Método path.resolve()

El método resolve() funciona de manera muy similar a el método join(), pero sirve para generar siempre rutas absolutas. Vamos a verlo con algunos ejemplos.

En este primer ejemplo indicamos varias rutas que se deben resolver. Como ninguna de ellas es absoluta y el método resolve siempre nos devolverá una ruta absoluta. Para componerla usará la ruta actual donde se encuentra el módulo:

const pathResolve = path.resolve('modules', 'file.js'); 

Si el directorio de trabajo es /Users/midesweb/sites entonces este método te devolvería /Users/midesweb/sites/modules/file.js.

Pero por ejemplo podríamos haber usado algo como esto:

const pathResolve2 = path.resolve('../modules', 'file.js');

En este caso estamos pidiendo llegar al directorio padre, por lo que el resultado, si el directorio de trabajo es /Users/midesweb/sites nos devolvería /Users/midesweb/modules/file.js.

Ahora, si indicamos rutas absolutas, resolve no hace nada en especial, porque ya las tiene:

const pathResolve3 = path.resolve('/foo', '/bar');

En este caso la variable pathResolve3 valdrá /bar, porque se resuelve usando la ruta absoluta indicada en último término.

Propiedad path.sep

Para trabajar con nuestros propios métodos que usan rutas adaptadas a Windows o Posix podemos usar también la propiedad path.sep que contiene el valor de una contrabarra si estamos en Windows o una barra normal para sistemas operativos Linux y MacOS.

console.log(path.sep);

Nos mostrará "/" en la consola si estamos en Linux o Mac. "" en el caso de estar ejecutando el código en Windows.

Conclusión y código completo de los ejemplos con path

Hemos visto algunas utilidades fundamentales del módulo path que puedes usar en tu día a día de manera habitual. Seguramente si usas algún sistema de bundelización de tus scripts con Webpack o similares has visto ese módulo en uso en repetidas ocasiones.

Como decíamos, estas son solo unas pocas de las posibilidades que te ofrece el módulo, tienes muchas otras en la documentación.

A modo de resumen, coloco aquí el código completo de ejemplo usado para ilustrar este artículo.

const path = require('path');

console.log(path.basename('src/foo.js'));

console.log(path.win32.basename('src\\foo.js'));
console.log(path.posix.basename('src\\foo.js'));

const ruta = path.join('foo', 'var', 'module.js');
const rutaWindows = path.win32.join('/foo', 'var', 'module.js');
const rutaPosix = path.posix.join('foo', 'var', 'module.js');
console.log(ruta);
console.log('rutaWindows:', rutaWindows);
console.log('rutaPosix:', rutaPosix);

const absolute = path.join(__dirname, 'modules', 'file.js')
console.log(absolute);

const pathResolve = path.resolve('modules', 'file.js');
console.log(pathResolve);

const pathResolve2 = path.resolve('../modules', 'file.js');
console.log('pathResolve2:', pathResolve2);

const pathResolve3 = path.resolve('/foo', '/bar');
console.log('pathResolve3:', pathResolve3);

console.log(path.sep);