核心模块-path

梦尘星月
96 阅读5分钟

  • path.basename(path[, suffix]) --- 获取路径中的基础名称

    suffix： 要删除的可选后缀

    1. 返回的就是接收路径当中的最后一部分

    2. 第二个参数表示扩展名，如果说没有设置则返回完整的文件名称带后缀

    3. 第二个参数做为后缀时，如果没有在当前路径中被匹配到，那么就会忽略

    4. 处理目录路径的时候如果说，结尾处有路径分割符，则也会被忽略掉

console.log(path.basename(__filename))
console.log(path.basename(__filename, '.js'))
console.log(path.basename(__filename, '.css'))
console.log(path.basename('/a/b/c'))
console.log(path.basename('/a/b/c/'))

path.basename('/foo/bar/baz/asdf/quux.html'); // 返回: 'quux.html'
path.basename('/foo/bar/baz/asdf/quux.html', '.html'); // 返回: 'quux'

尽管 Windows 通常以不区分大小写的方式处理文件名（包括文件扩展名），但此函数不会。 例如，C:\foo.html 和 C:\foo.HTML 指的是同一个文件，但 basename 将扩展名视为区分大小写的字符串：

path.win32.basename('C:\\foo.html', '.html'); // 返回: 'foo' 
path.win32.basename('C:\\foo.HTML', '.html'); // 返回: 'foo.HTML'

  • path.dirname(path) --- 获取路径中的目录名称（路径）

    path.dirname() 方法返回 path 的目录名，类似于 Unix dirname 命令。 尾随的目录分隔符被忽略

    1. 返回路径中最后一个部分的上一层目录所在路径

    2. 结尾处有路径分割符，会被忽略处理

path.dirname('/foo/bar/baz/asdf/quux'); // 返回: '/foo/bar/baz/asdf'

  • path.extname(path) --- 获取路径中的扩展名称

    path.extname() 方法返回 path 的扩展名，即 path 的最后一部分中从最后一次出现的 .（句点）字符到字符串的结尾。 如果 path 的最后一部分中没有 .，或者除了 path 的基本名称的第一个字符之外没有 . 个字符，则返回空字符串。

    1. 返回 path路径中相应文件的后缀名
    2. 如果 path 路径当中存在多个点，它匹配的是最后一个点，到结尾的内容
path.extname('index.html'); // 返回: '.html' 
path.extname('index.coffee.md'); // 返回: '.md' 
path.extname('index.'); // 返回: '.' 
path.extname('index'); // 返回: '' 
path.extname('.index'); // 返回: '' 
path.extname('.index.md'); // 返回: '.md'

  • 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.join([...paths]) --- 拼接多个路径片段

    ...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 {}'

  • path.parse(path) --- 解析路径

    path.parse() 方法返回一个对象，其属性表示 path 的重要元素。 尾随的目录分隔符被忽略

    1. 接收一个路径，返回一个对象，包含不同的信息，返回的对象将具有以下属性：
    • dir  文件路径
    • root  文件根路径
    • base  文件基础名称
    • name  文件名称
    • ext  扩展名

    例如，在 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 "
└──────┴──────────────┴──────┴─────┘
("" 行中的所有空格都应被忽略。它们纯粹是为了格式化。)

在 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 "
└──────┴──────────────┴──────┴─────┘
("" 行中的所有空格都应被忽略。它们纯粹是为了格式化。)

  • 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\\..\\');
// 返回: 'C:\\temp\\foo\\'

由于 Windows 识别多个路径分隔符，两个分隔符都将被 Windows 首选分隔符 () 的实例替换：

path.win32.normalize('C:////temp\\\\/\\/\\/foo/bar');
// 返回: 'C:\\temp\\foo\\bar'

  • path.resolve([...paths]) --- 返回绝对路径

    path.resolve() 方法将路径或路径片段的序列解析为绝对路径。

    给定的路径序列从右到左处理，每个后续的 path 会被追加到前面，直到构建绝对路径。 例如，给定路径片段的序列：/foo、/bar、baz，调用 path.resolve('/foo', '/bar', 'baz') 将返回 /bar/baz，因为 'baz' 不是绝对路径，而 '/bar' + '/' + 'baz' 是。

    生成的路径被规范化，并删除尾部斜杠（除非路径解析为根目录）。

    零长度的 path 片段被忽略。

    如果没有传入 path 片段，则 path.resolve() 将返回当前工作目录的绝对路径。

path.resolve('/foo/bar', './baz');
// 返回: '/foo/bar/baz' 

path.resolve('/foo/bar', '/tmp/file/'); 
// 返回: '/tmp/file' 

path.resolve('wwwroot', 'static_files/png/', '../gif/image.gif'); 
// 如果当前工作目录是 /home/myself/node， 
// 则返回 '/home/myself/node/wwwroot/static_files/gif/image.gif'

  • path.format(pathObject) --- 序列化路径

    pathObject  任何具有以下属性的 JavaScript 对象：

    • dir  文件路径
    • root  文件根路径
    • base  文件基础名称
    • name  文件名称
    • ext  扩展名

    path.format() 方法从对象返回路径字符串。 这与path.parse()相反。

    当向 pathObject 提供属性时，存在一个属性优先于另一个属性的组合：

    • 如果提供 pathObject.dir，则忽略 pathObject.root
    • 如果 pathObject.base 存在，则忽略 pathObject.ext 和 pathObject.name

例如，在 POSIX 上：

// 如果提供 `dir`、`root` 和 `base`， 
// 则将返回 `${dir}${path.sep}${base}`。 
// `root` 将被忽略。 
path.format({ 
    root: '/ignored',
    dir: '/home/user/dir',
    base: 'file.txt' 
}); 
// 返回: '/home/user/dir/file.txt' 

// 如果未指定 `dir`，则将使用 `root`。 
// 如果仅提供 `root` 或 `dir` 等于 `root`，则将不包括平台分隔符。 
// `ext` 将被忽略。 
path.format({ 
    root: '/', 
    base: 'file.txt', 
    ext: 'ignored' 
}); 
// 返回: '/file.txt' 

// 如果未指定 `base`，则将使用 `name` + `ext`。 
path.format({ 
    root: '/', 
    name: 'file', 
    ext: '.txt' 
}); 
// 返回: '/file.txt'

在 Windows 上：

path.format({ 
    dir: 'C:\\path\\dir', 
    base: 'file.txt' 
}); 
// 返回: 'C:\\path\\dir\\file.txt'
avatar
文章
阅读
粉丝