Einführung in den Pfadverarbeitungsmodulpfad in Node.js

Dieser Artikel stellt hauptsächlich den Pfad des Pfadverarbeitungsmoduls in Node.js vor. Jetzt kann ich ihn mit Ihnen teilen.

Ich glaube, das weiß jeder nodejs, path ist ein Modul, das häufig verwendet wird, das die Leute aber lieben und hassen. Weil einige Dokumente nicht klar genug sind und andere aufgrund von Plattformunterschieden in den Schnittstellen. Dieser Artikel gibt Ihnen eine detaillierte Einführung in den Pfadverarbeitungsmodulpfad in Node.js. Ich hoffe, er wird Ihnen beim Erlernen oder Verwenden des Modulpfads hilfreich sein.

Vorwort

In node.js werden viele Module bereitgestellt, die verwendet werden können und Attribute, die zum Verarbeiten und Konvertieren von Pfaden verwendet werden, sind nicht so verwirrend, wenn Sie die Schnittstellen von Pfaden nach ihrer Verwendung klassifizieren und sorgfältig darüber nachdenken. Im Folgenden stellen wir den Pfad des Pfadverarbeitungsmoduls in Node.js ausführlich vor.

Pfad/Dateiname/Erweiterung abrufen

Pfad abrufen: path.dirname(filepath)<code>path.dirname(filepath)<br>

Rufen Sie den Dateinamen ab: path.basename(filepath)<code>path.basename(filepath)<br>

Rufen Sie die Erweiterung ab: path.extname(filepath)<code>path.extname(filepath)<br>

Den Pfad abrufen

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 der Ausgabe Pfad und wird nicht feststellen, ob der 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 ist 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 )

Beginnen Sie mit dem Abfangen vom letzten von B bis zum letzten Charakter.

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

Schauen Sie sich direkt das offizielle Dokumentationsbeispiel 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ügen Sie die Pfade zusammen und normalisieren Sie 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 lang . Sie können sich vorstellen, dass Sie jetzt 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') );

Pfadanalyse

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) : Die Die Attribute root, dir, base, name und ext von pathObject werden nach bestimmten Regeln zu einem Dateipfad zusammengefasst.

path.parse(filepath) : Der umgekehrte Vorgang 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)

然后是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)

阅读相关API文档说明后发现，path.format(pathObject)中，pathObject的配置属性是可以进一步精简的。

根据接口的描述来看，以下两者是等价的。

root vs dir：两者可以互相替换，区别在于，路径拼接时，root后不会自动加/，而dir会。

base vs name+ext：两者可以互相替换。

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) 的反向操作，直接上官网例子。

四个属性，对于使用者是挺便利的，不过path.format(pathObject) 中也是四个配置属性，就有点容易搞混。

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

获取相对路径

接口：path.relative(from, to)

描述：从from路径，到to路径的相对路径。

边界：

如果from、to指向同个路径，那么，返回空字符串。

如果from、to中任一者为空，那么，返回当前工作路径。

上例子：

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"

平台相关接口/属性

以下属性、接口，都跟平台的具体实现相关。也就是说，同样的属性、接口，在不同平台上的表现不同。

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

以上就是本文的全部内容，希望对大家的学习有所帮助，更多相关内容请关注PHP中文网！

相关推荐：

关于Vuex管理登录的状态解析

关于vue解决跨域路由冲突问题的思路

Das obige ist der detaillierte Inhalt vonEinführung in den Pfadverarbeitungsmodulpfad in Node.js. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!