process对象是一个全局对象，可以在任何地方访问到它。 它是的一个实例。
Exit Codes
Node 执行程序正常情况下会返回 0，这也意味着，包括所有“异步”在内的操作都已结束。（笔者注：linux terminal 下使用 echo $? 查看，win cmd 下使用 echo %ERRORLEVEL% 查看）除此之外的其他返回状态如下：
1 未捕获的致命异常(Uncaught Fatal Exception) - There was an uncaught exception, and it was not handled by a domain or an uncaughtException event handler.
2 - 未使用(Unused) (reserved by Bash for builtin misuse)
3 解析错误(Internal JavaScript Parse Error) - The JavaScript source code internal in Node's bootstrapping process caused a parse error. This is extremely rare, and generally can only happen during development of Node itself.
4 评估失败(Internal JavaScript Evaluation Failure) - The JavaScript source code internal in Node's bootstrapping process failed to return a function value when evaluated. This is extremely rare, and generally can only happen during development of Node itself.
5 致命错误(Fatal Error) - There was a fatal unrecoverable error in V8. Typically a message will be printed to stderr with the prefix FATAL ERROR.
6 未正确的异常处理(Non-function Internal Exception Handler) - There was an uncaught exception, but the internal fatal exception handler function was somehow set to a non-function, and could not be called.
7 异常处理函数运行时失败(Internal Exception Handler Run-Time Failure) - There was an uncaught exception, and the internal fatal exception handler function itself threw an error while attempting to handle it. This can happen, for example, if a process.on('uncaughtException') or domain.on('error') handler throws an error.
8 - 未使用(Unused). In previous versions of Node, exit code 8 sometimes indicated an uncaught exception.
9 - 无效的参数(Invalid Argument) - Either an unknown option was specified, or an option requiring a value was provided without a value.
10 运行时失败(Internal JavaScript Run-Time Failure) - The JavaScript source code internal in Node's bootstrapping process threw an error when the bootstrapping function was called. This is extremely rare, and generally can only happen during development of Node itself.
12 无效的调试参数(Invalid Debug Argument) - The --debug and/or --debug-brk options were set, but an invalid port number was chosen.
&128 信号退出(Signal Exits) - If Node receives a fatal signal such as SIGKILL or SIGHUP, then its exit code will be 128 plus the value of the signal code. This is a standard Unix practice, since exit codes are defined to be 7-bit integers, and signal exits set the high-order bit, and then contain the value of the signal code.
事件: 'exit'
当进程将要退出时触发。这是一个在固定时间检查模块状态（如单元测试）的好时机。需要注意的是 'exit' 的回调结束后，主事件循环将不再运行，所以计时器也会失效。
监听 exit 事件的例子：
process.on('exit', function() {
// 设置一个延迟执行
setTimeout(function() {
console.log('主事件循环已停止，所以不会执行');
console.log('退出前执行');
事件: 'uncaughtException'（未捕获错误）
当一个异常冒泡回归到事件循环中就会触发这个事件，如果建立了一个监听器来监听这个异常，默认的行为（打印堆栈跟踪信息并退出）就不会发生。
监听 uncaughtException 示例:
// 故意制造一个异常，而且不catch捕获它.
nonexistentFunc();
console.log('This will not run.');
注意，uncaughtException未捕获异常是一个非常粗略的异常处理。
尽量不要使用它，使用
来代替它，如果你已经使用了，请在不处理这个异常之后重启你的应用。
请 不要 象使用node.js的有错误回复执行这样使用.一个未处理异常意味着你的应用和你的扩展Node.js自身是有未知状态的。盲目的恢复意味着任何事情都可能发生。
你在升级的系统时拉掉了电源线，然后恢复了。可能10次里有9次每一偶问题，但是第10次，你的系统就会崩溃。
你已经被警告。
Signal Events
当进程接收到信号时触发。信号列表详见 POSIX 标准的 sigaction（2）如 SIGINT、SIGUSR1 等。
监听 SIGINT 信号的示例：
// 设置 'SIGINT' 信号触发事件
process.on('SIGINT', function() {
console.log('收到 SIGINT 信号。
退出请使用 Ctrl + D ');
在大多数终端下，一个发送 SIGINT 信号的简单方法是按下 ctrl + c 。
process.stdout
一个指向标准输出流(stdout)的 可写的流(Writable Stream)。
举例: console.log 的实现
console.log = function(d) {
process.stdout.write(d + '\n');
process.stderr 和 process.stdout 不像 Node 中其他的流(Streams) 那样，他们通常是阻塞式的写入。当其引用指向 普通文件 或者 TTY文件描述符 时他们就是阻塞的（注：TTY 可以理解为终端的一种，可联想 PuTTY，详见）。当他们引用指向管道(pipes)时，他们就同其他的流(Streams)一样是非阻塞的。
要检查 Node 是否正在运行一个 TTY上下文 中（注：linux 中没有运行在 tty 下的进程是 守护进程 ），可以用使用 process.stderr、process.stdout 或 process.stdin 的 isTTY 属性：
$ node -p &Boolean(process.stdout.isTTY)&
$ node -p &Boolean(process.stdout.isTTY)& | cat
更多信息，请查看 。
process.stderr
一个指向标准错误流(stderr)的 可写的流(Writable Stream)。
process.stderr 和 process.stdout 不像 Node 中其他的流(Streams) 那样，他们通常是阻塞式的写入。当其引用指向 普通文件 或者 TTY文件描述符 时他们就是阻塞的（注：TTY 可以理解为终端的一种，可联想 PuTTY，详见）。当他们引用指向管道(pipes)时，他们就同其他的流(Streams)一样是非阻塞的。
process.stdin
一个指向 标准输入流(stdin) 的可读流(Readable Stream)。标准输入流默认是暂停 (pause) 的，所以必须要调用 process.stdin.resume() 来恢复 (resume) 接收。
打开标准输入流，并监听两个事件的示例：
process.stdin.on('end', function() {
process.stdout.write('end');
// gets 函数的简单实现
function gets(cb){
process.stdin.resume();
process.stdin.setEncoding('utf8');
process.stdin.on('data', function(chunk) {
process.stdin.pause();
cb(chunk);
gets(function(reuslt){
console.log(&[&+reuslt+&]&);
process.argv
一个包含命令行参数的数组。第一个元素会是 'node'， 第二个元素将是 .Js 文件的名称。接下来的元素依次是命令行传入的参数。
// 打印 process.argv
process.argv.forEach(function(val, index, array) {
console.log(index + ': ' + val);
输出将会是：
$ node process-2.js one two=three four
1: /Users/mjr/work/node/process-2.js
3: two=three
process.execPath
开启当前进程的这个可执行文件的绝对路径。
/usr/local/bin/node
process.execArgv
与 process.argv 类似，不过是用于保存 node特殊(node-specific) 的命令行选项（参数）。这些特殊的选项不会出现在 process.argv 中，而且 process.execArgv 不会保存 process.argv 中保存的参数（如 0:node 1:文件名 2.3.4.参数 等）， 所有文件名之后的参数都会被忽视。这些选项可以用于派生与与父进程相同执行环境的子进程。
$ node --harmony script.js --version
process.execArgv 中的特殊选项:
['--harmony']
process.argv 接收到的参数:
['/usr/local/bin/node', 'script.js', '--version']
process.abort()
这将导致 Node 触发一个abort事件，这会导致Node退出并且创建一个核心文件。
process.chdir(directory)
改变进程的当前进程的工作目录，若操作失败则抛出异常。
console.log('当前目录：' + process.cwd());
process.chdir('/tmp');
console.log('新目录：' + process.cwd());
catch (err) {
console.log('chdir: ' + err);
process.cwd()
返回进程当前的工作目录。
console.log('当前目录：' + process.cwd());
process.env
一个包括用户环境的对象。详细参见 environ(7)。
process.exit([code])
终止当前进程并返回给定的 code。如果省略了 code，退出是会默认返回成功的状态码('success' code) 也就是 0。
退出并返回失败的状态 ('failure' code):
process.exit(1);
执行上述代码，用来执行 node 的 shell 就能收到值为 1 的 exit code
process.exitCode
当进程既正常退出，或者通过未指定 code 的 process.exit() 退出时，这个属性中所存储的数字将会成为进程退出的错误码 (exit code)。
如果指名了 process.exit(code) 中退出的错误码 (code)，则会覆盖掉 process.exitCode 的设置。
process.getgid()
注意： 该函数仅适用于遵循 POSIX 标准的系统平台如 Unix、Linux等 而 Windows、 Android 等则不适用。
获取进程的群组标识（详见getgid(2)）。获取到的是群组的数字ID，不是群组名称。
if (process.getgid) {
console.log('当前 gid: ' + process.getgid());
process.setgid(id)
注意： 该函数仅适用于遵循 POSIX 标准的系统平台如 Unix、Linux等 而 Windows、 Android 等则不适用。
设置进程的群组标识（详见getgid(2)）。参数可以是一个数字ID或者群组名字符串。如果指定了一个群组名，这个方法会阻塞等待将群组名解析为数字ID。
if (process.getgid && process.setgid) {
console.log('当前 gid: ' + process.getgid());
process.setgid(501);
console.log('新 gid: ' + process.getgid());
catch (err) {
console.log('设置 gid 失败: ' + err);
process.getuid()
注意： 该函数仅适用于遵循 POSIX 标准的系统平台如 Unix、Linux等 而 Windows、 Android 等则不适用。
获取执行进程的用户ID（详见getgid(2)）。这是用户的数字ID，不是用户名。
if (process.getuid) {
console.log('当前 uid: ' + process.getuid());
process.setuid(id)
注意： 该函数仅适用于遵循 POSIX 标准的系统平台如 Unix、Linux等 而 Windows、 Android 等则不适用。
设置执行进程的用户ID（详见getgid(2)）。参数可以使一个数字ID或者用户名字符串。如果指定了一个用户名，那么该方法会阻塞等待将用户名解析为数字ID。
if (process.getuid && process.setuid) {
console.log('当前 uid: ' + process.getuid());
process.setuid(501);
console.log('新 uid: ' + process.getuid());
catch (err) {
console.log('设置 uid 失败: ' + err);
process.getgroups()
注意： 该函数仅适用于遵循 POSIX 标准的系统平台如 Unix、Linux等 而 Windows、 Android 等则不适用。
返回一个保存补充组ID(supplementary group ID)的数组。POSIX 标准没有指名 如果有效组 ID（effective group ID）被包括在内的情况，而在 node.js 中则确保它始终是。（POSIX leaves it unspecified if the effective group ID is included but node.js ensures it always is. ）
process.setgroups(groups)
注意： 该函数仅适用于遵循 POSIX 标准的系统平台如 Unix、Linux等 而 Windows、 Android 等则不适用。
设置补充分组的ID标识. 这是一个特殊的操作, 意味着你必须拥有root或者CAP_SETGID权限才可以。（译者：CAP_SETGID表示设定程序允许普通用户使用setgid函数,这与文件的setgid权限位无关）
这个列表可以包括分组的ID表示，或分组名或两者都有。
process.initgroups(user, extra_group)
注意： 该函数仅适用于遵循 POSIX 标准的系统平台如 Unix、Linux等 而 Windows、 Android 等则不适用。
读取 /etc/group 并且初始化group分组访问列表，使用改成员所在的所有分组， 这是一个特殊的操作, 意味着你必须拥有root或者CAP_SETGID权限才可以。
user 是一个用户名或者用户ID. extra_group是分组的组名或者分组ID。
有时候，当你在注销权限 (dropping privileges) 的时候需要注意。例如：
console.log(process.getgroups());
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('版本: ' + 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.exe 的配置选项的对象。内容与运行 ./configure 脚本生成的 &config.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' 或者 'SIGUSR1'。如果没有指定参数则会默认发送 'SIGTERM' 信号，更多信息请查看 kill(2) 。
值得注意的是，这个函数的名称虽然是 process.kill， 但就像 kill 系统调用（详见《Unix高级编程》）一样，它仅仅只是一个信号发送器。而信号的发送不仅仅只是用来杀死（kill）目标进程。
向当前进程发送信号的示例：
process.kill(process.pid, 'SIGHUP');
process.pid
当前进程的 PID
console.log('当前进程 id: ' + process.pid);
process.title
获取/设置 (Getter/setter) 'ps' 中显示的进程名。
当设置该属性时，所能设置的字符串最大长度视具体平台而定，如果超过的话会自动截断。
在 Linux 和 OS X 上，它受限于名称的字节长度加上命令行参数的长度，因为它有覆盖参数内存(argv memory)。
v0.8 版本允许更长的进程标题字符串，也支持覆盖环境内存，但是存在潜在的不安全和混乱（很难说清楚）。
process.arch
返回当前 CPU 处理器的架构：'arm'、'ia32' 或者 'x64'.
console.log('当前CPU架构是：' + process.arch);
process.platform
返回当前程序运行的平台：'darwin', 'freebsd', 'linux', 'sunos' 或者 'win32'
console.log('当前系统平台是： ' + process.platform);
process.memoryUsage()
返回一个对象，它描述了Node进程的内存使用情况单位是bytes。
console.log(util.inspect(process.memoryUsage()));
输出将会是：
{ rss: 4935680,
heapTotal: 1826816,
heapUsed: 650472 }
heapTotal 和 heapUsed 是根据 V8引擎的内存使用情况来的
process.nextTick(callback)
callback {Function}
在事件循环的下一次循环中调用 callback 回调函数。
这 不是 setTimeout(fn, 0) 函数的一个简单别名，因为它的效率高多了。该函数能在任何 I/O 事前之前调用我们的回调函数。但是这个函数在层次超过某个限制的时候，也会出现瑕疵，详细见 process.maxTickDepth。
console.log('开始');
process.nextTick(function() {
console.log('nextTick 回调');
console.log('已设定');
// nextTick 回调
如果你想要在【对象创建】之后而【I/O 操作】发生之前执行某些操作，那么这个函数对你而言就十分重要了。
// thing.startDoingStuff() 现在被调用了, 而不是之前.
【注意！！】保证你的函数一定是同步执行或者一定是异步执行，这非常重要！！参考如下的例子：
fs.stat('file', cb);
这样执行是很危险。如果你还不清楚上述行为的危害请看下面的例子：
maybeSync(true, function() {
那么，使用刚才那个不知道是同步还是异步的操作，在编程的时候你就会发现，你不能确定到底是 foo() 先执行，还是 bar() 先执行。
用下面的方法就可以更好的解决：
fs.stat('file', cb);
注意：nextTick 的队列会在完全执行完毕之后才调用 I/O 操作 (the nextTick queue is completely drained on each pass of the event loop before additional I/O is processed.) 。因此，递归设置 nextTick 的回调就像一个 while(true) ; 循环一样，将会阻止任何 I/O 操作的发生。
process.umask([mask])
设置或者读取进程的文件模式的创建掩码。子进程从父进程中继承这个掩码。如果设定了参数 mask 那么返回旧的掩码，否则返回当前的掩码。
oldmask = process.umask(newmask);
console.log('原掩码: ' + oldmask.toString(8) + '\n'
'新掩码: ' + newmask.toString(8));
process.uptime()
返回 Node 程序已运行的秒数。
process.hrtime()
返回当前的高分辨时间，形式为 [秒，纳秒] 的元组数组。它是相对于在过去的任意时间。该值与日期无关，因此不受时钟漂移的影响。主要用途是可以通过精确的时间间隔，来衡量程序的性能。
你可以将前一个 process.hrtime() 的结果传递给当前的 process.hrtime() 函数，结果会返回一个比较值，用于基准和衡量时间间隔。
console.log('基准相差 %d 纳秒', diff[0] * 1e9 + diff[1]);
// 基准相差
( 晋ICP备号
提供的镜像文件process对象 -- JavaScript 标准参考教程（alpha）
process对象
来自，by 阮一峰
process对象是Node的一个全局对象，提供当前Node进程的信息。它可以在脚本的任意位置使用，不必通过require命令加载。该对象部署了EventEmitter接口。
进程的退出码
进程退出时，会返回一个整数值，表示退出时的状态。这个整数值就叫做退出码。下面是常见的Node进程退出码。
0，正常退出
1，发生未捕获错误
5，V8执行错误
8，不正确的参数
128 + 信号值，如果Node接受到退出信号（比如SIGKILL或SIGHUP），它的退出码就是128加上信号值。由于128的二进制形式是, 所以退出码的后七位就是信号值。
Bash可以使用环境变量$?，获取上一步操作的退出码。
$ node nonexist.js
Error: Cannot find 'nonexist.js'
上面代码中，Node执行一个不存在的脚本文件，结果报错，退出码就是1。
process对象提供一系列属性，用于返回系统信息。
process.argv：返回当前进程的命令行参数数组。
process.env：返回一个对象，成员为当前Shell的环境变量，比如process.env.HOME。
process.installPrefix：node的安装路径的前缀，比如/usr/local，则node的执行文件目录为/usr/local/bin/node。
process.pid：当前进程的进程号。
process.platform：当前系统平台，比如Linux。
process.title：默认值为“node”，可以自定义该值。
process.version：Node的版本，比如v0.10.18。
下面是主要属性的介绍。
stdout，stdin，stderr
以下属性指向系统I/O。
（1）stdout
stdout属性指向标准输出（文件描述符1）。它的write方法等同于console.log，可用在标准输出向用户显示内容。
console.log = function(d) {
process.stdout.write(d + '\n');
下面代码表示将一个文件导向标准输出。
var fs = require('fs');
fs.createReadStream('wow.txt')
.pipe(process.stdout);
上面代码中，由于process.stdout和process.stdin与其他进程的通信，都是流（stream）形式，所以必须通过pipe管道命令中介。
var fs = require('fs');
var zlib = require('zlib');
fs.createReadStream('wow.txt')
.pipe(zlib.createGzip())
.pipe(process.stdout);
上面代码通过pipe方法，先将文件数据压缩，然后再导向标准输出。
（2）stdin
stdin代表标准输入（文件描述符0）。
process.stdin.pipe(process.stdout)
上面代码表示将标准输入导向标准输出。
由于stdin和stdout都部署了stream接口，所以可以使用stream接口的方法。
process.stdin.setEncoding('utf8');
process.stdin.on('readable', function() {
var chunk = process.stdin.read();
if (chunk !== null) {
process.stdout.write('data: ' + chunk);
process.stdin.on('end', function() {
process.stdout.write('end');
（3）stderr
stderr属性指向标准错误（文件描述符2）。
argv，execPath，execArgv
argv属性返回一个数组，由命令行执行脚本时的各个参数组成。它的第一个成员总是node，第二个成员是脚本文件名，其余成员是脚本文件的参数。
请看下面的例子，新建一个脚本文件argv.js。
// argv.js
console.log("argv: ",process.argv);
在命令行下调用这个脚本，会得到以下结果。
$ node argv.js a b c
[ 'node', '/path/to/argv.js', 'a', 'b', 'c' ]
上面代码表示，argv返回数组的成员依次是命令行的各个部分，真正的参数实际上是从process.argv[2]开始。要得到真正的参数部分，可以把argv.js改写成下面这样。
// argv.js
var myArgs = process.argv.slice(2);
console.log(myArgs);
execPath属性返回执行当前脚本的Node二进制文件的绝对路径。
& process.execPath
'/usr/local/bin/node'
execArgv属性返回一个数组，成员是命令行下执行脚本时，在Node可执行文件与脚本文件之间的命令行参数。
# script.js的代码为
# console.log(process.execArgv);
$ node --harmony script.js --version
process.env
process.env属性返回一个对象，包含了当前Shell的所有环境变量。比如，process.env.HOME返回用户的主目录。
通常的做法是，新建一个环境变量NODE_ENV，用它确定当前所处的开发阶段，生产阶段设为production，开发阶段设为develop或staging，然后在脚本中读取process.env.NODE_ENV即可。
运行脚本时，改变环境变量，可以采用下面的写法。
$ export NODE_ENV=production && node app.js
$ NODE_ENV=production node app.js
process对象提供以下方法：
process.chdir()：切换工作目录到指定目录。
process.cwd()：返回运行当前脚本的工作目录的路径。
process.exit()：退出当前进程。
process.getgid()：返回当前进程的组ID（数值）。
process.getuid()：返回当前进程的用户ID（数值）。
process.nextTick()：指定回调函数在当前执行栈的尾部、下一次Event Loop之前执行。
process.on()：监听事件。
process.setgid()：指定当前进程的组，可以使用数字ID，也可以使用字符串ID。
process.setuid()：指定当前进程的用户，可以使用数字ID，也可以使用字符串ID。
process.cwd()，process.chdir()
cwd方法返回进程的当前目录（绝对路径），chdir方法用来切换目录。
& process.cwd()
'/home/aaa'
& process.chdir('/home/bbb')
& process.cwd()
'/home/bbb'
注意，process.cwd()与__dirname的区别。前者进程发起时的位置，后者是脚本的位置，两者可能是不一致的。比如，node ./code/program.js，对于process.cwd()来说，返回的是当前目录（.）；对于__dirname来说，返回是脚本所在目录，即./code/program.js。
process.nextTick()
process.nextTick将任务放到当前一轮事件循环（Event Loop）的尾部。
process.nextTick(function () {
console.log('下一次Event Loop即将开始!');
上面代码可以用setTimeout(f,0)改写，效果接近，但是原理不同。
setTimeout(function () {
console.log('已经到了下一轮Event Loop！');
setTimeout(f,0)是将任务放到下一轮事件循环的头部，因此nextTick会比它先执行。另外，nextTick的效率更高，因为不用检查是否到了指定时间。
根据Node的事件循环的实现，基本上，进入下一轮事件循环后的执行顺序如下。
setTimeout(f,0)
各种到期的回调函数
process.nextTick
push(), sort(), reverse(), and splice()
### process.exit()
process.exit方法用来退出当前进程。它可以接受一个数值参数，如果参数大于0，表示执行失败；如果等于0表示执行成功。
if (err) {
process.exit(1);
process.exit(0);
process.exit()执行时，会触发exit事件。
process.on()
process对象部署了EventEmitter接口，可以使用on方法监听各种事件，并指定回调函数。
process.on('uncaughtException', function(err){
console.error('got an error: %s', err.message);
process.exit(1);
setTimeout(function(){
throw new Error('fail');
上面代码是process监听Node的一个全局性事件uncaughtException，只要有错误没有捕获，就会触发这个事件。
process支持的事件还有下面这些。
data事件：数据输出输入时触发
SIGINT事件：接收到系统信号SIGINT时触发，主要是用户按Ctrl + c时触发。
SIGTERM事件：系统发出进程终止信号SIGTERM时触发
exit事件：进程退出前触发
process.on('SIGINT', function () {
console.log('Got a SIGINT. Goodbye cruel world');
process.exit(0);
// 也可以忽略这个信号
process.on('SIGINT', function() {
console.log("Ignored Ctrl-C");
使用时，向该进程发出系统信号，就会导致进程退出。
$ kill -s SIGINT [process_id]
SIGTERM信号表示内核要求当前进程停止，进程可以自行停止，也可以忽略这个信号。
var http = require('http');
var server = http.createServer(function (req, res) {
process.on('SIGTERM', function () {
server.close(function () {
process.exit(0);
上面代码表示，进程接到SIGTERM信号之后，关闭服务器，然后退出进程。需要注意的是，这时进程不会马上退出，而是要回应完最后一个请求，处理完所有回调函数，然后再退出。
exit事件在Node进程退出前触发。
process.on('exit', function() {
console.log('Goodbye');
process.kill()
process.kill方法用来对指定ID的线程发送信号，默认为SIGINT信号。
process.kill(process.pid, 'SIGTERM');
上面代码用于杀死当前进程。
process.on('SIGTERM', function(){
console.log('terminating');
process.exit(1);
setTimeout(function(){
console.log('sending SIGTERM to process %d', process.pid);
process.kill(process.pid, 'SIGTERM');
setTimeout(function(){
console.log('never called');
上面代码中，500毫秒后向当前进程发送SIGTERM信号（终结进程），因此1000毫秒后的指定事件不会被触发。
当前进程退出时，会触发exit事件，可以对该事件指定回调函数。
process.on('exit', function () {
fs.writeFileSync('/tmp/myfile', '需要保存到硬盘的信息');
下面是一个例子，进程退出时，显示一段日志。
process.on("exit", code =&
console.log("exiting with code: " + code))
注意，此时回调函数只能执行同步操作，不能包含异步操作，因为执行完回调函数，进程就会退出，无法监听到回调函数的操作结果。
process.on('exit', function(code) {
// 不会执行
setTimeout(function() {
console.log('This will not run');
上面代码在exit事件的回调函数里面，指定了一个下一轮事件循环，所要执行的操作。这是无效的，不会得到执行。
beforeExit事件
beforeExit事件在Node清空了Event Loop以后，再没有任何待处理的任务时触发。正常情况下，如果没有任何待处理的任务，Node进程会自动退出，设置beforeExit事件的监听函数以后，就可以提供一个机会，再部署一些任务，使得Node进程不退出。
beforeExit事件与exit事件的主要区别是，beforeExit的监听函数可以部署异步任务，而exit不行。
此外，如果是显式终止程序（比如调用process.exit()），或者因为发生未捕获的错误，而导致进程退出，这些场合不会触发beforeExit事件。因此，不能使用该事件替代exit事件。
uncaughtException事件
当前进程抛出一个没有被捕捉的错误时，会触发uncaughtException事件。
process.on('uncaughtException', function (err) {
console.error('An uncaught error occurred!');
console.error(err.stack);
throw new Error('未捕获错误');
部署uncaughtException事件的监听函数，是免于Node进程终止的最后措施，否则Node就要执行process.exit()。出于除错的目的，并不建议发生错误后，还保持进程运行。
抛出错误之前部署的异步操作，还是会继续执行。只有完成以后，Node进程才会退出。
process.on('uncaughtException', function(err) {
console.log('Caught exception: ' + err);
setTimeout(function() {
console.log('本行依然执行');
// 下面的表达式抛出错误
nonexistentFunc();
上面代码中，抛出错误之后，此前setTimeout指定的回调函数亦然会执行。
操作系统内核向Node进程发出信号，会触发信号事件。实际开发中，主要对SIGTERM和SIGINT信号部署监听函数，这两个信号在非Windows平台会导致进程退出，但是只要部署了监听函数，Node进程收到信号后就不会退出。
// 读取标准输入，这主要是为了不让当前进程退出
process.stdin.resume();
process.on('SIGINT', function() {
console.log('SIGINT信号，按Control-D退出');
上面代码部署了SIGINT信号的监听函数，当用户按下Ctrl-C后，会显示提示文字。
José F. Romaniello,
Please enable JavaScript to view the
| last modified on}