嗯，对于node的学习还远远不够，这里先做一个简单的api的记录，后续深入学习。
第一部分：nodejs中的全局对象之process进程对象
在node中的全局对象是global，相当于浏览器中的window，而process进程对象是global的属性。
这一部分主要从 process中的事件、process中的标准流对象、process中的属性、process中的方法这四个方面来介绍，
1、process中的事件
process是EventEmitter的一个实例，所以也具有事件监听器的特征。 process中的事件监听器有 exit、 uncaughtException、一些signal。
（1）退出事件： ‘exit’
exit事件会在进程退出时触发，用来监听进程退出的状态。 在回调函数中会有一个进程退出的状态码。 如下：
process.on('exit', function(code) { // 进程退出后，其后的事件循环将会结束，计时器也不会被执行 setTimeout(function() { console.log('This will not run'); }, 0); console.log('进程退出码是:', code); }); //进程退出 process.exit(); //进程正常退出，其退出码为：0
（2）未处理异常： ‘uncaughtException’
当进程异常退出时，会触发‘uncaughtException’事件，但是这个异常一般并不明确，所以不建议使用。
//异常捕获 process.on('uncaughtException', function(exception) { console.log('捕获到的异常是:', exception); }); //一个未定义的方法，用来制造异常 nonexistentFunc(); //输出 捕获到的异常是: [ReferenceError: nonexistentFunc is not defined]
（3）信号相关事件
如SIGNIT事件，会在使用 ctrl + c的时候触发次信号：
process.stdin.resume(); //使用Control+C键，可以触发SIGINT信号 process.on('SIGINT', function() { console.log('收到SIGINT信号，按Control+D键可以退出进程'); });
2、process中的标准流对象
在Process中有三个标准流的操作，与stream流操作不同的是，Process中刘操作是阻塞的。
(1)标准输出流： process.stdout
这个输出流对象是一个指向标准输出流的可写流 writebal stream。 console.log就是通过 process.stdout 实现的，如下：
console.log = function(d) { process.stdout.write(d + ' '); };
（2）标准输入流： process.stdin
这是一个指向标准输入流的可读流 readable stream。 标准输入流式暂停的，所以必须调用 process.stdin.resume()来恢复 resume 接受。 使用如下：
process.stdin.on('end', function() { process.stdout.write('end'); }); //一个读取输入流的方法 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+"]"); });
（3）标准错误流：process.stderr
标准错误流是一个可写流 writable stream。 console.error 就是通过 process.stderr实现的。
3、process中的属性
（1）进程命令行参数的数组： process.argv
这是一个当前进程折参数组，第一个参数是node，第二个参数是当前执行的.js文件名，之后是执行的参数列表。
例如，当前文件名是 process.js，代码如下：
process.argv.forEach(function(val, index, array) { console.log(index + ': ' + val); });
那么执行了 node process.js 之后，输出如下；
0: node 1: /Users/liuht/code/itbilu/demo/process.js
增加两个参数 node process.js arg1 arg2执行后，输出如下：
0: node 1: /Users/liuht/code/itbilu/demo/process.js 2: arg1 3: arg2
（2）启动进程程序的路径： process.execPath
中文意思就是process的执行路径。 这个属性会返回启动进程程序的路径，例如 node process.js会返回，/user/local/bin/node， 即node的安装路径。 process.js 的代码如下：
console.log(process.execPath);
（3）node的命令行参数： process.execArgv
process.argv不仅仅是命令行参数，还包括其他参数，而这里的process.execArgv就是Node的命令行参数数组。代码如下：
$ node --harmony script.js --version
那么 process.execArgv 返回：
['--harmony']
而 process.argv 返回：
['/usr/local/bin/node', 'script.js', '--version']
（4）node的运行环境对象： process.env
这个属性会返回用户的运行环境对象，如下所示：
（5）进程退出码：process.exitCode
这个属性会返回进程默认的退出码， 或者process.exit(code)指定的退出码。
（6）node编译时的版本：process.version
这个属性会返回node编译时的版本号。
（7）node以及其依赖包版本信息： process.versions
这个属性返回node以及它所依赖的版本信息，如下：
即node是基于v8的，这里也返回了v8引擎的信息，还有node本身、http_parser、uv、zlib、ares、icu、modules、openssl。
（8）node编译时的配置信息：process.config
即这个属性会返回配置信息，与运行./configure脚本生成的config.gypi文件相同。
（9）指向启动脚本的模块： process.mainModule
这个属性会返回指向启动脚本的模块，与require.mian类似。
（10）当前的进程ID：process.pid
返回当前node的进程id。
（11）ps中显示的进程名： process.title
process.title属性会返回‘ps’中显示的进程名。 实际上就是node的路径。
（12）当前CPU的架构： process.arch
如我的电脑显示 X64
（13）当前进程的运行平台： process.platform
该属性返回执行当前进程的运行平台信息。 如我的电脑返回的是win32。
4、process中的方法
(1)触发abort事件： process.abort()
该方法会使得当前node进程abort。
（2）终止当前进程： process.exit([code])
该方法会终止当前进程，可以接受一个退出状态的可选参数 code， 不传入时， 会返回表示成功的状态码 0 ， 如下：
process.on('exit', function(code) { console.log('进程退出码是:%d', code); // 进程退出码是:1 }); process.exit(1);
（3）获取/设置进程的GID：process.getgid()、process.setuid(id)
有些系统不适用，不做讲解。
（4）获取/设置进程的UID：process.getuid()、process.setuid(id)
不做过多讲解。
GID为GroupId，即组ID，用来标识用户组的唯一标识符
UID为UserId，即用户ID，用来标识每个用户的唯一标示符
扩展：
用户组：将同一类用户设置为同一个组，如可将所有的系统管理员设置为admin组，便于分配权限，将某些重要的文件设置为所有admin组用户可以读写，这样可以进行权限分配。
每个用户都有一个唯一的用户id，每个用户组都有一个唯一的组id
（5）获取/设置单钱进程有操作权限的GID数组：process.getgroups()、process.setgroups(groups)
（6）初始化group分组访问列表： process.initgroups(user, extra_group)
（7）向指定进程发送一个信息： process.kill（pid[, signal]）
process.kill()方法是用来向指定进程发送一个信号，需要注意的时 kill 方法不仅是用来杀死指定进程的，可以是任何POSIX标准信息。
（8）返回内存使用情况：process.memoryUsage()
该方法用于查看内存使用情况：如下；
{ rss: 23105536, heapTotal: 10522624, heapUsed: 5836208 }
（9）延迟方法执行： process.nextTick()
process.nextTick(callback[, arg][, ...])
该方法用于延迟回调函数的执行，nextTick方法会将callback中的回调函数延迟到事件循环的下一次循环中，与setTimeout(fn, 0)相比nextTick方法效率高很多，该方法能在任何I/O事件之前调用我们的回调函数：
（10）设置或者读取进程文件的权限掩码： process.umask([mask])
该方法用于设置或者读取进程文件的权限掩码，子进程从父进程中继承这个掩码。 如果设定了参数mask那么返回旧的掩码，否则返回当前的：
var oldmask, newmask = 0022; oldmask = process.umask(newmask); console.log('原掩码: ' + oldmask.toString(8) + ' ' '新掩码: ' + newmask.toString(8));
（11）返回当前的高精度时间：process.hrtime()
（12）返回node程序已经运行的秒数： process.uptime()
（13）工作目录切换： process.chdir(directory)、process.cwd()
process.chdir()用于改变进程的工作目录。 process.cwd() 方法返回进程当前的工作目录。 示例如下：
console.log('当前目录：' + process.cwd()); try { process.chdir('/tmp'); console.log('新目录：' + process.cwd()); } catch (err) { console.log('chdir: ' + err); } //输出如下 当前目录：/Users/liuht/code/itbilu/demo 新目录：/private/tmp
第二部分：nodejs中进程、线程、单线程理解
这一部分，首先介绍进程和线程，node单线程这些知识的理解，后面介绍如何创建多线程。
- 在开启电脑后，会运行浏览器，微信，视频等软件，然而cpu数量很少，所以使用的时并发的方式，即cpu给不同的进程分配时间片。
- 打开视频，不仅可以有画面，还有音频播放等等，其实是这些进程内的线程在起作用。 一个进程至少要有一个线程。
node和浏览器中的JavaScript都是单线程的。 但是，我们要理解node的单线程到底是什么意思？
实际上， 这里所说的单线程是指我们所编写的代码运行在单线程上，实际上node不是真正的单线程。
比如我们执行 node app.js 时启动了一个进程，但是这个进程并不是只有一个线程，而是同时创建了很多歌线程（比如：异步IO需要的一些IO线程）。
但是，仍然只有一个线程会运行我们编写的代码。 这就是node中单线程的含义。
但是node单线程会导致下面的问题：
- 无法利用多核CPU（只能获得一个CPU的时间分片）。
- 错误就会引起整个应用退出（整个应用就一个进程，挂了就挂了）。
- 大量计算长时间占用CPU，导致阻塞线程内的其他操作（异步IO发不出调用，已完成的异步IO回调不能及时执行）。
第三部分：nodejs子进程的创建方式
在node中，大体有三种创建进程的方法：
- exex / execFile
- spawn
- fork
exec/execFile
exec(command, options, callback) 和 execFile(file, args, options, callback) 比较类似，会使用一个 Buffer 来存储进程执行后的标准输出结果，他们可以一次性在callback里面获取到。不太适合数据量大的场景。
另外，exec会首先创建一个新的shell进程出来，然后执行command； execFile则是直接将可执行的file创建为新进程执行。 所以，execfile 会比 exec 高效一些（后者多了一个shell步骤，前者是直接拿到execfile就执行了）。
exec比较适合来执行 shell 命令， 然后获取输出（比如： exec('ps aux | grep "node" ')），但是 execFile 没有这么实用， 因为它实际上只接受了一个可执行的命令，然后执行（没法使用shell里面的管道之类的东西）。
// child.js console.log('child argv: ', process.argv);
// parent.js const child_process = require('child_process'); const p = child_process.exec( 'node child.js a b', // 执行的命令 {}, (err, stdout, stderr) => { if (err) { // err.code 是进程退出时的 exit code，非 0 都被认为错误 // err.signal 是结束进程时发送给它的信号值 console.log('err:', err, err.code, err.signal); } console.log('stdout:', stdout); console.log('stderr:', stderr); } ); console.log('child pid:', p.pid);
const p = child_process.execFile( 'node', // 可执行文件 ['child.js', 'a', 'b'], // 传递给命令的参数 {}, (err, stdout, stderr) => { if (err) { // err.code 是进程退出时的 exit code，非 0 都被认为错误 // err.signal 是结束进程时发送给它的信号值 console.log('err:', err, err.code, err.signal); } console.log('stdout:', stdout); console.log('stderr:', stderr); } ); console.log('child pid:', p.pid);
两个方法还可以传递一些配置项，如下所示:
{ // 可以指定命令在哪个目录执行 'cwd': null, // 传递环境变量，node 脚本可以通过 process.env 获取到 'env': {}, // 指定 stdout 输出的编码，默认用 utf8 编码为字符串（如果指定为 buffer，那 callback 的 stdout 参数将会是 Buffer） 'encoding': 'utf8', // 指定执行命令的 shell，默认是 /bin/sh（unix） 或者 cmd.exe（windows） 'shell': '', // kill 进程时发送的信号量 'killSignal': 'SIGTERM', // 子进程超时未执行完，向其发送 killSignal 指定的值来 kill 掉进程 'timeout': 0, // stdout、stderr 允许的最大输出大小（以 byte 为单位），如果超过了，子进程将被 kill 掉（发送 killSignal 值） 'maxBuffer': 200 * 1024, // 指定用户 id 'uid': 0, // 指定组 id 'gid': 0 }
spawn
spawn(command, args, options)适合用在进程的输入、输出数据量比较大的情况（因为它支持steam的方式，而刚才的exec/execFile都是Buffer，而不支持stream的方式）， 可以用于任何命令。
// child.js console.log('child argv: ', process.argv); process.stdin.pipe(process.stdout);
// parent.js const p = child_process.spawn( 'node', // 需要执行的命令 ['child.js', 'a', 'b'], // 传递的参数 {} ); console.log('child pid:', p.pid); p.on('exit', code => { console.log('exit:', code); }); // 父进程的输入直接 pipe 给子进程（子进程可以通过 process.stdin 拿到） process.stdin.pipe(p.stdin); // 子进程的输出 pipe 给父进程的输出 p.stdout.pipe(process.stdout); /* 或者通过监听 data 事件来获取结果 var all = ''; p.stdout.on('data', data => { all += data; }); p.stdout.on('close', code => { console.log('close:', code); console.log('data:', all); }); */ // 子进程的错误输出 pipe 给父进程的错误输出 p.stderr.pipe(process.stderr);
我们可以执行 cat bigdata.txt | node parent.js 来进行测试，bigdata.txt 文件的内容将被打印到终端。
spawn 方法的配置（options）如下：
{ // 可以指定命令在哪个目录执行 'cwd': null, // 传递环境变量，node 脚本可以通过 process.env 获取到 'env': {}, // 配置子进程的 IO 'stdio': 'pipe', // 为子进程独立运行做好准备 'detached': false, // 指定用户 id 'uid': 0, // 指定组 id 'gid': 0 }
fork
fork(modulePath, args, options)实际上是spawn的一个“特例”， 会创建一个新的V8实例。新创建的进程只能用来运行node脚本，不能运行其他命令。
// child.js console.log('child argv: ', process.argv); process.stdin.pipe(process.stdout);
// parent.js const p = child_process.fork( 'child.js', // 需要执行的脚本路径 ['a', 'b'], // 传递的参数 {} ); console.log('child pid:', p.pid); p.on('exit', code => { console.log('exit:', code); });
总结：
- exec/execFile: 使用Buffer来存储进程的输出，可以在回调函数中获取输出结果，不太适合数据量大的情况，可以执行任何命令； 不创建V8实例。
- spawn: 支持stream方式操作输入输出，适合数据量打的情况； 可以执行任何命令； 不创建v8实例； 可以创建常驻的后台进程。
- fork: spawn的一个特例； 只能执行node脚本； 会创建一个 V8 实例； 会建立父子进程的IPC通道，能够进行通信。
同步/异步
大部分时候，子进程的创建是异步的。也就是说，它不会阻塞当前的事件循环，这对于性能的提升很有帮助。
当然，有的时候，同步的方式会更方便（阻塞事件循环），比如通过子进程的方式来执行shell脚本时。
node同样提供同步的版本，比如：
- spawnSync()
- execSync()
- execFileSync()
忽略上面的答案。。
- 显然：无法使用child_process.create() 来创建。
- spawn无法接受callback作为参数。
- execFile确实可以直接执行特定程序，参数不被shell解释，因此更具有安全性。
- fork可以在父子进程之前建立IPC管道，便于进程间通讯。
- 子进程可以是异步的也可以是同步的，大多数时候建立的时异步的，会比较方便。
- execFile不能执行shell命令，而是直接执行文件。