Detailed description of path processing module in Node. js

I believe everyone knows that in nodejs, path is a very frequently used but hateful module. Some documents are not clear enough, and some are due to platform differences of interfaces. This article will give you a detailed introduction to the path processing module path in Node. js, hoping to help you learn or use the module path. Let's take a look at it. Preface

In node. js provides a path block. In this module, it provides many methods and attributes that can be used to process and convert paths, classify the path interface according to its purpose, so it is not that difficult to understand. Next we will introduce in detail the path processing module path in Node. js.

Get path/file name/Extension

Obtain path: path. dirname (filepath)

Get File Name: path. basename (filepath)

Obtain the extension path. extname (filepath)

Obtain the path

Example:

Var path = require ('path'); var filepath = '/tmp/demo/js/test. js'; // output:/tmp/demo/jsconsole. log (path. dirname (filepath ));

Get File Name

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

But most of the time, we can use it as a simple "Get File Name" method.

Var path = require ('path'); // output: test. jsconsole. log (path. basename ('/tmp/demo/js/test. js '); // output: testconsole. log (path. basename ('/tmp/demo/js/test/'); // output: testconsole. log (path. basename ('/tmp/demo/js/test '));

What if I only want to get the file name, but does not include the file extension? The second parameter can be used.

// Output: testconsole. log (path. basename ('/tmp/demo/js/test. js','. js '));

Get File Extension

A simple example is as follows:

Var path = require ('path'); var filepath = '/tmp/demo/js/test. js'; // output :. jsconsole. log (path. extname (filepath ));

Get File Extension

A simple example is as follows:

Var path = require ('path'); var filepath = '/tmp/demo/js/test. js'; // output :. jsconsole. log (path. extname (filepath ));

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

It starts from the last. of B and ends with the last character.

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

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])

Combine paths and then normalize it. This sentence is inexplicable to me. You can refer to the following definition of pseudo code.

Example:

Var path = require ('path'); // output '/foo/bar/baz/asdf' path. join ('/foo', 'bar', 'baz/asdf', 'quux ','.. ');

The pseudo code defined by path 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 cool. As you can imagine, you can run the cd path command from left to right under the shell to obtain the absolute path/file name, which is the result returned by this interface.

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

cd /foo/barcd ./baz

More examples are as follows:

Var path = require ('path '); // assume that the current working path is/Users/a/Documents/git-code/nodejs-learning-guide/examples/2016.11.08-node-path // output/Users/a/Documents /git-code/nodejs-learning-guide/examples/2016.11.08-node-pathconsole.log (path. resolve ('') // output/Users/a/clients/git-code/nodejs-learning-guide/examples/2016.11.08-node-pathconsole.log (path. resolve ('. ') // output/foo/bar/bazconsole. log (path. resolve ('/foo/bar ','. /Baz'); // output/foo/bar/bazconsole. log (path. resolve ('/foo/bar ','. /baz/'); // output/tmp/fileconsole. log (path. resolve ('/foo/bar','/tmp/file /')); // output/Users/a/Documents/git-code/nodejs-learning-guide/examples/2016.11.08-node-path/www/js/mod. jsconsole. log (path. resolve ('www ', 'js/upload ','.. /mod. js '));

Path Parsing

Path. parse (path)

Path. normalize (filepath)

From the description in the official document, path. normalize (filepath) should be a relatively simple API, but it is always useless.

Why? The API description is too simple, including:

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

Combine duplicate path delimiters (such as linux/) in the path into one.

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

If the path has a slash (/), keep the slash /.

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 sample code is as follows. We recommend that you copy the code and run it to see the actual results.

Var path = require ('path'); var filepath = '/tmp/demo/js/test. js'; var index = 0; var compare = function (desc, callback) {console. log ('[Use Case % d]: % s', ++ index, desc); callback (); console. log ('\ n') ;}; compare ('path is null', function () {// output. console. log (path. normalize ('');}); compare ('specifies whether the path ends with/', function () {// output/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 ('repeated/', function () {// output/tmp/demo/js console. log (path. normalize ('/tmp/demo // js');}); compare (' path .. ', function () {// output/tmp/demo/js console. log (path. normalize ('/tmp/demo/js/upload /.. ');}); compare ('relative path', function () {// output demo/js/upload/console. log (path. normalize ('. /demo/js/upload/'); // outputs demo/js/upload/console. log (path. normalize ('demo/js/upload/');}); compare ('noncommonly used boundary', function () {// output .. console. log (path. normalize ('. /.. '); // output .. console. log (path. normalize ('.. '); // output .. /console. log (path. normalize ('.. /'); // output/console. log (path. normalize ('/.. /'); // output/console. log (path. normalize ('/.. '));});

File Path decomposition/Combination

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

Path. parse (filepath): reverse operation of path. format.

Let's take a look at the official website's description of relevant attributes.

First, in linux

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

In 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, we found that the Configuration Attribute of pathObject can be further simplified in path. format (pathObject.

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

Root vs dir: the two can be replaced with each other. The difference is that, when the path is spliced,/is not automatically added after root, and 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); // output/tmp/hello. js var p2 = path. format ({dir: '/tmp', name: 'hello', ext :'. js '}); console. log (p2); // output/tmp/hello. js

Path. parse (filepath)

Path. format (pathObject) reverse operation, directly on the official website example.

Four attributes are convenient for users, but path. format (pathObject) is also four configuration attributes, which is easy to confuse.

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

Obtain relative path

Interface: path. relative (from,)

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

Boundary:

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

If any of the from and to fields is empty, the current working path is returned.

Example above:

Var path = require ('path'); var p1 = path. relative ('/data/orandea/test/aaa','/data/orandea/impl/bbb'); console. log (p1); // output ".. /.. /impl/bbb "var p2 = path. relative ('/data/demo','/data/demo'); console. log (p2); // output "" var p3 = path. relative ('/data/demo', ''); console. log (p3); // output ".. /.. /Users/a/Documents/git-code/nodejs-learning-guide/examples/2016.11.08-node-path"

Platform related interfaces/attributes

The following attributes and interfaces are related to the specific implementation of the Platform. That is to say, the same attributes and interfaces have different performance on different platforms.

Path. posix: linux implementation of path related attributes and interfaces.

Path. win32: win32 Implementation of path-related attributes and interfaces.

Path. sep: path separator. On linux, It is/and on windows, it is ''.

Path. delimiter: delimiter set by path. On linux: On windows, yes ;.

Note: When the path. win32 interface is used, the parameter can also use/as the separator, but the delimiter returned by the interface will only be ''.

The example is more intuitive.

> 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 system example:

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 example:

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

Summary

The above is all the content of this article. I hope the content of this article can be learned or used by everyone. js is helpful. If you have any questions, you can leave a message. Thank you for your support for PHP.

For more details about the path processing module path in Node. js, refer to the PHP Chinese network!