Pfad

[Stabil: 2 - Stabil]

Das Modul node:path bietet Hilfsfunktionen zum Arbeiten mit Datei- und Verzeichnispfaden. Es kann wie folgt zugegriffen werden:

CJSESM

const path = require('node:path')

import path from 'node:path'

Windows vs. POSIX

Das Standardverhalten des Moduls node:path variiert je nach Betriebssystem, auf dem eine Node.js-Anwendung ausgeführt wird. Insbesondere wenn es auf einem Windows-Betriebssystem ausgeführt wird, geht das Modul node:path davon aus, dass Pfade im Windows-Stil verwendet werden.

So kann die Verwendung von path.basename() auf POSIX und Windows zu unterschiedlichen Ergebnissen führen:

Auf POSIX:

path.basename('C:\\temp\\myfile.html')
// Gibt zurück: 'C:\\temp\\myfile.html'

Auf Windows:

path.basename('C:\\temp\\myfile.html')
// Gibt zurück: 'myfile.html'

Um konsistente Ergebnisse bei der Arbeit mit Windows-Dateipfaden auf jedem Betriebssystem zu erzielen, verwenden Sie path.win32:

Auf POSIX und Windows:

path.win32.basename('C:\\temp\\myfile.html')
// Gibt zurück: 'myfile.html'

Um konsistente Ergebnisse bei der Arbeit mit POSIX-Dateipfaden auf jedem Betriebssystem zu erzielen, verwenden Sie path.posix:

Auf POSIX und Windows:

path.posix.basename('/tmp/myfile.html')
// Gibt zurück: 'myfile.html'

Unter Windows folgt Node.js dem Konzept des arbeitsverzeichnis pro Laufwerk. Dieses Verhalten kann beobachtet werden, wenn ein Laufwerkspfad ohne Backslash verwendet wird. Beispielsweise kann path.resolve('C:\\') möglicherweise ein anderes Ergebnis zurückgeben als path.resolve('C:'). Weitere Informationen finden Sie auf dieser MSDN-Seite.

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

[Verlauf]

Version	Änderungen
v6.0.0	Das Übergeben eines Nicht-Strings als `path`-Argument wirft jetzt einen Fehler.
v0.1.25	Hinzugefügt in: v0.1.25

path <string>
suffix <string> Ein optionales Suffix zum Entfernen
Gibt zurück: <string>

Die Methode path.basename() gibt den letzten Teil eines path zurück, ähnlich dem Unix-Befehl basename. Nachgestellte Verzeichnistrennzeichen werden ignoriert.

path.basename('/foo/bar/baz/asdf/quux.html')
// Gibt zurück: 'quux.html'

path.basename('/foo/bar/baz/asdf/quux.html', '.html')
// Gibt zurück: 'quux'

Obwohl Windows Dateinamen, einschließlich Dateierweiterungen, in der Regel ohne Berücksichtigung der Groß-/Kleinschreibung behandelt, tut dies diese Funktion nicht. Beispielsweise beziehen sich C:\\foo.html und C:\\foo.HTML auf dieselbe Datei, aber basename behandelt die Erweiterung als eine Zeichenkette, bei der die Groß-/Kleinschreibung beachtet wird:

path.win32.basename('C:\\foo.html', '.html')
// Gibt zurück: 'foo'

path.win32.basename('C:\\foo.HTML', '.html')
// Gibt zurück: 'foo.HTML'

Ein TypeError wird geworfen, wenn path kein String ist oder wenn suffix angegeben wird und kein String ist.

`path.delimiter`

Hinzugefügt in: v0.9.3

<string>

Stellt das plattformspezifische Pfadtrennzeichen bereit:

; für Windows
: für POSIX

Zum Beispiel unter POSIX:

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

process.env.PATH.split(path.delimiter)
// Gibt zurück: ['/usr/bin', '/bin', '/usr/sbin', '/sbin', '/usr/local/bin']

Unter Windows:

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

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

`path.dirname(path)`

[Verlauf]

Version	Änderungen
v6.0.0	Das Übergeben eines Nicht-Strings als `path`-Argument führt jetzt zu einer Fehlermeldung.
v0.1.16	Hinzugefügt in: v0.1.16

path <string>
Gibt zurück: <string>

Die Methode path.dirname() gibt den Verzeichnisnamen eines path zurück, ähnlich dem Unix-Befehl dirname. Nachgestellte Verzeichnistrennzeichen werden ignoriert, siehe path.sep.

path.dirname('/foo/bar/baz/asdf/quux')
// Gibt zurück: '/foo/bar/baz/asdf'

Ein TypeError wird ausgelöst, wenn path kein String ist.

`path.extname(path)`

[Verlauf]

Version	Änderungen
v6.0.0	Das Übergeben eines Nicht-Strings als `path`-Argument führt jetzt zu einer Fehlermeldung.
v0.1.25	Hinzugefügt in: v0.1.25

path <string>
Gibt zurück: <string>

Die Methode path.extname() gibt die Dateierweiterung des path zurück, vom letzten Vorkommen des . (Punkt)-Zeichens bis zum Ende des Strings im letzten Teil des path. Wenn im letzten Teil des path kein . vorhanden ist oder wenn keine .-Zeichen außer dem ersten Zeichen des Basisnamens von path (siehe path.basename()) vorhanden sind, wird ein leerer String zurückgegeben.

path.extname('index.html')
// Gibt zurück: '.html'

path.extname('index.coffee.md')
// Gibt zurück: '.md'

path.extname('index.')
// Gibt zurück: '.'

path.extname('index')
// Gibt zurück: ''

path.extname('.index')
// Gibt zurück: ''

path.extname('.index.md')
// Gibt zurück: '.md'

Ein TypeError wird ausgelöst, wenn path kein String ist.

`path.format(pathObject)`

[Verlauf]

Version	Änderungen
v19.0.0	Der Punkt wird hinzugefügt, wenn er in `ext` nicht angegeben ist.
v0.11.15	Hinzugefügt in: v0.11.15

pathObject <Object> Ein beliebiges JavaScript-Objekt mit den folgenden Eigenschaften:
- dir <string>
- root <string>
- base <string>
- name <string>
- ext <string>
Gibt zurück: <string>

Die path.format()-Methode gibt einen Pfad-String aus einem Objekt zurück. Dies ist das Gegenteil von path.parse().

Wenn Sie Eigenschaften für das pathObject angeben, denken Sie daran, dass es Kombinationen gibt, bei denen eine Eigenschaft Vorrang vor einer anderen hat:

pathObject.root wird ignoriert, wenn pathObject.dir angegeben ist
pathObject.ext und pathObject.name werden ignoriert, wenn pathObject.base vorhanden ist

Zum Beispiel auf POSIX:

// Wenn `dir`, `root` und `base` angegeben sind,
// wird `${dir}${path.sep}${base}`
// zurückgegeben. `root` wird ignoriert.
path.format({
  root: '/ignored',
  dir: '/home/user/dir',
  base: 'file.txt',
})
// Gibt zurück: '/home/user/dir/file.txt'

// `root` wird verwendet, wenn `dir` nicht angegeben ist.
// Wenn nur `root` angegeben ist oder `dir` gleich `root` ist, wird das
// Plattformtrennzeichen nicht hinzugefügt. `ext` wird ignoriert.
path.format({
  root: '/',
  base: 'file.txt',
  ext: 'ignored',
})
// Gibt zurück: '/file.txt'

// `name` + `ext` werden verwendet, wenn `base` nicht angegeben ist.
path.format({
  root: '/',
  name: 'file',
  ext: '.txt',
})
// Gibt zurück: '/file.txt'

// Der Punkt wird hinzugefügt, wenn er in `ext` nicht angegeben ist.
path.format({
  root: '/',
  name: 'file',
  ext: 'txt',
})
// Gibt zurück: '/file.txt'

Unter Windows:

path.format({
  dir: 'C:\\path\\dir',
  base: 'file.txt',
})
// Gibt zurück: 'C:\\path\\dir\\file.txt'

`path.matchesGlob(path, pattern)`

Hinzugefügt in: v22.5.0, v20.17.0

[Stabil: 1 - Experimentell]

Stabil: 1 Stabilität: 1 - Experimentell

path <string> Der Pfad, der mit dem Glob-Muster abgeglichen werden soll.
pattern <string> Das Glob-Muster, gegen das der Pfad geprüft werden soll.
Gibt zurück: <boolean> Gibt an, ob der path mit dem pattern übereinstimmt.

Die Methode path.matchesGlob() ermittelt, ob path mit dem pattern übereinstimmt.

Zum Beispiel:

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

Ein TypeError wird geworfen, wenn path oder pattern keine Strings sind.

`path.isAbsolute(path)`

Hinzugefügt in: v0.11.2

path <string>
Gibt zurück: <boolean>

Die Methode path.isAbsolute() ermittelt, ob path ein absoluter Pfad ist.

Wenn der angegebene path ein String der Länge Null ist, wird false zurückgegeben.

Zum Beispiel unter POSIX:

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

Unter 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

Ein TypeError wird geworfen, wenn path kein String ist.

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

Hinzugefügt in: v0.1.16

...paths <string> Eine Folge von Pfadsegmenten
Gibt zurück: <string>

Die Methode path.join() verbindet alle angegebenen path-Segmente unter Verwendung des plattformspezifischen Trennzeichens als Begrenzer und normalisiert dann den resultierenden Pfad.

Pfadsegmente der Länge Null werden ignoriert. Wenn der zusammengefügte Pfadstring ein String der Länge Null ist, wird '.' zurückgegeben, der das aktuelle Arbeitsverzeichnis repräsentiert.

path.join('/foo', 'bar', 'baz/asdf', 'quux', '..')
// Gibt zurück: '/foo/bar/baz/asdf'

path.join('foo', {}, 'bar')
// Wirft 'TypeError: Path muss ein String sein. Empfangen {}'

Ein TypeError wird geworfen, wenn eines der Pfadsegmente kein String ist.

`path.normalize(path)`

Hinzugefügt in: v0.1.23

path <string>
Gibt zurück: <string>

Die Methode path.normalize() normalisiert den angegebenen path und löst '..'- und '.'-Segmente auf.

Wenn mehrere aufeinanderfolgende Trennzeichen für Pfadsegmente gefunden werden (z. B. / auf POSIX und entweder \ oder / auf Windows), werden diese durch ein einzelnes Vorkommen des plattformspezifischen Trennzeichens für Pfadsegmente ersetzt (/ auf POSIX und \ auf Windows). Nachgestellte Trennzeichen werden beibehalten.

Wenn der path eine Zeichenkette der Länge Null ist, wird '.' zurückgegeben, was das aktuelle Arbeitsverzeichnis darstellt.

Auf POSIX halten sich die Arten der von dieser Funktion angewandten Normalisierung nicht strikt an die POSIX-Spezifikation. Beispielsweise ersetzt diese Funktion zwei führende Schrägstriche durch einen einzigen Schrägstrich, als ob es sich um einen regulären absoluten Pfad handeln würde, während einige POSIX-Systeme Pfaden, die mit genau zwei Schrägstrichen beginnen, eine spezielle Bedeutung zuweisen. Ebenso können andere von dieser Funktion durchgeführte Ersetzungen, wie z. B. das Entfernen von ..-Segmenten, die Art und Weise ändern, wie das zugrunde liegende System den Pfad auflöst.

Zum Beispiel auf POSIX:

path.normalize('/foo/bar//baz/asdf/quux/..')
// Gibt zurück: '/foo/bar/baz/asdf'

Auf Windows:

path.normalize('C:\\temp\\\\foo\\bar\\..\\')
// Gibt zurück: 'C:\\temp\\foo\\'

Da Windows mehrere Pfadtrennzeichen erkennt, werden beide Trennzeichen durch Instanzen des von Windows bevorzugten Trennzeichens (\) ersetzt:

path.win32.normalize('C:////temp\\\\/\\/\\/foo/bar')
// Gibt zurück: 'C:\\temp\\foo\\bar'

Ein TypeError wird ausgelöst, wenn path keine Zeichenkette ist.

`path.parse(path)`

Hinzugefügt in: v0.11.15

path <string>
Gibt zurück: <Object>

Die Methode path.parse() gibt ein Objekt zurück, dessen Eigenschaften signifikante Elemente des path darstellen. Nachgestellte Verzeichnistrennzeichen werden ignoriert, siehe path.sep.

Das zurückgegebene Objekt hat die folgenden Eigenschaften:

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

Zum Beispiel auf POSIX:

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

text

┌─────────────────────┬────────────┐
│          dir        │    base    │
├──────┬              ├──────┬─────┤
│ root │              │ name │ ext │
"  /    home/user/dir / file  .txt "
└──────┴──────────────┴──────┴─────┘
(Alle Leerzeichen in der ""-Zeile sollten ignoriert werden. Sie dienen nur der Formatierung.)

Auf Windows:

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

text

┌─────────────────────┬────────────┐
│          dir        │    base    │
├──────┬              ├──────┬─────┤
│ root │              │ name │ ext │
" C:\      path\dir   \ file  .txt "
└──────┴──────────────┴──────┴─────┘
(Alle Leerzeichen in der ""-Zeile sollten ignoriert werden. Sie dienen nur der Formatierung.)

Ein TypeError wird ausgelöst, wenn path keine Zeichenkette ist.

`path.posix`

[Verlauf]

Version	Änderungen
v15.3.0	Als `require('path/posix')` bereitgestellt.
v0.11.15	Hinzugefügt in: v0.11.15

<Object>

Die Eigenschaft path.posix bietet Zugriff auf POSIX-spezifische Implementierungen der path-Methoden.

Auf die API kann über require('node:path').posix oder require('node:path/posix') zugegriffen werden.

`path.relative(from, to)`

[Verlauf]

Version	Änderungen
v6.8.0	Unter Windows werden die führenden Schrägstriche für UNC-Pfade jetzt im Rückgabewert berücksichtigt.
v0.5.0	Hinzugefügt in: v0.5.0

from <string>
to <string>
Gibt zurück: <string>

Die Methode path.relative() gibt den relativen Pfad von from nach to basierend auf dem aktuellen Arbeitsverzeichnis zurück. Wenn from und to jeweils auf denselben Pfad auflösen (nachdem path.resolve() für jeden aufgerufen wurde), wird eine Zeichenkette der Länge Null zurückgegeben.

Wenn eine Zeichenkette der Länge Null als from oder to übergeben wird, wird das aktuelle Arbeitsverzeichnis anstelle der Zeichenketten der Länge Null verwendet.

Zum Beispiel auf POSIX:

path.relative('/data/orandea/test/aaa', '/data/orandea/impl/bbb')
// Gibt zurück: '../../impl/bbb'

Unter Windows:

path.relative('C:\\orandea\\test\\aaa', 'C:\\orandea\\impl\\bbb')
// Gibt zurück: '..\\..\\impl\\bbb'

Ein TypeError wird ausgelöst, wenn entweder from oder to keine Zeichenkette ist.

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

Hinzugefügt in: v0.3.4

...paths <string> Eine Folge von Pfaden oder Pfadsegmenten
Gibt zurück: <string>

Die Methode path.resolve() löst eine Folge von Pfaden oder Pfadsegmenten in einen absoluten Pfad auf.

Die angegebene Folge von Pfaden wird von rechts nach links verarbeitet, wobei jeder nachfolgende path vorangestellt wird, bis ein absoluter Pfad erstellt ist. Wenn beispielsweise die Folge von Pfadsegmenten /foo, /bar, baz gegeben ist, würde der Aufruf von path.resolve('/foo', '/bar', 'baz') /bar/baz zurückgeben, da 'baz' kein absoluter Pfad ist, aber '/bar' + '/' + 'baz' es ist.

Wenn nach der Verarbeitung aller angegebenen path-Segmente noch kein absoluter Pfad erzeugt wurde, wird das aktuelle Arbeitsverzeichnis verwendet.

Der resultierende Pfad wird normalisiert und nachfolgende Schrägstriche werden entfernt, es sei denn, der Pfad wird im Stammverzeichnis aufgelöst.

Pfadsegmente der Länge Null werden ignoriert.

Wenn keine path-Segmente übergeben werden, gibt path.resolve() den absoluten Pfad des aktuellen Arbeitsverzeichnisses zurück.

path.resolve('/foo/bar', './baz')
// Gibt zurück: '/foo/bar/baz'

path.resolve('/foo/bar', '/tmp/file/')
// Gibt zurück: '/tmp/file'

path.resolve('wwwroot', 'static_files/png/', '../gif/image.gif')
// Wenn das aktuelle Arbeitsverzeichnis /home/myself/node ist,
// gibt dies '/home/myself/node/wwwroot/static_files/gif/image.gif' zurück.

Ein TypeError wird ausgelöst, wenn eines der Argumente keine Zeichenkette ist.

`path.sep`

Hinzugefügt in: v0.7.9

<string>

Stellt den plattformspezifischen Pfadsegmenttrenner bereit:

\ unter Windows
/ unter POSIX

Zum Beispiel unter POSIX:

'foo/bar/baz'.split(path.sep)
// Gibt zurück: ['foo', 'bar', 'baz']

Unter Windows:

'foo\\bar\\baz'.split(path.sep)
// Gibt zurück: ['foo', 'bar', 'baz']

Unter Windows werden sowohl der Schrägstrich (/) als auch der umgekehrte Schrägstrich (\) als Pfadsegmenttrenner akzeptiert; die path-Methoden fügen jedoch nur umgekehrte Schrägstriche (\) hinzu.

`path.toNamespacedPath(path)`

Hinzugefügt in: v9.0.0

path <string>
Gibt zurück: <string>

Gibt nur unter Windows-Systemen einen äquivalenten Namespace-präfixierten Pfad für den angegebenen path zurück. Wenn path keine Zeichenkette ist, wird path ohne Änderungen zurückgegeben.

Diese Methode ist nur unter Windows-Systemen sinnvoll. Auf POSIX-Systemen ist die Methode funktionslos und gibt immer path ohne Änderungen zurück.

`path.win32`

[Verlauf]

Version	Änderungen
v15.3.0	Als `require('path/win32')` verfügbar gemacht.
v0.11.15	Hinzugefügt in: v0.11.15

<Object>

Die path.win32-Eigenschaft bietet Zugriff auf Windows-spezifische Implementierungen der path-Methoden.

Die API ist über require('node:path').win32 oder require('node:path/win32') zugänglich.

Pfad ​

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 ​

Pfad

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`