Node.js中的进程与子进程怎么处理

functionsafeChdir(dir){
try{
process.chdir(dir);
returntrue;
}catch(error){
returnfalse;
}
}

process.on("uncaughtException",(err,origin)=>{
console.log(err.message);
});

consta=1/b;
console.log("abc");//不会执行

上面的代码，控制台的输出是：b is not defined。捕获了错误信息，并且进程以0退出。开发者可以在 uncaughtException 事件中，清除一些已经分配的资源（文件描述符、句柄等），不推荐在其中重启进程。

process.on("unhandledRejection",(err,promise)=>{
console.log(err.message);
});

Promise.reject(newError("错误信息"));//未被catch捕获的异常，交由unhandledRejection事件处理

setTimeout(()=>{
console.log("我不会执行");
});

process.exit(0);

setTimeout(()=>{
console.log("我不会执行");
});

process.exitCode=1;

lethasSend=false;
process.on("beforeExit",()=>{
if(hasSend)return;//避免死循环

setTimeout(()=>{
console.log("mocksenddatatoserve");
hasSend=true;
},500);
});

console.log(".......");
//输出：
//.......
//mocksenddatatoserve

注意：在 beforeExit 事件中如果是异步任务，那么又会被添加到任务队列。此时，任务队列完成所有任务后，又回触发 beforeExit 事件。因此，不处理的话，可能出现死循环的情况。如果是显式调用 exit()，那么不会触发此事件。

process.stdin.setEncoding("utf8");

process.stdin.on("readable",()=>{
letchunk;
while((chunk=process.stdin.read())!==null){
process.stdout.write(`>>>${chunk}`);
}
});

process.stdin.on("end",()=>{
process.stdout.write("结束");
});

关于事件的含义，还是请看stream 的文档。

//被拆分成2个函数执行
functionBigThing(){
doPartThing();

process.nextTick(()=>finishThing());
}

在事件循环中，何时执行 nextTick 注册的任务呢？请看下面的代码：

setTimeout(function(){
console.log("第一个1秒");
process.nextTick(function(){
console.log("第一个1秒：nextTick");
});
},1000);

setTimeout(function(){
console.log("第2个1秒");
},1000);

console.log("我要输出1");

process.nextTick(function(){
console.log("nextTick");
});

console.log("我要输出2");

输出的结果如下，nextTick 是早于 setTimeout：

我要输出1
我要输出2
nextTick
第一个1秒
第一个1秒：nextTick
第2个1秒

在浏览器端，nextTick 会退化成 setTimeout(callback, 0)。但在 nodejs 中请使用 nextTick 而不是 setTimeout，前者效率更高，并且严格来说，两者创建的事件在任务队列中顺序并不一样（请看前面的代码）。

const{spawn}=require("child_process");
//返回ChildProcess对象，默认情况下其上的stdio不为null
constls=spawn("ls",["-lh"]);

ls.stdout.on("data",data=>{
console.log(`stdout:${data}`);
});

ls.stderr.on("data",data=>{
console.error(`stderr:${data}`);
});

ls.on("close",code=>{
console.log(`子进程退出，退出码${code}`);
});

child_process.exec()的使用：

const{exec}=require("child_process");
//通过回调函数来操作stdio
exec("ls-lh",(err,stdout,stderr)=>{
if(err){
console.error(`执行的错误:${err}`);
return;
}
console.log(`stdout:${stdout}`);
console.error(`stderr:${stderr}`);
});

父子进程通信

const{fork}=require("child_process");
constcp=fork("./sub.js");
cp.on("message",msg=>{
console.log("父进程收到消息：",msg);
});
cp.send("我是父进程");

sub.js 代码如下：

process.on("message",m=>{
console.log("子进程收到消息：",m);
});

process.send("我是子进程");

父进程收到消息：我是子进程
子进程收到消息：我是父进程

const{spawn}=require("child_process");
constsubprocess=spawn(process.argv0,["sub.js"],{
detached:true,
stdio:"ignore"
});

subprocess.unref();

setInterval(()=>{},1000);

constfs=require("fs");
constchild_process=require("child_process");

constsubprocess=child_process.spawn("ls",{
stdio:[
0,//使用父进程的stdin用于子进程。
"pipe",//把子进程的stdout通过管道传到父进程。
fs.openSync("err.out","w")//把子进程的stderr定向到一个文件。
]
});

const{spawn}=require("child_process");

constps=spawn("ps",["ax"]);
constgrep=spawn("grep",["ssh"]);

ps.stdout.on("data",data=>{
grep.stdin.write(data);
});

ps.stderr.on("data",err=>{
console.error(`psstderr:${err}`);
});

ps.on("close",code=>{
if(code!==0){
console.log(`ps进程退出，退出码${code}`);
}
grep.stdin.end();
});

grep.stdout.on("data",data=>{
console.log(data.toString());
});

grep.stderr.on("data",data=>{
console.error(`grepstderr:${data}`);
});

grep.on("close",code=>{
if(code!==0){
console.log(`grep进程退出，退出码${code}`);
}
});