Path

[Estable: 2 - Estable]

Código fuente: lib/path.js

El módulo node:path proporciona utilidades para trabajar con rutas de archivos y directorios. Se puede acceder a él utilizando:

CJSESM

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

import path from 'node:path';

Windows vs. POSIX

El funcionamiento predeterminado del módulo node:path varía según el sistema operativo en el que se ejecuta una aplicación Node.js. Específicamente, cuando se ejecuta en un sistema operativo Windows, el módulo node:path asumirá que se están utilizando rutas de estilo Windows.

Por lo tanto, usar path.basename() podría arrojar resultados diferentes en POSIX y Windows:

En POSIX:

path.basename('C:\\temp\\myfile.html');
// Devuelve: 'C:\\temp\\myfile.html'

En Windows:

path.basename('C:\\temp\\myfile.html');
// Devuelve: 'myfile.html'

Para lograr resultados consistentes al trabajar con rutas de archivos de Windows en cualquier sistema operativo, utilice path.win32:

En POSIX y Windows:

path.win32.basename('C:\\temp\\myfile.html');
// Devuelve: 'myfile.html'

Para lograr resultados consistentes al trabajar con rutas de archivos POSIX en cualquier sistema operativo, utilice path.posix:

En POSIX y Windows:

path.posix.basename('/tmp/myfile.html');
// Devuelve: 'myfile.html'

En Windows, Node.js sigue el concepto de directorio de trabajo por unidad. Este comportamiento se puede observar al usar una ruta de unidad sin una barra invertida. Por ejemplo, path.resolve('C:\\') podría potencialmente devolver un resultado diferente que path.resolve('C:'). Para obtener más información, consulte esta página de MSDN.

`path.basename(path[, suffix])`

[Historial]

Versión	Cambios
v6.0.0	Pasar un valor que no sea una cadena como argumento `path` ahora arrojará un error.
v0.1.25	Añadido en: v0.1.25

path <string>
suffix <string> Un sufijo opcional para eliminar
Devuelve: <string>

El método path.basename() devuelve la última parte de un path, similar al comando basename de Unix. Los separadores de directorio finales se ignoran.

path.basename('/foo/bar/baz/asdf/quux.html');
// Devuelve: 'quux.html'

path.basename('/foo/bar/baz/asdf/quux.html', '.html');
// Devuelve: 'quux'

Aunque Windows generalmente trata los nombres de archivo, incluidas las extensiones de archivo, de manera que no distingue entre mayúsculas y minúsculas, esta función no lo hace. Por ejemplo, C:\\foo.html y C:\\foo.HTML se refieren al mismo archivo, pero basename trata la extensión como una cadena que distingue entre mayúsculas y minúsculas:

path.win32.basename('C:\\foo.html', '.html');
// Devuelve: 'foo'

path.win32.basename('C:\\foo.HTML', '.html');
// Devuelve: 'foo.HTML'

Se lanza un TypeError si path no es una cadena o si se da suffix y no es una cadena.

`path.delimiter`

Añadido en: v0.9.3

<string>

Proporciona el delimitador de ruta específico de la plataforma:

; para Windows
: para POSIX

Por ejemplo, en POSIX:

console.log(process.env.PATH);
// Imprime: '/usr/bin:/bin:/usr/sbin:/sbin:/usr/local/bin'

process.env.PATH.split(path.delimiter);
// Devuelve: ['/usr/bin', '/bin', '/usr/sbin', '/sbin', '/usr/local/bin']

En Windows:

console.log(process.env.PATH);
// Imprime: 'C:\Windows\system32;C:\Windows;C:\Program Files\node\'

process.env.PATH.split(path.delimiter);
// Devuelve ['C:\\Windows\\system32', 'C:\\Windows', 'C:\\Program Files\\node\\']

`path.dirname(path)`

[Historial]

Versión	Cambios
v6.0.0	Pasar un valor que no sea una cadena como el argumento `path` ahora lanzará un error.
v0.1.16	Añadido en: v0.1.16

path <string>
Devuelve: <string>

El método path.dirname() devuelve el nombre del directorio de una path, similar al comando dirname de Unix. Los separadores de directorio finales se ignoran, véase path.sep.

path.dirname('/foo/bar/baz/asdf/quux');
// Devuelve: '/foo/bar/baz/asdf'

Se lanza un TypeError si path no es una cadena.

`path.extname(path)`

[Historial]

Versión	Cambios
v6.0.0	Pasar un valor que no sea una cadena como el argumento `path` ahora lanzará un error.
v0.1.25	Añadido en: v0.1.25

path <string>
Devuelve: <string>

El método path.extname() devuelve la extensión de la path, desde la última aparición del carácter . (punto) hasta el final de la cadena en la última parte de la path. Si no hay un . en la última parte de la path, o si no hay caracteres . que no sean el primer carácter del nombre base de path (véase path.basename()), se devuelve una cadena vacía.

path.extname('index.html');
// Devuelve: '.html'

path.extname('index.coffee.md');
// Devuelve: '.md'

path.extname('index.');
// Devuelve: '.'

path.extname('index');
// Devuelve: ''

path.extname('.index');
// Devuelve: ''

path.extname('.index.md');
// Devuelve: '.md'

Se lanza un TypeError si path no es una cadena.

`path.format(pathObject)`

[Historial]

Versión	Cambios
v19.0.0	El punto se añadirá si no se especifica en `ext`.
v0.11.15	Añadido en: v0.11.15

pathObject <Objeto> Cualquier objeto de JavaScript que tenga las siguientes propiedades:
- dir <string>
- root <string>
- base <string>
- name <string>
- ext <string>
Devuelve: <string>

El método path.format() devuelve una cadena de ruta de un objeto. Esto es lo contrario de path.parse().

Al proporcionar propiedades al pathObject, recuerde que hay combinaciones donde una propiedad tiene prioridad sobre otra:

pathObject.root se ignora si se proporciona pathObject.dir
pathObject.ext y pathObject.name se ignoran si existe pathObject.base

Por ejemplo, en POSIX:

// Si se proporcionan `dir`, `root` y `base`,
// se devolverá `${dir}${path.sep}${base}`. `root` se ignora.
path.format({
  root: '/ignored',
  dir: '/home/user/dir',
  base: 'file.txt',
});
// Devuelve: '/home/user/dir/file.txt'

// `root` se utilizará si no se especifica `dir`.
// Si solo se proporciona `root` o `dir` es igual a `root`, entonces el
// separador de plataforma no se incluirá. `ext` se ignorará.
path.format({
  root: '/',
  base: 'file.txt',
  ext: 'ignored',
});
// Devuelve: '/file.txt'

// Se utilizará `name` + `ext` si no se especifica `base`.
path.format({
  root: '/',
  name: 'file',
  ext: '.txt',
});
// Devuelve: '/file.txt'

// El punto se añadirá si no se especifica en `ext`.
path.format({
  root: '/',
  name: 'file',
  ext: 'txt',
});
// Devuelve: '/file.txt'

En Windows:

path.format({
  dir: 'C:\\path\\dir',
  base: 'file.txt',
});
// Devuelve: 'C:\\path\\dir\\file.txt'

`path.matchesGlob(path, pattern)`

Agregado en: v22.5.0, v20.17.0

[Estable: 1 - Experimental]

Estable: 1 Estabilidad: 1 - Experimental

path <string> La ruta con la que se comparará el patrón glob.
pattern <string> El glob con el que se verificará la ruta.
Devuelve: <boolean> Indica si el path coincide con el pattern.

El método path.matchesGlob() determina si path coincide con el pattern.

Por ejemplo:

path.matchesGlob('/foo/bar', '/foo/*'); // true
path.matchesGlob('/foo/bar*', 'foo/bird'); // false

Se lanza un TypeError si path o pattern no son cadenas.

`path.isAbsolute(path)`

Agregado en: v0.11.2

path <string>
Devuelve: <boolean>

El método path.isAbsolute() determina si path es una ruta absoluta.

Si el path dado es una cadena de longitud cero, se devolverá false.

Por ejemplo, en POSIX:

path.isAbsolute('/foo/bar'); // true
path.isAbsolute('/baz/..');  // true
path.isAbsolute('qux/');     // false
path.isAbsolute('.');        // false

En Windows:

path.isAbsolute('//server');    // true
path.isAbsolute('\\\\server');  // true
path.isAbsolute('C:/foo/..');   // true
path.isAbsolute('C:\\foo\\..'); // true
path.isAbsolute('bar\\baz');    // false
path.isAbsolute('bar/baz');     // false
path.isAbsolute('.');           // false

Se lanza un TypeError si path no es una cadena.

`path.join([...paths])`

Agregado en: v0.1.16

...paths <string> Una secuencia de segmentos de ruta
Devuelve: <string>

El método path.join() une todos los segmentos de path dados utilizando el separador específico de la plataforma como delimitador, luego normaliza la ruta resultante.

Los segmentos de path de longitud cero se ignoran. Si la cadena de ruta unida es una cadena de longitud cero, entonces se devolverá '.', representando el directorio de trabajo actual.

path.join('/foo', 'bar', 'baz/asdf', 'quux', '..');
// Devuelve: '/foo/bar/baz/asdf'

path.join('foo', {}, 'bar');
// Lanza 'TypeError: Path must be a string. Received {}'

Se lanza un TypeError si alguno de los segmentos de ruta no es una cadena.

`path.normalize(path)`

Agregado en: v0.1.23

path <string>
Devuelve: <string>

El método path.normalize() normaliza el path dado, resolviendo los segmentos '..' y '.'.

Cuando se encuentran múltiples caracteres de separación de segmentos de ruta secuenciales (por ejemplo, / en POSIX y \ o / en Windows), se reemplazan por una sola instancia del separador de segmentos de ruta específico de la plataforma (/ en POSIX y \ en Windows). Los separadores finales se conservan.

Si el path es una cadena de longitud cero, se devuelve '.', representando el directorio de trabajo actual.

En POSIX, los tipos de normalización aplicados por esta función no se adhieren estrictamente a la especificación POSIX. Por ejemplo, esta función reemplazará dos barras diagonales iniciales con una sola barra como si fuera una ruta absoluta regular, mientras que algunos sistemas POSIX asignan un significado especial a las rutas que comienzan con exactamente dos barras diagonales. De manera similar, otras sustituciones realizadas por esta función, como eliminar segmentos .., pueden cambiar la forma en que el sistema subyacente resuelve la ruta.

Por ejemplo, en POSIX:

path.normalize('/foo/bar//baz/asdf/quux/..');
// Devuelve: '/foo/bar/baz/asdf'

En Windows:

path.normalize('C:\\temp\\\\foo\\bar\\..\\');
// Devuelve: 'C:\\temp\\foo\\'

Dado que Windows reconoce múltiples separadores de ruta, ambos separadores se reemplazarán por instancias del separador preferido de Windows (\):

path.win32.normalize('C:////temp\\\\/\\/\\/foo/bar');
// Devuelve: 'C:\\temp\\foo\\bar'

Se lanza un TypeError si path no es una cadena.

`path.parse(path)`

Agregado en: v0.11.15

path <string>
Devuelve: <Object>

El método path.parse() devuelve un objeto cuyas propiedades representan elementos significativos del path. Los separadores de directorio finales se ignoran, consulte path.sep.

El objeto devuelto tendrá las siguientes propiedades:

dir <string>
root <string>
base <string>
name <string>
ext <string>

Por ejemplo, en POSIX:

path.parse('/home/user/dir/file.txt');
// Devuelve:
// { root: '/',
//   dir: '/home/user/dir',
//   base: 'file.txt',
//   ext: '.txt',
//   name: 'file' }

text

┌─────────────────────┬────────────┐
│          dir        │    base    │
├──────┬              ├──────┬─────┤
│ root │              │ name │ ext │
"  /    home/user/dir / file  .txt "
└──────┴──────────────┴──────┴─────┘
(Se deben ignorar todos los espacios en la línea "". Son puramente para formatear).

En Windows:

path.parse('C:\\path\\dir\\file.txt');
// Devuelve:
// { root: 'C:\\',
//   dir: 'C:\\path\\dir',
//   base: 'file.txt',
//   ext: '.txt',
//   name: 'file' }

text

┌─────────────────────┬────────────┐
│          dir        │    base    │
├──────┬              ├──────┬─────┤
│ root │              │ name │ ext │
" C:\      path\dir   \ file  .txt "
└──────┴──────────────┴──────┴─────┘
(Se deben ignorar todos los espacios en la línea "". Son puramente para formatear).

Se lanza un TypeError si path no es una cadena.

`path.posix`

[Historial]

Versión	Cambios
v15.3.0	Expuesto como `require('path/posix')`.
v0.11.15	Agregado en: v0.11.15

<Objeto>

La propiedad path.posix proporciona acceso a implementaciones específicas de POSIX de los métodos path.

Se puede acceder a la API a través de require('node:path').posix o require('node:path/posix').

`path.relative(from, to)`

[Historial]

Versión	Cambios
v6.8.0	En Windows, las barras inclinadas iniciales para las rutas UNC ahora se incluyen en el valor de retorno.
v0.5.0	Agregado en: v0.5.0

from <string>
to <string>
Devuelve: <string>

El método path.relative() devuelve la ruta relativa de from a to según el directorio de trabajo actual. Si from y to se resuelven a la misma ruta (después de llamar a path.resolve() en cada uno), se devuelve una cadena de longitud cero.

Si se pasa una cadena de longitud cero como from o to, se utilizará el directorio de trabajo actual en lugar de las cadenas de longitud cero.

Por ejemplo, en POSIX:

path.relative('/data/orandea/test/aaa', '/data/orandea/impl/bbb');
// Devuelve: '../../impl/bbb'

En Windows:

path.relative('C:\\orandea\\test\\aaa', 'C:\\orandea\\impl\\bbb');
// Devuelve: '..\\..\\impl\\bbb'

Se lanza un TypeError si from o to no es una cadena.

`path.resolve([...paths])`

Agregado en: v0.3.4

...paths <string> Una secuencia de rutas o segmentos de ruta
Devuelve: <string>

El método path.resolve() resuelve una secuencia de rutas o segmentos de ruta en una ruta absoluta.

La secuencia dada de rutas se procesa de derecha a izquierda, con cada path posterior antepuesto hasta que se construye una ruta absoluta. Por ejemplo, dada la secuencia de segmentos de ruta: /foo, /bar, baz, llamar a path.resolve('/foo', '/bar', 'baz') devolvería /bar/baz porque 'baz' no es una ruta absoluta, pero '/bar' + '/' + 'baz' sí lo es.

Si, después de procesar todos los segmentos path dados, aún no se ha generado una ruta absoluta, se utiliza el directorio de trabajo actual.

La ruta resultante se normaliza y se eliminan las barras diagonales finales, a menos que la ruta se resuelva en el directorio raíz.

Los segmentos path de longitud cero se ignoran.

Si no se pasan segmentos path, path.resolve() devolverá la ruta absoluta del directorio de trabajo actual.

path.resolve('/foo/bar', './baz');
// Devuelve: '/foo/bar/baz'

path.resolve('/foo/bar', '/tmp/file/');
// Devuelve: '/tmp/file'

path.resolve('wwwroot', 'static_files/png/', '../gif/image.gif');
// Si el directorio de trabajo actual es /home/myself/node,
// esto devuelve '/home/myself/node/wwwroot/static_files/gif/image.gif'

Se lanza un TypeError si alguno de los argumentos no es una cadena.

`path.sep`

Añadido en: v0.7.9

<string>

Proporciona el separador de segmentos de ruta específico de la plataforma:

\ en Windows
/ en POSIX

Por ejemplo, en POSIX:

'foo/bar/baz'.split(path.sep);
// Devuelve: ['foo', 'bar', 'baz']

En Windows:

'foo\\bar\\baz'.split(path.sep);
// Devuelve: ['foo', 'bar', 'baz']

En Windows, tanto la barra diagonal (/) como la barra invertida (\) se aceptan como separadores de segmentos de ruta; sin embargo, los métodos path solo añaden barras invertidas (\).

`path.toNamespacedPath(path)`

Añadido en: v9.0.0

path <string>
Devuelve: <string>

Solo en sistemas Windows, devuelve una ruta con prefijo de espacio de nombres equivalente para la ruta dada. Si path no es una cadena, path se devolverá sin modificaciones.

Este método solo tiene sentido en sistemas Windows. En sistemas POSIX, el método no está operativo y siempre devuelve path sin modificaciones.

`path.win32`

[Historial]

Versión	Cambios
v15.3.0	Expuesto como `require('path/win32')`.
v0.11.15	Añadido en: v0.11.15

<Object>

La propiedad path.win32 proporciona acceso a las implementaciones específicas de Windows de los métodos path.

Se puede acceder a la API a través de require('node:path').win32 o require('node:path/win32').

Path ​

Windows vs. POSIX ​

path.basename(path[, suffix]) ​

path.delimiter ​

path.dirname(path) ​

path.extname(path) ​

path.format(pathObject) ​

path.matchesGlob(path, pattern) ​

path.isAbsolute(path) ​

path.join([...paths]) ​

path.normalize(path) ​

path.parse(path) ​

path.posix ​

path.relative(from, to) ​

path.resolve([...paths]) ​

path.sep ​

path.toNamespacedPath(path) ​

path.win32 ​

Path

Windows vs. POSIX

`path.basename(path[, suffix])`

`path.delimiter`

`path.dirname(path)`

`path.extname(path)`

`path.format(pathObject)`

`path.matchesGlob(path, pattern)`

`path.isAbsolute(path)`

`path.join([...paths])`

`path.normalize(path)`

`path.parse(path)`

`path.posix`

`path.relative(from, to)`

`path.resolve([...paths])`

`path.sep`

`path.toNamespacedPath(path)`

`path.win32`