关于 ChildProcess 类
1、ChildProcess
类的实例都是 EventEmitter
,表示衍生的子进程
2、每个实例都有 stdout, stdin, stderr 三个流对象
3、通过 fork 产生的子进程与父进程可以用 send 方法及监听 message
事件来相互通信
4、 几个事件: error , message , exit , close , disconnect
child_process
创建异步进程方法
以下四个方法均返回 ChildProcess 的实例
child_process.exec
语法:child_process.exec(command[, options][, callback])
注意:
1、command 是一个 shell 命令的字符串,包含了命令的参数
2、可以使用 callback;
3、衍生一个 shell 然后在该 shell 中执行 command,command 一般是 shell
内置的 命令,如 ls,cat 等,也可以是 shell 脚本组成的文件,如 start.sh 等
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21
| const { exec } = require('child_process'); exec('cat *.js missing_file | wc -l', (error, stdout, stderr) => { if (error) { console.error(`执行出错: ${error}`); return; } console.log(`stdout: ${stdout}`); console.log(`stderr: ${stderr}`); });
const util = require('util'); const exec = util.promisify(require('child_process').exec);
async function lsExample() { const { stdout, stderr } = await exec('cat *.js missing_file | wc -l'); console.log('stdout:', stdout); console.log('stderr:', stderr); } lsExample();
|
child_process.execFile
语法:child_process.execFile(file[, args][, options][, callback])
注意:
1、与 exec
的不同是,命令的参数不能放在第一个参数,只能作为第二个参数传递;
2、默认情况下不会衍生 shell,指定的可执行 file
直接作为新进程衍生,使其比 child_process.exec() 稍微更高效
3、file 是要运行的可执行文件的名称或路径,如 node.exe,不能是 start.js
这种脚本文件
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17
| const { execFile } = require('child_process'); const child = execFile('node', ['--version'], (error, stdout, stderr) => { if (error) { throw error; } console.log(stdout); });
const util = require('util'); const execFile = util.promisify(require('child_process').execFile); async function getVersion() { const { stdout } = await execFile('node', ['--version']); console.log(stdout); } getVersion();
|
child_process.fork
语法:child_process.fork(modulePath[, args][, options])
注意:
1、该接口专门用于衍生新的 Node.js 进程
2、modulePath 是要在 node 子进程中运行的模块,由于是 node.js
的进程,所以可以是 start.js 这种 js 文件
3、无回调,参数要以第二个参数传入
4、返回的子进程将内置一个额外的 ipc
通信通道,允许消息在父进程和子进程之间来回传递。
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22
|
var child_process = require('child_process');
var child = child_process.fork('./child.js');
child.on('message', function(m){ console.log('message from child: ' + JSON.stringify(m)); });
child.send({from: 'parent'});
process.on('message', function(m){ console.log('message from parent: ' + JSON.stringify(m)); });
process.send({from: 'child'});
message from child: {"from":"child"} message from parent: {"from":"parent"}
|
child_process.spawn
语法:child_process.spawn(command[, args][, options])
注意:使用给定的 command 衍生一个新进程,并带上 args 中的命令行参数。
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16
| var spawn = require('child_process').spawn; var child = spawn('bad_command');
child.on('error', (err) => { console.log('Failed to start child process 1.'); });
var child2 = spawn('ls', ['nonexistFile']);
child2.stderr.on('data', function(data){ console.log('Error msg from process 2: ' + data); });
child2.on('error', (err) => { console.log('Failed to start child process 2.'); });
|
child_process
创建异步进程方法的区别
主要的区别在于第一个参数的含义不同:
- 对于 exec 和 execFile 传递的是 command 或 可执行文件,类似 ls 或者
start.sh 或者 node; 可接受回调; 二者不同的是命令的参数位置
- fork 传递的是 node 支持的脚本,类似 start.js,无回调
- spawn 是以上三个方法实现的基础。
对于构建开发环境而言,一般至少会起两个进程,主进程起
devServer;还需一个进程起 mock API 服务器,所以一般用 fork 较多
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28
| var fork = require('child_process').fork;
gulp.task('dev-server',function(){ gulpLivereload.listen(); gulp.watch('./public/scss/*.scss', gulp.series(['sass'])); fork('./server.js') })
gulp.task('default', gulp.series(['sass','dev-server']));
exec('node ./server.js',(err,stdout,stderr)=>{ if (err) { console.log('err',err) } else { console.log('stdout',stdout) } })
child.execFile('node', ['./server.js'],(err,stdout,stderr)=>{ if (err) { console.log('err',err) } else { console.log('stdout',stdout) } })
|
然后一个 gulp 命令就会启动两个进程
参考: