Node.js v0.11.11 マニュアル & ドキュメンテーション


process#

process はグローバルオブジェクトで、どこからでもアクセスすることができます。 それは EventEmitter のインスタンスです。

Exit Codes#

未完了の非同期な操作が無くなると、Node はステータスコード 0 で正常に 終了します。その他のケースでは、以下のステータスコードが使われます。

  • 1 捕捉されなかった致命的な例外 - 捕捉されなかった例外があり、 それがドメインや uncaughtException イベントハンドラによって 処理されなかった。
  • 2 - 未使用 (Bashに組み込まれた誤用のために予約)。
  • 3 内部的な JavaScript のパースエラー - Node がプロセスを ブートストラップする内部用の JavaScript ソースコードでパースエラーが 発生した。 これはきわめてまれで、通常 Node 自身を開発している時にしか起こりません。
  • 4 内部的な JavaScript の評価失敗 - Node がプロセスを ブートストラップする内部用の JavaScript ソースコードが評価された際、 関数を返すことに失敗した。 これはきわめてまれで、通常 Node 自身を開発している時にしか起こりません。
  • 5 致命的なエラー - 致命的で回復不可能なエラーが V8 で発生した。 通常、標準エラー出力に接頭辞 FATAL ERROR とともにメッセージが出力されます。
  • 6 内部的エラーハンドラが関数ではない - 捕捉されない例外が発生したが、 内部的な例外ハンドラにどういうわけか関数ではないものが設定されていて 呼び出せなかった。
  • 7 内部的なエラーハンドラが実行時に失敗 - 捕捉されない例外が発生し、 それを処理していた内部的な例外ハンドラ自身も例外をスローした。 これはたとえば、process.on('uncaughtException') または domain.on('error') のハンドラが例外をスローした場合に発生します。
  • 8 - 未使用。以前のバージョンの Node では、終了コード 8 は捕捉されない例外を 示すことがありました。
  • 9 不正な引数 - 未知のオプションが指定された、あるいは値が必須の オプションが値無しで指定された。
  • 10 内部的な JavaScript の実行時失敗 - Node がプロセスを ブートストラップする内部用の JavaScript ソースコードが評価された際、 例外をスローした。 これはきわめてまれで、通常 Node 自身を開発している時にしか起こりません。
  • 12 不正なデバッグ引数 - --debug または --debug-brk が指定されたが、 不正なポート番号が選ばれた。
  • >128 シグナルによる終了 - Node が SIGKILLSIGHUP などの致命的なシグナルを受け取ると、終了コードは 128 にシグナルコードを 加えた値になります。 これは終了コードが 7bit 整数で定義された時からの Unix の標準的な慣習で、 シグナルによる終了は最上位のビットを設定し、シグナルコードの値を含みます。

Event: 'exit'#

プロセスが終了しようとしている時に生成されます。 この位置からイベントループを抜けることを防ぐ方法はなく、全ての 'exit' リスナーの実行が完了すると、プロセスは終了します。 従って、このハンドラでできることは 同期 操作 だけ です。 これは (ユニットテストのように) モジュールの状態をチェックするのに適した フックとなります。 コールバックはプロセスの終了コードを唯一の引数として呼び出されます。

exit を監視する例:

process.on('exit', function(code) {
  // do *NOT* do this
  setTimeout(function() {
    console.log('This will not run');
  }, 0);
  console.log('About to exit with code:', code);
});

Event: 'uncaughtException'#

発生した例外がイベントループまでたどり着いた場合に生成されます。 もしこの例外に対するリスナーが加えられていれば、 デフォルトの動作 (それはスタックトレースをプリントして終了します) は起こりません。

uncaughtException を監視する例:

process.on('uncaughtException', function(err) {
  console.log('Caught exception: ' + err);
});

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

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

uncaughtException は例外を扱うとても荒削りなメカニズムであることに 注意してください。

これを使う代わりに、ドメイン を使ってください。 それを使えば、捕まえられない例外が発生した後でもアプリケーションを 再開することができます!

これを Node.js における On Error Resume Next として 使わないで ください。 捕まえられなかった例外は、アプリケーション - および Node.js 自身の拡張 - が未定義の状態となることを意味します。 やみくもな再開は どんなことでも 起こることを意味します。

電源を引き抜きながらアプリケーションをアップグレードすることを 想像してください。 10 回中 9 回は何も起こりません - しかし 10 回目にはそのシステムは使えなくなるかもしれません。

これは警告です。

Signal Events#

プロセスがシグナルを受信した場合に生成されます。 SIGINT、SIGHUP、その他の POSIX 標準シグナル名の一覧について は sigaction(2) を参照してください。

SIGINTを監視する例:

// Start reading from stdin so we don't exit.
process.stdin.resume();

process.on('SIGINT', function() {
  console.log('Got SIGINT.  Press Control-D to exit.');
});

多くの端末プログラムで簡単に SIGINT を送る方法は Control-C を押すことです。

注意:

  • SIGUSR1 は Node.js がデバッガを起動するために予約されています。 リスナを登録することは出来ますが、デバッガの起動を止めることは出来ません。
  • SIGTERM および SIGINT は、Windows 以外のプラットフォームでは 128 + シグナル番号で終了する前にターミナルのモードをリセットする デフォルトのハンドラを持ちます。 これらのシグナルのどちらかにリスナが登録されると、デフォルトの振る舞いは 削除されます (node は終了しなくなります)。
  • SIGPIPE はデフォルトでは無視され、リスナを登録することが出来ます。
  • SIGHUP は Windows ではコンソールウィンドウが閉じられると発生します。 他のプラットフォームでも同様の条件で発生します。詳細は signal(7) を参照してください。 リスナを登録することは出来ますが、Windows では約 10 秒後に node は無条件に Windows によって終了されます。 Windows 以外のプラットフォームでは、SIGHUP のデフォルトの振る舞いは nodeを終了することですが、リスナを登録するとデフォルトの振る舞いは 削除されます。
  • SIGTERM は Windows ではサポートされません。 しかし、リスナを登録することは可能です。
  • 端末からの SIGINT は全てのプラットフォームでサポートされ、通常 CTRL+C (おそらく設定可能でしょう) によって生成されます。 ターミナルが raw モードの場合は生成されません。
  • SIGBREAK は Windows において CTRL+BREAK が推された時に送られます。 Windows 以外のプラットフォームでもリスナを登録することは出来ますが、 それを生成したり送信する方法はありません。
  • SIGWINCH はコンソールのサイズが変更された場合に送られます。 Windows では、カーソルが移動するか、tty が raw モードの場合に、 コンソールへ書き込むと発生します。
  • SIGKILL のリスナを組み込むことは出来ません。 それは全てのプラットフォームで node を無条件に終了します。
  • SIGSTOP のリスナを組み込むことは出来ません。

Windows はシグナルの送信をサポートしていませんが、nodeはprocess.kill()child_process.kill() をエミュレートする方法を提供します:

  • シグナル 0 は既存のプロセスを検索するためのものです。
  • SIGINTSIGTERM、そして SIGKILL は、ターゲットのプロセスが無条件に 終了する原因となります。

process.stdout#

stdout に対する Writable Stream です。

例: console.log の定義

console.log = function(d) {
  process.stdout.write(d + '\n');
};

process.stderrprocess.stdout は他のストリームと異なり、 書き込みは通常ブロックします。 それらが通常ファイルや TTY のファイル記述子を参照しているケースでは、 それらはブロックします。 パイプを参照しているケースでは、他のストリームと同様にブロックしません。

Node が TTY のコンテキストで実行されているかチェックするには、 process.stderr, process.stdout, または process.stdinisTTY プロパティを参照します。

$ 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

より詳細は the tty docs を参照してください。

process.stderr#

stderr に対する Writable Stream です。

process.stderrprocess.stdout は他のストリームと異なり、 書き込みは通常ブロックします。 それらが通常ファイルや TTY のファイル記述子を参照しているケースでは、 それらはブロックします。 パイプを参照しているケースでは、他のストリームと同様にブロックしません。

process.stdin#

標準入力に対する Readable Stream です。 デフォルトでは、標準入力に対するストリームは中断されているため、 読み込みのためには process.stdin.resume() を呼び出さなければなりません。

標準入力をオープンして二つのイベントを監視する例:

process.stdin.resume();
process.stdin.setEncoding('utf8');

process.stdin.on('data', function(chunk) {
  process.stdout.write('data: ' + chunk);
});

process.stdin.on('end', function() {
  process.stdout.write('end');
});

process.argv#

コマンドライン引数を含む配列です。 最初の要素は 'node'、2 番目の要素は JavaScript ファイルの名前になります。 その後の要素はコマンドラインの追加の引数になります。

// print process.argv
process.argv.forEach(function(val, index, array) {
  console.log(index + ': ' + val);
});

このように出力されます:

$ node process-2.js one two=three four
0: node
1: /Users/mjr/work/node/process-2.js
2: one
3: two=three
4: four

process.execPath#

プロセスによって開始された実行可能ファイルの絶対パスです。

例:

/usr/local/bin/node

process.execArgv#

これはプロセス起動時に実行可能ファイルに与えられた node 固有の コマンドライン・オプション群です。 それらのオプションは process.argv には現れず、node の実行可能ファイルや スクリプト名、スクリプト名に続くどんなオプションも含まれません。 これらのオプションは親プロセスと同じ実行環境を持つ子プロセスを起動するために 役に立ちます。

例:

$ node --harmony script.js --version

process.execArgv の結果:

['--harmony']

そして process.argv の結果:

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

process.abort()#

これは node をアボートさせます。 これは node が終了してコアファイルを生成する原因となります。

process.chdir(directory)#

プロセスのカレントワーキングディレクトリを変更します。 もし失敗した場合は例外をスローします。

console.log('Starting directory: ' + process.cwd());
try {
  process.chdir('/tmp');
  console.log('New directory: ' + process.cwd());
}
catch (err) {
  console.log('chdir: ' + err);
}

process.cwd()#

プロセスのカレントワーキングディレクトリを返します。

console.log('Current directory: ' + process.cwd());

process.env#

ユーザの環境を含むオブジェクトです。environ(7) を参照してください。

process.exit([code])#

指定の code でプロセスを終了します。 もし省略されると、「成功」を示すコード 0 を使って終了します。

「失敗」を示すコードで終了する例:

process.exit(1);

node を実行したシェルで終了コードが 1 であることを見ることができるでしょう。

process.exitCode#

プロセスが正常終了する場合や、process.exit() でコードが指定されなかった 場合に、終了コードとなる数値。

process.exit(code) でコードが指定されると、以前 process.exitCode に 設定された値は上書きされます。

process.getgid()#

注意: この関数は POSIX プラットフォーム (すなわち、Windows と Android 以外) でのみ利用可能です。

プロセスのグループ識別子を取得します (getgid(2) 参照)。 これは数値によるグループ ID で、グループ名ではありません。

if (process.getgid) {
  console.log('Current gid: ' + process.getgid());
}

process.setgid(id)#

注意: この関数は POSIX プラットフォーム (すなわち、Windows と Android 以外) でのみ利用可能です。

プロセスのグループ識別子を設定します (setgid(2) 参照)。 これは数値による ID もグループ名の文字列のどちらも受け入れます。 もしグループ名が指定されると、数値による ID が解決できるまでこのメソッドはブロックします。

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

process.getuid()#

注意: この関数は POSIX プラットフォーム (すなわち、Windows と Android 以外) でのみ利用可能です。

プロセスのユーザ識別子を取得します (getuid(2) 参照)。 これは数値によるユーザ ID で、ユーザ名ではありません。

if (process.getuid) {
  console.log('Current uid: ' + process.getuid());
}

process.setuid(id)#

注意: この関数は POSIX プラットフォーム (すなわち、Windows と Android 以外) でのみ利用可能です。

プロセスのユーザ識別子を設定します (setuid(2) 参照)。 これは数値による ID もユーザ名の文字列のどちらも受け入れます。 もしユーザ名が指定されると、数値による ID が解決できるまでこのメソッドはブロックします。

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

process.getgroups()#

注意: この関数は POSIX プラットフォーム (すなわち、Windows と Android 以外) でのみ利用可能です。

補助グループ ID の配列を返します。 POSIX は実効グループ ID が含まれることを明示していませんが、 Node.js では常にそれが含まれることを保証します。

process.setgroups(groups)#

注意: この関数は POSIX プラットフォーム (すなわち、Windows と Android 以外) でのみ利用可能です。

補助グループ ID を設定します。 これは特権オペレーションであり、ルートであるか、または CAP_SETGID ケーパビリティを持つ必要があります。

リストはグループ ID、グループ名、または両方を含むことができます。

process.initgroups(user, extra_group)#

注意: この関数は POSIX プラットフォーム (すなわち、Windows と Android 以外) でのみ利用可能です。

/etc/group を読み込んでグループアクセスリストを初期化し、 user がメンバーである全てのグループを使用します。 これは特権オペレーションであり、ルートであるか、または CAP_SETGID ケーパビリティを持つ必要があります。

user はユーザ名またはユーザ ID、 extra_group はグループ名またはグループ ID です。

特権を落とす際は、いくつか注意すべき事があります。例:

console.log(process.getgroups());         // [ 0 ]
process.initgroups('bnoordhuis', 1000);   // switch user
console.log(process.getgroups());         // [ 27, 30, 46, 1000, 0 ]
process.setgid(1000);                     // drop root gid
console.log(process.getgroups());         // [ 27, 30, 46, 1000 ]

process.version#

NODE_VERSION を提示するコンパイル済みプロパティです。

console.log('Version: ' + process.version);

process.versions#

node と依存ライブラリのバージョン文字列を提示します。

console.log(process.versions);

は以下のように出力します。

{ http_parser: '1.0',
  node: '0.10.4',
  v8: '3.14.5.8',
  ares: '1.9.0-DEV',
  uv: '0.10.3',
  zlib: '1.2.3',
  modules: '11',
  openssl: '1.0.1e' }

process.config#

現在のnode実行ファイルをコンパイルした際に使われた configure のオプションを JavaScript で表現したオブジェクトを保持します。 これは ./configure スクリプトを実行した際に生成された "cofnig.gypi" ファイルと同じです。

実際の出力の例です:

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

process.kill(pid, [signal])#

プロセスにシグナルを送ります。 pid はプロセス ID で signal は送信されるシグナルを文字列で記述したものです。 シグナルの名前は 'SIGINT''SIGHUP' のような文字列です。 省略すると、シグナルは 'SIGTERM' となります。 詳細は Signal Events および kill(2) を参照してください。

対象が存在しない場合はエラーがスローされます。 特殊なケースとして、プロセスが存在することを確認するためにシグナル 0 を使うことが出来ます。

この関数の名前が process.kill であるとおり、これは kill システムコールのように単にシグナルを送信することに注意してください。 対象のプロセスを殺すためだけでなく、他のシグナルも送信できます。

自身にシグナルを送信する例:

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

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

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

注意: SIGUSR1 が Node.js によって受け取られると、それはデバッガを起動します。 Signal Events を参照してください。

process.pid#

このプロセスの PID です。

console.log('This process is pid ' + process.pid);

process.title#

'ps' でどのよう表示されるかを設定するための getter/setter です。

setter が使われる場合、その最大長はプラットフォーム依存で、おそらく短いです。

Linux と OS X では、それは argv のメモリを上書きするため、 バイナリ名にコマンドライン引数を加えたものに制限されます。

v0.8 はより長いプロセスタイトル文字列で環境を上書きしていましたが、 それはいくつかの (はっきりしない) ケースにおいて、 潜在的に危険で混乱していました。

process.arch#

実行しているプロセッサのアーキテクチャ: 'arm''ia32'、または 'x64'

console.log('This processor architecture is ' + process.arch);

process.platform#

どのプラットフォームで動いているかを示します: 'darwin''freebsd''linux''sunos'、または 'win32'

console.log('This platform is ' + process.platform);

process.memoryUsage()#

Node プロセスのメモリ使用状況をバイト単位で記述したオブジェクトを返します。

var util = require('util');

console.log(util.inspect(process.memoryUsage()));

このように生成されます:

{ rss: 4935680,
  heapTotal: 1826816,
  heapUsed: 650472 }

heapTotalheapUsed は V8 のメモリ使用状況を参照します。

process.nextTick(callback)#

  • callback Function

現在のイベントループが完了した後、コールバック関数を呼び出します。

これは setTimeout(fn, 0) の単純なエイリアスではなく、 はるかに効率的です。 これは他のどの I/O イベント (タイマを含みます) が発生するよりも前に 実行されます。

console.log('start');
process.nextTick(function() {
  console.log('nextTick callback');
});
console.log('scheduled');
// Output:
// start
// scheduled
// nextTick callback

これは API の開発において、オブジェクトが構築された後で どんな I/O イベントが発生するよりも前に、 イベントハンドラを割り当てるチャンスをユーザに与えたい場合に重要になります。

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

  process.nextTick(function() {
    this.startDoingStuff();
  }.bind(this));
}

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

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

API は 100% 同期的か、100% 非同期的かのどちらかであることがとても重要です。 この例を考えてみてください:

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

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

この API は危険です。こうすると:

maybeSync(true, function() {
  foo();
});
bar();

foo()bar() のどちらが先に呼び出されるか不明瞭になります。

以下のアプローチはずっと優れています:

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

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

注意: イベントループの各繰り返しでは、I/O が処理される に nextTick のキューが完全に空にされます。 この結果、再帰的に設定された nextTick のコールバックは、 while (true); ループのように全てのI/O をブロックします

process.umask([mask])#

プロセスのファイルモード作成マスクを設定または読み込みます。 子プロセスは親プロセスからマスクを継承します。 mask 引数が与えられると元のマスクが返され、そうでなければ現在のマスクが返されます。

var oldmask, newmask = 0644;

oldmask = process.umask(newmask);
console.log('Changed umask from: ' + oldmask.toString(8) +
            ' to ' + newmask.toString(8));

process.uptime()#

Node が実行されてからの秒数です。

process.hrtime()#

高分解能な現在時刻を [seconds, nanoseconds] の配列で返します。 過去の任意の時間との比較することができます。 それは一日における時刻には関連が無いため、クロックドリフトに影響されません。 主な用途はベンチマークやインターバルの測定です。

以前に process.hrtime() を呼び出した結果を渡すことにより、 差分を得ることができます。これはベンチマークやインターバルの測定に便利です。

var time = process.hrtime();
// [ 1800216, 25 ]

setTimeout(function() {
  var diff = process.hrtime(time);
  // [ 1, 552 ]

  console.log('benchmark took %d nanoseconds', diff[0] * 1e9 + diff[1]);
  // benchmark took 1000000527 nanoseconds
}, 1000);

Async Listeners#

Stability: 1 - Experimental

AsyncListener API は、開発者が非同期イベントの有効期間中に キーとなるイベントの通知を受け取ることを可能にする、 AsyncWrap クラスへの JavaScript インターフェースです。 Node は内部的に多くの非同期イベントを扱うため、この API を使用することは アプリケーションのパフォーマンスに 重大な影響 を与えます。

process.createAsyncListener(callbacksObj[, userData])#

  • callbacksObj {Object} 非同期イベントのライフサイクル中に、 指定された回数だけ呼び出されるオプションのコールバックを含むオブジェクト。
  • userData {Value} 全てのコールバックに渡される値。

構築された AsyncListener オブジェクトを返します。

非同期イベントを捉えるには、process.addAsyncListener()callbacksObj か既存の AsyncListener インスタンスのいずれかを渡してください。 同じ AsyncListener インスタンスは一度だけアクティブなキューに加えられます。 それ以降、インスタンスの追加を試みても無視されます。

イベントの捕捉を止めるには、AsyncListener インスタンスを process.removeAsyncListener() に渡してください。 それは以前に加えられた AsyncListener がコールバックされなくなることを 意味 しません。 一度非同期イベントに加えられると、それは非同期処理のコールスタックが有効な間、 持続します。

関数のパラメータの説明:

callbacksObj: オプションのフィールドを3つ持つことができる Object です。

  • create(userData): 非同期イベントが生成された時に呼び出される関数。 関数がもし Value を返すなら、それはイベントに割り当てられ、 process.createAsyncListener()storageValue 引数に渡された値を 上書きします。 作成時に storageValue の初期値が渡されていた場合、asyncListener() は 関数の引数としてそれを受け取ります。
  • before(context, userData): 非同期コールバックが実行される前に 呼び出される関数です。 それは呼び出される関数の context (すなわち this) と、 asyncListener の戻り値または構築時に渡された値 (両方の場合) のどちらかが storageValue として渡されます。
  • after(context, userData): 非同期イベントのコールバックが実行された後で 呼び出される関数です。 コールバックがエラーをスローしてそれが処理されなければ、 これは呼び出されないことに注意してください。
  • error(userData, error): イベントのコールバックがスローすると 呼び出されます。 もし登録された関数が true を返すと、Node はエラーが正しく処理されたと見なし、 正常に実行を再開します。 複数の error() が登録されている場合、エラーが処理されたと AsyncListener に 認められるには、一つ だけでもコールバックが true を返す必要がありますが、 全ての error() コールバックは常に実行されます。
  • userData: デフォルトで、新しいイベントのインスタンスに割り当てられる値 (つまり何でも)。create() が返す値によって上書きされるかもしれません。

userData が上書きされる例です:

process.createAsyncListener({
  create: function listener(value) {
    // value === true
    return false;
}, {
  before: function before(context, value) {
    // value === false
  }
}, true);

注意: EventEmitter は、非同期イベントを生成するために使われますが、 それ自身は非同期ではありません。 そのため、イベントが加えられても create() は呼び出されず、 コールバックが呼び出されても before/after は呼び出されません。

process.addAsyncListener(callbacksObj[, userData])#

process.addAsyncListener(asyncListener)#

AsyncListener オブジェクトを構築し、それを非同期イベントを捕捉するキューに 加えて返します。

関数の引数は process.createAsyncListener() と同じか、 構築された AsyncListener オブジェクトです。

エラーを捕捉する例:

var fs = require('fs');

var cntr = 0;
var key = process.addAsyncListener({
  create: function onCreate() {
    return { uid: cntr++ };
  },
  before: function onBefore(context, storage) {
    // Write directly to stdout or we'll enter a recursive loop
    fs.writeSync(1, 'uid: ' + storage.uid + ' is about to run\n');
  },
  after: function onAfter(context, storage) {
    fs.writeSync(1, 'uid: ' + storage.uid + ' is about to run\n');
  },
  error: function onError(storage, err) {
    // Handle known errors
    if (err.message === 'everything is fine') {
      fs.writeSync(1, 'handled error just threw:\n');
      fs.writeSync(1, err.stack + '\n');
      return true;
    }
  }
});

process.nextTick(function() {
  throw new Error('everything is fine');
});

// Output:
// uid: 0 is about to run
// handled error just threw:
// Error: really, it's ok
//     at /tmp/test2.js:27:9
//     at process._tickCallback (node.js:583:11)
//     at Function.Module.runMain (module.js:492:11)
//     at startup (node.js:123:16)
//     at node.js:1012:3

process.removeAsyncListener(asyncListener)#

AsyncListener を監視キューから削除します。

アクティブなキューから AsyncLister を削除することは、 登録されたイベントに対して asyncListener コールバックの 呼び出しが中断されることを意味 しません。 その後、コールバックが実行される間に生成される全てのイベントも、 将来の実行のために同じ asyncListener に割り当てられます。

var fs = require('fs');

var key = process.createAsyncListener({
  create: function asyncListener() {
    // Write directly to stdout or we'll enter a recursive loop
    fs.writeSync(1, 'You summoned me?\n');
  }
});

// We want to begin capturing async events some time in the future.
setTimeout(function() {
  process.addAsyncListener(key);

  // Perform a few additional async events.
  setTimeout(function() {
    setImmediate(function() {
      process.nextTick(function() { });
    });
  });

  // Removing the listener doesn't mean to stop capturing events that
  // have already been added.
  process.removeAsyncListener(key);
}, 100);

// Output:
// You summoned me?
// You summoned me?
// You summoned me?
// You summoned me?

4つの非同期イベントを記録したという事実は、Node の Timers 実装の詳細を 表しています。

非同期イベントの捕捉を特定のスタック上で止めたければ、 process.removeAsyncListener() はそのコールスタック自身で呼び出すべきです。 たとえば:

var fs = require('fs');

var key = process.createAsyncListener({
  create: function asyncListener() {
    // Write directly to stdout or we'll enter a recursive loop
    fs.writeSync(1, 'You summoned me?\n');
  }
});

// We want to begin capturing async events some time in the future.
setTimeout(function() {
  process.addAsyncListener(key);

  // Perform a few additional async events.
  setImmediate(function() {
    // Stop capturing from this call stack.
    process.removeAsyncListener(key);

    process.nextTick(function() { });
  });
}, 100);

// Output:
// You summoned me?

ユーザは削除したい AsyncListener をいつでも明示的に渡すべきです。 すべてのリスナを一度に削除することは出来ません。