Path

该模块封装了一些处理和转换文件路径的辅助函数，其中大多数主要用于对路径字符串的转换。文件系统不会去校验路径是否有效。

通过 require('path') 可以加载该模块。

path.basname(p[, ext])

该方法返回路径的最后一部分，类似于 Unix 中的 basename 命令：

  1. path.basename('/foo/bar/baz/asdf/quux.html')
  2. // returns 'quux.html'
  4. path.basename('/foo/bar/baz/asdf/quux.html', '.html')
  5. // returns 'quux'

path.delimiter

该方法根据当前平台特性返回路径定界符，比如 ; 或 :。

下面代码演示了在 *nix 下的执行结果：

  1. console.log(process.env.PATH)
  2. // '/usr/bin:/bin:/usr/sbin:/sbin:/usr/local/bin'
  4. process.env.PATH.split(path.delimiter)
  5. // returns ['/usr/bin', '/bin', '/usr/sbin', '/sbin', '/usr/local/bin']

下面代码演示了在 Windows 下的执行结果：

  1. console.log(process.env.PATH)
  2. // 'C:\Windows\system32;C:\Windows;C:\Program Files\node\'
  4. process.env.PATH.split(path.delimiter)
  5. // returns ['C:\\Windows\\system32', 'C:\\Windows', 'C:\\Program Files\\node\\']

path.dirname(p)

该方法返回一个路径的目录名，类似于 Unix 的 dirnaem 命令：

  1. path.dirname('/foo/bar/baz/asdf/quux')
  2. // returns '/foo/bar/baz/asdf'

path.extname(p)

该方法返回路径的扩展名，该扩展名为路径的最后一个 . 到结尾部分的字符串。如果路径最后一部分中没有 .，或者第一个字符就是 .，则返回一个空字符串：

  1. path.extname('index.html')
  2. // returns '.html'
  4. path.extname('index.coffee.md')
  5. // returns '.md'
  7. path.extname('index.')
  8. // returns '.'
  10. path.extname('index')
  11. // returns ''
  13. path.extname('.index')
  14. // returns ''

path.format(pathObject)

该方法根据传入的 pathObject 返回一个字符串形式的路径，与之相对的方法是 path.parse：

  1. path.format({
  2.     root : "/",
  3.     dir : "/home/user/dir",
  4.     base : "file.txt",
  5.     ext : ".txt",
  6.     name : "file"
  7. })
  8. // returns '/home/user/dir/file.txt'

path.isAbsolute(path)

该方法用于判断一个路径是否是绝对路径。绝对路径不需要依赖当前共走路径即可定位位置。

在 POSIX 系统下：

  1. path.isAbsolute('/foo/bar') // true
  2. path.isAbsolute('/baz/..')  // true
  3. path.isAbsolute('qux/')     // false
  4. path.isAbsolute('.')        // false

在 Windows 系统下：

  1. path.isAbsolute('//server')  // true
  2. path.isAbsolute('C:/foo/..') // true
  3. path.isAbsolute('bar\\baz')  // false
  4. path.isAbsolute('.')         // false

注意，如果传入的路径是一个空字符串，与其他 path 模块的方法所不同的是，该方法会返回 false。

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

该方法拼接所有的参数，然后标准化出一个路径。

该方法中的参数必须是字符串。在 v0.8 中，非字符串参数会被忽略，但在 v0.10+ 中，会抛出错误。

  1. path.join('/foo', 'bar', 'baz/asdf', 'quux', '..')
  2. // returns '/foo/bar/baz/asdf'
  4. path.join('foo', {}, 'bar')
  5. // throws exception TypeError: Arguments to path.join must be strings

注意，如果传入的路径是一个空字符串，与其他 path 模块的方法所不同的是，该方法会返回 .（代表当前路径）。

path.normalize(p)

该方法用于标准化路径，注意 .. 和 . 部分。

如果路径中存在多个斜线，则会被替换为单个斜线；如果路劲尾部存在斜线，则会被保留。在 Windows 中路径使用反斜线分隔。

  1. path.normalize('/foo/bar//baz/asdf/quux/..')
  2. // returns '/foo/bar/baz/asdf'

注意，如果传入的路径是一个空字符串，该方法会返回 .（代表当前路径）。

path.parse(pathString)

该方法根据字符串路径返回一个对象。

在 *nix 系统下：

  1. path.parse('/home/user/dir/file.txt')
  2. // returns
  3. {
  4.     root : "/",
  5.     dir : "/home/user/dir",
  6.     base : "file.txt",
  7.     ext : ".txt",
  8.     name : "file"
  9. }

在 Windows 系统下：

  1. path.parse('C:\\path\\dir\\index.html')
  2. // returns
  3. {
  4.     root : "C:\\",
  5.     dir : "C:\\path\\dir",
  6.     base : "index.html",
  7.     ext : ".html",
  8.     name : "index"
  9. }

path.posix

该属性决定是否以 POSX 兼容模式执行上述路径处理方法。

path.relative(from, to)

该方法根据 from 和 to 解析相对路径。

该方法根据传入的两个绝对路径，计算它们的相对路径。该方法实际上是 path.resolve 的逆方法：path.resolve(from, path.relative(from, to)) == path.resolve(to)。

  1. path.relative('C:\\orandea\\test\\aaa', 'C:\\orandea\\impl\\bbb')
  2. // returns '..\\..\\impl\\bbb'
  4. path.relative('/data/orandea/test/aaa', '/data/orandea/impl/bbb')
  5. // returns '../../impl/bbb'

注意，如果传入的路径存在空字符串，该空字符串会被 .（代表当前路径）代替。如果两个路径相同，则返回一个空字符串。

path.resolve([from…], to)

该方法将 to 解析为绝对路径。

如果 to 不是相对 from 的绝对路径，那么 to 就会被添加到 from 的右侧，直到找到一个而绝对路径。如果用尽所有的 from 都没有找到绝对路径，就会使用当前工作目录。最终的路径是标准化之后，已经去除了斜线，除非结果是根目录。非字符串的 from 参数会被忽略。

下面是一个该犯法的用例：

  1. path.resolve('foo/bar', '/tmp/file/', '..', 'a/../subfile')

类似于：

  1. cd foo/bar
  2. cd /tmp/file/
  3. cd ..
  4. cd a/../subfile
  5. pwd

不同之处在于，不同的路径可以不存在或者是文件。

  1. path.resolve('/foo/bar', './baz')
  2. // returns
  3. '/foo/bar/baz'
  5. path.resolve('/foo/bar', '/tmp/file/')
  6. // returns
  7. '/tmp/file'
  9. path.resolve('wwwroot', 'static_files/png/', '../gif/image.gif')
  10. // if currently in /home/myself/node, it returns
  11. '/home/myself/node/wwwroot/static_files/gif/image.gif'

注意，如果传入的路径存在空字符串，该空字符串会被 .（代表当前路径）代替。

path.sep

该属性表示当前平台的文件分隔符是 ‘\‘ 还是 ‘/‘。

在 *nix 系统下：

  1. 'foo/bar/baz'.split(path.sep)
  2. // returns ['foo', 'bar', 'baz']

在 Windows 系统下：

  1. 'foo\\bar\\baz'.split(path.sep)
  2. // returns ['foo', 'bar', 'baz']

path.win32

该属性决定是否以 win32 兼容模式执行上述路径处理方法。