Explication détaillée des API couramment utilisées des modules Process, Path et File System dans Node.js

Cet article vous présentera les API couramment utilisées des modules Processus, Path et File System dans Nodejs. Il a une certaine valeur de référence. Les amis dans le besoin peuvent s'y référer. J'espère qu'il sera utile à tout le monde.

Recommandations associées : "Tutoriel Nodejs"

Lorsque vous utilisez Node pour le développement quotidien, vous utiliserez certains systèmes de fichiers, Basic Les API telles que les opérations de chemin sont résumées ici pour faciliter la compréhension et l'utilisation directe par chacun.

Ici, nous ne présentons que les plus couramment utilisés, pas tous. Si vous souhaitez voir des informations plus complètes, consultez simplement la documentation officielle.

Essayez de ne pas dire de bêtises et d'écrire plus de code.

Module de processus

---

Introduisez d'abord le module de processus, qui fournit des informations sur l'environnement global liées au processus Node actuel. Utilisé dans les API ultérieures.

// 内置模块，直接使用
const process = require('process');

process.cwd()

Il s'agit d'une fonction qui renvoie le répertoire dans lequel le processus Node actuel est exécuté. Par exemple, un scénario courant :

Un module Node A est publié via NPM, et le module B est utilisé dans le projet A. Lorsque vous devez exploiter des fichiers sous le projet A dans B, vous pouvez utiliser process.cwd() pour obtenir le chemin du projet B.

const cwd = process.cwd(); // 输出：/Users/xiaolian/Code/node-api-test

process.argv

Lorsque le terminal exécute la commande via Node, les paramètres de ligne de commande entrants peuvent être obtenus via process.argv, et la valeur de retour est un array :

• 0 : Chemin du nœud (généralement non utilisé, ignorez-le simplement)
• 1 : Le chemin du fichier JS exécuté (généralement non utilisé, ignorez-le simplement)
• 2~n : Les paramètres de la commande entrante réelle**

Donc, il suffit de commencer à partir de process.argv[2]. Généralement, s'utilise ainsi :

const args = process.argv.slice(2);

obtient directement les paramètres souhaités.

process.env

Renvoie un objet qui stocke toutes les informations liées à l'environnement actuel, qui est rarement utilisé directement.

Généralement, nous monterons quelques variables sur process.env pour identifier l'environnement actuel. Par exemple, l'utilisation la plus courante est process.env.NODE_ENV pour distinguer development et production. Dans le code source de vue-cli, vous voyez souvent process.env.VUE_CLI_DEBUG indiquant si le mode actuel est un DEBUG.

Voici un plug-in webpack DefinePlugin Dans le processus de construction quotidien, nous utilisons souvent ce plug-in pour injecter différentes variables globales afin d'exécuter différents processus de construction, et dans le code Le. process.env.xxx sera remplacé par une valeur spécifique, et le deadCode sera supprimé lors de l'étape de compression Terser pour optimiser la taille du code.

process.platform

Ceci n'est pas beaucoup utilisé. Il renvoie les informations actuelles du système. La valeur d'énumération est la suivante :

console.log(process.platform);

// 'aix'
// 'darwin'  - macOS
// 'freebsd'
// 'linux' - linux
// 'openbsd'
// 'sunos'
// 'win32' - windows

<🎜. >Module Path

// 内置模块，直接使用
const path = require('path');

---

Presque

opérations liées au chemin dans Node utiliseront ce module.

Voici les 5 plus couramment utilisés :

path.join(...paths)

La fonction est de convertir les chemins multiples entrants sont combinés en un chemin complet. path.join

const dPath = path.join('template', 'aaa', 'bbb', 'ccc', 'd.js');
// 输出: template/aaa/bbb/ccc/d.js

Regardons un scénario très courant. Nous devons obtenir le fichier package.json du projet en cours. Nous pouvons obtenir son chemin comme ceci :

const pkgPath = path.join(process.cwd(), './package.json');
// 输出: /Users/xiaolian/Code/node-api-test/package.json

Vous pouvez passer. dans un nombre quelconque de chemins, par exemple : path.join

['package.json', 'README.md'].forEach(fileName => {
  const templateFilePath = path.join(process.cwd(), 'template', fileName);
  console.log(templateFilePath);
});
// 输出: /Users/xiaolian/Code/node-api-test/template/package.json
// 输出: /Users/xiaolian/Code/node-api-test/template/README.md

path.resolve(...paths)

La différence entre path.resovle et path.join est que sa fonction est de résoudre les chemins entrants et le chemin d'exécution actuel sont fusionnés en un chemin absolu complet.

Supposons que je sois maintenant index.js dans le répertoire scripts, puis que j'exécute node scripts/index.js dans le répertoire racine, son code est le suivant :

const dPath = path.resolve('aaa', 'bbb', 'ccc', 'd.js');
// 输出:  /Users/xiaolian/Code/node-api-test/aaa/bbb/ccc/d.js

Généralement, lorsque path.resolve Lorsque le premier paramètre est ./, on comprend directement qu'il se comporte de la même manière que path.join(processs.cwd(), '').

path.basename(path[, ext])

path.basename renvoie le dernier nom de chemin spécifié path, où le deuxième paramètre ext peut sélectionner pour indiquer l'extension du fichier. Par exemple :

console.log(path.basename('scripts/index.js'));  // index.js
console.log(path.basename('scripts/index.js', '.js'));  // 匹配到 .js，返回 index
console.log(path.basename('scripts/index.js', '.json'));  // 没匹配到，返回 index.js

path.dirname(path)

correspond à path.basename et renvoie le chemin avant le dernier nom de chemin spécifié dans path. Par exemple :

console.log(path.basename('scripts/index.js'));  // scripts
console.log(path.basename('scripts/hook/index.js'));  // scripts/hook

path.extname(path)

和 path.basename 对应，返回指定 path 最后一个路径名的文件扩展名（含小数点 .）。比如：

console.log(path.basename('scripts/index.js'));  // .js
console.log(path.basename('README.md'));  // .md

对比

最后再来对比一下各个路径相关的 API 的区别。

项目 A 的目录结构如下：

├── scripts
│   └── index.js
├── src
│   └── index.js
├── package.json
├── README.md

scripts/index.js 的代码如下：

const path = require('path');

console.log(path.join('package.json'));
console.log(path.resolve('package.json'));
console.log(path.join('src', 'index.js'));
console.log(path.resolve('src', 'index.js'));
console.log(path.join(process.cwd(), 'package.json'));
console.log(path.resolve('./', 'package.json'));
console.log(__filename);
console.log(__dirname);

然后，我们在项目 A 的跟目录下执行 node scripts/index.js，结果如下：

-> node scripts/index.js
package.json
/Users/xiaolian/Code/A/package.json
src/index.js
/Users/xiaolian/Code/A/src/index.js
/Users/xiaolian/Code/A/package.json
/Users/xiaolian/Code/A/package.json
/Users/xiaolian/Code/A/scripts/index.js
/Users/xiaolian/Code/A/scripts

品，仔细品，它们有什么区别。

个人而言，一般还是习惯用 path.join(process.cwd(), 'xxx')。

File System 模块

---

// 内置模块，直接使用
const fs = require('fs');

文件系统相关操作的模块，除了 fs 之外，我们还经常用到 fs-extra，后面会介绍。

这个模块在平时的 Node 开发中会被大量使用，这里简单列几个，其它的还是看文档哈：nodejs.org/dist/latest…

fs 模块的 API 默认都是异步回调的形式，如果你想使用同步的方法，有两种解决方法：

1. 使用 Node 提供的同步 API：xxxSync，也就是在 API 的后面加一个 Sync 后缀，它就是一个同步方法了（具体还是需要查文档哈，是否有提供同步 API）
2. 包装成一个 Promise 使用

fs.stat(path[, options], callback)

fs.stat() 返回一个文件或者目录的信息。

const fs = require('fs');

fs.stat('a.js', function(err, stats) {
  console.log(stats);
});

其中包含的参数有很多，介绍几个比较常用的：

export interface StatsBase<T> {
  isFile(): boolean;                 // 判断是否是一个文件
  isDirectory(): boolean;            // 判断是否一个目录

  size: T;                           // 大小（字节数）
  atime: Date;                       // 访问时间
  mtime: Date;                       // 上次文件内容修改时间
  ctime: Date;                       // 上次文件状态改变时间
  birthtime: Date;                   // 创建时间
}

一般我们会使用 fs.stat 来取文件的大小，做一些判断逻辑，比如发布的时候可以检测文件大小是否符合规范。在 CLI 中，经常需要获取一个路径下的所有文件，这时候也需要使用 fs.stat 来判断是目录还是文件，如果是目录则继续递归。当然，现在也有更方便的 API 可以完成这个工作。

同步方法

const fs = require('fs');

try {
  const stats = fs.statSync('a.js');
} catch(e) {}

fs.readdir(path[, options], callback)

fs.readdir(path) 获取 path 目录下的文件和目录，返回值为一个包含 file 和 directory 的数组。

假设当前目录为：

.
├── a
│   ├── a.js
│   └── b
│       └── b.js
├── index.js
└── package.json

执行以下代码：

const fs = require('fs');

fs.readdir(process.cwd(), function (error, files) {
  if (!error) {
    console.log(files);
  }
});

返回值为：

[ 'a',
  'index.js',
  'package.json' ]

可以看到这里只返回了根目录下的文件和目录，并没有去深度遍历。所以如果需要获取所有文件名，就需要自己实现递归。

同步方法

const fs = require('fs');

try {
  const dirs = fs.readdirSync(process.cwd());
} catch(e) {}

fs.readFile(path[, options], callback)

文件读取的 API，通过 fs.readFile 可以获取指定 path 的文件内容。

入参如下：

• 第一个参数: 文件路径
• 第二个参数: 配置对象，包括 encoding 和 flag，也可以直接传如 encoding 字符串
• 第三个参数: 回调函数

使用方法如下：

const fs = require('fs');
const path = require('path');

fs.readFile(path.join(process.cwd(), 'package.json'), 'utf-8', function (
  error,
  content
) {
  if (!error) {
    console.log(content);
  }
});

如果没传 encoding，则其默认值为 null，此时返回的文件内容为 Buffer 格式。

同步方法

const fs = require('fs');

try {
  fs.readFileSync(path.join(process.cwd(), 'package.json'), 'utf-8');
} catch(e) {}

fs.writeFile(file, data[, options], callback)

对应着读文件 readFile，fs 也提供了写文件的 API writeFile，接收四个参数：

• 第一个参数: 待写入的文件路径
• 第二个参数: 待写入的文件内容
• 第三个参数: 配置对象，包括 encoding 和 flag，也可以直接传如 encoding 字符串
• 第三个参数: 回调函数

使用方法如下：

const fs = require('fs');
const path = require('path');

fs.writeFile(
  path.join(process.cwd(), 'result.js'),
  'console.log("Hello World")',
  function (error, content) {
    console.log(error);
  }
);

同步方法

const fs = require('fs');
const path = require('path');

try {
  fs.writeFileSync(
    path.join(process.cwd(), 'result.js'),
    'console.log("Hello World")',
    'utf-8'
  );
} catch (e) {}

本文主要是总结了一下在开发 Node 时常用的一些 API，后续的文章会带来 Node 常用的一些三方包。

更多编程相关知识，请访问：编程视频！！

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!