- assert 断言
- async_hooks 异步钩子
- async_hooks/context 异步上下文
- buffer 缓冲区
- C++插件
- C/C++插件(使用Node-API)
- C++嵌入器
- child_process 子进程
- cluster 集群
- CLI 命令行
- console 控制台
- Corepack 核心包
- crypto 加密
- crypto/webcrypto 网络加密
- debugger 调试器
- deprecation 弃用
- dgram 数据报
- diagnostics_channel 诊断通道
- dns 域名服务器
- domain 域
- Error 错误
- events 事件触发器
- fs 文件系统
- global 全局变量
- http 超文本传输协议
- http2 超文本传输协议2.0
- https 安全超文本传输协议
- inspector 检查器
- Intl 国际化
- module 模块
- module/cjs CommonJS模块
- module/esm ECMAScript模块
- module/package 包模块
- net 网络
- os 操作系统
- path 路径
- perf_hooks 性能钩子
- permission 权限
- process 进程
- punycode 域名代码
- querystring 查询字符串
- readline 逐行读取
- repl 交互式解释器
- report 诊断报告
- sea 单个可执行应用程序
- stream 流
- stream/web 网络流
- string_decoder 字符串解码器
- test 测试
- timers 定时器
- tls 安全传输层
- trace_events 跟踪事件
- tty 终端
- url 网址
- util 实用工具
- v8 引擎
- vm 虚拟机
- wasi 网络汇编系统接口
- worker_threads 工作线程
- zlib 压缩
Node.js v18.16.0 文档
- Node.js v18.16.0
-
►
目录
- 路径
- Windows 与 POSIX
path.basename(path[, suffix])
path.delimiter
path.dirname(path)
path.extname(path)
path.format(pathObject)
path.isAbsolute(path)
path.join([...paths])
path.normalize(path)
path.parse(path)
path.posix
path.relative(from, to)
path.resolve([...paths])
path.sep
path.toNamespacedPath(path)
path.win32
- 路径
-
►
导航
- assert 断言
- async_hooks 异步钩子
- async_hooks/context 异步上下文
- buffer 缓冲区
- C++插件
- C/C++插件(使用Node-API)
- C++嵌入器
- child_process 子进程
- cluster 集群
- CLI 命令行
- console 控制台
- Corepack 核心包
- crypto 加密
- crypto/webcrypto 网络加密
- debugger 调试器
- deprecation 弃用
- dgram 数据报
- diagnostics_channel 诊断通道
- dns 域名服务器
- domain 域
- Error 错误
- events 事件触发器
- fs 文件系统
- global 全局变量
- http 超文本传输协议
- http2 超文本传输协议2.0
- https 安全超文本传输协议
- inspector 检查器
- Intl 国际化
- module 模块
- module/cjs CommonJS模块
- module/esm ECMAScript模块
- module/package 包模块
- net 网络
- os 操作系统
- path 路径
- perf_hooks 性能钩子
- permission 权限
- process 进程
- punycode 域名代码
- querystring 查询字符串
- readline 逐行读取
- repl 交互式解释器
- report 诊断报告
- sea 单个可执行应用程序
- stream 流
- stream/web 网络流
- string_decoder 字符串解码器
- test 测试
- timers 定时器
- tls 安全传输层
- trace_events 跟踪事件
- tty 终端
- url 网址
- util 实用工具
- v8 引擎
- vm 虚拟机
- wasi 网络汇编系统接口
- worker_threads 工作线程
- zlib 压缩
- ► 其他版本
- 云服务器
目录
- 路径
- Windows 与 POSIX
path.basename(path[, suffix])
path.delimiter
path.dirname(path)
path.extname(path)
path.format(pathObject)
path.isAbsolute(path)
path.join([...paths])
path.normalize(path)
path.parse(path)
path.posix
path.relative(from, to)
path.resolve([...paths])
path.sep
path.toNamespacedPath(path)
path.win32
路径#
源代码: lib/path.js
node:path
模块提供了用于处理文件和目录的路径的实用工具。 可以使用以下方式访问它:
const path = require('node:path');
Windows 与 POSIX#
node:path
模块的默认操作因运行 Node.js 应用程序的操作系统而异。 具体来说,当在 Windows 操作系统上运行时,node:path
模块将假定正在使用 Windows 风格的路径。
因此,在 POSIX 和 Windows 上使用 path.basename()
可能会产生不同的结果:
在 POSIX 上:
path.basename('C:\\temp\\myfile.html');
// Returns: 'C:\\temp\\myfile.html'
在 Windows 上:
path.basename('C:\\temp\\myfile.html');
// Returns: 'myfile.html'
当使用 Windows 文件路径时,若要在任何操作系统上获得一致的结果,则使用 path.win32
:
在 POSIX 和 Windows 上:
path.win32.basename('C:\\temp\\myfile.html');
// Returns: 'myfile.html'
当使用 POSIX 文件路径时,若要在任何操作系统上获得一致的结果,则使用 path.posix
:
在 POSIX 和 Windows 上:
path.posix.basename('/tmp/myfile.html');
// Returns: 'myfile.html'
在 Windows 上,Node.js 遵循独立驱动器工作目录的概念。
当使用不带反斜杠的驱动器路径时,可以观察到此行为。 例如,path.resolve('C:\\')
可能返回与 path.resolve('C:')
不同的结果。 有关详细信息,请参阅 这个 MSDN 页面。
path.basename(path[, suffix])
#
path.basename()
方法返回 path
的最后一部分,类似于 Unix basename
命令。 忽略尾随 目录分隔符。
path.basename('/foo/bar/baz/asdf/quux.html');
// Returns: 'quux.html'
path.basename('/foo/bar/baz/asdf/quux.html', '.html');
// Returns: 'quux'
尽管 Windows 通常以不区分大小写的方式处理文件名(包括文件扩展名),但此函数不会。 例如,C:\\foo.html
和 C:\\foo.HTML
指的是同一个文件,但 basename
将扩展名视为区分大小写的字符串:
path.win32.basename('C:\\foo.html', '.html');
// Returns: 'foo'
path.win32.basename('C:\\foo.HTML', '.html');
// Returns: 'foo.HTML'
如果 path
不是字符串,或者如果给定 suffix
并且不是字符串,则抛出 TypeError
。
path.delimiter
#
提供特定于平台的路径定界符:
;
用于 Windows:
用于 POSIX
例如,在 POSIX 上:
console.log(process.env.PATH);
// Prints: '/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);
// Prints: '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\\']
path.dirname(path)
#
path.dirname()
方法返回 path
的目录名,类似于 Unix dirname
命令。 尾随的目录分隔符被忽略,见 path.sep
。
path.dirname('/foo/bar/baz/asdf/quux');
// Returns: '/foo/bar/baz/asdf'
如果 path
不是字符串,则抛出 TypeError
。
path.extname(path)
#
path.extname()
方法返回 path
的扩展名,即 path
的最后一部分中从最后一次出现的 .
(句点)字符到字符串的结尾。 如果 path
的最后一部分中没有 .
,或者除了 path
的基本名称(参见 path.basename()
)的第一个字符之外没有 .
个字符,则返回空字符串。
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.extname('.index.md');
// Returns: '.md'
如果 path
不是字符串,则抛出 TypeError
。
path.format(pathObject)
#
path.format()
方法从对象返回路径字符串。 这与 path.parse()
相反。
当向 pathObject
提供属性时,存在一个属性优先于另一个属性的组合:
- 如果提供
pathObject.dir
,则忽略pathObject.root
- 如果
pathObject.base
存在,则忽略pathObject.ext
和pathObject.name
例如,在 POSIX 上:
// If `dir`, `root` and `base` are provided,
// `${dir}${path.sep}${base}`
// will be returned. `root` is ignored.
path.format({
root: '/ignored',
dir: '/home/user/dir',
base: 'file.txt',
});
// Returns: '/home/user/dir/file.txt'
// `root` will be used if `dir` is not specified.
// If only `root` is provided or `dir` is equal to `root` then the
// platform separator will not be included. `ext` will be ignored.
path.format({
root: '/',
base: 'file.txt',
ext: 'ignored',
});
// Returns: '/file.txt'
// `name` + `ext` will be used if `base` is not specified.
path.format({
root: '/',
name: 'file',
ext: '.txt',
});
// Returns: '/file.txt'
在 Windows 上:
path.format({
dir: 'C:\\path\\dir',
base: 'file.txt',
});
// Returns: 'C:\\path\\dir\\file.txt'
path.isAbsolute(path)
#
path.isAbsolute()
方法确定 path
是否为绝对路径。
如果给定的 path
是零长度字符串,则将返回 false
。
例如,在 POSIX 上:
path.isAbsolute('/foo/bar'); // true
path.isAbsolute('/baz/..'); // true
path.isAbsolute('qux/'); // false
path.isAbsolute('.'); // false
在 Windows 上:
path.isAbsolute('//server'); // true
path.isAbsolute('\\\\server'); // true
path.isAbsolute('C:/foo/..'); // true
path.isAbsolute('C:\\foo\\..'); // true
path.isAbsolute('bar\\baz'); // false
path.isAbsolute('bar/baz'); // false
path.isAbsolute('.'); // false
如果 path
不是字符串,则抛出 TypeError
。
path.join([...paths])
#
path.join()
方法使用特定于平台的分隔符作为定界符将所有给定的 path
片段连接在一起,然后规范化生成的路径。
零长度的 path
片段被忽略。 如果连接的路径字符串是零长度字符串,则将返回 '.'
,表示当前工作目录。
path.join('/foo', 'bar', 'baz/asdf', 'quux', '..');
// Returns: '/foo/bar/baz/asdf'
path.join('foo', {}, 'bar');
// Throws 'TypeError: Path must be a string. Received {}'
如果任何路径片段不是字符串,则抛出 TypeError
。
path.normalize(path)
#
path.normalize()
方法规范化给定的 path
,解析 '..'
和 '.'
片段。
当找到多个连续的路径片段分隔符(例如 POSIX 上的 /
和 Windows 上的 \
或 /
)时,则它们将被平台特定路径片段分隔符(POSIX 上的 /
和 Windows 上的 \
)的单个实例替换。 保留尾随的分隔符。
如果 path
是零长度字符串,则返回 '.'
,表示当前工作目录。
例如,在 POSIX 上:
path.normalize('/foo/bar//baz/asdf/quux/..');
// Returns: '/foo/bar/baz/asdf'
在 Windows 上:
path.normalize('C:\\temp\\\\foo\\bar\\..\\');
// Returns: 'C:\\temp\\foo\\'
由于 Windows 识别多个路径分隔符,两个分隔符都将被 Windows 首选分隔符 (\
) 的实例替换:
path.win32.normalize('C:////temp\\\\/\\/\\/foo/bar');
// Returns: 'C:\\temp\\foo\\bar'
如果 path
不是字符串,则抛出 TypeError
。
path.parse(path)
#
path.parse()
方法返回一个对象,其属性表示 path
的重要元素。 尾随的目录分隔符被忽略,见 path.sep
。
返回的对象将具有以下属性:
例如,在 POSIX 上:
path.parse('/home/user/dir/file.txt');
// Returns:
// { root: '/',
// dir: '/home/user/dir',
// base: 'file.txt',
// ext: '.txt',
// name: 'file' }
┌─────────────────────┬────────────┐
│ dir │ base │
├──────┬ ├──────┬─────┤
│ root │ │ name │ ext │
" / home/user/dir / file .txt "
└──────┴──────────────┴──────┴─────┘
(All spaces in the "" line should be ignored. They are purely for formatting.)
在 Windows 上:
path.parse('C:\\path\\dir\\file.txt');
// Returns:
// { root: 'C:\\',
// dir: 'C:\\path\\dir',
// base: 'file.txt',
// ext: '.txt',
// name: 'file' }
┌─────────────────────┬────────────┐
│ dir │ base │
├──────┬ ├──────┬─────┤
│ root │ │ name │ ext │
" C:\ path\dir \ file .txt "
└──────┴──────────────┴──────┴─────┘
(All spaces in the "" line should be ignored. They are purely for formatting.)
如果 path
不是字符串,则抛出 TypeError
。
path.posix
#
path.posix
属性提供对 path
方法的 POSIX 特定实现的访问。
API 可通过 require('node:path').posix
或 require('node:path/posix')
访问。
path.relative(from, to)
#
path.relative()
方法根据当前工作目录返回从 from
到 to
的相对路径。 如果 from
和 to
都解析为相同的路径(在分别调用 path.resolve()
之后),则返回零长度字符串。
如果零长度字符串作为 from
或 to
传入,则将使用当前工作目录而不是零长度字符串。
例如,在 POSIX 上:
path.relative('/data/orandea/test/aaa', '/data/orandea/impl/bbb');
// Returns: '../../impl/bbb'
在 Windows 上:
path.relative('C:\\orandea\\test\\aaa', 'C:\\orandea\\impl\\bbb');
// Returns: '..\\..\\impl\\bbb'
如果 from
或 to
不是字符串,则抛出 TypeError
。
path.resolve([...paths])
#
path.resolve()
方法将路径或路径片段的序列解析为绝对路径。
给定的路径序列从右到左处理,每个后续的 path
会被追加到前面,直到构建绝对路径。
例如,给定路径段的顺序: /foo
、/bar
、baz
,调用 path.resolve('/foo', '/bar', 'baz')
将返回 /bar/baz
,因为 'baz'
不是绝对路径,但 '/bar' + '/' + 'baz'
是。
如果在处理完所有给定的 path
片段之后,还没有生成绝对路径,则使用当前工作目录。
生成的路径被规范化,并删除尾部斜杠(除非路径解析为根目录)。
零长度的 path
片段被忽略。
如果没有传入 path
片段,则 path.resolve()
将返回当前工作目录的绝对路径。
path.resolve('/foo/bar', './baz');
// Returns: '/foo/bar/baz'
path.resolve('/foo/bar', '/tmp/file/');
// Returns: '/tmp/file'
path.resolve('wwwroot', 'static_files/png/', '../gif/image.gif');
// If the current working directory is /home/myself/node,
// this returns '/home/myself/node/wwwroot/static_files/gif/image.gif'
如果任何参数不是字符串,则抛出 TypeError
。
path.sep
#
提供特定于平台的路径片段分隔符:
- Windows 上是
\
- POSIX 上是
/
例如,在 POSIX 上:
'foo/bar/baz'.split(path.sep);
// Returns: ['foo', 'bar', 'baz']
在 Windows 上:
'foo\\bar\\baz'.split(path.sep);
// Returns: ['foo', 'bar', 'baz']
在 Windows 上,正斜杠 (/
) 和反斜杠 (\
) 都被接受为路径段分隔符; 但是,path
方法仅添加反斜杠 (\
)。
path.toNamespacedPath(path)
#
仅在 Windows 系统上,返回给定 path
的等效 命名空间前缀路径。 如果 path
不是字符串,则 path
将不加修改地返回。
此方法仅在 Windows 系统上有意义。 在 POSIX 系统上,该方法是不可操作的,并且始终返回 path
而不进行修改。
path.win32
#
path.win32
属性提供对 path
方法的 Windows 特定实现的访问。
API 可通过 require('node:path').win32
或 require('node:path/win32')
访问。