Maison > interface Web > js tutoriel > le corps du texte

Un article pour parler du module path dans node

青灯夜游
Libérer: 2022-12-14 20:04:15
avant
2580 Les gens l'ont consulté

Le module

Un article pour parler du module path dans node

path est un module intégré dans nodejs pour traiter les chemins de fichiers/répertoires. Il peut être considéré comme une boîte à outils, nous fournissant de nombreuses méthodes à utiliser, bien sûr toutes liées au traitement des chemins. Dans le même temps, le module path apparaît fréquemment dans le développement front-end, par exemple lors de la configuration du webpack. Cet article présente quelques méthodes couramment utilisées dans ce module. Apprenons ensemble. [Tutoriels associés recommandés : Tutoriel vidéo Nodejs, Enseignement de la programmation]

  • Il convient de noter que tous les modules (intégrés, personnalisés) dans nodejs doivent être importés à l'aide de requier, et la position d'importation générale est à la en haut du fichier.
const path = require('path');
Copier après la connexion

API

basename (obtenir le nom de base du chemin)

  • path.basename(path[,ext])
    • path : chemin du fichier/répertoire
    • ext : (facultatif) extension de fichier Par exemple .js .css, etc.
    • Valeur de retour : la dernière partie du chemin path
  • Remarque :
    • Si le chemin n'est pas une chaîne ou si le paramètre ext donné n'est pas une chaîne, TypeError est renvoyé
    • S'il y a est un paramètre ext. Lorsque le nom du suffixe ext correspond au nom du fichier, le nom de fichier renvoyé omettra le suffixe du fichier
    • S'il y a un séparateur de répertoire à la fin du chemin, il sera ignoré
const path = require("path");

path.basename('./ext/test.js') //test.js
path.basename('./ext/test.js','.js') //test (当后缀名与文件名匹配上时返回的文件名会省略文件后缀)
path.basename('./ext/test.js','.html') //test.js (没有匹配上时返回文件全名)
path.basename('./ext/foo/') // foo (尾部目录分隔符被忽略)
Copier après la connexion

dirname (obtient le nom du répertoire du chemin)

  • path .dirname(path)
    • path : chemin du fichier/répertoire
    • Valeur de retour : le nom du répertoire du chemin path
  • Remarque :
    • Si le chemin n'est pas un chaîne, une TypeError est levée
    • S'il y a un séparateur de répertoire à la fin du chemin, il sera ignoré
const path = require("path");

path.dirname('./foo/bar/baz'); //./foo/bar (相对路径/绝对路径均可)
path.dirname('/foo/bar/baz/'); // /foo/bar (尾部目录分隔符被忽略)
path.dirname('/foo/bar/baz/test.js'); // /foo/bar/baz
Copier après la connexion

extname (obtenir l'extension du chemin)

  • path.extname(path)
    • path: file /chemin du répertoire
    • Valeur de retour : extension du chemin, à partir du dernier. Le caractère '.' apparaît jusqu'à la fin de la chaîne dans la dernière partie du chemin, il renvoie vide. Remarque :
    Si path n'est pas une chaîne, une TypeError sera générée
    • const path = require("path");
      
      path.extname('foo/bar/baz/test.js'); // .js
      path.extname('foo/bar/baz');// '' (无扩展名返回 '')
      path.extname('foo/bar/baz/.'); // ''
      path.extname('foo/bar/baz/test.'); // '.'
      path.extname('foo/bar/baz/.test'); // ''
      path.extname('foo/bar/baz/.test.js'); // '.js'
      Copier après la connexion
    parse (analyser le chemin)

path.parse(path) ( str => obj )

path: file /chemin du répertoire
  • Valeur de retour : objet avec attributs (dir,root,base,name,ext)
    • root : répertoire racine
    • dir : le dossier où se trouve le fichier
      • base : fichier complet (index.js)
      • name : nom du fichier
      • ext : nom du suffixe du fichier
      Remarque :
    si le chemin n'est pas une chaîne, une TypeError sera générée
  • S'il y a un séparateur de répertoire à la fin, il le sera ignoré
    • Une image vaut mille mots
    ┌──────────────────┬────────────┐
    │          dir     │    base    │
    ├──────┬           ├──────┬─────┤
    │ root │           │ name │ ext │
    "  /    foo/bar/baz/ index  .js "
    Copier après la connexion
    const path = require("path");
    
    path.parse('/foo/bar/baz/index.js')
    // {
    //     root: '/',
    //     dir: '/foo/bar/baz',
    //     base: 'index.js',
    //     ext: '.js',
    //     name: 'index'
    //   }
    
    path.parse('/foo/bar/baz') //尾部目录分隔符省略
    // {
    //     root: '/',
    //     dir: '/foo/bar',
    //     base: 'baz',
    //     ext: '',
    //     name: 'baz'
    //   }
    
    path.parse('./foo/bar/baz/index.js') //当路径为相对路径 ./ 或../时 解析结果中root(代表根目录,绝对路径才有值)为 ''
    // {
    //     root: '',
    //     dir: './foo/bar/baz',
    //     base: 'index.js',
    //     ext: '.js',
    //     name: 'index'
    //   }
    Copier après la connexion
  • format (chemin de sérialisation)

path.format(pathObj) chemin de sérialisation Path, juste le contraire de path.parse()

  • pathObj : path object

    Valeur de retour : chemin de chaîne sérialisé (obj => string)
    • Remarque :
  • Si pathObject n'est pas un objet, une TypeError est levée. Les attributs de pathObject doivent faire attention au. priorité :

    Lorsque l'attribut dir existe, l'attribut racine est ignoré
    • Lorsque l'attribut de base existe, les attributs name et ext sont ignorés
      isAbsolute (qu'il s'agisse d'un chemin absolu)
    .

path.isAbsolute(path)

path: file/directory path
  • Valeur de retour: true/false

    • Remarque :
    Si le chemin n'est pas une chaîne, lancez TypeError
  • Si le chemin donné la longueur de la chaîne du chemin est 0, puis renvoie false

      Reportez-vous à
    • Réponses détaillées aux questions d'entretien initial
    const path = require("path");
    
    path.isAbsolute('//foo'); // true
    path.isAbsolute('\\\\foo'); // 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.isAbsolute('');  // false
    Copier après la connexion

    join(拼接路径片段)

    • path.join([...paths])
      • paths:路径片段
      • 返回值:使用平台特定的分隔符作为定界符将所有给定的 path 片段连接在一起规范化后生成的路径
    • 注意:
      • 如果 paths 不是字符串片段,则抛出 TypeError
      • 零长度的 path 片段会被忽略
      • 如果连接后的路径字符长度为0,则返回 '.',表示当前工作目录
      • 目录分隔符有平台差异,windows 返回为 ' \ '
    const path = require("path");
    
    path.join('') // '.'
    path.join('./') // '.\'path.join('../') // '..\'path.join('/foo/','bar','baz','../','index.js') // '\foo\bar\index.js'path.join('./bar','baz' ,'/','../','',index.js') // 'bar\index.js'
    path.join('foo', {}, 'bar'); // 'TypeError: Path must be a string. Received {}'
    Copier après la connexion

    normalize(规范化路径)

    • path.normalize(path)
      • path: 文件/目录路径
      • 返回值:规范后的路径字符串
    • 注意:
      • 如果 path 不是字符串片段,则抛出 TypeError
      • 尾部的分隔符会保留
      • 如果 path字符串长度为0,则返回 '.',表示当前工作目录
      • 路径中的目录分隔符均会被替换成平台特定的目录分隔符,windows 系统 会将 '/' 或'' 均替换成 ''
      • 路径中连续的多个分隔符会被规范化为一个
      • 路径中最好不要出现单个 ' \ ',因为当和字母在一起的时候会被当做转义符
    const path = require("path");
    
    path.normalize('') // '.'path.normalize('temp//foo//bar//..//'); // temp\foo\path.normalize('C:////temp\\\\/\\/\\/foo/bar') // C:\temp\foo\barpath.normalize('..////foo//\bar/baz/') // ..\fooar\baz\ (转义字符出现)path.normalize('temp//foo/\bar') // temp\fooar (转义字符出现)
    Copier après la connexion

    relative(获取 from 到 to 的相对路径)

    • path.relative(from,to)
      • from,to: 文件/目录路径
      • 返回值:from 到 to 的相对路径(to 相对于 form 的相对路径)
    • 注意:
      • 如果 from 和 to 指向相同路径相同 则返回 ''
      • 如果 from 或 to 任何一方为空,则使用当前工作目录代替其空路径
    const path = require("path");
    
    //当前工作目录为 \Stone\node\node\path_module
    path.relative('/foo/bar/baz','/foo/bar/dir/file.js') // ..\dir\file.js
    path.relative('/foo/bar/baz','/foo/bar/baz') // ''
    path.relative('/foo/bar/baz/files.js','') // ..\..\..\..\Stone\node\node\path_module
    path.relative('','/foo/bar/baz/files.js') // ..\..\..\..\foo\bar\baz\files.js
    path.relative('','./foo/bar/baz/files.js') // foo\bar\baz\files.js
    Copier après la connexion

    这里针对 from 或 to 任何一方为空,则使用当前工作目录代替其空路径。稍作说明下, 例如当前工作目录为 \Stone\node\node\path_module,则可以看到 path.relative('/foo/bar/baz/files.js','') 的输出结果为..\..\..\..\Stone\node\node\path_module,此时 to 为 \Stone\node\node\path_module, 要输出 to 相对于 from 的相对路径,则 from 需要先 ../ 的形式 一层一层退出,来检索与 to 的公共父级目录,直到遇到公共父级目录或者到根目录停止,然后cd 进 to 目录。这是针对另一方为绝对路径,如果另一方为相对路径,则直接就是当前另一方路径。

    resolve(将路径或路径片段的序列解析为绝对路径)

    • path.resolve([...paths])
      • paths: 路径或路径片段的序列
      • 返回值:路径或路径片段序列解析为绝对路径。(将路径片段解析后生成的绝对路径)
    • 注意:
      • 路径片段如果给出则必须是字符串类型,否则类型错误
      • 给定的路径序列从右到左进行处理,每个后续的 path 前置,直到构造出一个绝对路径
      • 如果处理完所有给定的 path 片段之后还未生成绝对路径,则再加上当前工作目录
      • 生成的路径均已规范化,并且除非将路径解析为根目录,否则将删除尾部斜杠
      • 零长度的 path 片段会被忽略
      • 若没有传入 path 片段,则 path.resolve() 将返回当前工作目录的绝对路径
    const path = require("path");
    
    //当前工作目录为 \Stone\node\node\path_module
    path.resolve('/foo/bar', './baz'); // '/foo/bar/baz'
    path.resolve('/foo/bar','', '/tmp/file/'); //'/tmp/file'
    path.resolve('root', 'foo/baz/', '../fun/bar') // '\Stone\node\node\path_module\root\foo\fun\bar'
    path.resolve() // '\Stone\node\node\path_module'
    Copier après la connexion

    path.resolve 方法解析路径片段的时候会从右往左的顺序依次解析,直到构造出一个绝对路径,否则会将当前工作目录加在路径开头。所以,通过 resolve 解析生成的路径一定是绝对路径。这个方法使用的非常多,应该特眼熟,对,前端我们配置 webpack 的时候会高频率用到,并且往往还会结合 __dirname 使用。

    __dirname,__filename

    • __dirname:可以看作是 nodejs 中的全局变量,它始终表示当前执行文件所在目录的完整目录名(绝对路径)
    • __filename:可以看作是 nodejs 中的全局变量,它始终表示当前执行文件的完整文件名(完整绝对路)

    我们先在 path_module 目录下运行 node test.js 命令

    <!--当前执行文件的完整路径为\Stone\node\node\path_module\test.js-->
    const path = require("path");
    
    console.log(__dirname); // \Stone\node\node\path_module
    console.log(__filename); // \Stone\node\node\path_module\test.js
    Copier après la connexion

    然后我们在 \Stone\node\node 目录下运行 node path_module\test.js,会发现输出结果同上, 所以这就是说明 __dirname 和 __filename 始终跟当前执行文件有关,跟启动脚本所在目录无关。

    ./ ../

    ./../ 我们都知道是相对路径的写法,但是使用的过程中配合 require() 使用与否的结果是不同的。

    • fs_module 目录下 执行 node test.js
    <!--当前启动脚本的执行命令所在目录 \Stone\node\node\fs_module\test.js-->
    const fs = require(&#39;fs&#39;)
    
    fs.readFileSync(&#39;./ext/test1.js&#39;,(err,data)=> {
        console.log(&#39;ok&#39;)
    })
    Copier après la connexion

    会正常打印出 ok

    • \Stone\node\node 目录下 执行 node fs_module\test.js
    <!--当前启动脚本的执行命令所在目录 \Stone\node\node-->
    const fs = require(&#39;fs&#39;)
    
    fs.readFile(&#39;./ext/test1.js&#39;,(err,data)=> {
        console.log(&#39;ok&#39;)
    })
    Copier après la connexion

    运行会报错 no such file or directory, open './ext/test1.js'

    这到底是为啥嘞,原因就是 './' 和 '../' 的路径表示意义需要分情况,当结合 require() 使用的时候相对于当前执行文件,如果不结合 require() 使用的情况下会相对于当前启动脚本的目录,因此只有在 require() 时才使用相对路径(./, ../) 的写法,其他地方一律使用绝对路径,这点一定要注意。

    结语

    关于nodejs path 模块,我们今天就说到这里了,虽然 api 不是很多,但是 path 模块在前端的使用频率还是非常高的,所以觉得很值得学习了解一下的。由于认知有限,本文若有不准确之处还望路过的各位兄台及时指正,吃瓜,吃瓜。

    更多node相关知识,请访问:nodejs 教程

    Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!

Étiquettes associées:
source:juejin.cn
Déclaration de ce site Web
Le contenu de cet article est volontairement contribué par les internautes et les droits d'auteur appartiennent à l'auteur original. Ce site n'assume aucune responsabilité légale correspondante. Si vous trouvez un contenu suspecté de plagiat ou de contrefaçon, veuillez contacter admin@php.cn
Tutoriels populaires
Plus>
Derniers téléchargements
Plus>
effets Web
Code source du site Web
Matériel du site Web
Modèle frontal
À propos de nous Clause de non-responsabilité Sitemap
Site Web PHP chinois:Formation PHP en ligne sur le bien-être public,Aidez les apprenants PHP à grandir rapidement!