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://nodejs.com.tw/download/release/v18.12.0/node-v18.12.0.tar.gz',
  headersUrl: 'https://nodejs.com.tw/download/release/v18.12.0/node-v18.12.0-headers.tar.gz',
  libUrl: 'https://nodejs.com.tw/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。