方法和属性

属性

方法


path.delimiter

平台特定的路径分隔符。';'':'

在 *nix 上的例子:

  1. console.log(process.env.PATH)
  2. // '/usr/bin:/bin:/usr/sbin:/sbin:/usr/local/bin'
  3. process.env.PATH.split(path.delimiter)
  4. // 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\'
  3. process.env.PATH.split(path.delimiter)
  4. // returns ['C:\\Windows\\system32', 'C:\\Windows', 'C:\\Program Files\\node\\']

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.posix

提供访问前面提到的 path 方法,但始终以兼容 posix 的方式进行交互。

path.win32

提供访问前面提到的 path 方法,但始终以兼容 win32 的方式进行交互。

path.resolve([from …], to)

to 解析为绝对路径。

从右到左的顺序,如果 to 不是绝对于 from 参数,则前置 from 参数,直到找到一个绝对路径为止。如果在使用所有的 from 路径后仍然没有找到绝对路径,将会使用当前工作目录。结果路径已经规范化,除非路径被解析到了根目录,否则会删除结尾的斜杠。from 中的非字符串参数会被忽略。

另一种思路, 是把它当成 shell 中的一系列 cd 命令。

  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 '/foo/bar/baz'
  3. path.resolve('/foo/bar', '/tmp/file/')
  4. // returns '/tmp/file'
  5. path.resolve('wwwroot', 'static_files/png/', '../gif/image.gif')
  6. // if currently in /home/myself/node, it returns
  7. // '/home/myself/node/wwwroot/static_files/gif/image.gif'

注意:如果 resolve 参数有零长度字符串,那么当前的工作目录将被用来替代它们。

path.relative(from, to)

from 解析相对路径到 to

有时,我们有两个绝对路径,我们需要导出从一个到另一个的相对路径。这实际上是反向转换 path.resolve,这意味着我们可以看到:

  1. 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'
  3. path.relative('/data/orandea/test/aaa', '/data/orandea/impl/bbb')
  4. // returns '../../impl/bbb'

注意:如果 relative 参数有零长度字符串,那么当前的工作目录会被用于代替零长度字符串。如果两个路径相同,那么将会返回一个零长度字符串。

path.format(pathObject)

从一个对象中返回一个路径字符串。这与 path.parse 相反。

如果 pathObject 拥有 dirbase 属性,返回的字符串会是 dir 属性的级联加上依赖于平台的路径分隔符以及 base 属性。

如果没有提供 dir 属性,那么 root 属性将被用于当成 dir 属性。然而,它会假定 root 属性已经以依赖于平台的路径分隔符结束。在这种情况下,返回的字符串将会是 root 属性的级联加上 base 属性。

如果都没有提供 dirroot 属性,那么返回的字符串将是 base 属性的内容。

如果没有提供 base 属性,name 属性的级联加上 ext 属性会被用于当成 base 属性。

示例:

一些 Posix 系统上例子:

  1. // If `dir` and `base` are provided, `dir` + platform separator + `base`
  2. // will be returned.
  3. path.format({
  4. dir: '/home/user/dir',
  5. base: 'file.txt'
  6. });
  7. // returns '/home/user/dir/file.txt'
  8. // `root` will be used if `dir` is not specified.
  9. // `name` + `ext` will be used if `base` is not specified.
  10. // If only `root` is provided or `dir` is equal to `root` then the
  11. // platform separator will not be included.
  12. path.format({
  13. root: '/',
  14. base: 'file.txt'
  15. });
  16. // returns '/file.txt'
  17. path.format({
  18. dir: '/',
  19. root: '/',
  20. name: 'file',
  21. ext: '.txt'
  22. });
  23. // returns '/file.txt'
  24. // `base` will be returned if `dir` or `root` are not provided.
  25. path.format({
  26. base: 'file.txt'
  27. });
  28. // returns 'file.txt'

一个 Windows 上的例子:

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

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.join([path1][, path2][, …])

把所有的参数加到一起,并规范生成的路径。

参数必须是字符串。在 v0.8 版本中,非字符串参数会被默认忽略。在 v0.10 及以上版本中,会抛出一个错误。

示例:

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

注意:与其他路径模块函数不同,如果 join 参数有零长度字符串,它们会被忽略。如果已合并的路径字符串是零长度字符串,那么将会返回 '.',它代表了当前的工作目录。

path.normalize(p)

规范化一个字符串路径,会考虑 '..''.' 部分。

当发现多个斜杠时,它们会由单一的斜杠替代;当路径包含尾斜杠时,它会被保存。在 Windows 上使用反斜杠。

示例:

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

注意:如果作为参数传递的路径字符串是零长度字符串,那么将会返回 '.',它代表了当前的工作目录。

path.dirname(p)

返回路径的目录名。类似于 Unix 中的 dirname 命令。

示例:

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

path.basename(p[, ext])

返回的路径的最后部分。类似于 Unix 中的 basename 命令。

示例:

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

path.extname(p)

返回路径的拓展名,在路径的最后部分中的从最后一个 '.' 到结尾的字符串。如果路径的最后部分没有 '.' 或它的第一个字符是 '.',那么它会返回一个空字符串。

示例:

  1. path.extname('index.html')
  2. // returns '.html'
  3. path.extname('index.coffee.md')
  4. // returns '.md'
  5. path.extname('index.')
  6. // returns '.'
  7. path.extname('index')
  8. // returns ''
  9. path.extname('.index')
  10. // returns ''

path.isAbsolute(path)

判定 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

注意:如果作为参数传递的路径字符串是零长度字符串,不像其他路径模块函数,它会保持原样,并返回一个 false