Detaillierte Erläuterung des Pfadverarbeitungsmodulpfads in Node.js

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 gibt path.basename(filepath) nur den letzten Teil des Pfades aus und bestimmt nicht, ob es sich um einen Dateinamen handelt.

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 ist wie folgt:

var path = require('path');
var filepath = '/tmp/demo/js/test.js';
 
// 输出：.js
console.log( path.extname(filepath) );

Dateierweiterung abrufen

Einfach Das 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: (unter der Annahme, dass path.basename(filepath) === B ist)

Beginnen Sie mit dem Abfangen ab dem letzten von B bis zum Ende ein Charakter.

Wenn . nicht in B existiert oder das erste Zeichen von B . ist, wird eine leere Zeichenfolge zurückgegeben.

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 langwierig. 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 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') );

Pfadanalyse

path.parse(path)

path.normalize(filepath)

From Die Beschreibung des offiziellen Dokuments, path.normalize(filepath), sollte eine relativ einfache API sein, aber ich fühle mich bei der Verwendung immer unsicher.

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.

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): Kombinieren Sie die Root-, Dir-, Base-, Name- und Ext-Attribute von pathObject gemäß bestimmten Regeln. in einen Dateipfad.

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)

Zugehörige API lesen Nach dem Lesen In der Dokumentation habe ich festgestellt, dass in path.format(pathObject) die Konfigurationseigenschaften von pathObject weiter optimiert werden können.

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. Beispiele für die umgekehrte Operation von

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) finden Sie direkt auf der offiziellen Website.

Die vier Attribute 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 Bis-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.

Das obige Beispiel:

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"

Plattformbezogene Schnittstellen/Eigenschaften

Die folgenden Eigenschaften und Schnittstellen beziehen sich auf die spezifische Implementierung der Plattform. Mit anderen Worten: Dieselben Eigenschaften und Schnittstellen verhalten sich auf verschiedenen Plattformen unterschiedlich.

path.posix: Linux-Implementierung pfadbezogener Attribute und Schnittstellen.

path.win32: Win32-Implementierung pfadbezogener Attribute und Schnittstellen.

path.sep: Pfadtrennzeichen. Unter Linux ist es /, unter Windows ist es „.

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\\']

总结

以上就是这篇文章的全部内容了，希望本文的内容对大家学习或者使用node.js能有所帮助，如果有疑问大家可以留言交流，谢谢大家对PHP中文网的支持。

更多Node.js中路径处理模块path详解相关文章请关注PHP中文网！