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 usando:

CJSESM

const path = require('node:path')

import path from 'node:path'

Windows vs. POSIX

La operación predeterminada 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 producir 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 cuando se trabaja con rutas de archivos de Windows en cualquier sistema operativo, use path.win32:

En POSIX y Windows:

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

Para lograr resultados consistentes cuando se trabaja con rutas de archivos POSIX en cualquier sistema operativo, use 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 barra invertida. Por ejemplo, path.resolve('C:\\') potencialmente puede devolver un resultado diferente a 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	Lanzará un error si se pasa un valor que no sea una cadena como argumento `path`.
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 normalmente trata los nombres de archivo, incluidas las extensiones de archivo, de manera no sensible a 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 sensible a 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 proporciona suffix y no es una cadena.

`path.delimiter`

Agregado 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	Ahora se lanzará una excepción si se pasa un valor que no sea una cadena como argumento `path`.
v0.1.16	Agregado en: v0.1.16

path <string>
Devuelve: <string>

El método path.dirname() devuelve el nombre del directorio de una ruta, similar al comando dirname de Unix. Los separadores de directorio finales se ignoran, consulte 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 no string como 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 del path, desde la última ocurrencia del carácter . (punto) hasta el final de la cadena en la última parte del path. Si no hay . en la última parte del path, o si no hay caracteres . distintos del primer carácter del nombre base de path (ver 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 agregará 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 a partir de un objeto. Esto es lo opuesto a path.parse().

Al proporcionar propiedades al pathObject, recuerde que existen 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: '/ignorado',
  dir: '/home/usuario/dir',
  base: 'archivo.txt',
})
// Devuelve: '/home/usuario/dir/archivo.txt'

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

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

// El punto se agregará si no se especifica en `ext`.
path.format({
  root: '/',
  name: 'archivo',
  ext: 'txt',
})
// Devuelve: '/archivo.txt'

En Windows:

path.format({
  dir: 'C:\\ruta\\dir',
  base: 'archivo.txt',
})
// Devuelve: 'C:\\ruta\\dir\\archivo.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 glob.
pattern <string> El glob con el que se verificará la ruta.
Devuelve: <boolean> Indica si la 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 arroja 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 la path dada 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 arroja 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 proporcionados utilizando el separador específico de la plataforma como delimitador y, a continuación, 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, se devolverá '.', que representa 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 varios caracteres de separación de segmentos de ruta secuenciales (por ejemplo, / en POSIX y \ o / en Windows), se reemplazan por una única instancia del separador de segmento 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 '.', que representa el directorio de trabajo actual.

En POSIX, los tipos de normalización aplicados por esta función no se ajustan estrictamente a la especificación POSIX. Por ejemplo, esta función reemplazará dos barras diagonales iniciales con una sola barra diagonal 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 la eliminación de 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 varios 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)`

Añadido 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 "
└──────┴──────────────┴──────┴─────┘
(Todos los espacios en la línea "" deben ignorarse. 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 "
└──────┴──────────────┴──────┴─────┘
(Todos los espacios en la línea "" deben ignorarse. 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	Añadido en: v0.11.15

<Object>

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

Se puede acceder a la API mediante 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 rutas UNC ahora se incluyen en el valor devuelto.
v0.5.0	Añadido en: v0.5.0

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

El método path.relative() devuelve la ruta relativa de from a to basada en el directorio de trabajo actual. Si from y to se resuelven a la misma ruta (después de llamar a path.resolve() en cada una), 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 son 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 de rutas dada se procesa de derecha a izquierda, con cada path subsiguiente 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 las barras diagonales finales se eliminan 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 segmento 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 segmento de ruta; sin embargo, los métodos path solo agregan 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, se devolverá path sin modificaciones.

Este método solo tiene sentido en sistemas Windows. En sistemas POSIX, el método no es 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

<Objeto>

La propiedad path.win32 proporciona acceso a 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`