Path

[Stable: 2 - Stable]

Code source : lib/path.js

Le module node:path fournit des utilitaires pour travailler avec les chemins de fichiers et de répertoires. Il est accessible en utilisant :

CJSESM

const path = require('node:path')

import path from 'node:path'

Windows vs. POSIX

Le fonctionnement par défaut du module node:path varie en fonction du système d’exploitation sur lequel une application Node.js est exécutée. Plus précisément, lors de l’exécution sur un système d’exploitation Windows, le module node:path suppose que des chemins de style Windows sont utilisés.

Ainsi, l’utilisation de path.basename() peut donner des résultats différents sur POSIX et Windows :

Sur POSIX :

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

Sur Windows :

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

Pour obtenir des résultats cohérents lors de l’utilisation de chemins de fichiers Windows sur n’importe quel système d’exploitation, utilisez path.win32 :

Sur POSIX et Windows :

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

Pour obtenir des résultats cohérents lors de l’utilisation de chemins de fichiers POSIX sur n’importe quel système d’exploitation, utilisez path.posix :

Sur POSIX et Windows :

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

Sur Windows, Node.js suit le concept de répertoire de travail par lecteur. Ce comportement peut être observé lors de l’utilisation d’un chemin de lecteur sans barre oblique inverse. Par exemple, path.resolve('C:\\') peut potentiellement renvoyer un résultat différent de path.resolve('C:'). Pour plus d’informations, consultez cette page MSDN.

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

[Historique]

Version	Changements
v6.0.0	Le fait de passer une valeur non-chaîne comme argument `path` lèvera désormais une exception.
v0.1.25	Ajouté dans : v0.1.25

path <string>
suffix <string> Un suffixe optionnel à supprimer
Retourne : <string>

La méthode path.basename() retourne la dernière partie d’un path, similaire à la commande Unix basename. Les séparateurs de répertoires de fin sont ignorés.

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

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

Bien que Windows traite généralement les noms de fichiers, y compris les extensions de fichiers, de manière insensible à la casse, cette fonction ne le fait pas. Par exemple, C:\\foo.html et C:\\foo.HTML font référence au même fichier, mais basename traite l’extension comme une chaîne sensible à la casse :

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

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

Une TypeError est levée si path n’est pas une chaîne ou si suffix est donné et n’est pas une chaîne.

`path.delimiter`

Ajouté dans : v0.9.3

<string>

Fournit le délimiteur de chemin spécifique à la plateforme :

; pour Windows
: pour POSIX

Par exemple, sur POSIX :

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

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

Sur Windows :

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

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

`path.dirname(path)`

[Historique]

Version	Modifications
v6.0.0	La transmission d’une valeur non-chaîne comme argument `path` lèvera désormais une erreur.
v0.1.16	Ajouté dans : v0.1.16

path <string>
Retourne : <string>

La méthode path.dirname() retourne le nom du répertoire d’un path, de manière similaire à la commande Unix dirname. Les séparateurs de répertoire de fin sont ignorés, voir path.sep.

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

Une erreur TypeError est levée si path n’est pas une chaîne de caractères.

`path.extname(path)`

[Historique]

Version	Modifications
v6.0.0	La transmission d’une valeur non-chaîne comme argument `path` lèvera désormais une erreur.
v0.1.25	Ajouté dans : v0.1.25

path <string>
Retourne : <string>

La méthode path.extname() retourne l’extension du path, de la dernière occurrence du caractère . (point) jusqu’à la fin de la chaîne dans la dernière partie du path. S’il n’y a pas de . dans la dernière partie du path, ou s’il n’y a pas de caractère . autre que le premier caractère du nom de base du path (voir path.basename()) , une chaîne vide est retournée.

path.extname('index.html')
// Retourne : '.html'

path.extname('index.coffee.md')
// Retourne : '.md'

path.extname('index.')
// Retourne : '.'

path.extname('index')
// Retourne : ''

path.extname('.index')
// Retourne : ''

path.extname('.index.md')
// Retourne : '.md'

Une erreur TypeError est levée si path n’est pas une chaîne de caractères.

`path.format(pathObject)`

[Historique]

Version	Modifications
v19.0.0	Le point sera ajouté s'il n'est pas spécifié dans `ext`.
v0.11.15	Ajouté dans : v0.11.15

pathObject <Object> Tout objet JavaScript ayant les propriétés suivantes :
- dir <string>
- root <string>
- base <string>
- name <string>
- ext <string>
Retourne : <string>

La méthode path.format() renvoie une chaîne de chemin à partir d'un objet. C'est l'inverse de path.parse().

Lorsque vous fournissez des propriétés à pathObject, souvenez-vous qu'il existe des combinaisons où une propriété a priorité sur une autre :

pathObject.root est ignoré si pathObject.dir est fourni
pathObject.ext et pathObject.name sont ignorés si pathObject.base existe

Par exemple, sur POSIX :

// Si `dir`, `root` et `base` sont fournis,
// `${dir}${path.sep}${base}`
// sera renvoyé. `root` est ignoré.
path.format({
  root: '/ignored',
  dir: '/home/user/dir',
  base: 'file.txt',
})
// Retourne : '/home/user/dir/file.txt'

// `root` sera utilisé si `dir` n'est pas spécifié.
// Si seul `root` est fourni ou si `dir` est égal à `root`, alors le
// séparateur de plateforme ne sera pas inclus. `ext` sera ignoré.
path.format({
  root: '/',
  base: 'file.txt',
  ext: 'ignored',
})
// Retourne : '/file.txt'

// `name` + `ext` sera utilisé si `base` n'est pas spécifié.
path.format({
  root: '/',
  name: 'file',
  ext: '.txt',
})
// Retourne : '/file.txt'

// Le point sera ajouté s'il n'est pas spécifié dans `ext`.
path.format({
  root: '/',
  name: 'file',
  ext: 'txt',
})
// Retourne : '/file.txt'

Sur Windows :

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

`path.matchesGlob(path, pattern)`

Ajouté dans : v22.5.0, v20.17.0

[Stable: 1 - Expérimental]

Stable: 1 Stabilité: 1 - Expérimental

path <string> Le chemin à comparer avec le motif glob.
pattern <string> Le motif glob à comparer avec le chemin.
Retourne : <boolean> Indique si le path correspond ou non au pattern.

La méthode path.matchesGlob() détermine si path correspond au pattern.

Par exemple :

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

Une TypeError est lancée si path ou pattern ne sont pas des chaînes de caractères.

`path.isAbsolute(path)`

Ajouté dans : v0.11.2

path <string>
Retourne : <boolean>

La méthode path.isAbsolute() détermine si path est un chemin absolu.

Si le path donné est une chaîne de caractères de longueur zéro, false sera retourné.

Par exemple, sur POSIX :

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

Sur 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

Une TypeError est lancée si path n’est pas une chaîne de caractères.

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

Ajouté dans : v0.1.16

...paths <string> Une séquence de segments de chemin
Retourne : <string>

La méthode path.join() joint tous les segments de path donnés en utilisant le séparateur spécifique à la plate-forme comme délimiteur, puis normalise le chemin résultant.

Les segments path de longueur nulle sont ignorés. Si la chaîne de chemin jointe est une chaîne de longueur nulle, alors '.' sera retourné, représentant le répertoire de travail actuel.

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

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

Une TypeError est lancée si l’un des segments de chemin n’est pas une chaîne de caractères.

`path.normalize(path)`

Ajouté dans : v0.1.23

path <string>
Renvoie : <string>

La méthode path.normalize() normalise le path donné, en résolvant les segments '..' et '.'.

Lorsque plusieurs caractères de séparation de segments de chemin séquentiels sont trouvés (par ex., / sur POSIX et \ ou / sur Windows), ils sont remplacés par une seule instance du séparateur de segment de chemin spécifique à la plate-forme (/ sur POSIX et \ sur Windows). Les séparateurs de fin sont conservés.

Si le path est une chaîne de longueur nulle, '.' est renvoyé, représentant le répertoire de travail actuel.

Sur POSIX, les types de normalisation appliqués par cette fonction n’adhèrent pas strictement à la spécification POSIX. Par exemple, cette fonction remplacera deux barres obliques initiales par une seule barre oblique, comme s’il s’agissait d’un chemin absolu régulier, tandis que quelques systèmes POSIX attribuent une signification particulière aux chemins commençant par exactement deux barres obliques. De même, d’autres substitutions effectuées par cette fonction, telles que la suppression des segments .., peuvent modifier la façon dont le système sous-jacent résout le chemin.

Par exemple, sur POSIX :

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

Sur Windows :

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

Étant donné que Windows reconnaît plusieurs séparateurs de chemin, les deux séparateurs seront remplacés par des instances du séparateur préféré de Windows (\):

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

Une erreur TypeError est levée si path n’est pas une chaîne.

`path.parse(path)`

Ajouté dans : v0.11.15

path <string>
Renvoie : <Object>

La méthode path.parse() renvoie un objet dont les propriétés représentent des éléments significatifs du path. Les séparateurs de répertoire de fin sont ignorés, voir path.sep.

L’objet renvoyé aura les propriétés suivantes :

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

Par exemple, sur POSIX :

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

text

┌─────────────────────┬────────────┐
│          dir        │    base    │
├──────┬              ├──────┬─────┤
│ root │              │ name │ ext │
"  /    home/user/dir / file  .txt "
└──────┴──────────────┴──────┴─────┘
(Tous les espaces dans la ligne "" doivent être ignorés. Ils sont purement destinés à la mise en forme.)

Sur Windows :

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

text

┌─────────────────────┬────────────┐
│          dir        │    base    │
├──────┬              ├──────┬─────┤
│ root │              │ name │ ext │
" C:\      path\dir   \ file  .txt "
└──────┴──────────────┴──────┴─────┘
(Tous les espaces dans la ligne "" doivent être ignorés. Ils sont purement destinés à la mise en forme.)

Une erreur TypeError est levée si path n’est pas une chaîne.

`path.posix`

[Historique]

Version	Modifications
v15.3.0	Exposé en tant que `require('path/posix')`.
v0.11.15	Ajouté dans la version : v0.11.15

<Object>

La propriété path.posix donne accès aux implémentations spécifiques POSIX des méthodes path.

L’API est accessible via require('node:path').posix ou require('node:path/posix').

`path.relative(from, to)`

[Historique]

Version	Modifications
v6.8.0	Sous Windows, les barres obliques de début pour les chemins UNC sont maintenant incluses dans la valeur de retour.
v0.5.0	Ajouté dans la version : v0.5.0

from <string>
to <string>
Retourne : <string>

La méthode path.relative() retourne le chemin relatif de from à to en fonction du répertoire de travail actuel. Si from et to sont résolus vers le même chemin (après avoir appelé path.resolve() sur chacun), une chaîne de longueur nulle est retournée.

Si une chaîne de longueur nulle est passée comme from ou to, le répertoire de travail actuel sera utilisé à la place des chaînes de longueur nulle.

Par exemple, sous POSIX :

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

Sous Windows :

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

Une TypeError est levée si from ou to n’est pas une chaîne de caractères.

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

Ajouté dans la version : v0.3.4

...paths <string> Une séquence de chemins ou de segments de chemin
Retourne : <string>

La méthode path.resolve() résout une séquence de chemins ou de segments de chemin en un chemin absolu.

La séquence de chemins donnée est traitée de droite à gauche, chaque path suivant étant ajouté jusqu’à ce qu’un chemin absolu soit construit. Par exemple, étant donné la séquence de segments de chemin : /foo, /bar, baz, appeler path.resolve('/foo', '/bar', 'baz') retournerait /bar/baz car 'baz' n’est pas un chemin absolu mais '/bar' + '/' + 'baz' l’est.

Si, après avoir traité tous les segments de path donnés, un chemin absolu n’a pas encore été généré, le répertoire de travail actuel est utilisé.

Le chemin résultant est normalisé et les barres obliques de fin sont supprimées, sauf si le chemin est résolu vers le répertoire racine.

Les segments path de longueur nulle sont ignorés.

Si aucun segment de path n’est passé, path.resolve() retourne le chemin absolu du répertoire de travail actuel.

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

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

path.resolve('wwwroot', 'static_files/png/', '../gif/image.gif')
// Si le répertoire de travail actuel est /home/myself/node,
// ceci retourne '/home/myself/node/wwwroot/static_files/gif/image.gif'

Une TypeError est levée si l’un des arguments n’est pas une chaîne de caractères.

`path.sep`

Ajouté dans : v0.7.9

<string>

Fournit le séparateur de segment de chemin spécifique à la plateforme :

\ sur Windows
/ sur POSIX

Par exemple, sur POSIX :

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

Sur Windows :

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

Sur Windows, la barre oblique (/) et la barre oblique inverse (\) sont acceptées comme séparateurs de segment de chemin ; toutefois, les méthodes path n’ajoutent que des barres obliques inverses (\).

`path.toNamespacedPath(path)`

Ajouté dans : v9.0.0

path <string>
Renvoie : <string>

Uniquement sur les systèmes Windows, renvoie un chemin préfixé par un espace de noms équivalent pour le path donné. Si path n’est pas une chaîne, path sera renvoyé sans modifications.

Cette méthode n’a de sens que sur les systèmes Windows. Sur les systèmes POSIX, la méthode n’est pas opérationnelle et renvoie toujours path sans modifications.

`path.win32`

[Historique]

Version	Modifications
v15.3.0	Exposé comme `require('path/win32')`.
v0.11.15	Ajouté dans : v0.11.15

<Objet>

La propriété path.win32 fournit l’accès aux implémentations spécifiques à Windows des méthodes path.

L’API est accessible via require('node:path').win32 ou 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`