Explication détaillée du chemin du module de traitement de chemin dans Node.js

Avant-propos

Dans node.js, un bloc de chemin est fourni. Dans ce module, de nombreuses méthodes et attributs sont fournis qui peuvent être utilisés pour traiter et convertir les chemins. Les interfaces de chemin sont classées en fonction de leurs utilisations. Si vous y réfléchissez bien, ce ne sera pas si déroutant. 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)

Obtenir le nom de fichier : path.basename(filepath)

Récupérez l'extension : path.extname(filepath)

Récupérez 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) ne génère que la dernière partie du chemin et ne détermine pas s'il s'agit d'un nom de 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') );

Obtenir l'extension de fichier

Un exemple simple est le suivant :

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

Obtenir l'extension de fichier

Simple L'exemple est le suivant :

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 que path.basename(filepath) === B )

Commencez l'interception à partir du dernier de B. jusqu'à la fin un personnage.

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

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([...paths])

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 longue. 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 suit :

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)

De la description du document officiel, path.normalize(filepath) devrait être une API relativement simple, mais je ne suis toujours pas sûr de l'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 gardez le /.

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 selon certaines règles. dans un chemin de fichier.

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.

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)

Puis sous 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)

Lire l'API associée Après lecture Dans la documentation, j'ai trouvé que dans path.format(pathObject), les propriétés de configuration de pathObject peuvent être davantage rationalisées.

D'après la description de l'interface, les deux suivantes sont équivalentes.

Root vs dir : les deux peuvent être remplacés l'un par l'autre. La différence est que lors de l'épissage des chemins, / ne sera pas automatiquement ajouté après root, mais dir le sera.

base vs name ext : les deux peuvent être remplacés l'un par l'autre. Pour l'opération inverse de

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), rendez-vous directement sur le site officiel pour des exemples.

Les quatre attributs sont très pratiques pour les utilisateurs, mais path.format(pathObject) a également quatre attributs de configuration, ce qui est un peu facile à confondre.

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

Obtenir le chemin relatif

Interface : path.relative(from, to)

Description : Chemin relatif du chemin d'origine au chemin d'arrivée.

Boundary :

Si from et to pointent vers le même chemin, alors une chaîne vide est renvoyée.

Si from ou to est vide, renvoie le chemin de travail actuel.

L'exemple ci-dessus :

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"

Interfaces/propriétés liées à la plate-forme

Les propriétés et interfaces suivantes sont liées à l'implémentation spécifique du plate-forme. En d’autres termes, les mêmes attributs et interfaces se comportent différemment sur différentes plateformes.

path.posix : implémentation Linux des attributs et interfaces liés au chemin.

path.win32 : implémentation Win32 des attributs et des interfaces liés au chemin.

path.sep : séparateur de chemin. Sous Linux, c'est /, sous Windows, c'est ``.

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中文网！