path

补一张标准的url结构图

────────────────────────────────────────────────────────────────────────────────────────────────┐
│                                              href                                              │
├──────────┬──┬─────────────────────┬────────────────────────┬───────────────────────────┬───────┤
│ protocol │  │        auth         │          host          │           path            │ hash  │
│          │  │                     ├─────────────────┬──────┼──────────┬────────────────┤       │
│          │  │                     │    hostname     │ port │ pathname │     search     │       │
│          │  │                     │                 │      │          ├─┬──────────────┤       │
│          │  │                     │                 │      │          │ │    query     │       │
"  https:   //    user   :   pass   @ sub.example.com : 8080   /p/a/t/h  ?  query=string   #hash "
│          │  │          │          │    hostname     │ port │          │                │       │
│          │  │          │          ├─────────────────┴──────┤          │                │       │
│ protocol │  │ username │ password │          host          │          │                │       │
├──────────┴──┼──────────┴──────────┼────────────────────────┤          │                │       │
│   origin    │                     │         origin         │ pathname │     search     │ hash  │
├─────────────┴─────────────────────┴────────────────────────┴──────────┴────────────────┴───────┤
│                                              href                                              │
└────────────────────────────────────────────────────────────────────────────────────────────────

Node中的相对路径解释&用法

process.cwd() returns the current working directory,
i.e. the directory from which you invoked the node command.
__dirname returns the directory name of the directory containing the JavaScript source code file

只有在 require() 时才使用相对路径(./, ../) 的写法，其他地方一律使用绝对路径，如下：

// 当前目录下
path.dirname(__filename) + '/test.js';
// 相邻目录下
path.resolve(__dirname, '../lib/common.js');

./& ../ &/

**./** 当前目录
**../** 父级目录
**/** 根目录

对window系统，目录分隔为’’, 对于UNIX系统，分隔符为’/‘，针对’..’返回上一级，发现多个斜杠或反斜杠时会替换成一个，/，//，与\都被统一转换为\

Node中Path api

path.resolve([path1], [path2], …)

按照顺序依次拼接，获取的是绝对路径，路径末尾的不会带有路径分隔符，若合并后的路径没有构成一个绝对路径，则会默认使用当前工作目录的绝对路径

 // 拼接路径中没有带有绝对路径,用当前工作目录来拼接
 var _path = path.resolve('path3', 'path4', 'a/b\\cc\\'); // 没有末尾的路径分隔符\
 // 结果为：C:\当前路径\path3\path4\a\b\cc  --> 所有的 / \\ // 都被换成 \ 了

 // 拼接路径中带有绝对路径 ~~ 第一个参数就是绝对路径
 var _path = path.resolve('D://work/ready/demo', 'path3', 'path4', 'a/b\\cc\\');
 // 结果为：D:\work\ready\demo\path3\path4\a\b\cc

path.join([path1], [path2], …)

按照顺序，依次拼接路径、并转为normalize后的结果路径，路径末尾的带有路径分隔符。

  var _path = path.join('path1', 'path2\\p/cc//', '/c/../ttt\\');
  // 结果为：path1\path2\p\cc\ttt\   ---> ../ 定位到父路径 所以是 cc\ttt

path.relative()

获取相对路径，获取两个路径之间的相对关系（结果是一个相对路径 以../开头）。

• from 当前路径，并且方法返回值是基于from指定到to的相对路径，路径末尾的不带有路径分隔符
• to 到哪路径

  var from = 'D:\\work\\server\\',
      to = 'D:/work/ready/demo';
  var _path = path.relative(from, to); // 表示从from 到 to的相对路径
  // 结果为：..\ready\demo
也就是以from路径为基准，去掉to路径与from相重复的，用../替代 然后拼接to未被匹配的路径

path.isAbsolute()

获取是否绝对路径，是一个绝对路径(比如 ‘E:/abc’或’E:\’)，或者是以“/”或“\”开头的路径，二者都会返回true。

path.normalize(path)

路径解析、得到规范化的格式。

 var _path = path.normalize(__dirname + '//test/a//b/..//c\\');
  // 结果为：D:\others\node\examples\test\a\c\

path.format(pathObject)

该方法用于将一个字符串类型的路径转化为一个路径对象（pathObject）。该路径对象当中包括文件目录，文件名，扩展名等。返回一个字符串

  var _path = path.format(path.format({ 
    root: 'E:\\',
    dir: 'D:\\others\\node\\examples/test',
    base: 'util you.mp4',
    ext: '.mp4',
    name: 'util you as me' 
    }
  ));
  // 结果为：D:\others\node\examples/test\util you.mp4

path.parse()

该方法用于将一个路径对象转化为一个字符串类型的路径（pathString），返回一个对象。

var _path = path.parse(__dirname + '/test/util you.mp3');
  // 结果为：
  // { root: 'D:\\',
  //   dir: 'D:\\others\\node\\examples/test',
  //   base: 'util you.mp3',
  //   ext: '.mp3',
  //   name: 'util you' 
  // }

path.dirname()

获取路径中目录结构，不会转为normalize后的结果路径。
最有一个/是忽略的，返回的是忽略后的倒数第二个/前的路径

  var _path = path.dirname(__dirname + '/test/hha/util you.mp3'); // 
  // 结果为：D:\others\node\examples/test/hha 
  var _path = path.dirname(__dirname + '/test/hha/'); // 注意/
  // 结果为：D:\others\node\examples/test --> 注意这里没有将/变为\ 也就是没有normalize

path.basename()

获取路径中文件名（.ext则包括后缀名）
下面的结果有点意思

var _path = path.basename(__dirname + '/test/util you.mp3', '.mp3');
var _path = path.basename(__dirname + '/test/util you', '.mp3');
var _path = path.basename(__dirname + '/test/util you', '.ext');
// 结果为：util you
var _path = path.basename(__dirname + '/test/util you.mp3');
var _path = path.basename(__dirname + '/test/util you.mp3', '');
var _path = path.basename(__dirname + '/test/util you.mp3', '.ext');
// 结果为：util you.mp3
var _path = path.basename(__dirname + '/test/', '.mp3');
// 结果为：test

path.extname()

获取路径中文件后缀名。

  var _path = path.extname(__dirname + '/test/util you.mp3');
  // 结果为：.mp3
  var _path = path.extname(__dirname + '/test/util you');
  // 结果为：为空

path.win32和path.posix

这两个均为属性。
path：会根据当前操作系统来确定是使用windows的方式来操作路径，还是使用linux的方式来操作路径。
path.win32：允许在任意操作系统上使用windows的方式来操作路径。
path.posix：允许在任意操作系统上使用linux的方式来操作路径。
故在windows系统中，path==path.win32，而在linux系统当中，path==path.posix。

console.log(path == path.win32); // true
  console.log(path == path.posix); // false

path.delimiter

返回操作系统中目录分隔符，如windows是’;’, Unix中是’:’。

console.log(path.delimiter);
  // 结果为：;

path.sep

返回操作系统中文件分隔符； window是’\’, Unix是’/‘。

console.log(path.sep);
  // 结果为：\
  console.log('foo\\bar\\baz'.split(path.sep));  
  // [ 'foo', 'bar', 'baz' ]
  console.log('foo/bar/baz'.split(path.sep));  
  // win下返回['foo/bar/baz']，但在*nix系统下会返回['foo','bar','baz']