它能够以完全非阻塞的方式与子进程的 stdin、stdout 和 stderr 以流式传递数据。（请注意，某些程序在内部使用行缓冲 I/O。这不会影响到 node.js，但您发送到子进程的数据不会被立即消费。）

类: ChildProcess

事件: ‘error‘

• err {Error Object} 错误。

1. 进程不能被创建, 或者
2. 进程不能被终止掉, 或者
3. 由任何原因引起的数据发送到子进程失败.

事件: ‘exit‘

• code {Number} 假如进程正常退出，则为它的退出代码。
• signal {String} 假如是被父进程终止，则为所传入的终止子进程的信号。

事件: ‘close‘

• code {Number} 假如进程正常退出，则为它的退出代码。
• signal {String} 假如是被父进程终止，则为所传入的终止子进程的信号。

事件: ‘disconnect‘

事件: ‘message‘

• message {Object} 一个已解析的JSON对象或者原始类型值
• sendHandle {Handle object} 一个socket 或者 server对象

child.stdin

• {Stream object}

child.stdout

• {Stream object}

child.stderr

• {Stream object}

child.pid

• {Integer}

var spawn = require(‘child_process‘).spawn,
    grep  = spawn(‘grep‘, [‘ssh‘]);

console.log(‘Spawned child pid: ‘ + grep.pid);
grep.stdin.end();

var spawn = require(‘child_process‘).spawn,
    grep  = spawn(‘grep‘, [‘ssh‘]);

grep.on(‘close‘, function (code, signal) {
  console.log(‘child process terminated due to receipt of signal ‘+signal);
});

// 将SIGHUP发送给进程
grep.kill(‘SIGHUP‘);

child.connected

若 .connected 为flase，将不再发送消息。

child.send(message, [sendHandle])

• message {Object}
• sendHandle {Handle object}

var cp = require(‘child_process‘);

var n = cp.fork(__dirname + ‘/sub.js‘);

n.on(‘message‘, function(m) {
  console.log(‘PARENT got message:‘, m);
});

n.send({ hello: ‘world‘ });

process.on(‘message‘, function(m) {
  console.log(‘CHILD got message:‘, m);
});

process.send({ foo: ‘bar‘ });

示例: 发送一个server对象

var child = require(‘child_process‘).fork(‘child.js‘);

// 开启一个server对象，并发送句柄。
var server = require(‘net‘).createServer();
server.on(‘connection‘, function (socket) {
  socket.end(‘handled by parent‘);
});
server.listen(1337, function() {
  child.send(‘server‘, server);
});

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

示例: 发送socket对象

var normal = require(‘child_process‘).fork(‘child.js‘, [‘normal‘]);
var special = require(‘child_process‘).fork(‘child.js‘, [‘special‘]);

// 开启service同时将套接字发送给子进程
var server = require(‘net‘).createServer();
server.on(‘connection‘, function (socket) {

  // 若是VIP
  if (socket.remoteAddress === ‘74.125.127.100‘) {
    special.send(‘socket‘, socket);
    return;
  }
  // just the usual dudes
  normal.send(‘socket‘, socket);
});
server.listen(1337);

process.on(‘message‘, function(m, socket) {
  if (m === ‘socket‘) {
    socket.end(‘You were handled as a ‘ + process.argv[2] + ‘ person‘);
  }
});

child.disconnect()

‘disconnect‘ 事件是当进程没有收到通知时最有可能立即发送通知的方法。

注意：你也可以在子进程与父进程有IPC连接时回调process.disconnect()(例如fork())。

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

• command {String}要运行的命令
• args {Array} 字符串参数列表
• options {Object}
  • cwd {String} 子进程的当前的工作目录
  • stdio {Array|String} 子进程 stdio 配置. (参阅下文)
  • customFds {Array} Deprecated 作为子进程 stdio 使用的 文件标示符. (参阅下文)
  • env {Object} 环境变量的键值对
  • detached {Boolean} 子进程将会变成一个进程组的领导者. (参阅下文)
  • uid {Number} 设置用户进程的ID. (See setuid(2).)
  • gid {Number} 设置进程组的ID. (See setgid(2).)
• 返回: {ChildProcess object}

{ cwd: undefined,
  env: process.env
}

var spawn = require(‘child_process‘).spawn,
    ls    = spawn(‘ls‘, [‘-lh‘, ‘/usr‘]);

ls.stdout.on(‘data‘, function (data) {
  console.log(‘stdout: ‘ + data);
});

ls.stderr.on(‘data‘, function (data) {
  console.log(‘stderr: ‘ + data);
});

ls.on(‘close‘, function (code) {
  console.log(‘child process exited with code ‘ + code);
});

示例: 一个非常精巧的方法执行 ‘ps ax | grep ssh‘

var spawn = require(‘child_process‘).spawn,
    ps    = spawn(‘ps‘, [‘ax‘]),
    grep  = spawn(‘grep‘, [‘ssh‘]);

ps.stdout.on(‘data‘, function (data) {
  grep.stdin.write(data);
});

ps.stderr.on(‘data‘, function (data) {
  console.log(‘ps stderr: ‘ + data);
});

ps.on(‘close‘, function (code) {
  if (code !== 0) {
    console.log(‘ps process exited with code ‘ + code);
  }
  grep.stdin.end();
});

grep.stdout.on(‘data‘, function (data) {
  console.log(‘‘ + data);
});

grep.stderr.on(‘data‘, function (data) {
  console.log(‘grep stderr: ‘ + data);
});

grep.on(‘close‘, function (code) {
  if (code !== 0) {
    console.log(‘grep process exited with code ‘ + code);
  }
});

var spawn = require(‘child_process‘).spawn,
    child = spawn(‘bad_command‘);

child.stderr.setEncoding(‘utf8‘);
child.stderr.on(‘data‘, function (data) {
  if (/^execvp\(\)/.test(data)) {
    console.log(‘Failed to start child process.‘);
  }
});

1. ‘pipe‘ -在子进程与父进程之间创建一个管道，管道的父进程端以 child_process 的属性的形式暴露给父进程，如 ChildProcess.stdio[fd]。 为 文件标识（fds） 0 - 2 建立的管道也可以通过 ChildProcess.stdin，ChildProcess.stdout 及 ChildProcess.stderr 分别访问。

2. ‘ipc‘ - 创建一个IPC通道以在父进程与子进程之间传递 消息/文件标识符。一个子进程只能有最多一个IPC stdio 文件标识。 设置该选项激活 ChildProcess.send() 方法。如果子进程向此文件标识符写JSON消息，则会触发 ChildProcess.on("message")。 如果子进程是一个nodejs程序，那么IPC通道的存在会激活process.send()和process.on(‘message‘)

3. ‘ignore‘ - 不在子进程中设置该文件标识。注意，Node 总是会为其spawn的进程打开 文件标识（fd） 0 - 2。 当其中任意一项被 ignored，node 会打开 /dev/null 并将其附给子进程的文件标识（fd）。

4. Stream 对象 - 与子进程共享一个与tty，文件，socket，或者管道(pipe)相关的可读或可写流。 该流底层（underlying）的文件标识在子进程中被复制给stdio数组索引对应的文件标识（fd）

5. 正数 - 该整形值被解释为父进程中打开的文件标识符。他与子进程共享，和Stream被共享的方式相似。

6. null, undefined - 使用默认值。 对于stdio fds 0,1,2（或者说stdin,stdout和stderr），pipe管道被建立。对于fd 3及往后，默认为ignore

• ignore - [‘ignore‘, ‘ignore‘, ‘ignore‘]
• pipe - [‘pipe‘, ‘pipe‘, ‘pipe‘]
• inherit - [process.stdin, process.stdout, process.stderr] or [0,1,2]

var spawn = require(‘child_process‘).spawn;

// 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 present a
// startd-style interface.
spawn(‘prg‘, [], { stdio: [‘pipe‘, null, null, null, ‘pipe‘] });

 var fs = require(‘fs‘),
     spawn = require(‘child_process‘).spawn,
     out = fs.openSync(‘./out.log‘, ‘a‘),
     err = fs.openSync(‘./out.log‘, ‘a‘);

 var child = spawn(‘prg‘, [], {
   detached: true,
   stdio: [ ‘ignore‘, out, err ]
 });

 child.unref();