Node.js v25.0.0 文档

进程事件#

process 对象是 EventEmitter 的一个实例。

import process from 'node:process';

process.on('beforeExit', (code) => {
  console.log('Process beforeExit event with code: ', code);
});

process.on('exit', (code) => {
  console.log('Process exit event with code: ', code);
});

console.log('This message is displayed first.');

// Prints:
// This message is displayed first.
// Process beforeExit event with code: 0
// Process exit event with code: 0const process = require('node:process');

process.on('beforeExit', (code) => {
  console.log('Process beforeExit event with code: ', code);
});

process.on('exit', (code) => {
  console.log('Process exit event with code: ', code);
});

console.log('This message is displayed first.');

// Prints:
// This message is displayed first.
// Process beforeExit event with code: 0
// Process exit event with code: 0copy

import process from 'node:process';

process.on('exit', (code) => {
  console.log(`About to exit with code: ${code}`);
});const process = require('node:process');

process.on('exit', (code) => {
  console.log(`About to exit with code: ${code}`);
});copy

import process from 'node:process';

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

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

import process from 'node:process';

const unhandledRejections = new Map();
process.on('unhandledRejection', (reason, promise) => {
  unhandledRejections.set(promise, reason);
});
process.on('rejectionHandled', (promise) => {
  unhandledRejections.delete(promise);
});const process = require('node:process');

const unhandledRejections = new Map();
process.on('unhandledRejection', (reason, promise) => {
  unhandledRejections.set(promise, reason);
});
process.on('rejectionHandled', (promise) => {
  unhandledRejections.delete(promise);
});copy

import process from 'node:process';
import fs from 'node:fs';

process.on('uncaughtException', (err, origin) => {
  fs.writeSync(
    process.stderr.fd,
    `Caught exception: ${err}\n` +
    `Exception origin: ${origin}\n`,
  );
});

setTimeout(() => {
  console.log('This will still run.');
}, 500);

// Intentionally cause an exception, but don't catch it.
nonexistentFunc();
console.log('This will not run.');const process = require('node:process');
const fs = require('node:fs');

process.on('uncaughtException', (err, origin) => {
  fs.writeSync(
    process.stderr.fd,
    `Caught exception: ${err}\n` +
    `Exception origin: ${origin}\n`,
  );
});

setTimeout(() => {
  console.log('This will still run.');
}, 500);

// Intentionally cause an exception, but don't catch it.
nonexistentFunc();
console.log('This will not run.');copy

import process from 'node:process';

process.on('uncaughtExceptionMonitor', (err, origin) => {
  MyMonitoringTool.logSync(err, origin);
});

// Intentionally cause an exception, but don't catch it.
nonexistentFunc();
// Still crashes Node.jsconst process = require('node:process');

process.on('uncaughtExceptionMonitor', (err, origin) => {
  MyMonitoringTool.logSync(err, origin);
});

// Intentionally cause an exception, but don't catch it.
nonexistentFunc();
// Still crashes Node.jscopy

import process from 'node:process';

process.on('unhandledRejection', (reason, promise) => {
  console.log('Unhandled Rejection at:', promise, 'reason:', reason);
  // Application specific logging, throwing an error, or other logic here
});

somePromise.then((res) => {
  return reportToUser(JSON.pasre(res)); // Note the typo (`pasre`)
}); // No `.catch()` or `.then()`const process = require('node:process');

process.on('unhandledRejection', (reason, promise) => {
  console.log('Unhandled Rejection at:', promise, 'reason:', reason);
  // Application specific logging, throwing an error, or other logic here
});

somePromise.then((res) => {
  return reportToUser(JSON.pasre(res)); // Note the typo (`pasre`)
}); // No `.catch()` or `.then()`copy

import process from 'node:process';

function SomeResource() {
  // Initially set the loaded status to a rejected promise
  this.loaded = Promise.reject(new Error('Resource not yet loaded!'));
}

const resource = new SomeResource();
// no .catch or .then on resource.loaded for at least a turnconst process = require('node:process');

function SomeResource() {
  // Initially set the loaded status to a rejected promise
  this.loaded = Promise.reject(new Error('Resource not yet loaded!'));
}

const resource = new SomeResource();
// no .catch or .then on resource.loaded for at least a turncopy

import process from 'node:process';

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

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

$ node
> events.defaultMaxListeners = 1;
> process.on('foo', () => {});
> process.on('foo', () => {});
> (node:38638) MaxListenersExceededWarning: Possible EventEmitter memory leak
detected. 2 foo listeners added. Use emitter.setMaxListeners() to increase limit copy

$ node --no-warnings
> const p = process.on('warning', (warning) => console.warn('Do not do that!'));
> events.defaultMaxListeners = 1;
> process.on('foo', () => {});
> process.on('foo', () => {});
> Do not do that! copy

import process from 'node:process';

// Begin reading from stdin so the process does not exit.
process.stdin.resume();

process.on('SIGINT', () => {
  console.log('Received SIGINT. Press Control-D to exit.');
});

// Using a single function to handle multiple signals
function handle(signal) {
  console.log(`Received ${signal}`);
}

process.on('SIGINT', handle);
process.on('SIGTERM', handle);const process = require('node:process');

// Begin reading from stdin so the process does not exit.
process.stdin.resume();

process.on('SIGINT', () => {
  console.log('Received SIGINT. Press Control-D to exit.');
});

// Using a single function to handle multiple signals
function handle(signal) {
  console.log(`Received ${signal}`);
}

process.on('SIGINT', handle);
process.on('SIGTERM', handle);copy

process.abort()#

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

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

process.allowedNodeEnvironmentFlags#

• 类型：<Set>

process.allowedNodeEnvironmentFlags 属性是一个特殊的、只读的 Set，包含了在 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 时，标志将只出现一次；每个标志都将以一个或多个破折号开头。传递给 V8 的标志将包含下划线而不是非前导的破折号：

import { allowedNodeEnvironmentFlags } from 'node:process';

allowedNodeEnvironmentFlags.forEach((flag) => {
  // -r
  // --inspect-brk
  // --abort_on_uncaught_exception
  // ...
});const { allowedNodeEnvironmentFlags } = require('node:process');

allowedNodeEnvironmentFlags.forEach((flag) => {
  // -r
  // --inspect-brk
  // --abort_on_uncaught_exception
  // ...
});copy

process.allowedNodeEnvironmentFlags 的 add()、clear() 和 delete() 方法什么也不做，并且会静默失败。

如果 Node.js 编译时没有 NODE_OPTIONS 支持（显示在 process.config 中），process.allowedNodeEnvironmentFlags 将包含本应允许的内容。

process.arch#

• 类型：<string>

Node.js 二进制文件编译时所针对的操作系统 CPU 架构。可能的值有：'arm'、'arm64'、'ia32'、'loong64'、'mips'、'mipsel'、'ppc64'、'riscv64'、's390'、's390x' 和 'x64'。

import { arch } from 'node:process';

console.log(`This processor architecture is ${arch}`);const { arch } = require('node:process');

console.log(`This processor architecture is ${arch}`);copy

process.argv#

• 类型：<string[]>

process.argv 属性返回一个数组，其中包含启动 Node.js 进程时传递的命令行参数。第一个元素将是 process.execPath。如果需要访问 argv[0] 的原始值，请参见 process.argv0。第二个元素将是正在执行的 JavaScript 文件的路径。其余元素将是任何额外的命令行参数。

例如，假设有以下脚本 process-args.js：

import { argv } from 'node:process';

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

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

像这样启动 Node.js 进程：

node process-args.js one two=three four copy

将会生成输出：

0: /usr/local/bin/node
1: /Users/mjr/work/node/process-args.js
2: one
3: two=three
4: four copy

process.argv0#

• 类型：<string>

process.argv0 属性存储了 Node.js 启动时传递的 argv[0] 原始值的只读副本。

$ bash -c 'exec -a customArgv0 ./node'
> process.argv[0]
'/Volumes/code/external/node/out/Release/node'
> process.argv0
'customArgv0' copy

process.availableMemory()#

• 类型：<number>

获取进程仍然可用的空闲内存量（以字节为单位）。

更多信息请参阅 uv_get_available_memory。

process.channel#

• 类型：<Object>

如果 Node.js 进程是使用 IPC 通道衍生的（参见子进程文档），process.channel 属性是对 IPC 通道的引用。如果不存在 IPC 通道，此属性为 undefined。

process.chdir(directory)#

• directory <string>

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

import { chdir, cwd } from 'node:process';

console.log(`Starting directory: ${cwd()}`);
try {
  chdir('/tmp');
  console.log(`New directory: ${cwd()}`);
} catch (err) {
  console.error(`chdir: ${err}`);
}const { chdir, cwd } = require('node:process');

console.log(`Starting directory: ${cwd()}`);
try {
  chdir('/tmp');
  console.log(`New directory: ${cwd()}`);
} catch (err) {
  console.error(`chdir: ${err}`);
}copy

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

process.config#

• 类型：<Object>

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

可能的输出示例如下：

{
  target_defaults:
   { cflags: [],
     default_configuration: 'Release',
     defines: [],
     include_dirs: [],
     libraries: [] },
  variables:
   {
     host_arch: 'x64',
     napi_build_version: 5,
     node_install_npm: 'true',
     node_prefix: '',
     node_shared_cares: 'false',
     node_shared_http_parser: 'false',
     node_shared_libuv: 'false',
     node_shared_zlib: 'false',
     node_use_openssl: 'true',
     node_shared_openssl: 'false',
     target_arch: 'x64',
     v8_use_snapshot: 1
   }
} copy

process.connected#

• 类型：<boolean>

如果 Node.js 进程是使用 IPC 通道衍生的（请参阅子进程和集群文档），只要 IPC 通道连接着，process.connected 属性将返回 true，在调用 process.disconnect() 后将返回 false。

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

process.constrainedMemory()#

• 类型：<number>

根据操作系统施加的限制，获取进程可用的内存量（以字节为单位）。如果没有这样的约束，或者约束未知，则返回 0。

更多信息请参阅 uv_get_constrained_memory。

process.cpuUsage([previousValue])#

• previousValue <Object> 上一次调用 process.cpuUsage() 的返回值
• 返回：<Object>
  • user <integer>
  • system <integer>

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

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

import { cpuUsage } from 'node:process';

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

// spin the CPU for 500 milliseconds
const now = Date.now();
while (Date.now() - now < 500);

console.log(cpuUsage(startUsage));
// { user: 514883, system: 11226 }const { cpuUsage } = require('node:process');

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

// spin the CPU for 500 milliseconds
const now = Date.now();
while (Date.now() - now < 500);

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

process.cwd()#

• 返回: <string>

process.cwd() 方法返回 Node.js 进程的当前工作目录。

import { cwd } from 'node:process';

console.log(`Current directory: ${cwd()}`);const { cwd } = require('node:process');

console.log(`Current directory: ${cwd()}`);copy

process.debugPort#

• 类型：<number>

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

import process from 'node:process';

process.debugPort = 5858;const process = require('node:process');

process.debugPort = 5858;copy

process.disconnect()#

如果 Node.js 进程是使用 IPC 通道衍生的（请参阅子进程和集群文档），process.disconnect() 方法将关闭到父进程的 IPC 通道，从而允许子进程在没有其他连接使其保持活动状态时优雅地退出。

调用 process.disconnect() 的效果与从父进程调用 ChildProcess.disconnect() 相同。

如果 Node.js 进程不是使用 IPC 通道衍生的，process.disconnect() 将是 undefined。

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

• module <Object>
• filename <string>
• flags <os.constants.dlopen> 默认： os.constants.dlopen.RTLD_LAZY

process.dlopen() 方法允许动态加载共享对象。它主要由 require() 用于加载 C++ 插件，并且除非在特殊情况下，否则不应直接使用。换句话说，除非有特定原因，例如自定义 dlopen 标志或从 ES 模块加载，否则应首选 require() 而不是 process.dlopen()。

flags 参数是一个整数，允许指定 dlopen 的行为。有关详细信息，请参阅 os.constants.dlopen 文档。

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

下面的示例展示了如何加载一个名为 local.node 的 C++ 插件，该插件导出一个 foo 函数。通过传递 RTLD_NOW 常量，所有符号在调用返回之前被加载。在这个例子中，假设该常量是可用的。

import { dlopen } from 'node:process';
import { constants } from 'node:os';
import { fileURLToPath } from 'node:url';

const module = { exports: {} };
dlopen(module, fileURLToPath(new URL('local.node', import.meta.url)),
       constants.dlopen.RTLD_NOW);
module.exports.foo();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();copy

process.emitWarning(warning[, options])#

• warning <string> | <Error> 要发出的警告。
• options <Object>
  • type <string> 当 warning 是 String 时，type 是用于发出的警告类型的名称。默认： 'Warning'。
  • code <string> 正在发出的警告实例的唯一标识符。
  • ctor <Function> 当 warning 是 String 时，ctor 是一个可选函数，用于限制生成的堆栈跟踪。默认： process.emitWarning。
  • detail <string> 与错误一起包含的附加文本。

process.emitWarning() 方法可用于发出自定义或特定于应用程序的进程警告。可以通过向 'warning' 事件添加处理程序来监听这些警告。

import { emitWarning } from 'node:process';

// Emit a warning with a code and additional detail.
emitWarning('Something happened!', {
  code: 'MY_WARNING',
  detail: 'This is some additional information',
});
// Emits:
// (node:56338) [MY_WARNING] Warning: Something happened!
// This is some additional informationconst { emitWarning } = require('node:process');

// Emit a warning with a code and additional detail.
emitWarning('Something happened!', {
  code: 'MY_WARNING',
  detail: 'This is some additional information',
});
// Emits:
// (node:56338) [MY_WARNING] Warning: Something happened!
// This is some additional informationcopy

在这个例子中，process.emitWarning() 内部生成一个 Error 对象，并将其传递给 'warning' 处理程序。

import process from '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'
});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'
});copy

如果 warning 作为 Error 对象传递，options 参数将被忽略。

process.emitWarning(warning[, type[, code]][, ctor])#

• warning <string> | <Error> 要发出的警告。
• type <string> 当 warning 是 String 时，type 是用于发出的警告类型的名称。默认： 'Warning'。
• code <string> 正在发出的警告实例的唯一标识符。
• ctor <Function> 当 warning 是 String 时，ctor 是一个可选函数，用于限制生成的堆栈跟踪。默认： process.emitWarning。

process.emitWarning() 方法可用于发出自定义或特定于应用程序的进程警告。可以通过向 'warning' 事件添加处理程序来监听这些警告。

import { emitWarning } from 'node:process';

// Emit a warning using a string.
emitWarning('Something happened!');
// Emits: (node: 56338) Warning: Something happened!const { emitWarning } = require('node:process');

// Emit a warning using a string.
emitWarning('Something happened!');
// Emits: (node: 56338) Warning: Something happened!copy

import { emitWarning } from 'node:process';

// Emit a warning using a string and a type.
emitWarning('Something Happened!', 'CustomWarning');
// Emits: (node:56338) CustomWarning: Something Happened!const { emitWarning } = require('node:process');

// Emit a warning using a string and a type.
emitWarning('Something Happened!', 'CustomWarning');
// Emits: (node:56338) CustomWarning: Something Happened!copy

import { emitWarning } from 'node:process';

emitWarning('Something happened!', 'CustomWarning', 'WARN001');
// Emits: (node:56338) [WARN001] CustomWarning: Something happened!const { emitWarning } = require('node:process');

process.emitWarning('Something happened!', 'CustomWarning', 'WARN001');
// Emits: (node:56338) [WARN001] CustomWarning: Something happened!copy

在前面的每个例子中，process.emitWarning() 内部都会生成一个 Error 对象，并将其传递给 'warning' 处理程序。

import process from 'node:process';

process.on('warning', (warning) => {
  console.warn(warning.name);
  console.warn(warning.message);
  console.warn(warning.code);
  console.warn(warning.stack);
});const process = require('node:process');

process.on('warning', (warning) => {
  console.warn(warning.name);
  console.warn(warning.message);
  console.warn(warning.code);
  console.warn(warning.stack);
});copy

如果 warning 是作为 Error 对象传递的，它将被原封不动地传递给 'warning' 事件处理程序（并且可选的 type、code 和 ctor 参数将被忽略）：

import { emitWarning } from 'node:process';

// Emit a warning using an Error object.
const myWarning = new Error('Something happened!');
// Use the Error name property to specify the type name
myWarning.name = 'CustomWarning';
myWarning.code = 'WARN001';

emitWarning(myWarning);
// Emits: (node:56338) [WARN001] CustomWarning: Something happened!const { emitWarning } = require('node:process');

// Emit a warning using an Error object.
const myWarning = new Error('Something happened!');
// Use the Error name property to specify the type name
myWarning.name = 'CustomWarning';
myWarning.code = 'WARN001';

emitWarning(myWarning);
// Emits: (node:56338) [WARN001] CustomWarning: Something happened!copy

如果 warning 是除了字符串或 Error 对象之外的任何东西，则会抛出 TypeError。

虽然进程警告使用 Error 对象，但进程警告机制并不是正常错误处理机制的替代品。

如果警告 type 是 'DeprecationWarning'，则会实现以下附加处理：

• 如果使用了 --throw-deprecation 命令行标志，弃用警告将被作为异常抛出，而不是作为事件发出。
• 如果使用了 --no-deprecation 命令行标志，弃用警告将被抑制。
• 如果使用了 --trace-deprecation 命令行标志，弃用警告将与完整的堆栈跟踪一起打印到 stderr。

import { emitWarning } from 'node:process';

function emitMyWarning() {
  if (!emitMyWarning.warned) {
    emitMyWarning.warned = true;
    emitWarning('Only warn once!');
  }
}
emitMyWarning();
// Emits: (node: 56339) Warning: Only warn once!
emitMyWarning();
// Emits nothingconst { emitWarning } = require('node:process');

function emitMyWarning() {
  if (!emitMyWarning.warned) {
    emitMyWarning.warned = true;
    emitWarning('Only warn once!');
  }
}
emitMyWarning();
// Emits: (node: 56339) Warning: Only warn once!
emitMyWarning();
// Emits nothingcopy

process.env#

• 类型：<Object>

process.env 属性返回一个包含用户环境的对象。参见 environ(7)。

该对象的一个示例如下：

{
  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'
} copy

可以修改这个对象，但这些修改不会反映到 Node.js 进程之外，或者（除非明确请求）反映到其他 Worker 线程。换句话说，以下示例将不起作用：

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

而以下示例则可以：

import { env } from 'node:process';

env.foo = 'bar';
console.log(env.foo);const { env } = require('node:process');

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

在 process.env 上分配属性将隐式地将值转换为字符串。此行为已被弃用。未来版本的 Node.js 在值不是字符串、数字或布尔值时可能会抛出错误。

import { env } from 'node:process';

env.test = null;
console.log(env.test);
// => 'null'
env.test = undefined;
console.log(env.test);
// => 'undefined'const { env } = require('node:process');

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

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

import { env } from 'node:process';

env.TEST = 1;
delete env.TEST;
console.log(env.TEST);
// => undefinedconst { env } = require('node:process');

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

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

import { env } from 'node:process';

env.TEST = 1;
console.log(env.test);
// => 1const { env } = require('node:process');

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

除非在创建 Worker 实例时明确指定，否则每个 Worker 线程都有其自己的 process.env 副本，该副本基于其父线程的 process.env，或者基于为 Worker 构造函数指定的 env 选项。对 process.env 的更改在 Worker 线程之间不可见，只有主线程可以进行对操作系统或原生插件可见的更改。在 Windows 上，Worker 实例上的 process.env 副本以区分大小写的方式操作，这与主线程不同。

process.execArgv#

• 类型：<string[]>

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

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

process.execArgv 的结果：

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

以及 process.argv 的结果：

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

有关此属性在工作线程中的详细行为，请参阅 Worker 构造函数。

process.execPath#

• 类型：<string>

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

'/usr/local/bin/node' copy

process.execve(file[, args[, env]])#

• file <string> 要运行的可执行文件的名称或路径。
• args <string[]> 字符串参数列表。任何参数都不能包含空字节（\u0000）。
• env <Object> 环境变量键值对。任何键或值都不能包含空字节（\u0000）。默认： process.env。

用新进程替换当前进程。

这是通过使用 execve POSIX 函数实现的，因此除了标准输入、标准输出和标准错误文件描述符外，当前进程的内存或其他资源都不会被保留。

所有其他资源在进程交换时都会被系统丢弃，不会触发任何退出或关闭事件，也不会运行任何清理处理程序。

除非发生错误，否则此函数永远不会返回。

此函数在 Windows 或 IBM i 上不可用。

process.exit([code])#

• code <integer> | <string> | <null> | <undefined> 退出码。对于字符串类型，只允许整数字符串（例如，'1'）。默认： 0。

process.exit() 方法指示 Node.js 以 code 的退出状态同步终止进程。如果省略 code，则退出使用“成功”代码 0 或 process.exitCode 的值（如果已设置）。Node.js 在所有 'exit' 事件监听器被调用之前不会终止。

以“失败”代码退出：

import { exit } from 'node:process';

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

exit(1);copy

执行 Node.js 的 shell 应该看到退出码为 1。

调用 process.exit() 将强制进程尽快退出，即使仍有尚未完全完成的异步操作在等待，包括对 process.stdout 和 process.stderr 的 I/O 操作。

在大多数情况下，实际上没有必要显式调用 process.exit()。如果事件循环中没有额外的待处理工作，Node.js 进程将自行退出。可以设置 process.exitCode 属性来告诉进程在正常退出时使用哪个退出码。

例如，下面的例子说明了对 process.exit() 方法的误用，这可能导致打印到 stdout 的数据被截断和丢失：

import { exit } from 'node:process';

// This is an example of what *not* to do:
if (someConditionNotMet()) {
  printUsageToStdout();
  exit(1);
}const { exit } = require('node:process');

// This is an example of what *not* to do:
if (someConditionNotMet()) {
  printUsageToStdout();
  exit(1);
}copy

这个问题的原因在于，在 Node.js 中对 process.stdout 的写入有时是异步的，并且可能在 Node.js 事件循环的多个轮次中发生。然而，调用 process.exit() 会强制进程在这些额外的 stdout 写入操作执行之前退出。

与其直接调用 process.exit()，代码应该设置 process.exitCode 并允许进程自然退出，方法是避免为事件循环调度任何额外的工作：

import process from 'node:process';

// How to properly set the exit code while letting
// the process exit gracefully.
if (someConditionNotMet()) {
  printUsageToStdout();
  process.exitCode = 1;
}const process = require('node:process');

// How to properly set the exit code while letting
// the process exit gracefully.
if (someConditionNotMet()) {
  printUsageToStdout();
  process.exitCode = 1;
}copy

如果由于错误条件需要终止 Node.js 进程，抛出一个未捕获的错误并允许进程相应地终止，比调用 process.exit() 更安全。

在 Worker 线程中，此函数会停止当前线程而不是当前进程。

process.exitCode#

• 类型：<integer> | <string> | <null> | <undefined> 退出码。对于字符串类型，只允许整数字符串（例如，'1'）。默认： undefined。

当进程正常退出，或者通过 process.exit() 退出而未指定代码时，将作为进程退出码的数字。

process.exitCode 的值可以通过给 process.exitCode 赋值或通过向 process.exit() 传递参数来更新：

$ node -e 'process.exitCode = 9'; echo $?
9
$ node -e 'process.exit(42)'; echo $?
42
$ node -e 'process.exitCode = 9; process.exit(42)'; echo $?
42 copy

当发生不可恢复的错误时（例如遇到未解决的顶层 await），Node.js 也会隐式设置该值。然而，对退出码的显式操作总是优先于隐式操作：

$ node --input-type=module -e 'await new Promise(() => {})'; echo $?
13
$ node --input-type=module -e 'process.exitCode = 9; await new Promise(() => {})'; echo $?
9 copy

process.features.cached_builtins#

• 类型：<boolean>

一个布尔值，如果当前的 Node.js 构建正在缓存内置模块，则为 true。

process.features.debug#

• 类型：<boolean>

一个布尔值，如果当前的 Node.js 构建是调试构建，则为 true。

process.features.inspector#

• 类型：<boolean>

一个布尔值，如果当前的 Node.js 构建包含检查器，则为 true。

process.features.ipv6#

• 类型：<boolean>

一个布尔值，如果当前的 Node.js 构建包含对 IPv6 的支持，则为 true。

由于所有 Node.js 构建都支持 IPv6，因此该值始终为 true。

process.features.require_module#

• 类型：<boolean>

一个布尔值，如果当前的 Node.js 构建支持使用 require() 加载 ECMAScript 模块，则为 true。

process.features.tls#

• 类型：<boolean>

一个布尔值，如果当前的 Node.js 构建包含对 TLS 的支持，则为 true。

process.features.tls_alpn#

• 类型：<boolean>

一个布尔值，如果当前的 Node.js 构建包含对 TLS 中 ALPN 的支持，则为 true。

在 Node.js 11.0.0 及更高版本中，OpenSSL 依赖项具有无条件的 ALPN 支持。因此，该值与 process.features.tls 的值相同。

process.features.tls_ocsp#

• 类型：<boolean>

一个布尔值，如果当前的 Node.js 构建包含对 TLS 中 OCSP 的支持，则为 true。

在 Node.js 11.0.0 及更高版本中，OpenSSL 依赖项具有无条件的 OCSP 支持。因此，该值与 process.features.tls 的值相同。

process.features.tls_sni#

• 类型：<boolean>

一个布尔值，如果当前的 Node.js 构建包含对 TLS 中 SNI 的支持，则为 true。

在 Node.js 11.0.0 及更高版本中，OpenSSL 依赖项具有无条件的 SNI 支持。因此，该值与 process.features.tls 的值相同。

process.features.typescript#

• 类型：<boolean> | <string>

一个值，默认情况下为 "strip"，如果 Node.js 使用 --experimental-transform-types 运行，则为 "transform"，如果 Node.js 使用 --no-experimental-strip-types 运行，则为 false。

process.features.uv#

• 类型：<boolean>

一个布尔值，如果当前的 Node.js 构建包含对 libuv 的支持，则为 true。

由于不可能在没有 libuv 的情况下构建 Node.js，因此该值始终为 true。

process.finalization.register(ref, callback)#

• ref <Object> | <Function> 正在被跟踪的资源的引用。
• callback <Function> 当资源被终结时要调用的回调函数。
  • ref <Object> | <Function> 正在被跟踪的资源的引用。
  • event <string> 触发终结的事件。默认为 'exit'。

此函数注册一个回调，如果 ref 对象未被垃圾回收，当进程发出 exit 事件时将被调用。如果 ref 对象在发出 exit 事件之前被垃圾回收，回调将从终结注册表中移除，并且在进程退出时不会被调用。

在回调函数内部，您可以释放由 ref 对象分配的资源。请注意，应用于 beforeExit 事件的所有限制也适用于 callback 函数，这意味着在特殊情况下，回调可能不会被调用。

这个函数的想法是帮助您在进程开始退出时释放资源，但如果对象不再被使用，也让其被垃圾回收。

例如：您可以注册一个包含缓冲区的对象，您想确保在进程退出时该缓冲区被释放，但如果该对象在进程退出前被垃圾回收，我们就不再需要释放该缓冲区了，所以在这种情况下，我们只需从终结注册表中移除回调即可。

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

// Please make sure that the function passed to finalization.register()
// does not create a closure around unnecessary objects.
function onFinalize(obj, event) {
  // You can do whatever you want with the object
  obj.dispose();
}

function setup() {
  // This object can be safely garbage collected,
  // and the resulting shutdown function will not be called.
  // There are no leaks.
  const myDisposableObject = {
    dispose() {
      // Free your resources synchronously
    },
  };

  finalization.register(myDisposableObject, onFinalize);
}

setup();import { finalization } from 'node:process';

// Please make sure that the function passed to finalization.register()
// does not create a closure around unnecessary objects.
function onFinalize(obj, event) {
  // You can do whatever you want with the object
  obj.dispose();
}

function setup() {
  // This object can be safely garbage collected,
  // and the resulting shutdown function will not be called.
  // There are no leaks.
  const myDisposableObject = {
    dispose() {
      // Free your resources synchronously
    },
  };

  finalization.register(myDisposableObject, onFinalize);
}

setup();copy

上面的代码依赖于以下假设：

• 避免使用箭头函数
• 建议常规函数在全局上下文（根）内

常规函数可能引用 obj 所在的上下文，导致 obj 无法被垃圾回收。

箭头函数将持有先前的上下文。例如，考虑：

class Test {
  constructor() {
    finalization.register(this, (ref) => ref.dispose());

    // Even something like this is highly discouraged
    // finalization.register(this, () => this.dispose());
  }
  dispose() {}
} copy

这个对象被垃圾回收的可能性很小（但不是不可能），但如果它没有被垃圾回收，dispose 将在调用 process.exit 时被调用。

请小心，避免依赖此功能来处理关键资源的释放，因为不保证在所有情况下都会调用回调。

process.finalization.registerBeforeExit(ref, callback)#

• ref <Object> | <Function> 正在被跟踪的资源的引用。
• callback <Function> 当资源被终结时要调用的回调函数。
  • ref <Object> | <Function> 正在被跟踪的资源的引用。
  • event <string> 触发终结的事件。默认为 'beforeExit'。

此函数的行为与 register 完全相同，只是如果 ref 对象未被垃圾回收，当进程发出 beforeExit 事件时，回调将被调用。

请注意，应用于 beforeExit 事件的所有限制也适用于 callback 函数，这意味着在特殊情况下，回调可能不会被调用。

process.finalization.unregister(ref)#

• ref <Object> | <Function> 之前注册的资源的引用。

此函数从终结注册表中移除对象的注册，因此回调将不再被调用。

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

// Please make sure that the function passed to finalization.register()
// does not create a closure around unnecessary objects.
function onFinalize(obj, event) {
  // You can do whatever you want with the object
  obj.dispose();
}

function setup() {
  // This object can be safely garbage collected,
  // and the resulting shutdown function will not be called.
  // There are no leaks.
  const myDisposableObject = {
    dispose() {
      // Free your resources synchronously
    },
  };

  finalization.register(myDisposableObject, onFinalize);

  // Do something

  myDisposableObject.dispose();
  finalization.unregister(myDisposableObject);
}

setup();import { finalization } from 'node:process';

// Please make sure that the function passed to finalization.register()
// does not create a closure around unnecessary objects.
function onFinalize(obj, event) {
  // You can do whatever you want with the object
  obj.dispose();
}

function setup() {
  // This object can be safely garbage collected,
  // and the resulting shutdown function will not be called.
  // There are no leaks.
  const myDisposableObject = {
    dispose() {
      // Free your resources synchronously
    },
  };

  // Please make sure that the function passed to finalization.register()
  // does not create a closure around unnecessary objects.
  function onFinalize(obj, event) {
    // You can do whatever you want with the object
    obj.dispose();
  }

  finalization.register(myDisposableObject, onFinalize);

  // Do something

  myDisposableObject.dispose();
  finalization.unregister(myDisposableObject);
}

setup();copy

process.getActiveResourcesInfo()#

• 返回：<string[]>

process.getActiveResourcesInfo() 方法返回一个字符串数组，其中包含当前使事件循环保持活动的活动资源的类型。

import { getActiveResourcesInfo } from 'node:process';
import { setTimeout } from 'node:timers';

console.log('Before:', getActiveResourcesInfo());
setTimeout(() => {}, 1000);
console.log('After:', getActiveResourcesInfo());
// Prints:
//   Before: [ 'CloseReq', 'TTYWrap', 'TTYWrap', 'TTYWrap' ]
//   After: [ 'CloseReq', 'TTYWrap', 'TTYWrap', 'TTYWrap', 'Timeout' ]const { getActiveResourcesInfo } = require('node:process');
const { setTimeout } = require('node:timers');

console.log('Before:', getActiveResourcesInfo());
setTimeout(() => {}, 1000);
console.log('After:', getActiveResourcesInfo());
// Prints:
//   Before: [ 'TTYWrap', 'TTYWrap', 'TTYWrap' ]
//   After: [ 'TTYWrap', 'TTYWrap', 'TTYWrap', 'Timeout' ]copy

process.getBuiltinModule(id)#

• id <string> 请求的内置模块的 ID。
• 返回：<Object> | <undefined>

process.getBuiltinModule(id) 提供了一种在全局可用函数中加载内置模块的方法。需要支持其他环境的 ES 模块可以使用它在 Node.js 中运行时有条件地加载 Node.js 内置模块，而无需处理在非 Node.js 环境中 import 可能抛出的解析错误，也无需使用动态 import()，后者要么将模块变成异步模块，要么将同步 API 变成异步 API。

if (globalThis.process?.getBuiltinModule) {
  // Run in Node.js, use the Node.js fs module.
  const fs = globalThis.process.getBuiltinModule('fs');
  // If `require()` is needed to load user-modules, use createRequire()
  const module = globalThis.process.getBuiltinModule('module');
  const require = module.createRequire(import.meta.url);
  const foo = require('foo');
} copy

如果 id 指定了当前 Node.js 进程中可用的内置模块，process.getBuiltinModule(id) 方法将返回相应的内置模块。如果 id 不对应任何内置模块，则返回 undefined。

process.getBuiltinModule(id) 接受 module.isBuiltin(id) 识别的内置模块 ID。一些内置模块必须使用 node: 前缀加载，请参阅具有强制性 node: 前缀的内置模块。即使使用者修改了 require.cache 使得 require(id) 返回其他内容，process.getBuiltinModule(id) 返回的引用也总是指向与 id 对应的内置模块。

process.getegid()#

process.getegid() 方法返回 Node.js 进程的数字有效组标识。(参见 getegid(2).)

import process from 'node:process';

if (process.getegid) {
  console.log(`Current gid: ${process.getegid()}`);
}const process = require('node:process');

if (process.getegid) {
  console.log(`Current gid: ${process.getegid()}`);
}copy

此功能仅在 POSIX 平台（即非 Windows 或 Android）上可用。

process.geteuid()#

• 返回：<Object>

process.geteuid() 方法返回进程的数字有效用户身份。(参见 geteuid(2).)

import process from 'node:process';

if (process.geteuid) {
  console.log(`Current uid: ${process.geteuid()}`);
}const process = require('node:process');

if (process.geteuid) {
  console.log(`Current uid: ${process.geteuid()}`);
}copy

此功能仅在 POSIX 平台（即非 Windows 或 Android）上可用。

process.getgid()#

• 返回：<Object>

process.getgid() 方法返回进程的数字组标识。(参见 getgid(2).)

import process from 'node:process';

if (process.getgid) {
  console.log(`Current gid: ${process.getgid()}`);
}const process = require('node:process');

if (process.getgid) {
  console.log(`Current gid: ${process.getgid()}`);
}copy

此功能仅在 POSIX 平台（即非 Windows 或 Android）上可用。

process.getgroups()#

• 返回：<integer[]>

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

import process from 'node:process';

if (process.getgroups) {
  console.log(process.getgroups()); // [ 16, 21, 297 ]
}const process = require('node:process');

if (process.getgroups) {
  console.log(process.getgroups()); // [ 16, 21, 297 ]
}copy

此功能仅在 POSIX 平台（即非 Windows 或 Android）上可用。

process.getuid()#

• 返回：<integer>

process.getuid() 方法返回进程的数字用户身份。(参见 getuid(2).)

import process from 'node:process';

if (process.getuid) {
  console.log(`Current uid: ${process.getuid()}`);
}const process = require('node:process');

if (process.getuid) {
  console.log(`Current uid: ${process.getuid()}`);
}copy

此功能在 Windows 上不可用。

process.hasUncaughtExceptionCaptureCallback()#

• 返回：<boolean>

指示是否已使用 process.setUncaughtExceptionCaptureCallback() 设置了回调。

process.hrtime([time])#

• time <integer[]> 上一次调用 process.hrtime() 的结果
• 返回：<integer[]>

这是在 JavaScript 中引入 bigint 之前 process.hrtime.bigint() 的旧版。

process.hrtime() 方法以 [秒, 纳秒] 元组 Array 的形式返回当前的高精度实时时间，其中 nanoseconds 是无法以秒精度表示的实时时间的剩余部分。

time 是一个可选参数，必须是上一次 process.hrtime() 调用的结果，用于与当前时间进行比较。如果传入的参数不是一个元组 Array，将会抛出 TypeError。传入用户定义的数组而不是上一次 process.hrtime() 调用的结果，将导致未定义的行为。

这些时间是相对于过去的某个任意时间点，与一天中的时间无关，因此不受时钟漂移的影响。其主要用途是测量时间间隔之间的性能。

import { hrtime } from 'node:process';

const NS_PER_SEC = 1e9;
const time = hrtime();
// [ 1800216, 25 ]

setTimeout(() => {
  const diff = hrtime(time);
  // [ 1, 552 ]

  console.log(`Benchmark took ${diff[0] * NS_PER_SEC + diff[1]} nanoseconds`);
  // Benchmark took 1000000552 nanoseconds
}, 1000);const { hrtime } = require('node:process');

const NS_PER_SEC = 1e9;
const time = hrtime();
// [ 1800216, 25 ]

setTimeout(() => {
  const diff = hrtime(time);
  // [ 1, 552 ]

  console.log(`Benchmark took ${diff[0] * NS_PER_SEC + diff[1]} nanoseconds`);
  // Benchmark took 1000000552 nanoseconds
}, 1000);copy

process.hrtime.bigint()#

• 返回：<bigint>

process.hrtime() 方法的 bigint 版本，以 bigint 形式返回当前的高精度实时时间（单位为纳秒）。

与 process.hrtime() 不同，它不支持额外的 time 参数，因为可以直接通过两个 bigint 相减来计算差值。

import { hrtime } from 'node:process';

const start = hrtime.bigint();
// 191051479007711n

setTimeout(() => {
  const end = hrtime.bigint();
  // 191052633396993n

  console.log(`Benchmark took ${end - start} nanoseconds`);
  // Benchmark took 1154389282 nanoseconds
}, 1000);const { hrtime } = require('node:process');

const start = hrtime.bigint();
// 191051479007711n

setTimeout(() => {
  const end = hrtime.bigint();
  // 191052633396993n

  console.log(`Benchmark took ${end - start} nanoseconds`);
  // Benchmark took 1154389282 nanoseconds
}, 1000);copy

process.initgroups(user, extraGroup)#

• user <string> | <number> 用户名或数字标识符。
• extraGroup <string> | <number> 组名或数字标识符。

process.initgroups() 方法读取 /etc/group 文件并初始化组访问列表，使用该用户所属的所有组。这是一个特权操作，要求 Node.js 进程具有 root 访问权限或 CAP_SETGID 能力。

在放弃权限时要小心。

import { getgroups, initgroups, setgid } from '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 ]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 ]copy

此函数仅在 POSIX 平台（即非 Windows 或 Android）上可用。此功能在 Worker 线程中不可用。

process.kill(pid[, signal])#

• pid <number> 进程 ID
• signal <string> | <number> 要发送的信号，可以是字符串或数字。默认值： 'SIGTERM'。

process.kill() 方法将 signal 发送给由 pid 标识的进程。

信号名称是诸如 'SIGINT' 或 'SIGHUP' 之类的字符串。有关更多信息，请参见信号事件和 kill(2)。

如果目标 pid 不存在，此方法将抛出错误。作为特例，信号 0 可用于测试进程是否存在。在 Windows 平台上，如果使用 pid 来终止一个进程组，将会抛出错误。

尽管此函数的名称是 process.kill()，但它实际上只是一个信号发送器，就像 kill 系统调用一样。发送的信号可能执行的操作不只是终止目标进程。

import process, { kill } from 'node:process';

process.on('SIGHUP', () => {
  console.log('Got SIGHUP signal.');
});

setTimeout(() => {
  console.log('Exiting.');
  process.exit(0);
}, 100);

kill(process.pid, 'SIGHUP');const process = require('node:process');

process.on('SIGHUP', () => {
  console.log('Got SIGHUP signal.');
});

setTimeout(() => {
  console.log('Exiting.');
  process.exit(0);
}, 100);

process.kill(process.pid, 'SIGHUP');copy

当 Node.js 进程接收到 SIGUSR1 时，Node.js 将启动调试器。请参见信号事件。

process.loadEnvFile(path)#

• path <string> | <URL> | <Buffer> | <undefined>。默认值： './.env'

将 .env 文件加载到 process.env 中。在 .env 文件中使用 NODE_OPTIONS 对 Node.js 不会产生任何影响。

const { loadEnvFile } = require('node:process');
loadEnvFile();import { loadEnvFile } from 'node:process';
loadEnvFile();copy

process.mainModule#

• 类型：<Object>

process.mainModule 属性提供了另一种检索 require.main 的方法。区别在于，如果主模块在运行时发生变化，require.main 在那些变化发生前被引入的模块中，可能仍然指向原始的主模块。通常可以安全地假设两者指向同一个模块。

与 require.main 一样，如果没有入口脚本，process.mainModule 将为 undefined。

process.memoryUsage()#

• 返回：<Object>
  • rss <integer>
  • heapTotal <integer>
  • heapUsed <integer>
  • external <integer>
  • arrayBuffers <integer>

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

import { memoryUsage } from 'node:process';

console.log(memoryUsage());
// Prints:
// {
//  rss: 4935680,
//  heapTotal: 1826816,
//  heapUsed: 650472,
//  external: 49879,
//  arrayBuffers: 9386
// }const { memoryUsage } = require('node:process');

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

• heapTotal 和 heapUsed 指的是 V8 的内存使用情况。
• external 指的是绑定到由 V8 管理的 JavaScript 对象的 C++ 对象的内存使用情况。
• rss，即驻留集大小（Resident Set Size），是进程在主内存设备中占用的空间量（是总分配内存的子集），包括所有 C++ 和 JavaScript 对象及代码。
• arrayBuffers 指的是为 ArrayBuffer 和 SharedArrayBuffer 分配的内存，包括所有的 Node.js Buffer。这部分也包含在 external 值中。当 Node.js 作为嵌入式库使用时，此值可能为 0，因为在这种情况下可能不会跟踪 ArrayBuffer 的分配。

当使用 Worker 线程时，rss 将是适用于整个进程的值，而其他字段仅指当前线程。

process.memoryUsage() 方法会遍历每个页面以收集有关内存使用的信息，这可能会根据程序的内存分配情况而变慢。

process.memoryUsage.rss()#

• 返回：<integer>

process.memoryUsage.rss() 方法返回一个表示驻留集大小（RSS）的整数，单位为字节。

驻留集大小是进程在主内存设备中占用的空间量（是总分配内存的子集），包括所有 C++ 和 JavaScript 对象及代码。

这与 process.memoryUsage() 提供的 rss 属性的值相同，但 process.memoryUsage.rss() 更快。

import { memoryUsage } from 'node:process';

console.log(memoryUsage.rss());
// 35655680const { memoryUsage } = require('node:process');

console.log(memoryUsage.rss());
// 35655680copy

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

• callback <Function>
• ...args <any> 调用 callback 时传递的额外参数。

process.nextTick() 将 callback 添加到“next tick 队列”。此队列在 JavaScript 栈上的当前操作运行完成后、事件循环被允许继续之前完全清空。如果递归调用 process.nextTick()，可能会创建一个无限循环。有关更多背景信息，请参见事件循环指南。

import { nextTick } from 'node:process';

console.log('start');
nextTick(() => {
  console.log('nextTick callback');
});
console.log('scheduled');
// Output:
// start
// scheduled
// nextTick callbackconst { nextTick } = require('node:process');

console.log('start');
nextTick(() => {
  console.log('nextTick callback');
});
console.log('scheduled');
// Output:
// start
// scheduled
// nextTick callbackcopy

这在开发 API 时非常重要，以便在对象被构造之后、任何 I/O 发生之前，给用户机会分配事件处理程序。

import { nextTick } from 'node:process';

function MyThing(options) {
  this.setupOptions(options);

  nextTick(() => {
    this.startDoingStuff();
  });
}

const thing = new MyThing();
thing.getReadyForStuff();

// thing.startDoingStuff() gets called now, not before.const { nextTick } = require('node:process');

function MyThing(options) {
  this.setupOptions(options);

  nextTick(() => {
    this.startDoingStuff();
  });
}

const thing = new MyThing();
thing.getReadyForStuff();

// thing.startDoingStuff() gets called now, not before.copy

对于 API 来说，要么 100% 同步，要么 100% 异步，这是非常重要的。考虑这个例子：

// WARNING!  DO NOT USE!  BAD UNSAFE HAZARD!
function maybeSync(arg, cb) {
  if (arg) {
    cb();
    return;
  }

  fs.stat('file', cb);
} copy

这个 API 是危险的，因为在以下情况下：

const maybeTrue = Math.random() > 0.5;

maybeSync(maybeTrue, () => {
  foo();
});

bar(); copy

不清楚是 foo() 还是 bar() 会先被调用。

以下方法要好得多：

import { nextTick } from 'node:process';

function definitelyAsync(arg, cb) {
  if (arg) {
    nextTick(cb);
    return;
  }

  fs.stat('file', cb);
}const { nextTick } = require('node:process');

function definitelyAsync(arg, cb) {
  if (arg) {
    nextTick(cb);
    return;
  }

  fs.stat('file', cb);
}copy

import { nextTick } from 'node:process';

Promise.resolve().then(() => console.log('resolve'));
queueMicrotask(() => console.log('microtask'));
nextTick(() => console.log('nextTick'));
// Output:
// resolve
// microtask
// nextTickconst { nextTick } = require('node:process');

Promise.resolve().then(() => console.log('resolve'));
queueMicrotask(() => console.log('microtask'));
nextTick(() => console.log('nextTick'));
// Output:
// nextTick
// resolve
// microtaskcopy

console.log('start');
queueMicrotask(() => {
  console.log('microtask callback');
});
console.log('scheduled');
// Output:
// start
// scheduled
// microtask callback copy

function deferred(a, b) {
  console.log('microtask', a + b);
}

console.log('start');
queueMicrotask(deferred.bind(undefined, 1, 2));
console.log('scheduled');
// Output:
// start
// scheduled
// microtask 3 copy

process.noDeprecation#

• 类型：<boolean>

process.noDeprecation 属性指示当前 Node.js 进程是否设置了 --no-deprecation 标志。有关此标志行为的更多信息，请参阅 'warning' 事件和 emitWarning() 方法的文档。

process.permission#

• 类型：<Object>

此 API 可通过 --permission 标志使用。

process.permission 是一个对象，其方法用于管理当前进程的权限。更多文档可在权限模型中找到。

// Check if the process has permission to read the README file
process.permission.has('fs.read', './README.md');
// Check if the process has read permission operations
process.permission.has('fs.read'); copy

process.pid#

• 类型：<integer>

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

import { pid } from 'node:process';

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

console.log(`This process is pid ${pid}`);copy

process.platform#

• 类型：<string>

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

当前可能的值有：

• 'aix'
• 'darwin'
• 'freebsd'
• 'linux'
• 'openbsd'
• 'sunos'
• 'win32'

import { platform } from 'node:process';

console.log(`This platform is ${platform}`);const { platform } = require('node:process');

console.log(`This platform is ${platform}`);copy

如果 Node.js 是在 Android 操作系统上构建的，也可能返回值 'android'。然而，Node.js 对 Android 的支持是实验性的。

process.ppid#

• 类型：<integer>

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

import { ppid } from 'node:process';

console.log(`The parent process is pid ${ppid}`);const { ppid } = require('node:process');

console.log(`The parent process is pid ${ppid}`);copy

process.ref(maybeRefable)#

• maybeRefable <any> 一个可能是“可引用”的对象。

一个对象是“可引用的”，如果它实现了 Node.js 的“Refable 协议”。具体来说，这意味着该对象实现了 Symbol.for('nodejs.ref') 和 Symbol.for('nodejs.unref') 方法。被“引用”（Ref'd）的对象将使 Node.js 事件循环保持活动状态，而被“取消引用”（unref'd）的对象则不会。历史上，这是通过直接在对象上使用 ref() 和 unref() 方法来实现的。然而，这种模式正在被弃用，以支持“Refable 协议”，以便更好地支持 Web 平台 API 类型，这些类型的 API 无法修改以添加 ref() 和 unref() 方法，但仍需支持该行为。

process.release#

• 类型：<Object>

process.release 属性返回一个包含与当前发布版本相关的元数据的 Object，包括源码 tarball 和仅头文件的 tarball 的 URL。

process.release 包含以下属性：

• name <string> 一个始终为 'node' 的值。
• sourceUrl <string> 一个指向包含当前发布版本源代码的 .tar.gz 文件的绝对 URL。
• headersUrl<string> 一个指向仅包含当前发布版本源头文件的 .tar.gz 文件的绝对 URL。此文件比完整源文件小得多，可用于编译 Node.js 原生插件。
• libUrl <string> | <undefined> 一个指向与当前发布版本的架构和版本匹配的 node.lib 文件的绝对 URL。此文件用于编译 Node.js 原生插件。此属性仅存在于 Node.js 的 Windows 构建版本中，在所有其他平台上都将缺失。
• lts <string> | <undefined> 一个标识此版本 LTS 标签的字符串。此属性仅存在于 LTS 版本中，对于所有其他发布类型（包括当前版本）均为 undefined。有效值包括 LTS 发布代号（包括那些不再受支持的）。
  • 对于从 14.15.0 开始的 14.x LTS 系列，为 'Fermium'。
  • 对于从 16.13.0 开始的 16.x LTS 系列，为 'Gallium'。
  • 对于从 18.12.0 开始的 18.x LTS 系列，为 'Hydrogen'。对于其他 LTS 发布代号，请参见 Node.js 更新日志归档。

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

在从非发布版本的源代码树进行的自定义构建中，可能只存在 name 属性。不应依赖其他属性的存在。

process.report#

• 类型：<Object>

process.report 是一个对象，其方法用于为当前进程生成诊断报告。更多文档可在报告文档中找到。

import { report } from 'node:process';

console.log(`Reports are compact? ${report.compact}`);const { report } = require('node:process');

console.log(`Reports are compact? ${report.compact}`);copy

import { report } from 'node:process';

console.log(`Report directory is ${report.directory}`);const { report } = require('node:process');

console.log(`Report directory is ${report.directory}`);copy

import { report } from 'node:process';

console.log(`Report filename is ${report.filename}`);const { report } = require('node:process');

console.log(`Report filename is ${report.filename}`);copy

import { report } from 'node:process';
import util from 'node:util';

const data = report.getReport();
console.log(data.header.nodejsVersion);

// Similar to process.report.writeReport()
import fs from 'node:fs';
fs.writeFileSync('my-report.log', util.inspect(data), 'utf8');const { report } = require('node:process');
const util = require('node:util');

const data = report.getReport();
console.log(data.header.nodejsVersion);

// Similar to process.report.writeReport()
const fs = require('node:fs');
fs.writeFileSync('my-report.log', util.inspect(data), 'utf8');copy

import { report } from 'node:process';

console.log(`Report on fatal error: ${report.reportOnFatalError}`);const { report } = require('node:process');

console.log(`Report on fatal error: ${report.reportOnFatalError}`);copy

import { report } from 'node:process';

console.log(`Report on signal: ${report.reportOnSignal}`);const { report } = require('node:process');

console.log(`Report on signal: ${report.reportOnSignal}`);copy

import { report } from 'node:process';

console.log(`Report on exception: ${report.reportOnUncaughtException}`);const { report } = require('node:process');

console.log(`Report on exception: ${report.reportOnUncaughtException}`);copy

import { report } from 'node:process';

console.log(`Report signal: ${report.signal}`);const { report } = require('node:process');

console.log(`Report signal: ${report.signal}`);copy

import { report } from 'node:process';

report.writeReport();const { report } = require('node:process');

report.writeReport();copy

process.resourceUsage()#

• 返回：<Object> 当前进程的资源使用情况。所有这些值都来自 uv_getrusage 调用，该调用返回一个 uv_rusage_t 结构。
  • userCPUTime <integer> 映射到以微秒计算的 ru_utime。它与 process.cpuUsage().user 的值相同。
  • systemCPUTime <integer> 映射到以微秒计算的 ru_stime。它与 process.cpuUsage().system 的值相同。
  • maxRSS <integer> 映射到 ru_maxrss，这是以 kibibytes (1024 字节) 为单位使用的最大驻留集大小。
  • sharedMemorySize <integer> 映射到 ru_ixrss，但任何平台都不支持。
  • unsharedDataSize <integer> 映射到 ru_idrss，但任何平台都不支持。
  • unsharedStackSize <integer> 映射到 ru_isrss，但任何平台都不支持。
  • minorPageFault <integer> 映射到 ru_minflt，这是进程的次要页面错误的数量，更多详细信息请参阅这篇文章。
  • majorPageFault <integer> 映射到 ru_majflt，这是进程的主要页面错误的数量，更多详细信息请参阅这篇文章。此字段在 Windows 上不受支持。
  • swappedOut <integer> 映射到 ru_nswap，但任何平台都不支持。
  • fsRead <integer> 映射到 ru_inblock，这是文件系统必须执行输入的次数。
  • fsWrite <integer> 映射到 ru_oublock，这是文件系统必须执行输出的次数。
  • ipcSent <integer> 映射到 ru_msgsnd，但任何平台都不支持。
  • ipcReceived <integer> 映射到 ru_msgrcv，但任何平台都不支持。
  • signalsCount <integer> 映射到 ru_nsignals，但任何平台都不支持。
  • voluntaryContextSwitches <integer> 映射到 ru_nvcsw，这是由于进程在其时间片完成前自愿放弃处理器（通常是为了等待资源可用）而导致的 CPU 上下文切换次数。此字段在 Windows 上不受支持。
  • involuntaryContextSwitches <integer> 映射到 ru_nivcsw，这是由于更高优先级的进程变为可运行或当前进程超出了其时间片而导致的 CPU 上下文切换次数。此字段在 Windows 上不受支持。

import { resourceUsage } from 'node:process';

console.log(resourceUsage());
/*
  Will output:
  {
    userCPUTime: 82872,
    systemCPUTime: 4143,
    maxRSS: 33164,
    sharedMemorySize: 0,
    unsharedDataSize: 0,
    unsharedStackSize: 0,
    minorPageFault: 2469,
    majorPageFault: 0,
    swappedOut: 0,
    fsRead: 0,
    fsWrite: 8,
    ipcSent: 0,
    ipcReceived: 0,
    signalsCount: 0,
    voluntaryContextSwitches: 79,
    involuntaryContextSwitches: 1
  }
*/const { resourceUsage } = require('node:process');

console.log(resourceUsage());
/*
  Will output:
  {
    userCPUTime: 82872,
    systemCPUTime: 4143,
    maxRSS: 33164,
    sharedMemorySize: 0,
    unsharedDataSize: 0,
    unsharedStackSize: 0,
    minorPageFault: 2469,
    majorPageFault: 0,
    swappedOut: 0,
    fsRead: 0,
    fsWrite: 8,
    ipcSent: 0,
    ipcReceived: 0,
    signalsCount: 0,
    voluntaryContextSwitches: 79,
    involuntaryContextSwitches: 1
  }
*/copy

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

• message <Object>
• sendHandle <net.Server> | <net.Socket>
• options <Object> 用于参数化发送特定类型的句柄。options 支持以下属性：
  • keepOpen <boolean> 一个可以在传递 net.Socket 实例时使用的值。当为 true 时，套接字在发送进程中保持打开状态。默认值： false。
• callback <Function>
• 返回：<boolean>

如果 Node.js 是通过 IPC 通道生成的，可以使用 process.send() 方法向父进程发送消息。消息将在父进程的 ChildProcess 对象上作为 'message' 事件接收。

如果 Node.js 不是通过 IPC 通道生成的，process.send 将为 undefined。

消息会经过序列化和解析。最终收到的消息可能与最初发送的消息不同。

process.setegid(id)#

• id <string> | <number> 组名或 ID

process.setegid() 方法设置进程的有效组标识。(参见 setegid(2)。) id 可以作为数字 ID 或组名字符串传递。如果指定了组名，此方法将在解析关联的数字 ID 时阻塞。

import process from 'node:process';

if (process.getegid && process.setegid) {
  console.log(`Current gid: ${process.getegid()}`);
  try {
    process.setegid(501);
    console.log(`New gid: ${process.getegid()}`);
  } catch (err) {
    console.error(`Failed to set gid: ${err}`);
  }
}const process = require('node:process');

if (process.getegid && process.setegid) {
  console.log(`Current gid: ${process.getegid()}`);
  try {
    process.setegid(501);
    console.log(`New gid: ${process.getegid()}`);
  } catch (err) {
    console.error(`Failed to set gid: ${err}`);
  }
}copy

此函数仅在 POSIX 平台（即非 Windows 或 Android）上可用。此功能在 Worker 线程中不可用。

process.seteuid(id)#

• id <string> | <number> 用户名或 ID

process.seteuid() 方法设置进程的有效用户标识。(参见 seteuid(2)。) id 可以作为数字 ID 或用户名字符串传递。如果指定了用户名，此方法将在解析关联的数字 ID 时阻塞。

import process from 'node:process';

if (process.geteuid && process.seteuid) {
  console.log(`Current uid: ${process.geteuid()}`);
  try {
    process.seteuid(501);
    console.log(`New uid: ${process.geteuid()}`);
  } catch (err) {
    console.error(`Failed to set uid: ${err}`);
  }
}const process = require('node:process');

if (process.geteuid && process.seteuid) {
  console.log(`Current uid: ${process.geteuid()}`);
  try {
    process.seteuid(501);
    console.log(`New uid: ${process.geteuid()}`);
  } catch (err) {
    console.error(`Failed to set uid: ${err}`);
  }
}copy

此函数仅在 POSIX 平台（即非 Windows 或 Android）上可用。此功能在 Worker 线程中不可用。

process.setgid(id)#

• id <string> | <number> 组名或 ID

process.setgid() 方法设置进程的组标识。(参见 setgid(2)。) id 可以作为数字 ID 或组名字符串传递。如果指定了组名，此方法将在解析关联的数字 ID 时阻塞。

import process from 'node:process';

if (process.getgid && process.setgid) {
  console.log(`Current gid: ${process.getgid()}`);
  try {
    process.setgid(501);
    console.log(`New gid: ${process.getgid()}`);
  } catch (err) {
    console.error(`Failed to set gid: ${err}`);
  }
}const process = require('node:process');

if (process.getgid && process.setgid) {
  console.log(`Current gid: ${process.getgid()}`);
  try {
    process.setgid(501);
    console.log(`New gid: ${process.getgid()}`);
  } catch (err) {
    console.error(`Failed to set gid: ${err}`);
  }
}copy

此函数仅在 POSIX 平台（即非 Windows 或 Android）上可用。此功能在 Worker 线程中不可用。

process.setgroups(groups)#

• groups <integer[]>

process.setgroups() 方法为 Node.js 进程设置补充组 ID。这是一个特权操作，需要 Node.js 进程具有 root 权限或 CAP_SETGID 能力。

groups 数组可以包含数字组 ID、组名或两者兼有。

import process from 'node:process';

if (process.getgroups && process.setgroups) {
  try {
    process.setgroups([501]);
    console.log(process.getgroups()); // new groups
  } catch (err) {
    console.error(`Failed to set groups: ${err}`);
  }
}const process = require('node:process');

if (process.getgroups && process.setgroups) {
  try {
    process.setgroups([501]);
    console.log(process.getgroups()); // new groups
  } catch (err) {
    console.error(`Failed to set groups: ${err}`);
  }
}copy

此函数仅在 POSIX 平台（即非 Windows 或 Android）上可用。此功能在 Worker 线程中不可用。

process.setuid(id)#

• id <integer> | <string>

process.setuid(id) 方法设置进程的用户标识。(参见 setuid(2)。) id 可以作为数字 ID 或用户名字符串传递。如果指定了用户名，此方法将在解析关联的数字 ID 时阻塞。

import process from 'node:process';

if (process.getuid && process.setuid) {
  console.log(`Current uid: ${process.getuid()}`);
  try {
    process.setuid(501);
    console.log(`New uid: ${process.getuid()}`);
  } catch (err) {
    console.error(`Failed to set uid: ${err}`);
  }
}const process = require('node:process');

if (process.getuid && process.setuid) {
  console.log(`Current uid: ${process.getuid()}`);
  try {
    process.setuid(501);
    console.log(`New uid: ${process.getuid()}`);
  } catch (err) {
    console.error(`Failed to set uid: ${err}`);
  }
}copy

此函数仅在 POSIX 平台（即非 Windows 或 Android）上可用。此功能在 Worker 线程中不可用。

process.setSourceMapsEnabled(val)#

• val <boolean>

此函数启用或禁用堆栈跟踪的源映射支持。

它提供了与使用命令行选项 --enable-source-maps 启动 Node.js 进程相同的功能。

只有在启用源映射后加载的 JavaScript 文件中的源映射才会被解析和加载。

这等同于使用选项 { nodeModules: true, generatedCode: true } 调用 module.setSourceMapsSupport()。

process.setUncaughtExceptionCaptureCallback(fn)#

• fn <Function> | <null>

process.setUncaughtExceptionCaptureCallback() 函数设置一个在发生未捕获异常时调用的函数，该函数将接收异常值本身作为其第一个参数。

如果设置了这样的函数，'uncaughtException' 事件将不会被触发。如果从命令行传递了 --abort-on-uncaught-exception 或通过 v8.setFlagsFromString() 设置了该选项，进程将不会中止。配置在异常时执行的操作（如生成报告）也会受到影响。

要取消设置捕获函数，可以使用 process.setUncaughtExceptionCaptureCallback(null)。在已设置另一个捕获函数的情况下，使用非 null 参数调用此方法将抛出错误。

使用此函数与使用已弃用的 domain 内置模块是互斥的。

process.sourceMapsEnabled#

• 类型：<boolean>

process.sourceMapsEnabled 属性返回堆栈跟踪的源映射支持是否已启用。

process.stderr#

• 类型: <Stream>

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

process.stderr 在重要方面与其他 Node.js 流不同。有关更多信息，请参见关于进程 I/O 的说明。

process.stdin#

• 类型: <Stream>

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

有关如何从 stdin 读取的详细信息，请参见 readable.read()。

作为一个双工流，process.stdin 也可以在“旧”模式下使用，该模式与为 v0.10 之前的 Node.js 编写的脚本兼容。有关更多信息，请参见流兼容性。

在“旧”流模式下，stdin 流默认是暂停的，因此必须调用 process.stdin.resume() 才能从中读取。另请注意，调用 process.stdin.resume() 本身会将流切换到“旧”模式。

process.stdout#

• 类型: <Stream>

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

例如，要将 process.stdin 复制到 process.stdout：

import { stdin, stdout } from 'node:process';

stdin.pipe(stdout);const { stdin, stdout } = require('node:process');

stdin.pipe(stdout);copy

process.stdout 在重要方面与其他 Node.js 流不同。有关更多信息，请参见关于进程 I/O 的说明。

$ node -p "Boolean(process.stdin.isTTY)"
true
$ echo "foo" | node -p "Boolean(process.stdin.isTTY)"
false
$ node -p "Boolean(process.stdout.isTTY)"
true
$ node -p "Boolean(process.stdout.isTTY)" | cat
false copy

process.throwDeprecation#

• 类型：<boolean>

process.throwDeprecation 的初始值表示当前 Node.js 进程是否设置了 --throw-deprecation 标志。process.throwDeprecation 是可变的，因此是否弃用警告会导致错误可以在运行时更改。有关更多信息，请参阅 'warning' 事件和 emitWarning() 方法的文档。

$ node --throw-deprecation -p "process.throwDeprecation"
true
$ node -p "process.throwDeprecation"
undefined
$ node
> process.emitWarning('test', 'DeprecationWarning');
undefined
> (node:26598) DeprecationWarning: test
> process.throwDeprecation = true;
true
> process.emitWarning('test', 'DeprecationWarning');
Thrown:
[DeprecationWarning: test] { name: 'DeprecationWarning' } copy

process.threadCpuUsage([previousValue])#

• previousValue <Object> 上一次调用 process.threadCpuUsage() 的返回值
• 返回：<Object>
  • user <integer>
  • system <integer>

process.threadCpuUsage() 方法返回当前工作线程的用户和系统 CPU 时间使用情况，以一个包含 user 和 system 属性的对象形式返回，其值为微秒值（百万分之一秒）。

可以将上一次调用 process.threadCpuUsage() 的结果作为参数传递给该函数，以获得差异读数。

process.title#

• 类型：<string>

process.title 属性返回当前进程的标题（即返回 ps 的当前值）。为 process.title 赋一个新值会修改 ps 的当前值。

当分配新值时，不同平台会对标题施加不同的最大长度限制。通常这些限制相当有限。例如，在 Linux 和 macOS 上，process.title 受限于二进制文件名加上命令行参数的长度，因为设置 process.title 会覆盖进程的 argv 内存。Node.js v0.8 允许更长的进程标题字符串，因为它也覆盖了 environ 内存，但这在某些（相当晦涩的）情况下可能不安全且令人困惑。

为 process.title 赋值可能不会在进程管理器应用程序（如 macOS 的活动监视器或 Windows 的服务管理器）中产生准确的标签。

process.traceDeprecation#

• 类型：<boolean>

process.traceDeprecation 属性指示当前 Node.js 进程是否设置了 --trace-deprecation 标志。有关此标志行为的更多信息，请参阅 'warning' 事件和 emitWarning() 方法的文档。

process.umask()#

process.umask() 返回 Node.js 进程的文件模式创建掩码。子进程从父进程继承掩码。

process.umask(mask)#

• mask <string> | <integer>

process.umask(mask) 设置 Node.js 进程的文件模式创建掩码。子进程从父进程继承掩码。返回先前的掩码。

import { umask } from 'node:process';

const newmask = 0o022;
const oldmask = umask(newmask);
console.log(
  `Changed umask from ${oldmask.toString(8)} to ${newmask.toString(8)}`,
);const { umask } = require('node:process');

const newmask = 0o022;
const oldmask = umask(newmask);
console.log(
  `Changed umask from ${oldmask.toString(8)} to ${newmask.toString(8)}`,
);copy

在 Worker 线程中，process.umask(mask) 将会抛出异常。

process.unref(maybeRefable)#

• maybeUnfefable <any> 一个可能是“可取消引用”的对象。

一个对象是“可取消引用的”，如果它实现了 Node.js 的“Refable 协议”。具体来说，这意味着该对象实现了 Symbol.for('nodejs.ref') 和 Symbol.for('nodejs.unref') 方法。被“引用”（Ref'd）的对象将使 Node.js 事件循环保持活动状态，而被“取消引用”（unref'd）的对象则不会。历史上，这是通过直接在对象上使用 ref() 和 unref() 方法来实现的。然而，这种模式正在被弃用，以支持“Refable 协议”，以便更好地支持 Web 平台 API 类型，这些类型的 API 无法修改以添加 ref() 和 unref() 方法，但仍需支持该行为。

process.uptime()#

• 返回：<number>

process.uptime() 方法返回当前 Node.js 进程已运行的秒数。

返回值包括秒的小数部分。使用 Math.floor() 来获取整数秒。

process.version#

• 类型：<string>

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

import { version } from 'node:process';

console.log(`Version: ${version}`);
// Version: v14.8.0const { version } = require('node:process');

console.log(`Version: ${version}`);
// Version: v14.8.0copy

要获取不带前缀 v 的版本字符串，请使用 process.versions.node。

process.versions#

• 类型：<Object>

process.versions 属性返回一个列出 Node.js 及其依赖项版本字符串的对象。process.versions.modules 表示当前的 ABI 版本，每当 C++ API 发生变化时，该版本就会增加。Node.js 将拒绝加载针对不同模块 ABI 版本编译的模块。

import { versions } from 'node:process';

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

console.log(versions);copy

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

{ node: '23.0.0',
  acorn: '8.11.3',
  ada: '2.7.8',
  ares: '1.28.1',
  base64: '0.5.2',
  brotli: '1.1.0',
  cjs_module_lexer: '1.2.2',
  cldr: '45.0',
  icu: '75.1',
  llhttp: '9.2.1',
  modules: '127',
  napi: '9',
  nghttp2: '1.61.0',
  nghttp3: '0.7.0',
  ngtcp2: '1.3.0',
  openssl: '3.0.13+quic',
  simdjson: '3.8.0',
  simdutf: '5.2.4',
  sqlite: '3.46.0',
  tz: '2024a',
  undici: '6.13.0',
  unicode: '15.1',
  uv: '1.48.0',
  uvwasi: '0.0.20',
  v8: '12.4.254.14-node.11',
  zlib: '1.3.0.1-motley-7d77fb7' } copy

退出码#

当没有更多异步操作待处理时，Node.js 通常会以状态码 0 退出。在其他情况下使用以下状态码：

• 1 未捕获的致命异常：存在一个未捕获的异常，并且它没有被域（domain）或 'uncaughtException' 事件处理程序处理。
• 2: 未使用（由 Bash 为内置命令误用保留）
• 3 内部 JavaScript 解析错误：Node.js 引导过程中的内部 JavaScript 源代码导致了解析错误。这种情况极为罕见，通常只可能在 Node.js 本身的开发过程中发生。
• 4 内部 JavaScript 评估失败：Node.js 引导过程中的内部 JavaScript 源代码在评估时未能返回一个函数值。这种情况极为罕见，通常只可能在 Node.js 本身的开发过程中发生。
• 5 致命错误：V8 中存在一个致命的不可恢复错误。通常会向 stderr 打印一条带有前缀 FATAL ERROR 的消息。
• 6 非函数的内部异常处理程序：存在一个未捕获的异常，但内部致命异常处理函数由于某种原因被设置为非函数，无法被调用。
• 7 内部异常处理程序运行时失败：存在一个未捕获的异常，并且内部致命异常处理函数本身在尝试处理它时抛出了一个错误。例如，当一个 'uncaughtException' 或 domain.on('error') 处理程序抛出错误时，可能会发生这种情况。
• 8: 未使用。在 Node.js 的早期版本中，退出码 8 有时表示未捕获的异常。
• 9 无效参数：指定了一个未知的选项，或者一个需要值的选项没有提供值。
• 10 内部 JavaScript 运行时失败：Node.js 引导过程中的内部 JavaScript 源代码在调用引导函数时抛出了一个错误。这种情况极为罕见，通常只可能在 Node.js 本身的开发过程中发生。
• 12 无效的调试参数：设置了 --inspect 和/或 --inspect-brk 选项，但选择的端口号无效或不可用。
• 13 未解决的顶层 Await：在顶层代码中函数之外使用了 await，但传递的 Promise 从未解决。
• 14 快照失败：Node.js 启动以构建 V8 启动快照，但由于应用程序状态的某些要求未得到满足而失败。
• >128 信号退出：如果 Node.js 收到一个致命信号，如 SIGKILL 或 SIGHUP，那么它的退出码将是 128 加上信号码的值。这是一种标准的 POSIX 实践，因为退出码被定义为 7 位整数，而信号退出会设置高位，然后包含信号码的值。例如，信号 SIGABRT 的值为 6，因此预期的退出码将是 128 + 6，即 134。