Introduction au chemin du module de traitement de chemin dans Node.js

Cet article présente principalement le chemin du module de traitement de chemin dans Node.js. Il a une certaine valeur de référence. Maintenant, je le partage avec vous. Les amis dans le besoin peuvent s'y référer

Je crois que tout le monde le sait dans In. nodejs, path est un module fréquemment utilisé, mais que les gens aiment et détestent. Parce que certains documents ne sont pas assez clairs, et d'autres le sont en raison des différences d'interface entre les plates-formes. Cet article vous donnera une introduction détaillée au chemin du module de traitement de chemin dans Node.js. J'espère qu'il vous sera utile pour apprendre ou utiliser le chemin du module.

Préface

Dans node.js, un bloc de chemin est fourni Dans ce module, de nombreux modules sont fournis qui peuvent être utilisés. les méthodes et attributs utilisés pour traiter et convertir les chemins ne sont pas si déroutants si vous classez les interfaces des chemins en fonction de leurs utilisations et que vous y réfléchissez attentivement. Ci-dessous, nous présenterons en détail le chemin du module de traitement de chemin dans Node.js.

Obtenir le chemin/nom de fichier/extension

Obtenir le chemin : path.dirname(filepath)<code>path.dirname(filepath)<br>

Obtenez le nom du fichier : path.basename(filepath)<code>path.basename(filepath)<br>

Obtenez l'extension : path.extname(filepath)<code>path.extname(filepath)<br>

Obtenir le chemin

L'exemple est le suivant :

var path = require('path');
var filepath = '/tmp/demo/js/test.js';

// 输出：/tmp/demo/js
console.log( path.dirname(filepath) );

Obtenir le nom du fichier

À proprement parler, path.basename(filepath) n'est que la dernière partie de le chemin de sortie et ne détermine pas si le nom du fichier.

Mais la plupart du temps, nous pouvons l'utiliser comme une méthode simple pour "obtenir le nom du fichier".

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

Que faire si vous souhaitez uniquement obtenir le nom du fichier, mais pas l'extension du fichier ? Le deuxième paramètre peut être utilisé.

// 输出：test
console.log( path.basename('/tmp/demo/js/test.js', '.js') );

Obtenez l'extension de fichier

Un exemple simple est comme suit :

var path = require('path');
var filepath = '/tmp/demo/js/test.js';

// 输出：.js
console.log( path.extname(filepath) );

Les règles plus détaillées sont les suivantes : (en supposant path.basename(filepath) === B )

Commencez à intercepter à partir du dernier . de B, jusqu'au dernier caractère.

Si . n'existe pas dans B, ou si le premier caractère de B est ., alors une chaîne vide est renvoyée.

Regardez directement l'exemple de documentation officielle

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

Combinaison de chemins

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

path.join([...chemins])

Rassemblez les chemins puis normalisez-les. Cette phrase m'est de toute façon incompréhensible. Vous pouvez vous référer à la définition du pseudocode ci-dessous.

Un exemple est le suivant :

var path = require('path');

// 输出 '/foo/bar/baz/asdf'
path.join('/foo', 'bar', 'baz/asdf', 'quux', '..');

Le pseudocode de la définition du chemin est le suivant :

module.exports.join = function(){
 var paths = Array.prototye.slice.call(arguments, 0);
 return this.normalize( paths.join('/') );
};

path.resolve([...paths])

La description de cette interface est un peu verbeux. Vous pouvez imaginer que vous exécutez maintenant la commande cd path de gauche à droite sous le shell, et le chemin/nom de fichier absolu finalement obtenu est le résultat renvoyé par cette interface.

Par exemple, path.resolve('/foo/bar', './baz') peut être vu comme le résultat de la commande suivante

cd /foo/bar
cd ./baz

D'autres exemples de comparaison sont les suivants :

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

Analyse du chemin

path.parse(path)

path.normalize(filepath)

À en juger par la description dans le document officiel, path.normalize(filepath) devrait être une API relativement simple, mais J'ai toujours l'impression que c'est déroutant à utiliser.

Pourquoi ? La description de l'API est trop brève et comprend les éléments suivants :

Si le chemin est vide, retournez., ce qui est équivalent au chemin de travail actuel.

Fusionner les séparateurs de chemin répétés (tels que / sous Linux) dans le chemin en un seul.

Traitez les ., .. dans le chemin. (Semblable au cd en shell..)

S'il y a un / à la fin du chemin, alors conservez le /.

J'ai l'impression qu'un frère sur stackoverflow a une explication plus réaliste de cette API, voici le lien original.

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"

L'exemple de code est le suivant. Il est recommandé aux lecteurs de copier le code et de l'exécuter pour voir l'effet réel.

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('/..') );
});

Décomposition/combinaison du chemin de fichier

path.format(pathObject) : Combinez les attributs root, dir, base, name et ext de pathObject dans un chemin de fichier selon certaines règles.

path.parse(filepath)  : L'opération inverse de la méthode path.format().

Jetons d’abord un coup d’œil à la description des attributs associés sur le site officiel.

Tout d'abord, sous 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解决跨域路由冲突问题的思路

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!