> 在现代的`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中的全局对象

> `Node.js`，这个神奇的技术，融合了前端与后端的力量，让`JavaScript`在服务器端发挥了异乎寻常的魔力。本文将通过代码和文字解释，全面介绍`Node.js`的特点，从异步非阻塞`I/O`到强大的模块系统，再到丰富的包管理和事件驱动编程，一步步揭开`Node.js`的神秘面纱。




## 异步非阻塞I/O：高性能的秘密武器

`Node.js`的核心特点之一就是采用了异步非阻塞`I/O`模型。这意味着`Node.js`在执行`I/O`操作（如读写文件、网络请求等）时不会阻塞程序的其他部分，而是通过事件循环和回调函数，在操作完成后异步地通知程序处理结果。这使得`Node.js`能够在高并发环境下表现出色，极大提高了服务器的性能。


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

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

console.log('异步读取文件进行中...');
```

在这个示例中，我们使用`Node.js`的文件系统模块`(fs)`异步地读取`example.txt`文件。在调用`fs.readFile`时，`Node.js`不会阻塞后续代码的执行，而是继续执行后面的`console.log`。当文件读取完成后，回调函数被触发，异步地输出文件内容。这种非阻塞`I/O`特性让`Node.js`能够高效地处理大量并发请求。


## 单线程：轻盈灵活的运行环境

`Node.js`是单线程的运行环境，这意味着它在同一时间只能执行一个任务。然而，通过异步非阻塞`I/O`，`Node.js`能够高效地处理大量并发请求。虽然`Node.js`本身是单线程的，但可以通过创建多个子进程来充分利用多核处理器。

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

http.createServer((req, res) => {
  res.writeHead(200, { 'Content-Type': 'text/plain' });
  res.end('Hello, Node.js!');
}).listen(3000);

console.log('服务器启动中...');
```

在这个示例中，我们使用`Node.js`的`http`模块创建一个简单的`HTTP`服务器，并监听端口3000。当执行`http.createServer`时，`Node.js`会创建一个`HTTP`服务器，然后继续执行后面的`console.log`，不会阻塞服务器的运行。这样，`Node.js`能够轻盈灵活地处理客户端的请求。

## 模块系统：代码组织与复用的利器

`Node.js`拥有强大的模块系统，让代码的组织和复用变得简单。在`Node.js`中，每个文件就是一个模块，可以通过`require`关键字引入其他模块。这种模块化的编程风格，使得`Node.js`社区拥有丰富的第三方模块，方便开发者快速扩展应用功能。

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

module.exports = {
    add,
    subtract
}
```

```js
// app.js
const math = require('./math');

console.log(math.add(5, 3)); // 输出: 8
console.log(math.subtract(5, 3)); // 输出: 2
```


在这个示例中，我们将数学运算封装在一个模块`math.js`中，并通过`module.exports`方式导出两个方法`add`和`subtract`。在`app.js`中，我们使用`require`关键字引入`math`模块，并调用其中的方法。这种模块化的方式，让我们能够更好地组织和复用代码。

## npm（Node Package Manager）：开源生态系统

`npm`是`Node.js`的包管理工具，是全球最大的开源软件注册表。它提供了丰富的开源模块供开发者使用，同时也允许开发者将自己的模块分享给全球社区。借助`npm`，开发者可以轻松地安装、发布和管理`Node.js`模块，极大地促进了代码的共享和协作。

我们在安装`Node.js`时，会默认内置`npm`。可以打开命令行，分别输入`node -v`和`npm -v`来验证是否能正常使用。


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

```shell
# 安装第三方模块
npm install lodash=
```

在这个示例中，我们使用`npm`安装了一个非常流行的第三方模块`lodash`，它提供了很多实用的工具函数。通过这种方式，我们可以轻松地引入和使用其他开发者共享的模块，加快项目的开发速度。


## 事件驱动编程：优雅而高效的处理方式

`Node.js`采用事件驱动的编程范式，通过触发事件和监听器来进行异步处理。开发者可以通过事件驱动方式，轻松处理复杂的数据流和状态变化。这种事件驱动的编程方式使得代码看起来更加优雅、高效。

```js
const EventEmitter = require('events');

class MyEmitter extends EventEmitter {}

const myEmitter = new MyEmitter();

// 监听事件
myEmitter.on('event', () => {
  console.log('事件被触发！');
});
```

在这个示例中，我们使用`Node.js`的`events`模块创建了一个自定义的事件发射器`MyEmitter`，它继承自`EventEmitter`。然后，我们创建了一个`myEmitter`实例，并通过`on`方法监听了一个名为`event`的事件。当`event`事件被触发时，回调函数会被执行，输出"事件被触发！"。通过事件驱动的方式，我们可以轻松地实现模块间的通信和数据传递，让代码变得更加清晰和可维护。

## V8引擎：高性能的加持

`Node.js`运行在`Chrome V8`引擎上，`V8`引擎是一个高性能、快速的`JavaScript`引擎，为`Node.js`的执行效率提供了强大支持。`V8`引擎的优秀性能使得`Node.js`成为处理高并发请求的理想选择。

```js
const arr = Array.from({ length: 1000000 }, (_, index) => index + 1);

console.time('排序耗时');
arr.sort((a, b) => a - b);
console.timeEnd('排序耗时');

```

在这个示例中，我们进行了一次对数组的排序。由于`V8`引擎的高性能，即使数组长度为1000000，排序也能在短时间内完成。`V8`引擎的高性能是`Node.js`能够高效处理大量并发请求的重要保障。

## 缓冲区（Buffer）：处理二进制数据

在`Node.js`中，`Buffer`是用来处理二进制数据的机制。由于`JavaScript`本身没有处理二进制数据的能力，`Buffer`允许我们在`Node.js`中高效地操作二进制数据，比如处理文件流或网络数据。

```js
// 创建一个长度为5的Buffer
const buf = Buffer.alloc(5);

// 向Buffer写入数据
buf.write('hello');

// 读取Buffer数据
console.log(buf.toString()); // 输出: hello
```

在这个示例中，我们使用`Buffer.alloc`创建了一个长度为5的`Buffer`。然后，我们使用`buf.write`向`Buffer`中写入字符串`"hello"`。最后，我们通过`buf.toString`方法读取`Buffer`中的数据并输出。通过`Buffer`，我们可以方便地处理和操作二进制数据。

## 流（Stream）：高效处理大量数据

`Node.js`提供了流的概念，它允许我们在数据尚未完全加载到内存的情况下进行处理。通过流，我们可以降低内存消耗，并且更快地处理大量数据，尤其在处理文件流和网络数据时，流显得格外高效。

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

// 创建可读流
const readableStream = fs.createReadStream('largefile.txt');

// 创建可写流
const writableStream = fs.createWriteStream('output.txt');

// 管道连接可读流和可写流
readableStream.pipe(writableStream);
```

在这个示例中，我们使用`fs`模块创建了一个可读流`readableStream`，它从名为`largefile.txt`的文件中读取数据。同时，我们也创建了一个可写流`writableStream`，它将数据写入名为`output.txt`的文件。通过`pipe`方法，我们将可读流和可写流连接在一起，使得数据能够从可读流流向可写流，实现高效的数据传输和处理。

## 跨平台：全方位的支持

`Node.js`是跨平台的，可以运行在`Windows`、`MacOS`、`Linux`等多种操作系统上。这使得开发者可以在不同的平台上编写、测试和部署`Node.js`应用，享受全方位的支持。

`Node.js`的跨平台特性使得开发者可以在不同操作系统上运行同样的代码，而无需担心平台的差异性。这为开发者提供了更大的灵活性和便利性，让`Node.js`应用在各个平台上都能得到良好的运行体验。

## 社区活力：共建开源世界

`Node.js`社区是一个充满活力和创意的开源社区，有着众多积极参与的开发者。他们不仅共享自己的知识和经验，还开发了大量优秀的`Node.js`模块和工具，为其他开发者提供了宝贵的资源和帮助。这种积极的社区氛围，极大地促进了`Node.js`技术的发展和应用。


## 总结

本文通过代码和文字解释全面介绍了`Node.js`的特点与魅力。从异步非阻塞`I/O`到强大的模块系统，再到`npm`包管理、事件驱动编程以及`V8`引擎的高性能支持等。`Node.js`展现出了强大的编程能力和灵活的运行环境。`Node.js`已经改变了许多开发者的生活，你也可以在`Node.js`的世界里创造属于自己的奇迹！

学习Node.js的基础知识和核心概念

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