Node.js v25.0.0 ドキュメンテーション

Windowsでの.batおよび.cmdファイルのを起動#

child_process.exec()とchild_process.execFile()の区別の重要性は、プラットフォームによって異なります。Unix系オペレーティングシステム（Unix、Linux、macOS）では、child_process.execFile()はデフォルトでシェルを起動しないため、より効率的です。しかし、Windowsでは.batおよび.cmdファイルはターミナルなしでは自己実行できないため、child_process.execFile()を使用して起動することはできません。Windowsで実行する場合、.batおよび.cmdファイルは、shellオプションを設定したchild_process.spawn()、child_process.exec()、またはcmd.exeを起動して.batや.cmdファイルを引数として渡す（shellオプションとchild_process.exec()が行うことです）ことで呼び出すことができます。どの場合でも、スクリプトファイル名にスペースが含まれている場合は引用符で囲む必要があります。

// OR...
const { exec, spawn } = require('node:child_process');

exec('my.bat', (err, stdout, stderr) => {
  if (err) {
    console.error(err);
    return;
  }
  console.log(stdout);
});

// Script with spaces in the filename:
const bat = spawn('"my script.cmd" a b', { shell: true });
// or:
exec('"my script.cmd" a b', (err, stdout, stderr) => {
  // ...
});// OR...
import { exec, spawn } from 'node:child_process';

exec('my.bat', (err, stdout, stderr) => {
  if (err) {
    console.error(err);
    return;
  }
  console.log(stdout);
});

// Script with spaces in the filename:
const bat = spawn('"my script.cmd" a b', { shell: true });
// or:
exec('"my script.cmd" a b', (err, stdout, stderr) => {
  // ...
});copy

child_process.exec(command[, options][, callback])#

• command <string> 実行するコマンド。引数はスペースで区切られます。
• options <Object>
  • cwd <string> | <URL> 子プロセスの現在の作業ディレクトリ。 デフォルト: process.cwd()。
  • env <Object> 環境変数のキーと値のペア。 デフォルト: process.env。
  • encoding <string> デフォルト: 'utf8'
  • shell <string> コマンドを実行するシェル。シェルの要件およびデフォルトのWindowsシェルを参照してください。 デフォルト: Unixでは'/bin/sh'、Windowsではprocess.env.ComSpec。
  • signal <AbortSignal> AbortSignalを使用して子プロセスを中止できます。
  • timeout <number> デフォルト: 0
  • maxBuffer <number> stdoutまたはstderrで許可される最大のデータ量（バイト単位）。超過した場合、子プロセスは終了させられ、すべての出力は切り詰められます。maxBufferとUnicodeの注意点を参照してください。 デフォルト: 1024 * 1024。
  • killSignal <string> | <integer> デフォルト: 'SIGTERM'
  • uid <number> プロセスのユーザーIDを設定します（setuid(2)参照）。
  • gid <number> プロセスのグループIDを設定します（setgid(2)参照）。
  • windowsHide <boolean> Windowsシステムで通常作成されるサブプロセスのコンソールウィンドウを非表示にします。 デフォルト: false。
• callback <Function> プロセスが終了したときに出力とともに呼び出されます。
  • error <Error>
  • stdout <string> | <Buffer>
  • stderr <string> | <Buffer>
• 戻り値: <ChildProcess>

シェルを起動し、そのシェル内でcommandを実行し、生成された出力をバッファリングします。exec関数に渡されるcommand文字列はシェルによって直接処理されるため、特殊文字（シェルによって異なります）は適宜対処する必要があります。

const { exec } = require('node:child_process');

exec('"/path/to/test file/test.sh" arg1 arg2');
// Double quotes are used so that the space in the path is not interpreted as
// a delimiter of multiple arguments.

exec('echo "The \\$HOME variable is $HOME"');
// The $HOME variable is escaped in the first instance, but not in the second.import { exec } from 'node:child_process';

exec('"/path/to/test file/test.sh" arg1 arg2');
// Double quotes are used so that the space in the path is not interpreted as
// a delimiter of multiple arguments.

exec('echo "The \\$HOME variable is $HOME"');
// The $HOME variable is escaped in the first instance, but not in the second.copy

サニタイズされていないユーザー入力をこの関数に決して渡さないでください。シェルメタ文字を含む入力は、任意のコマンド実行をトリガーするために使用される可能性があります。

callback関数が提供された場合、引数(error, stdout, stderr)で呼び出されます。成功した場合、errorはnullになります。エラーの場合、errorはErrorのインスタンスになります。error.codeプロパティはプロセスの終了コードになります。慣例として、0以外の終了コードはエラーを示します。error.signalはプロセスを終了させたシグナルになります。

コールバックに渡されるstdoutとstderr引数には、子プロセスの標準出力と標準エラー出力が含まれます。デフォルトでは、Node.jsは出力をUTF-8としてデコードし、文字列をコールバックに渡します。encodingオプションを使用して、stdoutとstderrの出力のデコードに使用する文字エンコーディングを指定できます。encodingが'buffer'、または認識されない文字エンコーディングの場合、代わりにBufferオブジェクトがコールバックに渡されます。

const { exec } = require('node:child_process');
exec('cat *.js missing_file | wc -l', (error, stdout, stderr) => {
  if (error) {
    console.error(`exec error: ${error}`);
    return;
  }
  console.log(`stdout: ${stdout}`);
  console.error(`stderr: ${stderr}`);
});import { exec } from 'node:child_process';
exec('cat *.js missing_file | wc -l', (error, stdout, stderr) => {
  if (error) {
    console.error(`exec error: ${error}`);
    return;
  }
  console.log(`stdout: ${stdout}`);
  console.error(`stderr: ${stderr}`);
});copy

timeoutが0より大きい場合、子プロセスがtimeoutミリ秒より長く実行された場合、親プロセスはkillSignalプロパティで指定されたシグナル（デフォルトは'SIGTERM'）を送信します。

exec(3) POSIXシステムコールとは異なり、child_process.exec()は既存のプロセスを置き換えせず、シェルを使用してコマンドを実行します。

このメソッドがutil.promisify()化されたバージョンとして呼び出された場合、stdoutとstderrプロパティを持つObjectに対するPromiseを返します。返されたChildProcessインスタンスは、childプロパティとしてPromiseにアタッチされます。エラーの場合（0以外の終了コードになるエラーを含む）、拒否されたPromiseが返されます。これにはコールバックで与えられるのと同じerrorオブジェクトが含まれますが、stdoutとstderrという2つの追加プロパティが付きます。

const util = require('node:util');
const exec = util.promisify(require('node:child_process').exec);

async function lsExample() {
  const { stdout, stderr } = await exec('ls');
  console.log('stdout:', stdout);
  console.error('stderr:', stderr);
}
lsExample();import { promisify } from 'node:util';
import child_process from 'node:child_process';
const exec = promisify(child_process.exec);

async function lsExample() {
  const { stdout, stderr } = await exec('ls');
  console.log('stdout:', stdout);
  console.error('stderr:', stderr);
}
lsExample();copy

signalオプションが有効な場合、対応するAbortControllerで.abort()を呼び出すことは、子プロセスで.kill()を呼び出すのと似ていますが、コールバックに渡されるエラーはAbortErrorになります。

const { exec } = require('node:child_process');
const controller = new AbortController();
const { signal } = controller;
const child = exec('grep ssh', { signal }, (error) => {
  console.error(error); // an AbortError
});
controller.abort();import { exec } from 'node:child_process';
const controller = new AbortController();
const { signal } = controller;
const child = exec('grep ssh', { signal }, (error) => {
  console.error(error); // an AbortError
});
controller.abort();copy

child_process.execFile(file[, args][, options][, callback])#

• file <string> 実行する実行可能ファイルの名前またはパス。
• args <string[]> 文字列引数のリスト。
• options <Object>
  • cwd <string> | <URL> 子プロセスの現在の作業ディレクトリ。
  • env <Object> 環境変数のキーと値のペア。 デフォルト: process.env。
  • encoding <string> デフォルト: 'utf8'
  • timeout <number> デフォルト: 0
  • maxBuffer <number> stdoutまたはstderrで許可される最大のデータ量（バイト単位）。超過した場合、子プロセスは終了させられ、すべての出力は切り詰められます。maxBufferとUnicodeの注意点を参照してください。 デフォルト: 1024 * 1024。
  • killSignal <string> | <integer> デフォルト: 'SIGTERM'
  • uid <number> プロセスのユーザーIDを設定します（setuid(2)参照）。
  • gid <number> プロセスのグループIDを設定します（setgid(2)参照）。
  • windowsHide <boolean> Windowsシステムで通常作成されるサブプロセスのコンソールウィンドウを非表示にします。 デフォルト: false。
  • windowsVerbatimArguments <boolean> Windowsでは引数の引用符付けやエスケープは行われません。Unixでは無視されます。 デフォルト: false。
  • shell <boolean> | <string> trueの場合、シェル内でcommandを実行します。Unixでは'/bin/sh'を使用し、Windowsではprocess.env.ComSpecを使用します。文字列として別のシェルを指定することもできます。シェルの要件およびデフォルトのWindowsシェルを参照してください。 デフォルト: false（シェルなし）。
  • signal <AbortSignal> AbortSignalを使用して子プロセスを中止できます。
• callback <Function> プロセス終了時に出力と共に呼び出されます。
  • error <Error>
  • stdout <string> | <Buffer>
  • stderr <string> | <Buffer>
• 戻り値: <ChildProcess>

child_process.execFile()関数はchild_process.exec()と似ていますが、デフォルトでシェルを起動しない点が異なります。代わりに、指定された実行可能ファイルfileが新しいプロセスとして直接起動されるため、child_process.exec()よりも若干効率的です。

child_process.exec()と同じオプションがサポートされています。シェルが起動されないため、I/Oリダイレクトやファイルグロビングのような動作はサポートされていません。

const { execFile } = require('node:child_process');
const child = execFile('node', ['--version'], (error, stdout, stderr) => {
  if (error) {
    throw error;
  }
  console.log(stdout);
});import { execFile } from 'node:child_process';
const child = execFile('node', ['--version'], (error, stdout, stderr) => {
  if (error) {
    throw error;
  }
  console.log(stdout);
});copy

コールバックに渡されるstdoutとstderr引数には、子プロセスの標準出力と標準エラー出力が含まれます。デフォルトでは、Node.jsは出力をUTF-8としてデコードし、文字列をコールバックに渡します。encodingオプションを使用して、stdoutとstderrの出力のデコードに使用する文字エンコーディングを指定できます。encodingが'buffer'、または認識されない文字エンコーディングの場合、代わりにBufferオブジェクトがコールバックに渡されます。

このメソッドがutil.promisify()化されたバージョンとして呼び出された場合、stdoutとstderrプロパティを持つObjectに対するPromiseを返します。返されたChildProcessインスタンスは、childプロパティとしてPromiseにアタッチされます。エラーの場合（0以外の終了コードになるエラーを含む）、拒否されたPromiseが返されます。これにはコールバックで与えられるのと同じerrorオブジェクトが含まれますが、stdoutとstderrという2つの追加プロパティが付きます。

const util = require('node:util');
const execFile = util.promisify(require('node:child_process').execFile);
async function getVersion() {
  const { stdout } = await execFile('node', ['--version']);
  console.log(stdout);
}
getVersion();import { promisify } from 'node:util';
import child_process from 'node:child_process';
const execFile = promisify(child_process.execFile);
async function getVersion() {
  const { stdout } = await execFile('node', ['--version']);
  console.log(stdout);
}
getVersion();copy

shellオプションが有効な場合、サニタイズされていないユーザー入力をこの関数に渡さないでください。シェルメタ文字を含む入力は、任意のコマンド実行をトリガーするために使用される可能性があります。

signalオプションが有効な場合、対応するAbortControllerで.abort()を呼び出すことは、子プロセスで.kill()を呼び出すのと似ていますが、コールバックに渡されるエラーはAbortErrorになります。

const { execFile } = require('node:child_process');
const controller = new AbortController();
const { signal } = controller;
const child = execFile('node', ['--version'], { signal }, (error) => {
  console.error(error); // an AbortError
});
controller.abort();import { execFile } from 'node:child_process';
const controller = new AbortController();
const { signal } = controller;
const child = execFile('node', ['--version'], { signal }, (error) => {
  console.error(error); // an AbortError
});
controller.abort();copy

child_process.fork(modulePath[, args][, options])#

• modulePath <string> | <URL> 子プロセスで実行するモジュール。
• args <string[]> 文字列引数のリスト。
• options <Object>
  • cwd <string> | <URL> 子プロセスの現在の作業ディレクトリ。
  • detached <boolean> 親プロセスから独立して実行するように子プロセスを準備します。具体的な動作はプラットフォームに依存します（options.detached参照）。
  • env <Object> 環境変数のキーと値のペア。 デフォルト: process.env。
  • execPath <string> 子プロセスを作成するために使用される実行可能ファイル。
  • execArgv <string[]> 実行可能ファイルに渡される文字列引数のリスト。 デフォルト: process.execArgv。
  • gid <number> プロセスのグループIDを設定します（setgid(2)参照）。
  • serialization <string> プロセス間でメッセージを送信する際に使用するシリアライゼーションの種類を指定します。可能な値は'json'と'advanced'です。詳細は高度なシリアライゼーションを参照してください。 デフォルト: 'json'。
  • signal <AbortSignal> AbortSignalを使用して子プロセスを終了できます。
  • killSignal <string> | <integer> 起動されたプロセスがタイムアウトまたはアボートシグナルによってキルされる際に使用されるシグナル値。 デフォルト: 'SIGTERM'。
  • silent <boolean> trueの場合、子プロセスのstdin、stdout、stderrは親プロセスにパイプされます。そうでない場合、それらは親プロセスから継承されます。詳細については、child_process.spawn()のstdioの'pipe'および'inherit'オプションを参照してください。 デフォルト: false。
  • stdio <Array> | <string> child_process.spawn()のstdioを参照してください。このオプションが提供されると、silentを上書きします。配列形式を使用する場合、値'ipc'を持つ項目を正確に1つ含める必要があり、そうでない場合はエラーがスローされます。例: [0, 1, 2, 'ipc']。
  • uid <number> プロセスのユーザーIDを設定します（setuid(2)参照）。
  • windowsVerbatimArguments <boolean> Windowsでは引数の引用符付けやエスケープは行われません。Unixでは無視されます。 デフォルト: false。
  • timeout <number> プロセスが実行を許可される最大時間（ミリ秒単位）。 デフォルト: undefined。
• 戻り値: <ChildProcess>

child_process.fork()メソッドは、特に新しいNode.jsプロセスを起動するために使用されるchild_process.spawn()の特殊なケースです。child_process.spawn()と同様に、ChildProcessオブジェクトが返されます。返されたChildProcessには、親と子の間でメッセージをやり取りできる追加の通信チャネルが組み込まれています。詳細はsubprocess.send()を参照してください。

起動されたNode.jsの子プロセスは、両者間に確立されたIPC通信チャネルを除いて、親から独立していることに注意してください。各プロセスは独自のメモリとV8インスタンスを持っています。追加のリソース割り当てが必要なため、多数の子Node.jsプロセスを起動することは推奨されません。

デフォルトでは、child_process.fork()は親プロセスのprocess.execPathを使用して新しいNode.jsインスタンスを起動します。optionsオブジェクトのexecPathプロパティにより、代替の実行パスを使用できます。

カスタムのexecPathで起動されたNode.jsプロセスは、子プロセスの環境変数NODE_CHANNEL_FDで識別されるファイルディスクリプタ（fd）を使用して親プロセスと通信します。

fork(2) POSIXシステムコールとは異なり、child_process.fork()は現在のプロセスを複製しません。

child_process.spawn()で利用可能なshellオプションはchild_process.fork()ではサポートされておらず、設定されても無視されます。

signalオプションが有効な場合、対応するAbortControllerで.abort()を呼び出すことは、子プロセスで.kill()を呼び出すのと似ていますが、コールバックに渡されるエラーはAbortErrorになります。

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

if (process.argv[2] === 'child') {
  setTimeout(() => {
    console.log(`Hello from ${process.argv[2]}!`);
  }, 1_000);
} else {
  const controller = new AbortController();
  const { signal } = controller;
  const child = fork(__filename, ['child'], { signal });
  child.on('error', (err) => {
    // This will be called with err being an AbortError if the controller aborts
  });
  controller.abort(); // Stops the child process
}import { fork } from 'node:child_process';
import process from 'node:process';

if (process.argv[2] === 'child') {
  setTimeout(() => {
    console.log(`Hello from ${process.argv[2]}!`);
  }, 1_000);
} else {
  const controller = new AbortController();
  const { signal } = controller;
  const child = fork(import.meta.url, ['child'], { signal });
  child.on('error', (err) => {
    // This will be called with err being an AbortError if the controller aborts
  });
  controller.abort(); // Stops the child process
}copy

child_process.spawn(command[, args][, options])#

• command <string> 実行するコマンド。
• args <string[]> 文字列引数のリスト。
• options <Object>
  • cwd <string> | <URL> 子プロセスの現在の作業ディレクトリ。
  • env <Object> 環境変数のキーと値のペア。 デフォルト: process.env。
  • argv0 <string> 子プロセスに送信されるargv[0]の値を明示的に設定します。指定しない場合、commandに設定されます。
  • stdio <Array> | <string> 子の標準入出力設定（options.stdio参照）。
  • detached <boolean> 親プロセスから独立して実行するように子プロセスを準備します。具体的な動作はプラットフォームに依存します（options.detached参照）。
  • uid <number> プロセスのユーザーIDを設定します（setuid(2)参照）。
  • gid <number> プロセスのグループIDを設定します（setgid(2)参照）。
  • serialization <string> プロセス間でメッセージを送信する際に使用するシリアライゼーションの種類を指定します。可能な値は'json'と'advanced'です。詳細は高度なシリアライゼーションを参照してください。 デフォルト: 'json'。
  • shell <boolean> | <string> trueの場合、シェル内でcommandを実行します。Unixでは'/bin/sh'を使用し、Windowsではprocess.env.ComSpecを使用します。文字列として別のシェルを指定することもできます。シェルの要件およびデフォルトのWindowsシェルを参照してください。 デフォルト: false（シェルなし）。
  • windowsVerbatimArguments <boolean> Windowsでは引数の引用符付けやエスケープは行われません。Unixでは無視されます。shellが指定され、それがCMDの場合、自動的にtrueに設定されます。 デフォルト: false。
  • windowsHide <boolean> Windowsシステムで通常作成されるサブプロセスのコンソールウィンドウを非表示にします。 デフォルト: false。
  • signal <AbortSignal> AbortSignalを使用して子プロセスを中止できます。
  • timeout <number> プロセスが実行を許可される最大時間（ミリ秒単位）。 デフォルト: undefined。
  • killSignal <string> | <integer> 起動されたプロセスがタイムアウトまたはアボートシグナルによってキルされる際に使用されるシグナル値。 デフォルト: 'SIGTERM'。
• 戻り値: <ChildProcess>

child_process.spawn()メソッドは、指定されたcommandと、argsのコマンドライン引数を使用して新しいプロセスを起動します。省略された場合、argsは空の配列にデフォルト設定されます。

shellオプションが有効な場合、サニタイズされていないユーザー入力をこの関数に渡さないでください。シェルメタ文字を含む入力は、任意のコマンド実行をトリガーするために使用される可能性があります。

3番目の引数は、追加のオプションを指定するために使用でき、以下のデフォルト値があります。

const defaults = {
  cwd: undefined,
  env: process.env,
}; copy

cwdを使用して、プロセスが起動される作業ディレクトリを指定します。指定しない場合、デフォルトは現在の作業ディレクトリを継承することです。指定されたがパスが存在しない場合、子プロセスはENOENTエラーを発し、即座に終了します。コマンドが存在しない場合もENOENTが発行されます。

envを使用して、新しいプロセスから見える環境変数を指定します。デフォルトはprocess.envです。

env内のundefined値は無視されます。

ls -lh /usrを実行し、stdout、stderr、および終了コードをキャプチャする例：

const { spawn } = require('node:child_process');
const ls = spawn('ls', ['-lh', '/usr']);

ls.stdout.on('data', (data) => {
  console.log(`stdout: ${data}`);
});

ls.stderr.on('data', (data) => {
  console.error(`stderr: ${data}`);
});

ls.on('close', (code) => {
  console.log(`child process exited with code ${code}`);
});import { spawn } from 'node:child_process';
const ls = spawn('ls', ['-lh', '/usr']);

ls.stdout.on('data', (data) => {
  console.log(`stdout: ${data}`);
});

ls.stderr.on('data', (data) => {
  console.error(`stderr: ${data}`);
});

ls.on('close', (code) => {
  console.log(`child process exited with code ${code}`);
});copy

例: ps ax | grep sshを実行するための非常に手の込んだ方法

const { spawn } = require('node:child_process');
const ps = spawn('ps', ['ax']);
const grep = spawn('grep', ['ssh']);

ps.stdout.on('data', (data) => {
  grep.stdin.write(data);
});

ps.stderr.on('data', (data) => {
  console.error(`ps stderr: ${data}`);
});

ps.on('close', (code) => {
  if (code !== 0) {
    console.log(`ps process exited with code ${code}`);
  }
  grep.stdin.end();
});

grep.stdout.on('data', (data) => {
  console.log(data.toString());
});

grep.stderr.on('data', (data) => {
  console.error(`grep stderr: ${data}`);
});

grep.on('close', (code) => {
  if (code !== 0) {
    console.log(`grep process exited with code ${code}`);
  }
});import { spawn } from 'node:child_process';
const ps = spawn('ps', ['ax']);
const grep = spawn('grep', ['ssh']);

ps.stdout.on('data', (data) => {
  grep.stdin.write(data);
});

ps.stderr.on('data', (data) => {
  console.error(`ps stderr: ${data}`);
});

ps.on('close', (code) => {
  if (code !== 0) {
    console.log(`ps process exited with code ${code}`);
  }
  grep.stdin.end();
});

grep.stdout.on('data', (data) => {
  console.log(data.toString());
});

grep.stderr.on('data', (data) => {
  console.error(`grep stderr: ${data}`);
});

grep.on('close', (code) => {
  if (code !== 0) {
    console.log(`grep process exited with code ${code}`);
  }
});copy

失敗したspawnを確認する例

const { spawn } = require('node:child_process');
const subprocess = spawn('bad_command');

subprocess.on('error', (err) => {
  console.error('Failed to start subprocess.');
});import { spawn } from 'node:child_process';
const subprocess = spawn('bad_command');

subprocess.on('error', (err) => {
  console.error('Failed to start subprocess.');
});copy

特定のプラットフォーム（macOS、Linux）はプロセス名にargv[0]の値を使用しますが、他のプラットフォーム（Windows、SunOS）はcommandを使用します。

Node.jsは起動時にargv[0]をprocess.execPathで上書きするため、Node.jsの子プロセス内のprocess.argv[0]は、親からspawnに渡されたargv0パラメータと一致しません。代わりにprocess.argv0プロパティで取得してください。

signalオプションが有効な場合、対応するAbortControllerで.abort()を呼び出すことは、子プロセスで.kill()を呼び出すのと似ていますが、コールバックに渡されるエラーはAbortErrorになります。

const { spawn } = require('node:child_process');
const controller = new AbortController();
const { signal } = controller;
const grep = spawn('grep', ['ssh'], { signal });
grep.on('error', (err) => {
  // This will be called with err being an AbortError if the controller aborts
});
controller.abort(); // Stops the child processimport { spawn } from 'node:child_process';
const controller = new AbortController();
const { signal } = controller;
const grep = spawn('grep', ['ssh'], { signal });
grep.on('error', (err) => {
  // This will be called with err being an AbortError if the controller aborts
});
controller.abort(); // Stops the child processcopy

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

const subprocess = spawn(process.argv[0], ['child_program.js'], {
  detached: true,
  stdio: 'ignore',
});

subprocess.unref();import { spawn } from 'node:child_process';
import process from 'node:process';

const subprocess = spawn(process.argv[0], ['child_program.js'], {
  detached: true,
  stdio: 'ignore',
});

subprocess.unref();copy

const { openSync } = require('node:fs');
const { spawn } = require('node:child_process');
const out = openSync('./out.log', 'a');
const err = openSync('./out.log', 'a');

const subprocess = spawn('prg', [], {
  detached: true,
  stdio: [ 'ignore', out, err ],
});

subprocess.unref();import { openSync } from 'node:fs';
import { spawn } from 'node:child_process';
const out = openSync('./out.log', 'a');
const err = openSync('./out.log', 'a');

const subprocess = spawn('prg', [], {
  detached: true,
  stdio: [ 'ignore', out, err ],
});

subprocess.unref();copy

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

// Child will use parent's stdios.
spawn('prg', [], { stdio: 'inherit' });

// Spawn child sharing only stderr.
spawn('prg', [], { stdio: ['pipe', 'pipe', process.stderr] });

// Open an extra fd=4, to interact with programs presenting a
// startd-style interface.
spawn('prg', [], { stdio: ['pipe', null, null, null, 'pipe'] });import { spawn } from 'node:child_process';
import process from 'node:process';

// Child will use parent's stdios.
spawn('prg', [], { stdio: 'inherit' });

// Spawn child sharing only stderr.
spawn('prg', [], { stdio: ['pipe', 'pipe', process.stderr] });

// Open an extra fd=4, to interact with programs presenting a
// startd-style interface.
spawn('prg', [], { stdio: ['pipe', null, null, null, 'pipe'] });copy

child_process.execFileSync(file[, args][, options])#

• file <string> 実行する実行可能ファイルの名前またはパス。
• args <string[]> 文字列引数のリスト。
• options <Object>
  • cwd <string> | <URL> 子プロセスの現在の作業ディレクトリ。
  • input <string> | <Buffer> | <TypedArray> | <DataView> 起動されたプロセスにstdinとして渡される値。stdio[0]が'pipe'に設定されている場合、この値を指定するとstdio[0]が上書きされます。
  • stdio <string> | <Array> 子の標準入出力設定。child_process.spawn()のstdioを参照してください。stdioが指定されない限り、stderrはデフォルトで親プロセスのstderrに出力されます。 デフォルト: 'pipe'。
  • env <Object> 環境変数のキーと値のペア。 デフォルト: process.env。
  • uid <number> プロセスのユーザーIDを設定します（setuid(2)参照）。
  • gid <number> プロセスのグループIDを設定します（setgid(2)参照）。
  • timeout <number> プロセスが実行を許可される最大時間（ミリ秒単位）。 デフォルト: undefined。
  • killSignal <string> | <integer> 起動されたプロセスがキルされる際に使用されるシグナル値。 デフォルト: 'SIGTERM'。
  • maxBuffer <number> stdoutまたはstderrで許可される最大のデータ量（バイト単位）。超過した場合、子プロセスは終了させられます。maxBufferとUnicodeの注意点を参照してください。 デフォルト: 1024 * 1024。
  • encoding <string> すべてのstdio入出力に使用されるエンコーディング。 デフォルト: 'buffer'。
  • windowsHide <boolean> Windowsシステムで通常作成されるサブプロセスのコンソールウィンドウを非表示にします。 デフォルト: false。
  • shell <boolean> | <string> trueの場合、シェル内でcommandを実行します。Unixでは'/bin/sh'を使用し、Windowsではprocess.env.ComSpecを使用します。文字列として別のシェルを指定することもできます。シェルの要件およびデフォルトのWindowsシェルを参照してください。 デフォルト: false（シェルなし）。
• 戻り値: <Buffer> | <string> コマンドからの標準出力。

child_process.execFileSync()メソッドは、メソッドが子プロセスが完全に閉じるまで戻らないという点を除いて、一般的にchild_process.execFile()と同一です。タイムアウトが発生し、killSignalが送信された場合、メソッドはプロセスが完全に終了するまで戻りません。

子プロセスがSIGTERMシグナルを捕捉して処理し、終了しない場合でも、親プロセスは子プロセスが終了するまで待ち続けます。

プロセスがタイムアウトするか、ゼロ以外の終了コードを持つ場合、このメソッドは、基になるchild_process.spawnSync()の完全な結果を含むErrorをスローします。

shellオプションが有効な場合、サニタイズされていないユーザー入力をこの関数に渡さないでください。シェルメタ文字を含む入力は、任意のコマンド実行をトリガーするために使用される可能性があります。

const { execFileSync } = require('node:child_process');

try {
  const stdout = execFileSync('my-script.sh', ['my-arg'], {
    // Capture stdout and stderr from child process. Overrides the
    // default behavior of streaming child stderr to the parent stderr
    stdio: 'pipe',

    // Use utf8 encoding for stdio pipes
    encoding: 'utf8',
  });

  console.log(stdout);
} catch (err) {
  if (err.code) {
    // Spawning child process failed
    console.error(err.code);
  } else {
    // Child was spawned but exited with non-zero exit code
    // Error contains any stdout and stderr from the child
    const { stdout, stderr } = err;

    console.error({ stdout, stderr });
  }
}import { execFileSync } from 'node:child_process';

try {
  const stdout = execFileSync('my-script.sh', ['my-arg'], {
    // Capture stdout and stderr from child process. Overrides the
    // default behavior of streaming child stderr to the parent stderr
    stdio: 'pipe',

    // Use utf8 encoding for stdio pipes
    encoding: 'utf8',
  });

  console.log(stdout);
} catch (err) {
  if (err.code) {
    // Spawning child process failed
    console.error(err.code);
  } else {
    // Child was spawned but exited with non-zero exit code
    // Error contains any stdout and stderr from the child
    const { stdout, stderr } = err;

    console.error({ stdout, stderr });
  }
}copy

child_process.execSync(command[, options])#

• command <string> 実行するコマンド。
• options <Object>
  • cwd <string> | <URL> 子プロセスの現在の作業ディレクトリ。
  • input <string> | <Buffer> | <TypedArray> | <DataView> 起動されたプロセスにstdinとして渡される値。stdio[0]が'pipe'に設定されている場合、この値を指定するとstdio[0]が上書きされます。
  • stdio <string> | <Array> 子の標準入出力設定。child_process.spawn()のstdioを参照してください。stdioが指定されない限り、stderrはデフォルトで親プロセスのstderrに出力されます。 デフォルト: 'pipe'。
  • env <Object> 環境変数のキーと値のペア。 デフォルト: process.env。
  • shell <string> コマンドを実行するシェル。シェルの要件およびデフォルトのWindowsシェルを参照してください。 デフォルト: Unixでは'/bin/sh'、Windowsではprocess.env.ComSpec。
  • uid <number> プロセスのユーザーIDを設定します。（setuid(2)参照）。
  • gid <number> プロセスのグループIDを設定します。（setgid(2)参照）。
  • timeout <number> プロセスが実行を許可される最大時間（ミリ秒単位）。 デフォルト: undefined。
  • killSignal <string> | <integer> 起動されたプロセスがキルされる際に使用されるシグナル値。 デフォルト: 'SIGTERM'。
  • maxBuffer <number> stdoutまたはstderrで許可される最大のデータ量（バイト単位）。超過した場合、子プロセスは終了させられ、すべての出力は切り詰められます。maxBufferとUnicodeの注意点を参照してください。 デフォルト: 1024 * 1024。
  • encoding <string> すべてのstdio入出力に使用されるエンコーディング。 デフォルト: 'buffer'。
  • windowsHide <boolean> Windowsシステムで通常作成されるサブプロセスのコンソールウィンドウを非表示にします。 デフォルト: false。
• 戻り値: <Buffer> | <string> コマンドからの標準出力。

child_process.execSync()メソッドは、メソッドが子プロセスが完全に閉じるまで戻らないという点を除いて、一般的にchild_process.exec()と同一です。タイムアウトが発生してkillSignalが送信された場合、メソッドはプロセスが完全に終了するまで戻りません。子プロセスがSIGTERMシグナルを捕捉して処理し、終了しない場合でも、親プロセスは子プロセスが終了するまで待ち続けます。

プロセスがタイムアウトするか、ゼロ以外の終了コードを持つ場合、このメソッドは例外をスローします。Errorオブジェクトには、child_process.spawnSync()からの完全な結果が含まれます。

サニタイズされていないユーザー入力をこの関数に決して渡さないでください。シェルメタ文字を含む入力は、任意のコマンド実行をトリガーするために使用される可能性があります。

child_process.spawnSync(command[, args][, options])#

• command <string> 実行するコマンド。
• args <string[]> 文字列引数のリスト。
• options <Object>
  • cwd <string> | <URL> 子プロセスの現在の作業ディレクトリ。
  • input <string> | <Buffer> | <TypedArray> | <DataView> 起動されたプロセスにstdinとして渡される値。stdio[0]が'pipe'に設定されている場合、この値を指定するとstdio[0]が上書きされます。
  • argv0 <string> 子プロセスに送信されるargv[0]の値を明示的に設定します。指定しない場合、commandに設定されます。
  • stdio <string> | <Array> 子の標準入出力設定。child_process.spawn()のstdioを参照してください。 デフォルト: 'pipe'。
  • env <Object> 環境変数のキーと値のペア。 デフォルト: process.env。
  • uid <number> プロセスのユーザーIDを設定します（setuid(2)参照）。
  • gid <number> プロセスのグループIDを設定します（setgid(2)参照）。
  • timeout <number> プロセスが実行を許可される最大時間（ミリ秒単位）。 デフォルト: undefined。
  • killSignal <string> | <integer> 起動されたプロセスがキルされる際に使用されるシグナル値。 デフォルト: 'SIGTERM'。
  • maxBuffer <number> stdoutまたはstderrで許可される最大のデータ量（バイト単位）。超過した場合、子プロセスは終了させられ、すべての出力は切り詰められます。maxBufferとUnicodeの注意点を参照してください。 デフォルト: 1024 * 1024。
  • encoding <string> すべてのstdio入出力に使用されるエンコーディング。 デフォルト: 'buffer'。
  • shell <boolean> | <string> trueの場合、シェル内でcommandを実行します。Unixでは'/bin/sh'を使用し、Windowsではprocess.env.ComSpecを使用します。文字列として別のシェルを指定することもできます。シェルの要件およびデフォルトのWindowsシェルを参照してください。 デフォルト: false（シェルなし）。
  • windowsVerbatimArguments <boolean> Windowsでは引数の引用符付けやエスケープは行われません。Unixでは無視されます。shellが指定され、それがCMDの場合、自動的にtrueに設定されます。 デフォルト: false。
  • windowsHide <boolean> Windowsシステムで通常作成されるサブプロセスのコンソールウィンドウを非表示にします。 デフォルト: false。
• 戻り値: <Object>
  • pid <number> 子プロセスのPID。
  • output <Array> stdio出力からの結果の配列。
  • stdout <Buffer> | <string> output[1]の内容。
  • stderr <Buffer> | <string> output[2]の内容。
  • status <number> | <null> サブプロセスの終了コード、またはサブプロセスがシグナルにより終了した場合はnull。
  • signal <string> | <null> サブプロセスをキルするために使用されたシグナル、またはサブプロセスがシグナルにより終了しなかった場合はnull。
  • error <Error> 子プロセスが失敗したかタイムアウトした場合のエラーオブジェクト。

child_process.spawnSync()メソッドは、関数が子プロセスが完全に閉じるまで戻らないという点を除いて、一般的にchild_process.spawn()と同一です。タイムアウトが発生してkillSignalが送信された場合、メソッドはプロセスが完全に終了するまで戻りません。プロセスがSIGTERMシグナルを捕捉して処理し、終了しない場合でも、親プロセスは子プロセスが終了するまで待ち続けます。

shellオプションが有効な場合、サニタイズされていないユーザー入力をこの関数に渡さないでください。シェルメタ文字を含む入力は、任意のコマンド実行をトリガーするために使用される可能性があります。

イベント: 'close'#

• code <number> 子プロセスが自ら終了した場合の終了コード、または子プロセスがシグナルにより終了した場合はnull。
• signal <string> 子プロセスが終了させられたシグナル、または子プロセスがシグナルにより終了しなかった場合はnull。

'close'イベントは、プロセスが終了し、かつ子プロセスのstdioストリームが閉じられた後に発行されます。これは'exit'イベントとは異なります。なぜなら、複数のプロセスが同じstdioストリームを共有する可能性があるからです。'close'イベントは、'exit'が既に発行された後、または子プロセスの起動に失敗した場合は'error'の後に常に発行されます。

プロセスが終了した場合、codeはプロセスの最終的な終了コードで、それ以外はnullです。プロセスがシグナルの受信により終了した場合、signalはシグナルの文字列名で、それ以外はnullです。2つのうちどちらかは常に非nullです。

const { spawn } = require('node:child_process');
const ls = spawn('ls', ['-lh', '/usr']);

ls.stdout.on('data', (data) => {
  console.log(`stdout: ${data}`);
});

ls.on('close', (code) => {
  console.log(`child process close all stdio with code ${code}`);
});

ls.on('exit', (code) => {
  console.log(`child process exited with code ${code}`);
});import { spawn } from 'node:child_process';
const ls = spawn('ls', ['-lh', '/usr']);

ls.stdout.on('data', (data) => {
  console.log(`stdout: ${data}`);
});

ls.on('close', (code) => {
  console.log(`child process close all stdio with code ${code}`);
});

ls.on('exit', (code) => {
  console.log(`child process exited with code ${code}`);
});copy

イベント: 'disconnect'#

'disconnect'イベントは、親プロセスでsubprocess.disconnect()メソッドを呼び出した後、または子プロセスでprocess.disconnect()を呼び出した後に発行されます。切断後はメッセージの送受信ができなくなり、subprocess.connectedプロパティはfalseになります。

イベント: 'error'#

• err <Error> エラー。

'error'イベントは以下の場合に発行されます：

• プロセスを起動できなかった。
• プロセスをキルできなかった。
• 子プロセスへのメッセージ送信に失敗した。
• signalオプションによって子プロセスが中止された。

エラーが発生した後、'exit'イベントは発行される場合とされない場合があります。'exit'と'error'の両方のイベントをリッスンする場合、誤ってハンドラ関数を複数回呼び出さないように注意してください。

subprocess.kill()およびsubprocess.send()も参照してください。

イベント: 'exit'#

• code <number> 子プロセスが自ら終了した場合の終了コード、または子プロセスがシグナルにより終了した場合はnull。
• signal <string> 子プロセスが終了させられたシグナル、または子プロセスがシグナルにより終了しなかった場合はnull。

'exit'イベントは、子プロセスが終了した後に発行されます。プロセスが終了した場合、codeはプロセスの最終的な終了コードで、それ以外はnullです。プロセスがシグナルの受信により終了した場合、signalはシグナルの文字列名で、それ以外はnullです。2つのうちどちらかは常に非nullです。

'exit'イベントがトリガーされたとき、子プロセスのstdioストリームはまだ開いている可能性があります。

Node.jsはSIGINTとSIGTERMのシグナルハンドラを確立し、Node.jsプロセスはこれらのシグナルを受信してもすぐには終了しません。代わりに、Node.jsは一連のクリーンアップアクションを実行し、その後、処理されたシグナルを再発生させます。

waitpid(2)を参照してください。

イベント: 'message'#

• message <Object> パースされたJSONオブジェクトまたはプリミティブ値。
• sendHandle <Handle> | <undefined> undefined、またはnet.Socket、net.Server、またはdgram.Socketオブジェクト。

'message'イベントは、子プロセスがprocess.send()を使用してメッセージを送信したときにトリガーされます。

メッセージはシリアライゼーションとパースを経ます。結果のメッセージは、元々送信されたものと同じではないかもしれません。

子プロセスを起動する際にserializationオプションが'advanced'に設定されていた場合、message引数にはJSONが表現できないデータが含まれることがあります。詳細は高度なシリアライゼーションを参照してください。

イベント: 'spawn'#

'spawn'イベントは、子プロセスが正常に起動した後に一度発行されます。子プロセスが正常に起動しない場合、'spawn'イベントは発行されず、代わりに'error'イベントが発行されます。

発行された場合、'spawn'イベントは他のすべてのイベントの前、およびstdoutまたはstderr経由でデータが受信される前に発生します。

'spawn'イベントは、起動されたプロセス内でエラーが発生するかどうかに関わらず発行されます。たとえば、bash some-commandが正常に起動した場合、bashがsome-commandの起動に失敗したとしても、'spawn'イベントは発行されます。この注意点は{ shell: true }を使用する場合にも当てはまります。

subprocess.channel#

• 型: <Object> 子プロセスへのIPCチャネルを表すパイプ。

subprocess.channelプロパティは、子のIPCチャネルへの参照です。IPCチャネルが存在しない場合、このプロパティはundefinedです。

subprocess.connected#

• 型: <boolean> subprocess.disconnect()が呼び出された後にfalseに設定されます。

subprocess.connectedプロパティは、子プロセスからメッセージを送受信することがまだ可能かどうかを示します。subprocess.connectedがfalseの場合、メッセージの送受信はできなくなります。

subprocess.disconnect()#

親と子のプロセス間のIPCチャネルを閉じ、他に子プロセスを生かし続ける接続がない場合に、子プロセスが正常に終了できるようにします。このメソッドを呼び出した後、親と子プロセス（それぞれ）のsubprocess.connectedとprocess.connectedプロパティはfalseに設定され、プロセス間でメッセージを渡すことはできなくなります。

'disconnect'イベントは、受信中のメッセージがないときに発行されます。これは、ほとんどの場合、subprocess.disconnect()を呼び出した直後にトリガーされます。

子プロセスがNode.jsインスタンスである場合（例: child_process.fork()を使用して起動された場合）、子プロセス内でprocess.disconnect()メソッドを呼び出してIPCチャネルを閉じることもできます。

subprocess.exitCode#

• 型: <integer>

subprocess.exitCodeプロパティは、子プロセスの終了コードを示します。子プロセスがまだ実行中の場合、このフィールドはnullになります。

subprocess.kill([signal])#

• signal <number> | <string>
• 戻り値: <boolean>

subprocess.kill()メソッドは、子プロセスにシグナルを送信します。引数が指定されない場合、プロセスには'SIGTERM'シグナルが送信されます。利用可能なシグナルのリストについてはsignal(7)を参照してください。この関数はkill(2)が成功した場合はtrueを、そうでなければfalseを返します。

const { spawn } = require('node:child_process');
const grep = spawn('grep', ['ssh']);

grep.on('close', (code, signal) => {
  console.log(
    `child process terminated due to receipt of signal ${signal}`);
});

// Send SIGHUP to process.
grep.kill('SIGHUP');import { spawn } from 'node:child_process';
const grep = spawn('grep', ['ssh']);

grep.on('close', (code, signal) => {
  console.log(
    `child process terminated due to receipt of signal ${signal}`);
});

// Send SIGHUP to process.
grep.kill('SIGHUP');copy

シグナルが配送できない場合、ChildProcessオブジェクトは'error'イベントを発行することがあります。既に終了した子プロセスにシグナルを送信することはエラーではありませんが、予期せぬ結果を招く可能性があります。具体的には、プロセス識別子（PID）が別のプロセスに再割り当てされている場合、シグナルはそのプロセスに配送され、予期しない結果につながる可能性があります。

この関数名はkillですが、子プロセスに配送されるシグナルが実際にプロセスを終了させるとは限りません。

参考としてkill(2)を参照してください。

POSIXシグナルが存在しないWindowsでは、signal引数は'SIGKILL'、'SIGTERM'、'SIGINT'、'SIGQUIT'を除いて無視され、プロセスは常に強制的にかつ突然（'SIGKILL'と同様に）キルされます。詳細はシグナルイベントを参照してください。

Linuxでは、親プロセスをキルしようとしても、その子プロセスの子プロセスは終了しません。これは、シェルで新しいプロセスを実行したり、ChildProcessのshellオプションを使用した場合に起こり得ます。

const { spawn } = require('node:child_process');

const subprocess = spawn(
  'sh',
  [
    '-c',
    `node -e "setInterval(() => {
      console.log(process.pid, 'is alive')
    }, 500);"`,
  ], {
    stdio: ['inherit', 'inherit', 'inherit'],
  },
);

setTimeout(() => {
  subprocess.kill(); // Does not terminate the Node.js process in the shell.
}, 2000);import { spawn } from 'node:child_process';

const subprocess = spawn(
  'sh',
  [
    '-c',
    `node -e "setInterval(() => {
      console.log(process.pid, 'is alive')
    }, 500);"`,
  ], {
    stdio: ['inherit', 'inherit', 'inherit'],
  },
);

setTimeout(() => {
  subprocess.kill(); // Does not terminate the Node.js process in the shell.
}, 2000);copy

subprocess[Symbol.dispose]()#

subprocess.kill()を'SIGTERM'で呼び出します。

subprocess.killed#

• 型: <boolean> subprocess.kill()を使用して子プロセスにシグナルを正常に送信した後にtrueに設定されます。

subprocess.killedプロパティは、子プロセスがsubprocess.kill()からシグナルを正常に受信したかどうかを示します。killedプロパティは、子プロセスが終了したことを示すものではありません。

subprocess.pid#

• 型: <integer> | <undefined>

子プロセスのプロセス識別子（PID）を返します。エラーにより子プロセスが起動に失敗した場合、値はundefinedとなり、errorが発行されます。

const { spawn } = require('node:child_process');
const grep = spawn('grep', ['ssh']);

console.log(`Spawned child pid: ${grep.pid}`);
grep.stdin.end();import { spawn } from 'node:child_process';
const grep = spawn('grep', ['ssh']);

console.log(`Spawned child pid: ${grep.pid}`);
grep.stdin.end();copy

subprocess.ref()#

subprocess.unref()を呼び出した後にsubprocess.ref()を呼び出すと、子プロセスの削除された参照カウントが復元され、親プロセスは自身が終了する前に子プロセスが終了するのを待つようになります。

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

const subprocess = spawn(process.argv[0], ['child_program.js'], {
  detached: true,
  stdio: 'ignore',
});

subprocess.unref();
subprocess.ref();import { spawn } from 'node:child_process';
import process from 'node:process';

const subprocess = spawn(process.argv[0], ['child_program.js'], {
  detached: true,
  stdio: 'ignore',
});

subprocess.unref();
subprocess.ref();copy

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

• message <Object>
• sendHandle <Handle> | <undefined> undefined、またはnet.Socket、net.Server、またはdgram.Socketオブジェクト。
• options <Object> options引数が存在する場合、それは特定の種類のハンドルの送信をパラメータ化するために使用されるオブジェクトです。optionsは以下のプロパティをサポートします：
  • keepOpen <boolean> net.Socketのインスタンスを渡す際に使用できる値。trueの場合、ソケットは送信プロセスで開いたままになります。 デフォルト: false。
• callback <Function>
• 戻り値: <boolean>

親と子のプロセス間にIPCチャネルが確立されている場合（例: child_process.fork()を使用している場合）、subprocess.send()メソッドを使用して子プロセスにメッセージを送信できます。子プロセスがNode.jsインスタンスの場合、これらのメッセージは'message'イベントを介して受信できます。

メッセージはシリアライゼーションとパースを経ます。結果のメッセージは、元々送信されたものと同じではないかもしれません。

例えば、親スクリプトでは：

const { fork } = require('node:child_process');
const forkedProcess = fork(`${__dirname}/sub.js`);

forkedProcess.on('message', (message) => {
  console.log('PARENT got message:', message);
});

// Causes the child to print: CHILD got message: { hello: 'world' }
forkedProcess.send({ hello: 'world' });import { fork } from 'node:child_process';
const forkedProcess = fork(`${import.meta.dirname}/sub.js`);

forkedProcess.on('message', (message) => {
  console.log('PARENT got message:', message);
});

// Causes the child to print: CHILD got message: { hello: 'world' }
forkedProcess.send({ hello: 'world' });copy

そして子スクリプト'sub.js'は次のようになります：

process.on('message', (message) => {
  console.log('CHILD got message:', message);
});

// Causes the parent to print: PARENT got message: { foo: 'bar', baz: null }
process.send({ foo: 'bar', baz: NaN }); copy

子Node.jsプロセスは、子プロセスが親プロセスにメッセージを送り返すことができる独自のprocess.send()メソッドを持ちます。

{cmd: 'NODE_foo'}メッセージを送信する際には特別なケースがあります。cmdプロパティにNODE_プレフィックスを含むメッセージは、Node.jsコア内で使用するために予約されており、子の'message'イベントでは発行されません。むしろ、そのようなメッセージは'internalMessage'イベントを使用して発行され、Node.jsによって内部的に消費されます。アプリケーションは、予告なく変更される可能性があるため、そのようなメッセージの使用や'internalMessage'イベントのリッスンを避けるべきです。

subprocess.send()に渡すことができるオプションのsendHandle引数は、TCPサーバーまたはソケットオブジェクトを子プロセスに渡すためのものです。子プロセスは、'message'イベントに登録されたコールバック関数に渡される2番目の引数としてオブジェクトを受け取ります。ソケットで受信されバッファリングされたデータは子に送信されません。WindowsではIPCソケットの送信はサポートされていません。

オプションのcallbackは、メッセージが送信された後、しかし子プロセスがそれを受信する前に呼び出される関数です。この関数は単一の引数で呼び出されます：成功した場合はnull、失敗した場合はErrorオブジェクトです。

callback関数が提供されず、メッセージが送信できない場合、ChildProcessオブジェクトによって'error'イベントが発行されます。これは、例えば子プロセスが既に終了している場合に発生する可能性があります。

subprocess.send()は、チャネルが閉じているか、未送信メッセージのバックログがそれ以上送信するのが賢明でないしきい値を超えている場合にfalseを返します。それ以外の場合、メソッドはtrueを返します。callback関数を使用してフロー制御を実装できます。

const { fork } = require('node:child_process');
const { createServer } = require('node:net');

const subprocess = fork('subprocess.js');

// Open up the server object and send the handle.
const server = createServer();
server.on('connection', (socket) => {
  socket.end('handled by parent');
});
server.listen(1337, () => {
  subprocess.send('server', server);
});import { fork } from 'node:child_process';
import { createServer } from 'node:net';

const subprocess = fork('subprocess.js');

// Open up the server object and send the handle.
const server = createServer();
server.on('connection', (socket) => {
  socket.end('handled by parent');
});
server.listen(1337, () => {
  subprocess.send('server', server);
});copy

process.on('message', (m, server) => {
  if (m === 'server') {
    server.on('connection', (socket) => {
      socket.end('handled by child');
    });
  }
}); copy

const { fork } = require('node:child_process');
const { createServer } = require('node:net');

const normal = fork('subprocess.js', ['normal']);
const special = fork('subprocess.js', ['special']);

// Open up the server and send sockets to child. Use pauseOnConnect to prevent
// the sockets from being read before they are sent to the child process.
const server = createServer({ pauseOnConnect: true });
server.on('connection', (socket) => {

  // If this is special priority...
  if (socket.remoteAddress === '74.125.127.100') {
    special.send('socket', socket);
    return;
  }
  // This is normal priority.
  normal.send('socket', socket);
});
server.listen(1337);import { fork } from 'node:child_process';
import { createServer } from 'node:net';

const normal = fork('subprocess.js', ['normal']);
const special = fork('subprocess.js', ['special']);

// Open up the server and send sockets to child. Use pauseOnConnect to prevent
// the sockets from being read before they are sent to the child process.
const server = createServer({ pauseOnConnect: true });
server.on('connection', (socket) => {

  // If this is special priority...
  if (socket.remoteAddress === '74.125.127.100') {
    special.send('socket', socket);
    return;
  }
  // This is normal priority.
  normal.send('socket', socket);
});
server.listen(1337);copy

process.on('message', (m, socket) => {
  if (m === 'socket') {
    if (socket) {
      // Check that the client socket exists.
      // It is possible for the socket to be closed between the time it is
      // sent and the time it is received in the child process.
      socket.end(`Request handled with ${process.argv[2]} priority`);
    }
  }
}); copy

subprocess.signalCode#

• 型: <string> | <null>

subprocess.signalCodeプロパティは、子プロセスが受信したシグナルを示します。もしあれば、なければnullです。

subprocess.spawnargs#

• 型: <Array>

subprocess.spawnargsプロパティは、子プロセスが起動された際の完全なコマンドライン引数のリストを表します。

subprocess.spawnfile#

• 型: <string>

subprocess.spawnfileプロパティは、起動された子プロセスの実行可能ファイル名を示します。

child_process.fork()の場合、その値はprocess.execPathと等しくなります。child_process.spawn()の場合、その値は実行可能ファイルの名前になります。child_process.exec()の場合、その値は子プロセスが起動されたシェルの名前になります。

subprocess.stderr#

• 型: <stream.Readable> | <null> | <undefined>

子プロセスの stderr を表す Readable Stream です。

子プロセスが stdio[2] を 'pipe' 以外に設定して生成された場合、これは null になります。

subprocess.stderr は subprocess.stdio[2] のエイリアスです。両方のプロパティは同じ値を参照します。

子プロセスの生成に成功しなかった場合、subprocess.stderr プロパティは null または undefined になることがあります。

subprocess.stdin#

• 型: <stream.Writable> | <null> | <undefined>

子プロセスの stdin を表す Writable Stream です。

子プロセスがすべての入力を読み込むのを待つ場合、このストリームが end() によって閉じられるまで子プロセスは続行しません。

子プロセスが stdio[0] を 'pipe' 以外に設定して生成された場合、これは null になります。

subprocess.stdin は subprocess.stdio[0] のエイリアスです。両方のプロパティは同じ値を参照します。

子プロセスの生成に成功しなかった場合、subprocess.stdin プロパティは null または undefined になることがあります。

subprocess.stdio#

• 型: <Array>

child_process.spawn() に渡される stdio オプション内の 'pipe' という値に設定された位置に対応する、子プロセスへのパイプの疎な配列です。subprocess.stdio[0]、subprocess.stdio[1]、および subprocess.stdio[2] は、それぞれ subprocess.stdin、subprocess.stdout、および subprocess.stderr としても利用できます。

次の例では、子の fd 1 (stdout) のみがパイプとして設定されているため、親の subprocess.stdio[1] のみがストリームであり、配列内の他のすべての値は null です。

const assert = require('node:assert');
const fs = require('node:fs');
const child_process = require('node:child_process');

const subprocess = child_process.spawn('ls', {
  stdio: [
    0, // Use parent's stdin for child.
    'pipe', // Pipe child's stdout to parent.
    fs.openSync('err.out', 'w'), // Direct child's stderr to a file.
  ],
});

assert.strictEqual(subprocess.stdio[0], null);
assert.strictEqual(subprocess.stdio[0], subprocess.stdin);

assert(subprocess.stdout);
assert.strictEqual(subprocess.stdio[1], subprocess.stdout);

assert.strictEqual(subprocess.stdio[2], null);
assert.strictEqual(subprocess.stdio[2], subprocess.stderr);import assert from 'node:assert';
import fs from 'node:fs';
import child_process from 'node:child_process';

const subprocess = child_process.spawn('ls', {
  stdio: [
    0, // Use parent's stdin for child.
    'pipe', // Pipe child's stdout to parent.
    fs.openSync('err.out', 'w'), // Direct child's stderr to a file.
  ],
});

assert.strictEqual(subprocess.stdio[0], null);
assert.strictEqual(subprocess.stdio[0], subprocess.stdin);

assert(subprocess.stdout);
assert.strictEqual(subprocess.stdio[1], subprocess.stdout);

assert.strictEqual(subprocess.stdio[2], null);
assert.strictEqual(subprocess.stdio[2], subprocess.stderr);copy

子プロセスの生成に成功しなかった場合、subprocess.stdio プロパティは undefined になることがあります。

subprocess.stdout#

• 型: <stream.Readable> | <null> | <undefined>

子プロセスの stdout を表す Readable Stream です。

子プロセスが stdio[1] を 'pipe' 以外に設定して生成された場合、これは null になります。

subprocess.stdout は subprocess.stdio[1] のエイリアスです。両方のプロパティは同じ値を参照します。

const { spawn } = require('node:child_process');

const subprocess = spawn('ls');

subprocess.stdout.on('data', (data) => {
  console.log(`Received chunk ${data}`);
});import { spawn } from 'node:child_process';

const subprocess = spawn('ls');

subprocess.stdout.on('data', (data) => {
  console.log(`Received chunk ${data}`);
});copy

子プロセスの生成に成功しなかった場合、subprocess.stdout プロパティは null または undefined になることがあります。

subprocess.unref()#

デフォルトでは、親プロセスはデタッチされた子プロセスが終了するのを待ちます。親プロセスが特定の subprocess の終了を待たないようにするには、subprocess.unref() メソッドを使用します。これにより、親のイベントループは参照カウントに子プロセスを含めなくなり、子と親の間に確立されたIPCチャネルがない限り、親は子とは独立して終了できるようになります。

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

const subprocess = spawn(process.argv[0], ['child_program.js'], {
  detached: true,
  stdio: 'ignore',
});

subprocess.unref();import { spawn } from 'node:child_process';
import process from 'node:process';

const subprocess = spawn(process.argv[0], ['child_program.js'], {
  detached: true,
  stdio: 'ignore',
});

subprocess.unref();copy