Detailed explanation of path processing module path in Node.js

Foreword

In node.js, a path block is provided. In this module, many methods and attributes are provided that can be used to process and convert paths. The interfaces of path are classified according to their uses. If you think about it carefully, it's not so confusing. Below we will introduce in detail the path processing module path in Node.js.

Get path/file name/extension

Get path: path.dirname(filepath)

Get file name: path.basename(filepath)

Get extension: path.extname(filepath)

Get the path

The example is as follows:

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

Get the file name

Strictly speaking, path.basename(filepath) is only the last part of the output path and does not determine whether it is a file name.

But most of the time, we can use it as a simple method of "getting the file name".

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

What if you only want to get the file name, excluding the file extension? The second parameter can be used.

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

Get the file extension

A simple example is as follows:

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

The more detailed rules are as follows: (assuming path.basename(filepath) === B )

From B The last one. Start intercepting until the last character.

If . does not exist in B, or the first character of B is ., then an empty string is returned.

Look directly at the examples in the official documentation

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

Path combination

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

path.join([...paths])

Put the paths together and then normalize them. This sentence is incomprehensible to me anyway. You can refer to the pseudocode definition below.

The example is as follows:

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

The pseudocode of path definition is as follows:

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

path.resolve([...paths])

The description of this interface is a bit verbose. You can imagine that you are running the cd path command from left to right under the shell, and the absolute path/file name finally obtained is the result returned by this interface.

For example, path.resolve('/foo/bar', './baz') can be seen as the result of the following command

cd /foo/bar
cd ./baz

More comparison examples are as follows:

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)

From the description of the official document , path.normalize(filepath) should be a relatively simple API, but I always feel unsure when using it.

Why? The API description is too brief and includes the following:

If the path is empty, return., which is equivalent to the current working path.

Merge the repeated path separators (such as / under Linux) in the path into one.

Process the ., .. in the path. (Similar to cd in shell..)

If there is a / at the end of the path, then keep the /.

I feel like a brother on stackoverflow has a more realistic explanation of this API, here is the original link.

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"

The code example is as follows. It is recommended that readers copy the code and run it to see the actual effect.

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

File path decomposition/combination

path.format(pathObject): Combine the root, dir, base, name, and ext attributes of pathObject into a file path according to certain rules.

path.parse(filepath): The reverse operation of the path.format() method.

Let’s first take a look at the official website’s description of related attributes.

First under linux

┌─────────────────────┬────────────┐
│   dir  │ base │
├──────┬    ├──────┬─────┤
│ root │    │ name │ ext │
" / home/user/dir / file .txt "
└──────┴──────────────┴──────┴─────┘
(all spaces in the "" line should be ignored -- they are purely for formatting)

Then under 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)

After reading the relevant API documentation, I found that path.form at(pathObject) , the configuration properties of pathObject can be further streamlined.

According to the description of the interface, the following two are equivalent.

Root vs dir: The two can be replaced with each other. The difference is that when the paths are spliced, / will not be automatically added after root, but dir will.

base vs name+ext: The two can be replaced with each other.

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

The four attributes are very convenient for users, but path.format(pathObject) also has four configuration attributes, which is a bit confusing.

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

Get the relative path

Interface: path.relative(from, to)

Description: The relative path from the from path to the to path.

Boundary:

If from and to point to the same path, then an empty string is returned.

If either from or to is empty, then return the current working path.

The above example:

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"

Platform-related interfaces/attributes

The following attributes and interfaces are all related to the specific implementation of the platform. In other words, the same properties and interfaces behave differently on different platforms.

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