Node.js v24.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';

process.on('multipleResolves', (type, promise, reason) => {
  console.error(type, promise, reason);
  setImmediate(() => process.exit(1));
});

async function main() {
  try {
    return await new Promise((resolve, reject) => {
      resolve('First call');
      resolve('Swallowed resolve');
      reject(new Error('Swallowed reject'));
    });
  } catch {
    throw new Error('Failed');
  }
}

main().then(console.log);
// resolve: Promise { 'First call' } 'Swallowed resolve'
// reject: Promise { 'First call' } Error: Swallowed reject
//     at Promise (*)
//     at new Promise (<anonymous>)
//     at main (*)
// First callconst process = require('node:process');

process.on('multipleResolves', (type, promise, reason) => {
  console.error(type, promise, reason);
  setImmediate(() => process.exit(1));
});

async function main() {
  try {
    return await new Promise((resolve, reject) => {
      resolve('First call');
      resolve('Swallowed resolve');
      reject(new Error('Swallowed reject'));
    });
  } catch {
    throw new Error('Failed');
  }
}

main().then(console.log);
// resolve: Promise { 'First call' } 'Swallowed resolve'
// reject: Promise { 'First call' } Error: Swallowed reject
//     at Promise (*)
//     at new Promise (<anonymous>)
//     at main (*)
// First callcopy

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.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 通道生成的（请参阅子进程和集群文档），则 process.connected 属性只要 IPC 通道已连接，就会返回 true，并且在调用 process.disconnect() 之后将返回 false。

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

process.constrainedMemory()#

• <number>

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

有关更多信息，请参阅 uv_get_constrained_memory。

process.availableMemory()#

• <number>

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

有关更多信息，请参阅 uv_get_available_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 实例。 然后可以通过 module.exports 访问 C++ 插件导出的函数。

下面的示例演示如何加载名为 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

在此示例中，Error 对象由 process.emitWarning() 在内部生成，并通过传递给 '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.exit([code])#

• code <integer> | <string> | <null> | <undefined> 退出代码。 对于字符串类型，仅允许整数字符串（例如，“1”）。 默认值: 0。

process.exit() 方法指示 Node.js 以退出状态 code 同步终止进程。 如果省略 code，则 exit 使用“成功”代码 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.exitCode，并通过避免安排事件循环的任何其他工作来允许进程自然退出，而不是直接调用 process.exit()：

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.exit() 来更新 process.exitCode 的值。

$ 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 构建包含 inspector，则为 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

这个对象很可能（并非不可能）不会被垃圾回收，但如果不是，则在调用 process.exit 时将调用 dispose。

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

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 来测试进程是否存在。如果 pid 用于终止进程组，则 Windows 平台将抛出错误。

即使此函数的名称是 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，常驻集大小，是进程在主内存设备（即已分配的总内存的子集）中占用的空间量，包括所有 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 添加到“下一个 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> 一个可能被“refable”的对象。

如果一个对象实现了 Node.js "Refable 协议"，则该对象是 "refable"。 具体来说，这意味着该对象实现了 Symbol.for('nodejs.ref') 和 Symbol.for('nodejs.unref') 方法。"Ref'd" 对象将保持 Node.js 事件循环的活动状态，而 "unref'd" 对象则不会。 从历史上看，这是通过直接在对象上使用 ref() 和 unref() 方法来实现的。 但是，为了更好地支持 Web 平台 API 类型，该模式正在被弃用，转而支持 "Refable 协议"，因为这些 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.x LTS 系列（从 14.15.0 开始）的 'Fermium'。
  • 16.x LTS 系列（从 16.13.0 开始）的 'Gallium'。
  • 18.x LTS 系列（从 18.12.0 开始）的 'Hydrogen'。 有关其他 LTS 版本代码名称，请参见 Node.js Changelog Archive

{
  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.execve(file[, args[, env]])#

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

用新进程替换当前进程。

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

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

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

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

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，它是以千字节为单位使用的最大常驻集大小。
  • 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>

此函数启用或禁用堆栈跟踪的 Source Map v3 支持。

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

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

这意味着使用选项 { 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 属性返回是否启用了堆栈跟踪的 Source Map v3 支持。

process.stderr#

• <Stream>

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

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

process.stdin#

• <Stream>

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

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

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

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

process.stdout#

• <Stream>

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

例如，将 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 的“可引用协议”，那么它就是“不可引用”的。具体来说，这意味着该对象实现了 Symbol.for('nodejs.ref') 和 Symbol.for('nodejs.unref') 方法。“已引用”的对象会保持 Node.js 事件循环处于活动状态，而“未引用”的对象则不会。从历史上看，这是通过直接在对象上使用 ref() 和 unref() 方法来实现的。然而，为了更好地支持 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 未捕获的致命异常: 存在一个未捕获的异常，并且它没有被域或 'uncaughtException' 事件处理程序处理。
• 2: 未使用（Bash 保留用于内置错误）
• 3 内部 JavaScript 解析错误: Node.js 引导过程中内部的 JavaScript 源代码导致了解析错误。这种情况非常罕见，通常只发生在 Node.js 本身的开发过程中。
• 4 内部 JavaScript 求值失败: Node.js 引导过程中内部的 JavaScript 源代码在求值时未能返回函数值。这种情况非常罕见，通常只发生在 Node.js 本身的开发过程中。
• 5 致命错误: V8 中存在一个无法恢复的致命错误。通常，一条消息会以 FATAL ERROR 为前缀打印到 stderr。
• 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。