Process

提供有关当前Node.js进程的信息并对其进行控制

const process = require('node:process');

进程事件

该 process 对象是 EventEmitter de实例

beforeExit

当 Node.js 清空其事件循环并且没有要安排的其他工作时，将发出 'beforeExit' 该事件。通常，当没有计划工作时，Node.js进程将退出，但在 'beforeExit' 事件中注册的侦听器可以进行异步调用，从而导致Node.js进程继续。

调用侦听器回调函数时，将传递 process.exitCode 的值作为唯一参数

对于导致显式终止的情况（例如调用 process.exit() 或未捕获的异常），不会发出该 'beforeExit' 事件。

除非打算安排额外的工作，否则不应将其 'beforeExit' 用作 'exit' 事件的替代方法。

const process = require('node:process')

process.on('beforeExit', (code) => {
  console.log('进程 beforeExit 事件 code 为：', code)
})

process.on('exit', (code) => {
  console.log('进程 exit 事件 code 为：', code)
})

console.log('这条消息最先显示');

/**
 * 打印：
 * 这条消息最先显示
 * 进程 beforeExit 事件 code 为： 0
 * 进程 exit 事件 code 为： 0
 */

exit

当Node.js进程由于以下任一原因即将退出时，将发出该 'exit' 事件：

显式调用 process.exit() 的方法;
Node.js事件循环不再有任何其他工作要执行。此时无法阻止事件循环退出，一旦所有 'exit' 侦听器都运行完毕，Node.js进程将终止侦听器回调函数使用 process.exitCode 属性指定的退出代码或传递给方法的 exitCode process.exit() 参数进行调用

const process = require('node:process');

process.on('exit', (code) => {
  console.log(`即将退出， code: ${code}`);
});

侦听器函数只能执行同步操作。调用 'exit' 事件侦听器后，Node.js进程将立即退出，从而导致放弃仍在事件循环中排队的任何其他工作。例如，在以下示例中，永远不会执行：

const process = require('node:process');

process.on('exit', (code) => {
  setTimeout(() => {
    console.log('This will not run');
  }, 0);
});

warning

每当Node.js发出进程警告时，就会发出该 'warning' 事件

wanning 事件有以下属性：

name: 警告的名称。默认值： 'Warning'
message 系统提供的警告说明。
stack 对代码中发出警告的位置的堆栈跟踪

const process = require('node:process')

process.on('warning', (warning) => {
  console.warn(warning.message); // Print the warning message
  console.warn(warning.name);    // Print the warning name
  console.warn(warning.stack);   // Print the stack trace
});

默认情况下，Node.js 会将进程警告打印到 stderr 。 --no-warnings 命令行选项可用于禁止显示默认控制台输出，但 process 该 'warning' 事件仍将由对象发出。

worker

该 'worker' 事件在创建新线程后发出

Signal events（信号事件）

当 Node.js 进程收到信号时，将发出信号事件。信号在线程上 Worker 不可用。

信号处理程序将接收信号的名称（ 'SIGINT' 、 'SIGTERM' 等）作为第一个参数。

每个事件的名称将是信号的大写通用名称（例如 'SIGINT' SIGINT 信号）

const process = require('node:process')

process.stdin.resume()

process.on('SIGINT', () => {
  console.log('收到 SIGINT。按 Control-D 退出');
})

process.on('SIGTERM', (signal) => {
  console.log('收到', signal);
})

'SIGUSR1' 由Node.js保留以启动调试器。可以安装侦听器，但这样做可能会干扰调试器
'SIGTERM' 并在 'SIGINT' 非 Windows 平台上具有默认处理程序，这些处理程序在使用代码 128 + signal number 退出之前重置终端模式。如果其中一个信号安装了侦听器，则其默认行为将被删除（Node.js将不再退出）
'SIGPIPE' 默认情况下被忽略。它可以安装侦听器
'SIGHUP' 在控制台窗口关闭时在 Windows 上生成，在各种类似条件下在其他平台上生成，它可以安装侦听器，但大约 10 秒后，Windows 将无条件终止Node.js侦听器。在非 Windows 平台上，默认 SIGHUP 行为是终止Node.js，但一旦安装了侦听器，其默认行为将被删除。
'SIGTERM' 在 Windows 上不受支持，可以监听
'SIGINT' 所有平台都支持 From the Terminal，通常可以使用 Ctrl + C 生成（尽管这可能是可配置的）。当启用终端原始模式并使用 Ctrl + C 时，不会生成它
'SIGBREAK' 在 Windows 上按下 Break + Ctrl 时会传递此信息。在非Windows平台上，可以监听它，但无法发送或生成它。
'SIGWINCH' 在调整控制台大小时交付。在 Windows 上，这只会在移动光标时写入控制台时发生，或者在原始模式下使用可读 tty 时发生。
SIGKILL' 无法安装侦听器，它将无条件终止所有平台上的Node.js
'SIGSTOP' 无法安装侦听器。
'SIGBUS', 'SIGFPE', 'SIGSEGV', and 'SIGILL' 当不使用kill(2)人为引发时，本质上会使进程处于调用 JS 侦听器不安全的状态。这样做可能会导致进程停止响应。
0 可以发送去测试一个进程的存在，如果进程存在，它就没有效果，但如果进程不存在，就会抛出错误。

Windows 不支持信号，因此没有与信号终止等效的功能，但 Node.js 提供了一些 process.kill(), and subprocess.kill() 模拟

发送 SIGINT 、 SIGTERM 和 SIGKILL 将导致目标进程无条件终止，之后，子进程将报告该进程已通过信号终止。
发送信号 0 可以用作独立于平台的方式来测试进程的存在。

process.abort()

该 process.abort() 方法使Node.js进程立即退出并生成核心文件

此功能在线程中 Worker 不可用。

process.allowedNodeEnvironmentFlags

process.allowedNodeEnvironmentFlags 属性是 NODE_OPTIONS 环境变量中允许的特殊、只读标志集

process.allowedNodeEnvironmentFlags 扩展了 Set，但重写了 Set.prototype.has 以识别几种不同的可能的标志表示形式。 process.allowedNodeEnvironmentFlags.has() 在以下情况下将返回 true：

标志可以省略前导单破折号 (-) 或双破折号 (--)；例如，inspect-brk 代表 --inspect-brk，或 r 代表 -r
传递到 V8 的标志（如 --v8-options 中列出）可以替换一个或多个非前导破折号作为下划线，反之亦然；例如，--perf_basic_prof、--perf-basic-prof、--perf_basic-prof 等
标志可以包含一个或多个等于（ = ）字符;包括第一个等号之后和包括第一个等号在内的所有字符都将被忽略;例如， --stack-trace-limit=100
NODE_OPTIONS 中必须允许使用标志

process.allowedNodeEnvironmentFlags 的 add()、clear() 和 delete() 方法不执行任何操作，并且会默默失败。

如果 Node.js 是在没有 NODE_OPTIONS 支持的情况下编译的（如 process.config 中所示），则 process.allowedNodeEnvironmentFlags 将包含允许的内容

process.arch

process.arch 属性返回当前 Node.js 进程的 CPU 架构, 如 'arm' 's390' 's390x' 'mips' 'mipsel' 'ppc' 'ppc64' 'riscv64' 'ia32' 'loong64' 'arm64' 'x64'

process.argv

该 process.argv 属性返回一个数组，其中包含启动Node.js进程时传递的命令行参数。

第一个元素将是 process.execPath node 程序的完整路径
第二个元素是正在执行的 JavaScript 文件的路径，其余元素将是任何其他命令行参数。

const { argv } = require('node:process');

// print process.argv
argv.forEach((val, index) => {
  console.log(`${index}: ${val}`);
});

启动Node.js流程：

bash

node process-args.js one two=three four

将生成输出：

bash

0: C:\Program Files\nodejs\node.exe
1: C:\Users\keying\Desktop\app-docs\docs\server\nodejs\demo.js
2: one
3: two=three
4: four

process.channel

判断 Node.js进程是使用 IPC 通道生成的，如果不存在 IPC 通道，则此属性为 undefined

process.chdir(directory)

process.chdir() 方法更改 Node.js 进程的当前工作目录，如果失败（例如，如果指定的目录不存在），则抛出异常

const { chdir, cwd } = require('node:process')

console.log('起始目录', cwd())

try {
  chdir('/tmp');
  console.log(`新目录: ${cwd()}`);
} catch (err) {
  console.error(`chdir: ${err}`);
}

process.config

该 process.config 属性返回一个冻结 Object ，其中包含用于编译当前Node.js可执行文件的配置选项的 JavaScript 表示形式。这与运行 ./configure 脚本时生成 config.gypi 的文件相同。

process.connected

如果Node.js进程是使用 IPC 通道生成的, 则只要 IPC 通道已连接，该 process.connected 属性就会返回 true ，并在调用后 process.disconnect() 返回 false

一旦 process.connected ， false 就不能再使用 process.send() 通过 IPC 通道发送消息。

process.cpuUsage([previousValue])

previousValue 调用 process.cpuUsage() 的上一个返回值

该 process.cpuUsage() 方法返回当前进程的用户和系统 CPU 时间使用情况，该对象具有属性 user 和 system ，其值为微秒值（百万分之一秒）。这些值分别测量在用户代码和系统代码中花费的时间，如果多个 CPU 内核正在执行此过程的工作，则最终可能会大于实际运行的时间。

上一个调用的结果 process.cpuUsage() 可以作为参数传递给函数，以获得差异读数

const { cpuUsage } = require('node:process')

const startUsage = cpuUsage();
// { user: 38579, system: 6986 }

// 让 CPU 旋转 500 毫秒
const now = Date.now();
while (Date.now() - now < 500);

console.log(cpuUsage(startUsage));
// { user: 514883, system: 11226 }

process.cwd()

返回Node.js进程的当前工作目录

const { cwd } = require('node:process');

console.log(`当前目录: ${cwd()}`);

process.debugPort

启用时Node.js调试器使用的端口

const process = require('node:process');

process.debugPort = 5858;

process.dlopen(module, filename[, flags])

flags 默认值： os.constants.dlopen.RTLD_LAZY 该 process.dlopen() 方法允许动态加载共享对象。它主要用于 require() 加载 C++ 插件，除非在特殊情况下，否则不应直接使用。换句话说，除非有特定原因，例如自定义 dlopen 标志或从 ES 模块加载， require() 否则应该优先 process.dlopen() 于此。

该 flags 参数是一个整数，允许指定 dlopen 行为

调用 process.dlopen() 时的一个重要要求是必须传递 module 实例。然后可以通过访问 C++ 插件导出的函数 module.exports

下面的示例演示如何加载名为 local.node 的 C++ 插件，用于导出函数 foo 。在调用返回之前，通过传递 RTLD_NOW 常量加载所有符号。在此示例中，假定常量可用

const { dlopen } = require('node:process');
const { constants } = require('node:os');
const { join } = require('node:path');

const module = { exports: {} };
dlopen(module, join(__dirname, 'local.node'), constants.dlopen.RTLD_NOW);
module.exports.foo();

process.emitWarning(warning[, options])

第二种写法：process.emitWarning(warning[, type[, code]][, ctor])

warning | 发出的警告
options | 选项
- type 当警告是字符串时，类型是用于发出警告类型的名称。默认值："Warning"。
- code 发出的警告实例的唯一标识符
- ctor 当 warning 是字符串时，ctor 是一个可选函数，用于限制生成的堆栈跟踪。默认值：process.emitWarning。
- detail 要包含在错误中的其他文本

获取抛出警告中的信息

const process = require('node:process');

process.on('warning', (warning) => {
  console.warn(warning.name);    // 'Warning'
  console.warn(warning.message); // 'Something happened!'
  console.warn(warning.code);    // 'MY_WARNING'
  console.warn(warning.stack);   // Stack trace
  console.warn(warning.detail);  // 'This is some additional information'
});

避免重复警告

最佳做法是，每个进程只应发出一次警告。为此，请将布尔 emitWarning() 值放在后面

const { emitWarning } = require('node:process');

function emitMyWarning() {
  if (!emitMyWarning.warned) {
    emitMyWarning.warned = true;
    emitWarning('Only warn once!');
  }
}
emitMyWarning();
// 发出：（节点：56339）警告：仅警告一次！
emitMyWarning();
// 不发出任何信号

process.env

该 process.env 属性返回一个包含用户环境的对象

此对象的示例如下所示：

{
  TERM: 'xterm-256color',
  SHELL: '/usr/local/bin/bash',
  USER: 'maciej',
  PATH: '~/.bin/:/usr/bin:/bin:/usr/sbin:/sbin:/usr/local/bin',
  PWD: '/Users/maciej',
  EDITOR: 'vim',
  SHLVL: '1',
  HOME: '/Users/maciej',
  LOGNAME: 'maciej',
  _: '/usr/local/bin/node'
}

可以修改此对象，但此类修改不会反映在Node.js进程之外，也不会（除非明确请求）反映到其他 Worker 线程。换言之，以下示例将不起作用：

bash

node -e 'process.env.foo = "bar"' && echo $foo

而以下将：

const { env } = require('node:process');

env.foo = 'bar';
console.log(env.foo);

赋值 process.env 会隐式将值转换为字符串。此行为已弃用。当值不是字符串、数字或布尔值时，Node.js 的未来版本可能会引发错误

const { env } = require('node:process');

env.test = null;
console.log(env.test);
// => 'null'
env.test = undefined;
console.log(env.test);
// => 'undefined'

用于 delete 从 process.env 中删除属性。

const { env } = require('node:process');

env.TEST = 1;
delete env.TEST;
console.log(env.TEST);
// => undefined

在 Windows 操作系统上，环境变量不区分大小写

const { env } = require('node:process');

env.TEST = 1;
console.log(env.test);
// => 1

除非在创建 Worker 实例时明确指定，否则每个 Worker 线程都有自己的 process.env 副本，基于其父线程 process.env 的，或指定为 Worker 构造函数 env 选项的任何内容。对 process.env 的更改在线程中 Worker 不可见，只有主线程才能进行对操作系统或本机加载项可见的更改。在 Windows 上， process.env 与主线程不同，on 实例 Worker 的副本以区分大小写的方式运行。

process.execArgv

该 process.execArgv 属性返回在启动Node.js进程时传递的一组特定于Node.js的命令行选项。这些选项不会出现在 process.argv 属性返回的数组中，并且不包括Node.js可执行文件、脚本名称或脚本名称后面的任何选项。这些选项对于生成具有与父进程相同的执行环境的子进程非常有用。

bash

node --icu-data-dir=./foo --require ./bar.js script.js --version

结果： process.execArgv

["--icu-data-dir=./foo", "--require", "./bar.js"]

以及 process.argv

['/usr/local/bin/node', 'script.js', '--version']

process.execPath

该 process.execPath 属性返回启动Node.js进程的可执行文件的绝对路径名。符号链接（如果有）将得到解决。

bash

C:\Program Files\nodejs\node.exe

process.exit([code])

code 退出代码。对于字符串类型，仅允许整数字符串（例如“1”）。默认值：0。该 process.exit() 方法指示Node.js以退出状态同步 code 终止进程。如果 code 省略，则 exit 使用“成功”代码 0 或已设置的 process.exitCode 值。在调用所有 'exit' 事件侦听器之前，Node.js不会终止。

const { exit } = require('node:process');

exit(1);

process.exitCode

退出代码。对于字符串类型，只允许使用整数字符串（例如，“1”）。默认值： undefined

当进程正常退出或退出方式时，该数字将是进程退出代码，或者在未指定代码的情况下退出 process.exit()

指定代码将 process.exit(code) 覆盖的任何先前设置 process.exitCode 值

process.getegid()

该 process.getegid() 方法返回Node.js进程的数值有效组标识

process.geteuid()

该 process.geteuid() 方法返回进程的数字有效用户标识

process.getgid()

该 process.getgid() 方法返回进程的数字组标识

process.getgroups()

方法返回一个包含补充组 ID 的数组。 POSIX 未指定是否包含有效组 ID，但 Node.js 确保始终如此。

process.getuid()

该 process.getuid() 方法返回进程的数字用户标识。

process.initgroups(user, extraGroup)

user 用户名或数字标识符
extraGroup 附加组名或数字标识符该 process.initgroups() 方法读取 /etc/group 文件并初始化组访问列表，使用用户所属的所有组。这是一项特权操作，要求Node.js进程具有 root 访问权限或 CAP_SETGID 功能。

删除权限时要小心：

const { getgroups, initgroups, setgid } = require('node:process');

console.log(getgroups());         // [ 0 ]
initgroups('nodeuser', 1000);     // switch user
console.log(getgroups());         // [ 27, 30, 46, 1000, 0 ]
setgid(1000);                     // drop root gid
console.log(getgroups());         // [ 27, 30, 46, 1000 ]

process.kill(pid[, signal])

pid 进程ID
signal 要发送的信号，可以是字符串或数字。默认值: 'SIGTERM'process.kill() 方法将信号发送到由 pid 标识的进程。

信号名称是字符串，例如 “SIGINT” 或 “SIGHUP”

process.memoryUsage()

返回一个对象，该对象描述以字节为单位的 Node.js 进程的内存使用情况。

const { memoryUsage } = require('node:process');

console.log(memoryUsage());
// Prints:
// {
//  rss: 4935680,
//  heapTotal: 1826816,
//  heapUsed: 650472,
//  external: 49879,
//  arrayBuffers: 9386
// }

heapTotal 和 heapUsed 指的是 V8 的内存使用情况。
external 指的是与 V8 管理的 JavaScript 对象绑定的 C++ 对象的内存使用情况
rss（驻留集大小）是进程在主内存设备（即总分配内存的子集）中占用的空间量，包括所有 C++ 和 JavaScript 对象和代码。
arrayBuffers 指的是为 ArrayBuffers 和 SharedArrayBuffers 分配的内存，包括所有 Node.js Buffers。这也包含在外部值中, 当 Node.js 用作嵌入式库时，该值可能为 0，因为在这种情况下可能无法跟踪 ArrayBuffer 的分配。

使用 Worker 线程时， rss 将为对整个进程有效的值，而其他字段将仅引用当前线程。

该 process.memoryUsage() 方法循环访问每个页面以收集有关内存使用情况的信息，根据程序内存分配，这些信息可能会很慢

process.nextTick(callback[, ...args])

callback 回调函数
...args 调用回调时要传递的附加参数 process.nextTick() 将 callback 添加到“下一个任务队列”。在 JavaScript 堆栈上的当前操作运行完成之后且在允许事件循环继续之前，此队列将完全排空，如果要递归调用 process.nextTick()，则可能会创建无限循环

const process = require('node:process');
console.log('start')

process.nextTick(() => {
  console.log('nextTick callback');
})

console.log('end');
/**
 * 打印结果：
 * start
 * end
 * nextTick callback
 */

何时使用 queueMicrotask() vs process.nextTick()

queueMicrotask：微任务队列，异步执行，在微任务之前执行该 queueMicrotask() API 是一种替代方案 process.nextTick() ，它还使用相同的微任务队列来延迟函数的执行，该队列用于执行已解决承诺的 then、catch 和 finally 处理程序

在Node.js内，每次 “下一个任务队列” 被清空时，微任务队列都会立即被清空。

在简单方案中，queueMicrotask() 可以直接替代 process.nextTick()

const { nextTick } = require('node:process');

queueMicrotask(() => console.log('1'));
Promise.resolve().then(() => console.log('2'))
nextTick(() => console.log('3'))

// 打印：3, 1, 2

从下一个任务队列和微任务队列中引发的错误处理方式略有不同。在排队的微任务回调中引发的错误应尽可能在排队的回调中处理。如果不是， process.on('uncaughtException') 则可以使用事件处理程序来捕获和处理错误。

如有疑问，除非需要特定 process.nextTick() 功能，否则请使用 queueMicrotask() .

process.permission

此 API 可通过 --experimental-permission 标志设置

process.permission 是一个对象，其方法用于管理当前进程的权限。权限模型中提供了文档属性

process.permission.has(scope[, reference])

检查进程是否具有文件系统访问权限

可用的范围包括：

fs - 所有文件系统
fs.read - 文件系统读取操作
fs.write - 文件系统写入操作
child - 子进程生成操作
worker - 工作线程生成操作

// 检查进程是否有权限读取README文件
process.permission.has('fs.read', './README.md');

// 判断进程是否有读权限操作
process.permission.has('fs.read');

process.pid

该 process.pid 属性返回进程的 PID。

const { pid } = require('node:process');
console.log(pid)

process.platform

该 process.platform 属性返回一个字符串，该字符串标识为其编译Node.js二进制文件的操作系统平台。

目前可能的值为：

aix
'darwin'
'freebsd'
'linux'
'openbsd'
'sunos'
'win32' 如果Node.js是在 Android 操作系统上构建的，则也可能返回该值 'android' 。但是，Node.js 中的 Android 支持是实验性的

process.ppid

该 process.ppid 属性返回当前进程的父进程的 PID。

const { ppid } = require('node:process');

console.log(`父进程的 pid 是：${ppid}`);

process.release

该 process.release 属性返回与当前版本相关的 Object 包含元数据，包括源 tarball 和仅标头 tarball 的 URL。 process.release 包含以下属性:

name 一个永远是 'node' 的值。
sourceUrl 指向包含当前版本源代码 .tar.gz 的文件的绝对 URL。
headersUrl 指向仅包含当前版本的源头文件 .tar.gz 的文件的绝对 URL。此文件比完整的源文件小得多，可用于编译Node.js本机附加组件
libUrl | 指向与当前版本的体系结构和版本匹配 node.lib 的文件的绝对 URL。此文件用于编译Node.js本机附加组件。此属性仅存在于 Node.js 的 Windows 版本中，在所有其他平台上都将缺失
lts | 标识此版本的 LTS 标签的字符串标签。此属性仅适用于 LTS 版本，并且适用于 undefined 所有其他版本类型，包括当前版本。有效值包括 LTS 版本代码名称（包括不再支持的代码名称）。
- 'Fermium' 对于从 14.15.0 开始的 14.x LTS
- 'Gallium' 对于从 16.13.0 开始的 16.x LTS
- 'Hydrogen' 对于从 18.12.0 开始的 18.x LTS

{
  name: 'node',
  lts: 'Hydrogen',
  sourceUrl: 'https://nodejs.org/download/release/v18.14.0/node-v18.14.0.tar.gz',
  headersUrl: 'https://nodejs.org/download/release/v18.14.0/node-v18.14.0-headers.tar.gz',
  libUrl: 'https://nodejs.org/download/release/v18.14.0/win-x64/node.lib'
}

在源代码树的非发布版本的自定义生成中，可能只存在该 name 属性。不应依赖其他属性的存在。

process.report

process.report 是一个对象，其方法用于生成当前进程的诊断报告

process.report.compact

以紧凑的单行 JSON 格式编写报告，与为人类使用而设计的默认多行格式相比，日志处理系统更容易使用

process.resourceUsage()

返回：当前进程的资源使用情况。所有这些值都来自返回 uv_rusage_t 结构的 uv_getrusage 调用

process.send(message[, sendHandle[, options]][, callback])

message | 要发送的消息
sendHandle | 要发送的句柄
options | 选项
keepOpen 传递的 net.Socket 实例时可以使用的值。当 true 时，套接字在发送过程中保持打开状态。默认值： false 如果使用 IPC 通道生成Node.js，则该 process.send() 方法可用于向父进程发送消息。消息将作为父 ChildProcess 对象上 'message' 的事件接收

如果 Node.js 不是使用 IPC 通道生成的， process.send 则为 undefined。

消息经过序列化和解析。生成的消息可能与最初发送的消息不同

process.setegid(id)

id | 组名称或 ID 该 process.setegid() 方法设置进程的有效组标识

process.stderr

process.stderr 属性返回连接到 stderr (fd 2) 的流。它是一个 net.Socket （这是一个双工流），除非 fd 2 引用一个文件，在这种情况下它是一个可写流。

process.stderr 与其他 Node.js 流有很多重要的不同之处

process.stdin

该 process.stdin 属性返回连接到 stdin （fd 0 ）的流。它是一个 net.Socket （双工流），除非 fd 0 引用一个文件，在这种情况下，它是一个可读流

process.title

该 process.title 属性返回当前进程标题（即返回 ps 的当前值）。分配一个新值以 process.title 修改的 ps 当前值

process.uptime()

返回当前Node.js进程运行的秒数, 返回值包括几分之一秒。用于 Math.floor() 获取整秒

process.version

该 process.version 属性包含Node.js版本字符串。

process.versions

该 process.versions 属性返回一个对象，其中列出了 Node.js 的版本字符串及其依赖项

将生成类似于以下内容的对象：

{
  node: '18.14.0',
  v8: '10.2.154.23-node.22',
  uv: '1.44.2',
  zlib: '1.2.13',
  brotli: '1.0.9',
  ares: '1.18.1',
  modules: '108',
  nghttp2: '1.51.0',
  napi: '8',
  llhttp: '6.0.10',
  uvwasi: '0.0.14',
  acorn: '8.8.1',
  simdutf: '3.1.0',
  undici: '5.14.0',
  openssl: '3.0.7+quic',
  cldr: '42.0',
  icu: '72.1',
  tz: '2022g',
  unicode: '15.0',
  ngtcp2: '0.8.1',
  nghttp3: '0.7.0'
}

Exit codes (退出代码)

当没有更多异步操作挂起时，Node.js通常会退出并显示 0 状态代码。在其他情况下使用以下状态代码：

1 未捕获的致命异常：存在未捕获的异常，并且未由域或“uncaughtException”事件处理程序处理
2：未使用（由 Bash 保留用于内置误用）
3 内部 JavaScript 解析错误：Node.js 引导过程中内部的 JavaScript 源代码导致了解析错误。这种情况极为罕见，通常只会在 Node.js 本身的开发过程中发生。
4 内部 JavaScript 评估失败：Node.js 引导过程中的内部 JavaScript 源代码在评估时无法返回函数值。这种情况极为罕见，通常只能在Node.js本身的发育过程中发生。
5 致命错误：V8 中存在致命且不可恢复的错误。通常，一条带有前缀 FATAL ERROR 的消息将打印到 stderr
6 非函数内部异常处理程序：存在未捕获的异常，但内部致命异常处理程序函数不知何故设置为非函数，无法调用。更多查看 nodejs官网

Process ​

进程事件 ​

beforeExit ​

exit ​

warning ​

worker ​

Signal events（信号事件） ​

process.abort() ​

process.allowedNodeEnvironmentFlags ​

process.arch ​

process.argv ​

process.channel ​

process.chdir(directory) ​

process.config ​

process.connected ​

process.cpuUsage([previousValue]) ​

process.cwd() ​

process.debugPort ​

process.dlopen(module, filename[, flags]) ​

process.emitWarning(warning[, options]) ​

避免重复警告 ​

process.env ​

process.execArgv ​

process.execPath ​

process.exit([code]) ​

process.exitCode ​

process.getegid() ​

process.geteuid() ​

process.getgid() ​

process.getgroups() ​

process.getuid() ​

process.initgroups(user, extraGroup) ​

process.kill(pid[, signal]) ​

process.memoryUsage() ​

process.nextTick(callback[, ...args]) ​

何时使用 queueMicrotask() vs process.nextTick() ​

process.permission ​

process.permission.has(scope[, reference]) ​

process.pid ​

process.platform ​

process.ppid ​

process.release ​

process.report ​

process.report.compact ​

process.resourceUsage() ​

process.send(message[, sendHandle[, options]][, callback]) ​

process.setegid(id) ​

process.stderr ​

process.stdin ​

process.title ​

process.uptime() ​

process.version ​

process.versions ​

Exit codes (退出代码) ​

Process

进程事件

beforeExit

exit

warning

worker

Signal events（信号事件）

process.abort()

process.allowedNodeEnvironmentFlags

process.arch

process.argv

process.channel

process.chdir(directory)

process.config

process.connected

process.cpuUsage([previousValue])

process.cwd()

process.debugPort

process.dlopen(module, filename[, flags])

process.emitWarning(warning[, options])

避免重复警告

process.env

process.execArgv

process.execPath

process.exit([code])

process.exitCode

process.getegid()

process.geteuid()

process.getgid()

process.getgroups()

process.getuid()

process.initgroups(user, extraGroup)

process.kill(pid[, signal])

process.memoryUsage()

process.nextTick(callback[, ...args])

何时使用 queueMicrotask() vs process.nextTick()

process.permission

process.permission.has(scope[, reference])

process.pid

process.platform

process.ppid

process.release

process.report

process.report.compact

process.resourceUsage()

process.send(message[, sendHandle[, options]][, callback])

process.setegid(id)

process.stderr

process.stdin

process.title

process.uptime()

process.version

process.versions

Exit codes (退出代码)