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 プロパティは、NODE_OPTIONS 環境変数内で許可されるフラグの特別な読み取り専用 Set です。

process.allowedNodeEnvironmentFlags は Set を拡張しますが、いくつかの異なる可能なフラグ表現を認識するために Set.prototype.has をオーバーライドします。process.allowedNodeEnvironmentFlags.has() は以下の場合に true を返します。

• フラグは先頭の単一 (-) または二重 (--) ダッシュを省略できます。例: --inspect-brk の場合は inspect-brk、-r の場合は r。
• V8 に渡されるフラグ (--v8-options にリストされている) は、1つ以上の先頭でないダッシュをアンダースコアに置き換えるか、その逆も可能です。例: --perf_basic_prof、--perf-basic-prof、--perf_basic-prof など。
• フラグは1つ以上の等号 (=) 文字を含むことができます。最初の等号以降のすべての文字は無視されます。例: --stack-trace-limit=100。
• フラグは NODE_OPTIONS 内で許可されている必要があります。

process.allowedNodeEnvironmentFlags を反復処理する場合、フラグは一度だけ表示されます。それぞれが1つ以上のダッシュで始まります。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 を参照してください。2番目の要素は実行されている 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 プロパティは、現在の Node.js 実行可能ファイルをコンパイルするために使用された設定オプションの JavaScript 表現を含む凍結された Object を返します。これは、./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>

OS によって課せられた制限に基づいて、プロセスが利用できるメモリの量 (バイト単位) を取得します。そのような制約がないか、制約が不明な場合は 0 が返されます。

詳細については uv_get_constrained_memory を参照してください。

process.cpuUsage([previousValue])#

• previousValue <Object> process.cpuUsage() を呼び出した以前の戻り値
• 戻り値: <Object>
  • user <integer>
  • system <integer>

process.cpuUsage() メソッドは、現在のプロセスのユーザーとシステムの CPU 時間使用量を、user と system のプロパティを持つオブジェクトで返します。これらの値はマイクロ秒 (100万分の1秒) であり、それぞれユーザーコードとシステムコードで費やされた時間を測定します。複数の 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 モジュールからのロードなど、特定の理由がない限り、process.dlopen() よりも require() を優先すべきです。

flags 引数は、dlopen の動作を指定できる整数です。詳細は os.constants.dlopen のドキュメントを参照してください。

process.dlopen() を呼び出す際の重要な要件は、module インスタンスを渡す必要があることです。C++ アドオンによってエクスポートされた関数は、module.exports を介してアクセス可能になります。

以下の例は、foo 関数をエクスポートする local.node という名前の C++ アドオンをロードする方法を示しています。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

前の各例では、Error オブジェクトが process.emitWarning() によって内部的に生成され、'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

process.env からプロパティを削除するには delete を使用します。

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、または Worker コンストラクターの env オプションとして指定されたものに基づいて、独自の process.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 関数を使用して実現されるため、標準入力、標準出力、標準エラーのファイルディスクリプタを除き、現在のプロセスからのメモリやその他のリソースは保持されません。

他のすべてのリソースは、プロセスが交換されるときにシステムによって破棄され、exit または close イベントをトリガーしたり、クリーンアップハンドラーを実行したりしません。

この関数は、エラーが発生しない限り、決して返りません。

この関数は Windows または IBM i では利用できません。

process.exit([code])#

• code <integer> | <string> | <null> | <undefined> 終了コード。文字列型の場合、整数文字列 (例: '1') のみが許可されます。デフォルト: 0。

process.exit() メソッドは、Node.js にプロセスを同期的に終了コード code で終了するように指示します。code が省略された場合、exit は 'success' コード 0 を使用するか、process.exitCode が設定されている場合はその値を使用します。Node.js は、すべての 'exit' イベントリスナーが呼び出されるまで終了しません。

'failure' コードで終了するには:

import { exit } from 'node:process';

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

exit(1);copy

Node.js を実行したシェルは、終了コードを 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 になるブール値。

Node.js を libuv なしでビルドすることはできないため、この値は常に true です。

process.finalization.register(ref, callback)#

• ref <Object> | <Function> 追跡対象のリソースへの参照。
• callback <Function> リソースがファイナライズされたときに呼び出されるコールバック関数。
  • ref <Object> | <Function> 追跡対象のリソースへの参照。
  • event <string> ファイナライズをトリガーしたイベント。デフォルトは 'exit' です。

この関数は、ref オブジェクトがガベージコレクションされなかった場合に、プロセスが exit イベントを発行したときに呼び出されるコールバックを登録します。exit イベントが発行される前にオブジェクト ref がガベージコレクションされた場合、コールバックはファイナライゼーションレジストリから削除され、プロセス終了時には呼び出されません。

コールバック内では、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 がスローする可能性のある解決エラーに対処したり、モジュールを非同期モジュールにするか、同期 API を非同期 API にする動的な import() を使用したりする必要がなくなります。

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: プレフィックスが必須のビルトインモジュールを参照してください。process.getBuiltinModule(id) によって返される参照は、ユーザーが require.cache を変更して require(id) が何か別のものを返すようにした場合でも、常に id に対応するビルトインモジュールを指します。

process.getegid()#

process.getegid() メソッドは、Node.js プロセスの数値による実効グループ ID を返します。( 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() メソッドは、プロセスの数値による実効ユーザー ID を返します。( 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() メソッドは、プロセスの数値によるグループ ID を返します。( 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() メソッドは、プロセスの数値によるユーザー ID を返します。( 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 で返します。ここで、ナノ秒 は秒の精度で表現できない実時間の残りの部分です。

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() とは異なり、2つの bigint の引き算で差分を直接計算できるため、追加の time 引数をサポートしません。

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() メソッドは、pid で識別されるプロセスに signal を送信します。

シグナル名は '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は変更が発生する前に必要とされたモジュール内で、元のメインモジュールを参照し続ける可能性があることです。一般的に、これら2つが同じモジュールを参照していると仮定しても安全です。

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は、すべてのNode.jsのBufferを含む、ArrayBufferとSharedArrayBufferに割り当てられたメモリを参照します。これはexternalの値にも含まれます。Node.jsが組み込みライブラリとして使用される場合、そのケースではArrayBufferの割り当てが追跡されない可能性があるため、この値は0になることがあります。

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> 「ref可能」なオブジェクト。

オブジェクトがNode.jsの「Refableプロトコル」を実装している場合、そのオブジェクトは「ref可能」です。具体的には、オブジェクトがSymbol.for('nodejs.ref')とSymbol.for('nodejs.unref')メソッドを実装していることを意味します。「Refされた」オブジェクトはNode.jsのイベントループをアクティブに保ちますが、「unrefされた」オブジェクトはそうではありません。歴史的には、これはオブジェクトに直接ref()とunref()メソッドを使用することで実装されていました。しかし、このパターンは、APIを変更してref()とunref()メソッドを追加できないが、その動作をサポートする必要があるWebプラットフォームAPIタイプをより良くサポートするために、「Refableプロトコル」を優先して非推奨になっています。

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ネイティブアドオンのコンパイルに使用されます。このプロパティはWindowsビルドのNode.jsにのみ存在し、他のすべてのプラットフォームでは存在しません。
• lts <string> | <undefined> このリリースのLTSラベルを識別する文字列ラベル。このプロパティはLTSリリースにのみ存在し、Currentリリースを含む他のすべてのリリースタイプでは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 Changelog Archiveを参照してください。

{
  name: 'node',
  lts: 'Hydrogen',
  sourceUrl: 'https://node.dokyumento.jp/download/release/v18.12.0/node-v18.12.0.tar.gz',
  headersUrl: 'https://node.dokyumento.jp/download/release/v18.12.0/node-v18.12.0-headers.tar.gz',
  libUrl: 'https://node.dokyumento.jp/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_rusage_t構造体を返すuv_getrusage呼び出しから得られます。
  • userCPUTime <integer> マイクロ秒単位で計算されたru_utimeにマッピングされます。これはprocess.cpuUsage().userと同じ値です。
  • systemCPUTime <integer> マイクロ秒単位で計算されたru_stimeにマッピングされます。これはprocess.cpuUsage().systemと同じ値です。
  • maxRSS <integer> ru_maxrssにマッピングされ、これはキビバイト（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()メソッドは、プロセスの実効グループIDを設定します。（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()メソッドは、プロセスの実効ユーザーIDを設定します。（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()メソッドは、プロセスのグループIDを設定します。（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)メソッドは、プロセスのユーザー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ファイル内のソースマップのみが解析およびロードされます。

これは、module.setSourceMapsSupport()を{ nodeModules: true, generatedCode: true }オプションで呼び出すことを意味します。

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（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時間とシステムCPU時間の使用量を、userとsystemプロパティを持つオブジェクトで返します。これらの値はマイクロ秒（100万分の1秒）の値です。

以前の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> 「unref可能」なオブジェクト。

オブジェクトがNode.jsの「Refableプロトコル」を実装している場合、そのオブジェクトは「unref可能」です。具体的には、オブジェクトがSymbol.for('nodejs.ref')とSymbol.for('nodejs.unref')メソッドを実装していることを意味します。「Refされた」オブジェクトはNode.jsのイベントループをアクティブに保ちますが、「unrefされた」オブジェクトはそうではありません。歴史的には、これはオブジェクトに直接ref()とunref()メソッドを使用することで実装されていました。しかし、このパターンは、APIを変更してref()とunref()メソッドを追加できないが、その動作をサポートする必要があるWebプラットフォームAPIタイプをより良くサポートするために、「Refableプロトコル」を優先して非推奨になっています。

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になります。