> 在`Nodejs`中，文件操作是非常常见的任务之一。它允许我们读取和写入文件，以及处理大型文件而不会消耗太多内存。本篇博文将会首先介绍一下文件和文件流的区别，然后全面介绍如何在`Nodejs`中实现文件操作和读写，包括使用文件系统模块`（fs）`和文件流`（streams）`。




在讨论如何读取文件和文件流之前，我们先讨论一下文件和文件流的区别。

## 文件和文件流的区别

### 文件

一个文件是一组有序的字节数据，存储在存储介质（如硬盘、SSD等）上，每个文件都有一个唯一的文件名和路径。文件可以是文本文件、图像文件、音频文件、视频文件等。

文件的读写操作通常涉及将整个文件的内容一次性加载到内存中，然后进行操作。在文件操作期间，可能会将整个文件加载到内存中，因此处理大型文件可能会导致内存消耗过高。

### 文件流

文件流是一种逐块处理文件数据的方式，它允许我们按块（或一小部分一小部分）读取或写入文件数据，而不需要将整个文件加载到内存中。这对于处理大型文件或需要逐步处理数据的情况非常有用，因为它能够降低内存消耗并提高性能。

文件流将文件数据分为多个数据块（或缓冲区），并以逐块的方式进行读取或写入。这种流式处理的方式使得可以在不等待整个文件读取或写入完成的情况下，逐步处理文件数据。

## 读写文件

### 读取

在`Nodejs`中，可以使用文件系统模块`（fs）`来读取文件。最常见的方式是通过`fs.readFile()`方法实现异步读取文件内容，`fs`也提供了同步读取文件的方法`fs.readFileSync()`，大家可以根据实际业务来自行使用对应的方法。

```js
// example.txt
我是文件内容我是文件内容我是文件内容我是文件内容我是文件内容我是文件内容


// file.js
const fs = require('fs');

fs.readFile('example.txt', 'utf8', (err, data) => {
  if (err) {
    console.error('读取文件失败:', err);
    return;
  }
  console.log('文件内容:', data);
});
```
在上面的代码中，我们使用`fs.readFile()`方法异步地读取名为`example.txt`的文件。`'utf8'`参数指定编码格式，以便正确解析文本文件。

运行代码后，结果如下：

![image.png](http://creatorblog.cn/static/img/65bcaf14a2c33fedb67b58d613a0a4c1.image.webp)

### 写入


要写入文件，我们可以使用`fs.writeFile()`方法。该方法用于异步地将数据写入文件。`fs`同样提供同步写入文件的方法`fs.writeFileSync()`。如果文件不存在，则会创建一个新文件；如果文件已经存在，则会覆盖其内容。

```js
// file.js
const fs = require('fs');

const fileContent = '这是我准备写入的文件内容';

fs.writeFile('output.txt', fileContent, 'utf8', (err) => {
  if (err) {
    console.error('写入文件失败:', err);
    return;
  }
  console.log('写入文件成功!');
});
```

在上面的代码中，我们使用`fs.writeFile()`方法异步地将`fileContent`的内容写入名为`output.txt`的文件。

运行代码后，结果如下：

![image.png](http://creatorblog.cn/static/img/06c836d40e54484caa98b63137982ebc.image.webp)


![image.png](http://creatorblog.cn/static/img/6fe37af8997cfa3762b086aadfc91d04.image.webp)

## 读写文件流

文件流是`Nodejs`中处理大型文件的一种有效方式。它们允许我们在读取或写入文件时，分块处理数据，避免将整个文件加载到内存中。

在`Nodejs`中，对于流式读取和写入文件，通常只提供异步的方法，而没有同步的方法。这是因为流操作通常涉及大量的数据处理，如果使用同步的方式，可能会阻塞主线程，导致应用性能下降。

### 读取

使用文件流进行文件读取的一种方法是使用`fs.createReadStream()`方法。这允许我们逐块读取文件数据。

```js
// file.js
const fs = require('fs');

const readStream = fs.createReadStream('largefile.txt', 'utf8');

readStream.on('data', (chunk) => {
  console.log('接收到一块数据:', chunk);
});

readStream.on('end', () => {
  console.log('文件读取完成.');
});

readStream.on('error', (err) => {
  console.error('文件读取失败:', err);
});
```

**largefile.txt**文件内容如下：

![image.png](http://creatorblog.cn/static/img/1ed57c6687afc104948e538b9012892d.image.webp)

在上面的代码中，我们使用`fs.createReadStream()`方法创建一个文件读取流，然后监听`'data'`事件来处理每个数据块，`'end'`事件表示文件读取结束，`'error'`事件处理可能出现的错误。

运行代码后，结果如下：

![image.png](http://creatorblog.cn/static/img/f449778e2603bebb4ff14c422f3237ad.image.webp)

### 写入

类似地，可以使用`fs.createWriteStream()`方法创建文件写入流，将数据分块写入文件。

```js
// file.js
const fs = require('fs');

const writeStream = fs.createWriteStream('output_large.txt', 'utf8');

writeStream.write('文件块1 1 ');
writeStream.write('文件块2 2 ');
writeStream.write('文件块3 3 ');

writeStream.end();

writeStream.on('finish', () => {
  console.log('写入文件结束.');
});

writeStream.on('error', (err) => {
  console.error('写入文件异常:', err);
});
```

在上面的代码中，我们使用`fs.createWriteStream()`方法创建一个文件写入流，并使用`write()`方法写入文件的不同数据块，最后通过调用`end()`方法来完成写入操作。`'finish'`事件表示文件写入完成，`'error'`事件处理可能出现的错误。

运行代码后，结果如下：

![image.png](http://creatorblog.cn/static/img/1223e0164954facb47be4528b2f80154.image.webp)



![image.png](http://creatorblog.cn/static/img/209f95b86b69cf324739ac461ff29fa5.image.webp)


## 总结

本文全面介绍了如何在`Nodejs`中实现文件操作和读写，包括使用文件系统模块和文件流。文件操作是`Nodejs`中常见且重要的任务，希望本文提供的代码示例和解释能够帮助读者深入了解如何在`Nodejs`中处理文件操作，同时避免一些常见的错误。使用文件流可以有效地处理大型文件，避免内存溢出等问题，因此在处理大文件时，推荐使用文件流的方式。

记得在使用文件操作时，要考虑异常处理和错误处理，确保代码的健壮性和可靠性。

Nodejs实现读写文件和文件流

> 在现代的`JavaScript`开发中，模块化是一个至关重要的概念，它有助于将代码拆分为独立的、可维护的部分，使开发过程更加高效和可靠。在`JavaScript`社区中，有两种主要的模块化规范：`CommonJS`（通用模块化规范）和`ESM`（`ECMAScript`模块）规范。本文将深入探讨这两种规范的异同点、应用场景以及注意事项。




## CommonJS规范

`CommonJS`是一种早期引入的模块化规范，最初用于服务器端`JavaScript`（如`Nodejs`）。它的主要特点包括：

- 同步加载模块： `CommonJS`模块是同步加载的，即在需要的地方使用`require`函数加载模块，并立即获取其导出内容。
- 导出方式： 使用`module.exports`导出模块内容，或者通过给`exports`对象添加属性来导出单个成员

### 姿势一：module.exports集中导出

```js
// 导出
// utils.js
module.exports = {
  add: (a, b) => a + b,
  subtract: (a, b) => a - b
};

// 导入
// app.js
const { add, subtract } = require('./utils');
console.log(add(5, 3)); // 输出: 8
console.log(subtract(5, 3)); // 输出: 2
```

### 姿势二：exports逐个导出

```js
// 导出
// utils.js
exports.add = (a, b) => a + b;
exports.subtract = (a, b) => a - b;

// 导入
// app.js
const { add, subtract } = require('./utils');
console.log(add(5, 3)); // 输出: 8
console.log(subtract(5, 3)); // 输出: 2
```

### 姿势三：直接赋值给module.exports

```js
// 导出
// utils.js
module.exports = (a, b) => a + b;

// 导入
// app.js
const add = require('./utils');
console.log(add(5, 3)); // 输出: 8
```



## ESM规范

`ESM`是`ECMAScript`官方引入的模块化规范，它在现代浏览器和`Nodejs`中都得到了广泛支持。它的主要特点包括：

- 异步加载模块： `ESM`模块是异步加载的，模块需要使用`import`语句加载，可以在运行时动态加载模块。
- 导出方式： 使用`export`关键字导出模块内容，可以导出多个成员，也可以起别名。

### 姿势一：export命名导出

使用`export`关键字，可以命名导出一个或多个成员，这些成员在导入时需要使用相应的名称来访问。

```js
// 导出
// utils.js
export function add(a, b) {
  return a + b;
}

export function subtract(a, b) {
  return a - b;
}

// 导入
// app.js
import { add, subtract } from './utils';
console.log(add(5, 3)); // 输出: 8
console.log(subtract(5, 3)); // 输出: 2
```
### 姿势二：export default默认导出

使用`export default`关键字，可以导出一个默认成员，一个模块只能有一个默认导出。

```js
// 导出
// utils.js
const add = (a, b) => a + b;
export default add;

// 导入
import add from './utils';
console.log(add(5, 3)); // 输出: 8
```


在导入时，可以自定义默认导出成员的名称：

```js
// 导入并重命名
import myAddFunction from './utils';
console.log(myAddFunction(5, 3)); // 输出: 8
```


### 姿势三：export + export default 混合导出

在一个模块中，既可以有命名导出，又可以有默认导出。

```js
// 导出
// utils.js
export function add(a, b) {
  return a + b;
}

function subtract(a, b) {
  return a - b;
}

export default subtract;

// 导入
// app.js
import subtract, { add } from './utils';
console.log(add(5, 3)); // 输出: 8
console.log(subtract(5, 3)); // 输出: 2
```

### 姿势四：重新导出

可以在一个模块中重新导出另一个模块的成员，方便从一个中心模块导出所有需要的内容。

```js
// 导出一
// mathUtils.js
export function add(a, b) {
  return a + b;
}

// 导出二
// utils.js
export function subtract(a, b) {
  return a - b;
}

export function multiply(a, b) {
  return a * b;
}

// 引入后重新集中导出
// main.js
export { add } from './mathUtils';
export { subtract, multiply } from './utils';

// 导入
// app.js
import { add, subtract, multiply } from './main';
console.log(add(5, 3)); // 输出: 8
console.log(subtract(5, 3)); // 输出: 2
console.log(multiply(5, 3)); // 输出: 15

```

### 姿势五：全部导入

使用`import * as <alias>`语法，可以将一个模块的所有导出成员导入为一个对象。

```js
// 导出
// utils.js
export function add(a, b) {
  return a + b;
}

export function subtract(a, b) {
  return a - b;
}

// 导入
// app.js
import * as math from './utils';
console.log(math.add(5, 3)); // 输出: 8
console.log(math.subtract(5, 3)); // 输出: 2
```

这些是`ESM`规范中常见的导出方式，通过灵活运用它们，可以更好地组织和管理模块化的`JavaScript`代码。


## 异同点对比

### 加载方式

- `CommonJS`使用同步加载模块，适合服务器端，但在浏览器中可能会造成阻塞。
- `ESM`使用异步加载模块，更适合浏览器环境，可以提高性能。

### 静态分析

- `ESM`可以在静态分析时确定模块依赖关系，这使得一些优化和工具更易实现。
- `CommonJS`在运行时才能确定依赖，限制了某些优化的可能性。

### 动态导入

- `ESM`允许使用`import()`函数在运行时动态加载模块，以支持按需加载。
- `CommonJS`没有原生的动态导入方式，尽管在`Nodejs`中可以使用实验性的`import()`函数。


### 应用场景

- `CommonJS`适用于服务器端应用，特别是在`Nodejs`环境中，可以方便地管理模块依赖。
- `ESM`适用于浏览器和现代`Nodejs`应用，尤其在前端项目中，可以利用浏览器的异步加载能力


## 注意事项

- 当在`Nodejs`中使用`ESM`规范时，需要在脚本文件中使用`.mjs`扩展名，并在`package.json`中设置`"type"`: `"module"`。
- `ESM`中的模块路径解析相对于当前文件，而`CommonJS`中相对于包含模块的目录。
- `ESM`中的导入和导出是静态的，不能根据条件进行导入或导出，而`CommonJS`可以在运行时根据条件加载模块。


## 总结

`CommonJS`和`ESM`规范各有优势，选择取决于应用的环境和需求。

在`Nodejs`环境中，可以根据项目需求选择使用哪种规范，而在现代的浏览器环境中，`ESM`规范更加适用。

熟悉这两种规范的异同以及各自的应用场景，将有助于开发者更好地进行模块化开发并提高代码质量和可维护性。

CommonJS和ESM：JavaScript模块化规范对比

> `Nodejs`是一个基于`Chrome V8`引擎的`JavaScript`运行时环境，它允许开发者使用`JavaScript`在服务器端运行代码。`在Nodejs`中，模块化是一种组织和重用代码的重要方式。模块化允许我们将代码拆分成小块，使得代码结构更清晰、易于维护，并促进团队合作。





`在Nodejs`中，模块化是一种组织和重用代码的重要方式。模块化允许我们将代码拆分成小块，使得代码结构更清晰、易于维护，并促进团队合作。本文将详细介绍`Nodejs`中的模块化，并包含以下内容：

1. CommonJS规范：`Nodejs`使用的模块化规范。
2. 创建和导出模块：如何创建和导出自定义模块。
3. 导入和使用模块：如何导入模块并使用其中的功能。
4. 内置模块：`Nodejs`自带的一些常用模块。
5. 第三方模块：如何使用和安装来自`NPM（Node Package Manager）`的第三方模块。

## CommonJS规范

`Nodejs`遵循`CommonJS`规范，该规范定义了如何组织和使用模块。按照`CommonJS`规范，每个文件都被视为一个独立的模块，模块内部的变量和函数默认情况下是私有的，不会影响其他模块。要使模块中的内容可供其他模块使用，必须显式地将其导出。

`CommonJS`规范定义了两个核心方法来处理模块：

- `require`: 用于导入模块
- `module.exports`: 用于导出模块中的功能

## 创建和导出模块

让我们来创建一个简单的模块，并导出其中的功能。首先，创建一个名为`math.js`的文件，其中包含以下代码：

```js
// math.js
const add = (a, b) => a + b;
const subtract = (a, b) => a - b;

// 导出模块中的功能
module.exports = {
  add,
  subtract,
};
```

在上面的代码中，我们定义了两个函数`add`和`subtract`，然后使用`module.exports`将它们导出，以便其他模块可以访问它们。

## 导入和使用模块

有了`math.js`模块后，我们可以在另一个文件中导入并使用这些功能。创建一个名为`app.js`的文件，内容如下：

```js
// app.js
// 导入math.js模块
const { add, subtract } = require('./math');

const result1 = add(5, 3);
console.log('加法结果:', result1); // 输出: 加法结果: 8

const result2 = subtract(10, 4);
console.log('减法结果:', result2); // 输出: 减法结果: 6
```

在上面的代码中，我们使用`require`导入`math.js`模块，并通过`ES6`的语法解构出返回对象中的`add`和`subtract`函数。然后，我们可以直接使用`add`和`subtract`函数，并执行相关的操作。

## 内置模块

`Nodejs`提供了许多内置模块，这些模块无需安装即可直接使用。以下是一些常用的内置模块：

### fs模块

`fs`模块很常用，在服务端我们经常需要对文件进行操作，`fs`模块便是用于处理文件系统操作，例如读取文件、写入文件等。

```js
const fs = require('fs');

// 读取文件
fs.readFile('file.txt', 'utf8', (err, data) => {
  if (err) throw err;
  console.log(data);
});

// 写入文件
fs.writeFile('newFile.txt', 'Hello, Node.js!', (err) => {
  if (err) throw err;
  console.log('File written successfully!');
});
```

### http模块

`http`模块用于创建`HTTP`服务器和客户端，以便在`Nodejs`中进行网络通信。

```js
const http = require('http');

// 创建HTTP服务器
const server = http.createServer((req, res) => {
  res.writeHead(200, { 'Content-Type': 'text/plain' });
  res.end('Hello, Node.js!');
});

server.listen(3000, () => {
  console.log('Server is running on http://localhost:3000/');
});
```

## 第三方模块

`npm`是`Nodejs`的包管理器，允许开发者安装和管理第三方模块。要使用第三方模块，最好先在项目中初始化一个`package.json`文件：

```shell
npm init
```

然后，通过`npm install`命令安装所需的模块：

```shell
npm install lodash
```

现在，我们可以在代码中导入并使用第三方模块：

```js
// 使用lodash模块
const _ = require('lodash');

const numbers = [1, 2, 3, 4, 5];
const sum = _.sum(numbers);
console.log('sum:', sum); // 输出: sum: 15
```

## 总结

`Nodejs`中的模块化是一种强大的组织和重用代码的方式。我们可以通过`CommonJS`规范创建自定义模块，并在其他文件中导入和使用它们。此外，`Nodejs`还提供了许多内置模块，以及通过`npm`安装的第三方模块，为开发者提供了丰富的功能和工具。

通过模块化，我们可以更好地组织代码，降低耦合度，提高代码的可维护性，并加速开发过程。在构建复杂的`Nodejs`应用程序时，模块化是必不可少的技术手段。

详解Nodejs中的模块化

> 在`Nodejs`中，`process`是一个全局对象，它提供了与当前进程和运行时环境交互的方法和属性。通过`process`对象，我们可以访问进程的信息、控制流程和进行进程间通信，这些都是服务端语言应该具备的能力。本文将全面介绍`process`对象的使用场景，从基础概念到高级应用，带有代码示例，让您深入了解它的功能与用途。





## 简单使用

首先，我们来看一些简单的`process`对象的基础用法。

### 获取命令行参数

通过`process.argv`属性可以获取命令行参数，其中`argv[0]`是`Nodejs`可执行文件的路径，`argv[1]`是当前执行的脚本文件路径，后续元素是传递给脚本的命令行参数。

```js
// process.js
console.log(process.argv);
```

执行以下命令：

```shell
node process.js arg1 arg2 arg3
```

输出结果：

![](http://creatorblog.cn/static/img/524ca30d9d0fc8532f06234556f42685.image.webp)


结果分析：

```shell
[
  'D:\\Nodejs\\node-v16.20.1-win-x86\\node.exe', // Nodejs可执行文件路径
  'D:\\代码\\code-test\\process.js',  // 当前执行的脚本路径
  'arg1', // 命令行参数
  'arg2',
  'arg3'
]
```

### 获取环境变量

通过`process.env`属性可以获取当前进程的环境变量，这在配置不同环境下的应用程序时非常有用。

写入环境变量的方式有很多很多，在前端通常在脚手架里通过cross-env来控制传入环境变量，今天我们写一个最容易演示的，直接在js文件里写入。

```js
// env.js
process.env.NODE_ENV = 'production';
// process.js
require('./env');
console.log(process.env);
console.log(process.env.NODE_ENV);
```

执行以下命令：

```shell
node process.js
```

输出结果：


![image.png](http://creatorblog.cn/static/img/5a9a3c56c20a17a0cd9ca635dae3f810.image.webp)


在正式的项目里，咱们可以通过判断环境变量所处的环境，比如开发环境、测试环境、生产环境，来做不同的应对，比如对请求后端接口的前置路径的控制等。

### 退出进程

通过`process.exit()`方法可以使进程退出，接收一个可选的退出码参数。

```js
// process.js
console.log("退出前");
process.exit(0);
console.log("退出后"); // 不会执行到这里
```

执行以下命令：

```shell
node process.js
```

输出结果：

![image.png](http://creatorblog.cn/static/img/86ecb89ac553ea56ec339dd3d3f46f73.image.webp)


结果分析：

从结果上来看，在输出 "退出前" 之后，通过`process`提供的`exit`方法退出此进程，导致后续并没有输出 "退出后"。

### 信号处理

通过`process.on('SIGINT', callback)`方法可以捕获`SIGINT`信号（通常由`Ctrl+C`触发），从而实现对进程的优雅退出。

```js
// process.js
process.on('SIGINT', () => {
    console.log("接收到SIGINT信号。正在退出...");
    process.exit(0);
});
console.log("正在等待SIGINT信号...");

setTimeout(() => {

}, 1000000);
```

因为要复现通过`Ctrl + C`实现捕获`SIGINT`信号的方式结束进程，所以我们需要让进程一直运行中，方式有很多，比如起一个`web`服务等方式，最简单粗暴的，肯定还是使用定时器，给一个很大的延迟秒数，促使此进程不会很快结束，让我们可以手动通过`Ctrl + C`捕获信号的形式来执行回调函数的内容。

执行以下命令：

```shell
node process.js
```
输出结果：

![image.png](http://creatorblog.cn/static/img/e76180952817c426eece581beea82a12.image.webp)

通过实际操作，可以复现既定的效果，让我们在进程结束之前通过回调函数做很多需要做的事情

## 进程间通信

在`Nodejs`中，我们可以通过`process`对象实现进程间通信，这对于父子进程之间的协作或者多个进程之间的数据传递都很有用。`Nodejs`提供了`child_process`模块来实现与子进程的交互。

### 子进程的创建与通信

通过`spawn()`方法创建一个子进程，并通过`stdin`、`stdout`、`stderr`来进行通信。

```js
// process.js
const { spawn } = require('child_process');

const command = process.platform === 'win32' ? 'cmd.exe' : 'ls';
const args = process.platform === 'win32' ? ['/c', 'dir', '/b'] : ['-l'];

const childProcess = spawn(command, args);

childProcess.stdout.on('data', (data) => {
  console.log(`子进程输出:\n${data}`);
});

childProcess.stderr.on('data', (data) => {
  console.error(`子进程异常:\n${data}`);
});

childProcess.on('close', (code) => {
  console.log(`子进程已退出，返回代码:${code}`);
});

```
在不同的操作系统和不同的系统位数中，相关处理可能不同，所以我们做了兼容。

执行以下命令：

```shell
node process.js
```

输出结果：


![image.png](http://creatorblog.cn/static/img/fa909164af4038de8c0dfe08e253bfef.image.webp)

在上述示例中，我们创建了一个子进程来执行一些输出目录信息的命令，并通过`stdout`和`stderr`事件捕获子进程的输出和错误信息。`close`事件在子进程退出时触发。

### 父进程与子进程之间的消息传递

除了通过标准输入输出进行通信外，父进程和子进程还可以通过消息传递的方式进行通信，`Nodejs`提供了`fork()`方法来创建具有`IPC`通信的子进程。

```js
// process.js
const { fork } = require('child_process');

const childProcess = fork('./child.js');

childProcess.on('message', (message) => {
  console.log(`父进程收到消息: ${message}`);
});

childProcess.send('Hello，我是父进程！');
```

```js
// child.js
process.on('message', (message) => {
    console.log(`子进程收到消息: ${message}`);
    process.send('你好，我是子进程！');
});
```


执行以下命令：

```shell
node process.js
```

输出结果：


![image.png](http://creatorblog.cn/static/img/c2e528c45f3a720efabf6a0d29caf8ab.image.webp)

## 进程信号与事件

`Nodejs`中的`process`对象提供了许多事件和信号，用于监听和处理进程相关的状态和事件。

### exit事件

`exit`事件在进程即将退出时触发，可以用来执行一些清理工作。

```js
// process.js
process.on('exit', (code) => {
  console.log(`进程将退出，返回的代码是: ${code}`);
});

console.log("开始！");
```

执行以下命令：

```shell
node process.js
```

输出结果：

![image.png](http://creatorblog.cn/static/img/514c493ac08df8006746b154c76d58d7.image.webp)


### uncaughtException事件

`uncaughtException`事件用于捕获未被捕获的异常，但注意它不能替代正常的异常处理，只应该用于记录异常并尽量优雅地退出进程。

```js
// process.js
process.on('uncaughtException', (err) => {
    console.error(`未被捕获的异常: ${err.message}`);
    // 这里可以进行一些异常处理逻辑
});

console.log("开始！");

// 模拟未被捕获的异常
throw new Error("出了问题");
console.log("这里不会被输出");
```

执行以下命令：

```shell
node process.js
```

输出结果：


![image.png](http://creatorblog.cn/static/img/2ac7d9cc86f6739c121631ff2024ddab.image.webp)


### warning事件

`warning`事件用于捕获一些废弃的`API`使用或其它可能导致问题的警告信息。

```js
// process.js
process.on('warning', (warning) => {
    console.warn(`警告: ${warning.message}`);
});

// 模拟发出一个废弃API的警告
process.emitWarning("这是不推荐使用的API用法，不推荐使用警告");

```

执行以下命令：

```shell
node process.js
```

输出结果：


![image.png](http://creatorblog.cn/static/img/aeb13f2309432fbb283d3fd40bc0eafb.image.webp)


### beforeExit事件

`beforeExit`事件在进程即将退出之前触发，可以用于执行一些异步操作，但不能阻止进程的退出。

```js
process.on('beforeExit', (code) => {
    console.log(`进程将退出，返回的代码是: ${code}`);
});

console.log("开始！");

// 模拟异步操作
setTimeout(() => {
    console.log("已执行异步操作");
}, 1000);

```

执行以下命令：

```shell
node process.js
```

输出结果：


![image.png](http://creatorblog.cn/static/img/9b191cea9e70ead0f0cd21634cc583a4.image.webp)


### SIGINT信号


`SIGINT`之前已经介绍过一次了。`SIGINT`信号通常由`Ctrl+C`触发，用于请求进程终止。我们可以捕获该信号，并实现优雅地退出进程。

```js
// process.js
process.on('SIGINT', () => {
    console.log("接收到SIGINT信号。正在退出...");
    process.exit(0);
});

console.log("等待SIGINT信号...");

setTimeout(() => {

}, 1000000);
```

执行以下命令：

```shell
node process.js
```

输出结果：


![image.png](http://creatorblog.cn/static/img/300e5c5bbc0d8d44f54d616e731367e9.image.webp)


### SIGHUP、SIGTERM、SIGQUIT信号

除了`SIGINT`信号，还有一些其他信号可以用于控制进程的行为，例如`SIGHUP`、`SIGTERM`和`SIGQUIT`等。可以使用类似的方式捕获这些信号并实现相应的处理，这几个信号对于大部分人来说可能不常用，下面我简单叙述一下：

#### SIGHUP信号

`SIGHUP（Hang Up）`信号通常在以下情况下发送给进程：

1. 当终端连接（例如`SSH`会话）关闭时，与该终端关联的所有进程会收到`SIGHUP`信号。
2. 如果操作系统出现某些问题，导致终端会话意外终止，进程也可能收到`SIGHUP`信号。


默认情况下，对于大多数终端连接，`SIGHUP`会终止进程。但是，您可以在`Nodejs`中通过监听`process`对象的`SIGHUP`事件来处理这个信号，并在进程终止之前执行一些清理操作。

以下是一个简单的代码示例：

```js
process.on('SIGHUP', () => {
  console.log('收到SIGHUP信号。正在执行清理...');
  // 执行清理操作，如关闭数据库连接、保存数据等
  process.exit(0); // 可以选择退出进程，或执行其他操作
});
```
#### SIGTERM信号

`SIGTERM`信号是由系统管理员或其他进程发送给进程，用于请求进程优雅地终止。`SIGTERM`通常用于正常关闭进程，允许进程完成正在进行的操作并进行清理，然后自行终止。

在`Nodejs`中，您可以通过监听`process`对象的`SIGTERM`事件来处理`SIGTERM`信号，并在进程终止之前执行清理操作。

以下是一个简单的代码示例：

```js
process.on('SIGTERM', () => {
  console.log('收到SIGTERM信号。正在执行清理...');
  // 执行清理操作，如关闭数据库连接、保存数据等
  process.exit(0); // 可以选择退出进程，或执行其他操作
});
```

#### SIGQUIT信号

`SIGQUIT`信号也是由系统管理员或其他进程发送给进程，用于请求进程终止，但与`SIGTERM`不同的是，`SIGQUIT`会产生`core dump`文件，用于进程调试和故障排除。

在`Nodejs`中，可以通过监听`process`对象的`SIGQUIT`事件来处理`SIGQUIT`信号，并在进程终止之前执行一些清理操作。

以下是一个简单的代码示例：

```js
process.on('SIGQUIT', () => {
  console.log('收到SIGQUIT信号。正在执行清理...');
  // 执行清理操作，如关闭数据库连接、保存数据等
  process.exit(0); // 可以选择退出进程，或执行其他操作
});
```

请注意，这些信号的处理方式可以根据应用程序的需求进行自定义。对于`SIGTERM`和`SIGQUIT`信号，您可以在收到信号后执行清理操作，并自行决定是否退出进程。对于`SIGHUP`信号，默认行为是终止进程，但您可以通过监听`SIGHUP`信号并处理它来更改这种行为。

## 进程资源与性能

`process`对象还提供了一些方法，用于获取当前进程的资源使用情况和性能指标。


### 获取内存使用情况

```js
// process.js
const used = process.memoryUsage();

console.log(`Memory Usage:`);
console.log(`  - RSS: ${used.rss} bytes`);
console.log(`  - Heap Total: ${used.heapTotal} bytes`);
console.log(`  - Heap Used: ${used.heapUsed} bytes`);
console.log(`  - External: ${used.external} bytes`);
```

执行以下命令：

```shell
node process.js
```

输出结果：

![](http://creatorblog.cn/static/img/5338d6901fa3099e471a4aff4c0fb473.image.webp)

### 获取CPU使用情况

```js
// process.js
const startTime = process.hrtime();

setTimeout(() => {
  const endTime = process.hrtime(startTime);
  console.log(`CPU Usage:`);
  console.log(`  - Execution time: ${endTime[0]}s ${endTime[1] / 1000000}ms`);
}, 1000);
```

执行以下命令：

```shell
node process.js
```

输出结果：


![image.png](http://creatorblog.cn/static/img/5266b9ca8e2b3565fdfd771ab221f688.image.webp)

### 设置进程标题与优先级

#### 设置进程标题

```js
// process.js

// 设置进程标题
process.title = "My Node.js App";

// 输出进程标题
console.log(process.title);
```

执行以下命令：

```shell
node process.js
```

输出结果：

![image.png](http://creatorblog.cn/static/img/aa3dba5b154ef5e8b82ef0e06a67c22b.image.webp)

#### 设置进程优先级

在`Nodejs`中，可以使用`os`模块来设置进程的优先级。具体来说，可以使用`os.priority()`方法来设置进程的调度优先级。

```js
// process.js
const os = require('os');

// 设置进程的调度优先级为高
os.setPriority(os.constants.priority.PRIORITY_HIGH);

// 获取进程的调度优先级
const priority = os.getPriority();
console.log(`进程优先级: ${priority}`);
```

执行以下命令：

```shell
node process.js
```

输出结果：

![image.png](http://creatorblog.cn/static/img/6339cb7041ed860b85e457c24f79fa5b.image.webp)


#### 注意

在`Nodejs`中，`os.getPriority()`方法返回的数值表示进程的调度优先级。不同的操作系统可能有不同的标准来表示进程优先级，但通常情况下，较小的负数值表示较高的优先级。

在`Windows`系统中，优先级值的范围是 -15 到 15，其中 -15 表示最高优先级，15 表示最低优先级。因此，我在`Nodejs`中使用`os.getPriority()`方法返回值为 -14，那么在Windows系统中这个值表示的是接近最高优先级的状态。

需要注意的是，在不同的操作系统上，`os.getPriority()`方法返回的值可能会有所不同。例如，`Linux`操作系统上的优先级值范围可能是不同的，具体取决于操作系统的调度策略。

要实现跨平台的代码，最好避免硬编码特定操作系统的优先级值，而是根据需要使用更具有可移植性的方法和方式来设置进程优先级。如果你的应用程序需要使用特定优先级，请确保在不同操作系统上进行适当的测试和调整。

## 总结

`process`对象是`Nodejs`中非常重要的全局对象，提供了许多与进程和运行时环境交互的方法和属性。

在本文中，我们从基础的命令行参数获取和环境变量访问开始，逐步深入到进程间通信、信号处理、进程资源与性能等高级用法。

希望这篇博文能够帮助大家全面了解并灵活应用`process`对象在`Nodejs`应用程序开发中。

详解Nodejs中的Process对象

> 今天我们将探讨`Nodejs`中的全局对象，这是`Nodejs`中重要且有趣的知识点。我们将通过生动形象的例子和风趣的风格来深入理解这些概念，并比较`Nodejs`中的全局对象与前端`JavaScript`中的全局对象之间的异同点。





## 全局对象是什么？

在`Nodejs`环境中，有一个全局对象`global`，它在所有模块中都是可见的，类似于前端`JavaScript`中的`window`全局对象。然而，不同于浏览器环境，`Nodejs`中没有浏览器窗口，所以没有类似`window`这样的对象。而是使用`global`来提供类似的功能。

```js
// app.js
console.log(global);
```

在`Nodejs`中，当我们运行上述代码时，会输出一个包含许多全局属性和方法的对象。这些全局属性和方法是`Nodejs`运行时提供的基础功能。


![image.png](http://creatorblog.cn/static/img/6cfdba32e0c5b9adbfdb17f626948f3d.image.webp)

## 常见的全局对象属性和方法

### __dirname和__filename

`__dirname`是一个字符串，表示当前执行脚本所在的目录的绝对路径。而`__filename`则表示当前执行脚本的文件名（包含绝对路径）。

```js
// app.js
console.log(__dirname);
console.log(__filename);
```

运行 `node app.js`，输出如下：


![image.png](http://creatorblog.cn/static/img/b633ab49dde9f30e4297ed2874ac21d0.image.webp)


### setTimeout和setInterval

在`Nodejs`中，我们可以使用`setTimeout`和`setInterval`方法来设置定时器。这两个方法在前端`JavaScript`中也是常见的。

```js
// app.js
console.log("开始");
setTimeout(() => {
  console.log("这是一个延迟了2s的信息");
}, 2000);

setInterval(() => {
  console.log("这个信息每过1s都会发送一次");
}, 1000);
```

运行 `node app.js`，输出如下：

![image.png](http://creatorblog.cn/static/img/c70ef32b6a1cd538b6fe3415e4cc5899.image.webp)


### process

`process`是一个全局对象，提供与当前`Nodejs`进程相关的信息和控制功能。

```js
// app.js
console.log(process.pid); // 当前进程的PID（进程ID）
console.log(process.platform); // 当前操作系统平台
console.log(process.version); // Node.js的版本号
```
运行 `node app.js`，输出如下：


![image.png](http://creatorblog.cn/static/img/c02a3b1b4c64ba99e3d9fc0f4393883a.image.webp)

### require和module.exports

在`Nodejs`中，我们使用`require`方法来引入其他模块。`module.exports`则用于导出当前模块的功能。

```js
// math.js
const add = (a, b) => a + b;
module.exports = { add };

// app.js
const math = require('./math');
console.log(math.add(2, 3)); // 输出 5
```

运行 `node app.js`，输出如下：

![image.png](http://creatorblog.cn/static/img/e529a32fed21e5dfe7657479c0c87fcd.image.webp)


### global对象的自定义属性

除了上述内置属性和方法，我们也可以在`global`对象上定义自己的属性。

```js
// customGlobal.js
global.customMessage = "Hello, 我是一个自定义的global属性";
```

```js
// app.js
require('./customGlobal');
console.log(global.customMessage); // 输出 "Hello, 我是一个自定义的global属性"
```

请注意，虽然在某些情况下全局变量可能很方便，但应谨慎使用全局变量，因为它们可能导致命名冲突和代码维护问题。

运行 `node app.js`，输出如下：

![image.png](http://creatorblog.cn/static/img/faef94040b85cad588063980ccb7345e.image.webp)



## Nodejs全局对象global和前端JavaScript中全局对象window的异同点

### 共同点

无论是`Nodejs`中的全局对象`global`还是前端`JavaScript`中的全局对象`window`，它们都提供了全局作用域，并且可以在任何地方访问。

### 不同点

最显著的不同是，前端`JavaScript`中的`window`对象提供了许多与浏览器窗口和`DOM`相关的功能，比如`document`、`navigator`等。而`Nodejs`中的`global`对象主要提供了与服务器和操作系统相关的功能，比如`process`、`require`等。

此外，`Nodejs`中的全局对象没有`window`的概念，因为`Nodejs`是基于`V8`引擎的`JavaScript`运行时，没有浏览器的窗口概念。相反，`Node.js`提供了许多与服务器端开发相关的功能，比如文件系统访问、网络请求等。

## 总结

全局对象是`Nodejs`中非常重要的概念，它为我们提供了许多有用的功能和属性。通过对`Nodejs`中的全局对象深入了解，我们可以更好地利用`Nodejs`构建强大的服务器端应用程序。同时，通过与前端`JavaScript`中的全局对象进行比较，我们也能更清楚地理解它们之间的异同点。

Nodejs中的全局对象

欢迎来到我的博客，这里是我分享前端、web3、理财、互联网等方面的知识和心得的地方。我是一名热爱编程的前端程序员，我希望通过我的博客能够帮助更多的人学习和进步。在这里，你可以找到最新最实用的前端技术教程，了解最前沿的互联网动态和趋势，掌握最有效的理财方法和策略。我也会不定期地发布一些个人项目和作品，展示我的创意和能力。如果你对我的博客感兴趣，欢迎你留言、评论、收藏、关注，也可以通过邮箱或社交媒体与我联系，交流学习和合作。谢谢你的支持！