Vorwort
In node.js wird ein Pfadblock bereitgestellt. In diesem Modul werden viele Methoden und Attribute bereitgestellt, mit denen Pfade verarbeitet und konvertiert werden können . Wenn Sie sorgfältig darüber nachdenken, wird es nicht so verwirrend sein. Im Folgenden stellen wir den Pfad des Pfadverarbeitungsmoduls in Node.js ausführlich vor.
Pfad/Dateiname/Erweiterung abrufen
Pfad abrufen: path.dirname(filepath)
Dateinamen abrufen: path.basename(filepath )
Erhalten Sie die Erweiterung: path.extname(filepath)
Erhalten Sie den Pfad
Das Beispiel lautet wie folgt:
var path = require('path'); var filepath = '/tmp/demo/js/test.js'; // 输出：/tmp/demo/js console.log( path.dirname(filepath) );
Den Dateinamen abrufen
Genau genommen ist path.basename(filepath) nur der letzte Teil des Ausgabepfads und tut dies auch nicht feststellen, ob Dateiname.
Aber meistens können wir es als einfache Methode verwenden, um „den Dateinamen zu ermitteln“.
var path = require('path'); // 输出：test.js console.log( path.basename('/tmp/demo/js/test.js') ); // 输出：test console.log( path.basename('/tmp/demo/js/test/') ); // 输出：test console.log( path.basename('/tmp/demo/js/test') );
Was ist, wenn Sie nur den Dateinamen, aber nicht die Dateierweiterung erhalten möchten? Der zweite Parameter kann verwendet werden.
// 输出：test console.log( path.basename('/tmp/demo/js/test.js', '.js') );
Dateierweiterung abrufen
Ein einfaches Beispiel lautet wie folgt:
var path = require('path'); var filepath = '/tmp/demo/js/test.js'; // 输出：.js console.log( path.extname(filepath) );
Die detaillierteren Regeln lauten wie folgt: (vorausgesetzt, path.basename(filepath) === B )
Abfangen vom letzten von B bis zum letzten Zeichen.
Wenn . nicht in B existiert oder das erste Zeichen von B . ist, wird eine leere Zeichenfolge zurückgegeben.
Schauen Sie sich direkt das offizielle Dokumentbeispiel an
path.extname('index.html') // returns '.html' path.extname('index.coffee.md') // returns '.md' path.extname('index.') // returns '.' path.extname('index') // returns '' path.extname('.index') // returns ''
Pfadkombination
path.join([...paths]) path.resolve([...paths])
path.join([...paths])
Füge die Pfade zusammen und normalisiere sie dann. Dieser Satz ist für mich sowieso unverständlich. Sie können sich auf die Pseudocode-Definition unten beziehen.
Ein Beispiel lautet wie folgt:
var path = require('path'); // 输出 '/foo/bar/baz/asdf' path.join('/foo', 'bar', 'baz/asdf', 'quux', '..');
Der Pseudocode der Pfaddefinition lautet wie folgt:
module.exports.join = function(){
var paths = Array.prototye.slice.call(arguments, 0);
return this.normalize( paths.join('/') );
};
path.resolve([...paths])
Die Beschreibung dieser Schnittstelle ist etwas ausführlich. Sie können sich vorstellen, dass Sie den Befehl cd path von links nach rechts unter der Shell ausführen und der letztendlich erhaltene absolute Pfad/Dateiname das von dieser Schnittstelle zurückgegebene Ergebnis ist.
Zum Beispiel kann path.resolve('/foo/bar', './baz') als Ergebnis des folgenden Befehls angesehen werden
cd /foo/bar cd ./baz
Weitere Vergleichsbeispiele sind wie folgt:
var path = require('path'); // 假设当前工作路径是 /Users/a/Documents/git-code/nodejs-learning-guide/examples/2016.11.08-node-path // 输出 /Users/a/Documents/git-code/nodejs-learning-guide/examples/2016.11.08-node-path console.log( path.resolve('') ) // 输出 /Users/a/Documents/git-code/nodejs-learning-guide/examples/2016.11.08-node-path console.log( path.resolve('.') ) // 输出 /foo/bar/baz console.log( path.resolve('/foo/bar', './baz') ); // 输出 /foo/bar/baz console.log( path.resolve('/foo/bar', './baz/') ); // 输出 /tmp/file console.log( path.resolve('/foo/bar', '/tmp/file/') ); // 输出 /Users/a/Documents/git-code/nodejs-learning-guide/examples/2016.11.08-node-path/www/js/mod.js console.log( path.resolve('www', 'js/upload', '../mod.js') ); 路径解析 path.parse(path) path.normalize(filepath)
Aus der Beschreibung des offiziellen Dokuments sollte path.normalize(filepath) eine relativ einfache API sein, aber ich bin mir immer unsicher, wann es benutzen.
Warum? Die API-Beschreibung ist zu kurz und enthält Folgendes:
Wenn der Pfad leer ist, geben Sie zurück., was dem aktuellen Arbeitspfad entspricht.
Wiederholte Pfadtrennzeichen (z. B. / unter Linux) im Pfad zu einem zusammenführen.
Verarbeiten Sie die ., .. im Pfad. (Ähnlich wie cd in der Shell.)
Wenn am Ende des Pfads ein / steht, behalten Sie das / bei.
Ich habe das Gefühl, dass ein Bruder von Stackoverflow eine realistischere Erklärung dieser API hat, hier ist der Originallink.
In other words, path.normalize is "What is the shortest path I can take that will take me to the same place as the input"
Das Codebeispiel lautet wie folgt. Es wird empfohlen, dass Leser den Code kopieren und ausführen, um den tatsächlichen Effekt zu sehen.
var path = require('path');
var filepath = '/tmp/demo/js/test.js';
var index = 0;
var compare = function(desc, callback){
console.log('[用例%d]：%s', ++index, desc);
callback();
console.log('\n');
};
compare('路径为空', function(){
// 输出 .
console.log( path.normalize('') );
});
compare('路径结尾是否带/', function(){
// 输出 /tmp/demo/js/upload
console.log( path.normalize('/tmp/demo/js/upload') );
// /tmp/demo/js/upload/
console.log( path.normalize('/tmp/demo/js/upload/') );
});
compare('重复的/', function(){
// 输出 /tmp/demo/js
console.log( path.normalize('/tmp/demo//js') );
});
compare('路径带..', function(){
// 输出 /tmp/demo/js
console.log( path.normalize('/tmp/demo/js/upload/..') );
});
compare('相对路径', function(){
// 输出 demo/js/upload/
console.log( path.normalize('./demo/js/upload/') );
// 输出 demo/js/upload/
console.log( path.normalize('demo/js/upload/') );
});
compare('不常用边界', function(){
// 输出 ..
console.log( path.normalize('./..') );
// 输出 ..
console.log( path.normalize('..') );
// 输出 ../
console.log( path.normalize('../') );
// 输出 /
console.log( path.normalize('/../') );
// 输出 /
console.log( path.normalize('/..') );
});
Dateipfadzerlegung/-kombination
path.format(pathObject): Konvertieren Sie das Stammverzeichnis, das Verzeichnis und die Basis von Die Attribute pathObject , name und ext werden nach bestimmten Regeln zu einem Dateipfad zusammengefasst.
path.parse(filepath): Die umgekehrte Operation der path.format()-Methode.
Werfen wir zunächst einen Blick auf die Beschreibung der zugehörigen Attribute auf der offiziellen Website.
Zuerst unter Linux
┌─────────────────────┬────────────┐ │ dir │ base │ ├──────┬ ├──────┬─────┤ │ root │ │ name │ ext │ " / home/user/dir / file .txt " └──────┴──────────────┴──────┴─────┘ (all spaces in the "" line should be ignored -- they are purely for formatting)
Dann unter Windows
┌─────────────────────┬────────────┐ │ dir │ base │ ├──────┬ ├──────┬─────┤ │ root │ │ name │ ext │ " C:\ path\dir \ file .txt " └──────┴──────────────┴──────┴─────┘ (all spaces in the "" line should be ignored -- they are purely for formatting)
path.format(pathObject)
Nachdem ich die entsprechende API-Dokumentation gelesen hatte, fand ich das in path.format(pathObject), dem Konfigurationsattribut von pathObject Es kann weiter optimiert werden.
Laut Beschreibung der Schnittstelle sind die folgenden beiden gleichwertig.
Root vs. dir: Die beiden können durcheinander ersetzt werden. Der Unterschied besteht darin, dass beim Zusammenfügen von Pfaden / nicht automatisch nach root hinzugefügt wird, wohl aber dir.
base vs name+ext: Die beiden können miteinander ersetzt werden. Die vier Attribute
var path = require('path');
var p1 = path.format({
root: '/tmp/',
base: 'hello.js'
});
console.log( p1 ); // 输出 /tmp/hello.js
var p2 = path.format({
dir: '/tmp',
name: 'hello',
ext: '.js'
});
console.log( p2 ); // 输出 /tmp/hello.js
path.parse(filepath)
path.format(pathObject) 的反向操作，直接上官网例子。sind für Benutzer sehr praktisch, aber path.format(pathObject) verfügt auch über vier Konfigurationsattribute, was leicht zu Verwirrung führen kann.
path.parse('/home/user/dir/file.txt')
// returns
// {
// root : "/",
// dir : "/home/user/dir",
// base : "file.txt",
// ext : ".txt",
// name : "file"
// }
Relativen Pfad abrufen
Schnittstelle: path.relative(from, to)
Beschreibung : Relativer Pfad vom Von-Pfad zum Nach-Pfad.
Grenze:
Wenn from und to auf denselben Pfad zeigen, wird eine leere Zeichenfolge zurückgegeben.
Wenn entweder von oder bis leer ist, wird der aktuelle Arbeitspfad zurückgegeben.
Beispiel oben:
var path = require('path'); var p1 = path.relative('/data/orandea/test/aaa', '/data/orandea/impl/bbb'); console.log(p1); // 输出 "../../impl/bbb" var p2 = path.relative('/data/demo', '/data/demo'); console.log(p2); // 输出 "" var p3 = path.relative('/data/demo', ''); console.log(p3); // 输出 "../../Users/a/Documents/git-code/nodejs-learning-guide/examples/2016.11.08-node-path"
Schnittstellen beziehen sich alle auf die spezifische Implementierung der Plattform. Mit anderen Worten: Dieselben Eigenschaften und Schnittstellen verhalten sich auf verschiedenen Plattformen unterschiedlich.
path.posix：path相关属性、接口的linux实现。
path.win32：path相关属性、接口的win32实现。
path.sep：路径分隔符。在linux上是/，在windows上是``。
path.delimiter：path设置的分割符。linux上是:，windows上是;。
注意，当使用 path.win32 相关接口时，参数同样可以使用/做分隔符，但接口返回值的分割符只会是``。
直接来例子更直观。
> path.win32.join('/tmp', 'fuck') '\\tmp\\fuck' > path.win32.sep '\\' > path.win32.join('\tmp', 'demo') '\\tmp\\demo' > path.win32.join('/tmp', 'demo') '\\tmp\\demo' path.delimiter
linux系统例子：
console.log(process.env.PATH) // '/usr/bin:/bin:/usr/sbin:/sbin:/usr/local/bin' process.env.PATH.split(path.delimiter) // returns ['/usr/bin', '/bin', '/usr/sbin', '/sbin', '/usr/local/bin']
windows系统例子：
console.log(process.env.PATH) // 'C:\Windows\system32;C:\Windows;C:\Program Files\node\' process.env.PATH.split(path.delimiter) // returns ['C:\\Windows\\system32', 'C:\\Windows', 'C:\\Program Files\\node\\']
