原文地址在我的博客，转载请注明出处，谢谢！

node 模块是node 完成强大功能的实现者。node 的核心模块包括events、fs、buffer、stream、cluster、http、net、一些操作OS和工具模块、全局对象等。本文将在node核心特性理解的基础上进一步深入探讨node核心模块的具体细节。本文主要探讨的模块有：全局对象global及其重要属性、多进程cluster、events重要类EventEmitter、流Stream、文件系统fs、网络http，还会介绍node框架express相关。

概述

本文先来介绍全局对象global及其重要属性、多进程cluster模块。

正文

node全局对象global

与浏览器对应的window一样，在node中global是全局对象，在全局作用域定义的任何变量都会保存为global的属性，称为全局变量。下面是global一些重要的属性：

• 模块：module、require、exports

  这三个全局变量组成了node 的模块定义和引入，是 commonJS 的实现。node将每个文件视为一个模块，在执行到每个模块之前都会定义好上述三个变量，因此可以直接使用。来看它们之间的协作：

  // module1.js
  exports.fun = function(a,b) {
      return a + b;
  } //绑定在exports的属性可以被其他模块引入使用
  
  //module2.js
  var module1 = require('./module1')
  module1.fun(3,2)  //5
  

  相关机制：

  • module 表示对这个模块的引用，因此module 实际上不是全局的，而是每个模块本地的。module除了exports 还有其他关于模块的属性，例如module.children
  • exports 其实是module.exports的简写，表示这个模块的输出。有一点需要注意，对exports直接赋值exports = {...}并不会被输出，因为exports事先已经被定义了，再次这样赋值会被覆盖，需要带上module：module.exports = {...}
  • require 表示引入某个模块，填写模块路径即可，在node_modules里面的模块填写名字即可，js文件可以不用写扩展名。

  另外，由于V8引擎对ES6的不断支持，node 中也可以直接使用ES6的一些特性、例如promise、class等，ES6的模块也被node 实验性的引入并且是稳定的。详情见nodejs中文网。可以在node.green查看支持的特性

• 异步操作 setTimeout、setInterval、setImmediate、process.nextTick

  • setTimeout和setInterval跟浏览器端一样，不同的是，node实现了setImmediate（目前浏览器端只有 IE实现了该方法）。它表示在 Node.js 事件循环的当前回合结束时要调用的函数，用来把一些需要长时间运行的操作放在一个回调函数里,在node主线程完成后面的其他语句后,就立刻执行这个回调函数，参数是一个函数和用作这个函数的参数，作用跟setTimeout(fn,0)差不多，都是相当于立即在事件队列末尾插入一个事件，但也有差别。

  • process.nextTick(fn,...args)表示在当前调用栈结束后，在下一个事件执行前调用回调函数。node 提供这个API是为了把复杂耗时的任务放到最后去处理，以便优先执行简单的任务。来看它们之间的比较：

    setTimeout(() => console.log("setTimeout0"),0)
    setImmediate(() => console.log("setImmediate"))
    process.nextTick(() => console.log("nextTick"))
    //输出nextTick setTimeout0 setImmediate 或者 nextTick setImmediate setTimeout0 
    

    无论process.nextTick写在什么地方，它总是第一个输出。无论setTimeout和setImmediate谁先谁后，都可能出现两种结果，其中setTimeout(fn,0)先于setImmediate多一点。这是因为它们三个产生的事件推入到了不同的watcher（观察者）中—— setTimeout推入到了定时器观察者，setImmediate是check观察者，而process.nextTick()是idle观察者 ，而node主线程在事件循环时调用watcher 的顺序一般是 idle观察者 > check观察者，idle观察者 > 定时器观察者，check 和定时器不分先后，但定时器先于check的概率大一点。

• node进程： process

  process 是node对进程的表示，提供了操作进程的接口，可以用process来提供进程有关信息，控制进程 。

  process提供的接口包括

  描述进程的一些状态（事件）：exit、beforeExit、uncaughtException、Signal

  进程退出返回的状态码：Uncaught Fatal Exception、Signal Exits、Unused等

  进程的相关信息：stdout、stderr、config、stdin、exitCode、pid(进程编号)等

  操作进程的方法：abort、chdir、cwd、kill(发送信号给进程)、exit、nextTick、getgid、setgid、uptime等

• 其他： console、__filename、 __dirname

  这些都是全局变量，可以在任何地方引用

node 子进程：child_process模块

一个进程只能利用一个CPU时间分片，为了高效利用多核CPU，node 提供了可以创建子进程(注意不是子线程)的child_process模块，来帮助主进程高效利用多核CPU完成其他复杂的任务。之所以提供创建子进程而不是子线程的接口，是因为这让我们的程序状态单一，不用在意状态同步、死锁、上下文切换开销等等多线程编程中的头疼问题。这样以来一个进程只有一个线程。虽然单线程也会带来一些问题，如错误会引起整个应用退出等，但这都有了很好的解决方案。

创建子进程

node有三种创建子进程的接口：

• exec / execFile: 这两者都会创建子进程来执行，执行的结果会存储在Buffer中。不同的是前者创建一个shell进程来执行命令，后者直接创建一个进程用来执行可执行文件，因此前者适合用来执行shell命令然后获取输出，后者效率较高。这两者因为输出的结果存储在Buffer中，因此只适合输出轻量的数据。
• spawn：适合用于进程输入、输出数据量比较大的情况，因为它支持以 stream 的形式输入输出，可以用于任何命令。spawn的参数option有一个stdio配置项，用来配置子进程与父进程之间的IO通道，还有一个detached来配置子进程是否独立运行，可以创建常驻后台进程。总之，给予了子进程更多的灵活性。
• fork：fork 其实是spawn的特例，它会创建一个V8实例，只能用来运行node.js程序，并且与上面两种方法不同的是，fork会在父子进程间建立 IPC 通道，父子进程之间可以互相收发消息——通过监听 message 事件和调用 send 方法，就可以在父子进程间进行通信了。

父子进程通信

首先，这三种API都返回ChildProcess实例，因此都可以通过访问stdout属性来得到输出，exec/execFile 接口还可以在参数里绑定回调函数拿到子进程的stdout 。

const { exec, execFile, spawn, fork } = require("child_process")

// exec/execFile 接口既可以在参数里绑定回调函数拿到输出流，也可以利用返回的ChildProcess实例
const exec_process = exec("node child_process.js", {}, (err, stdout, stderr) => {
    if (err) {
        console.log(err)
    } else if(stdout) {
        console.log(stdout)
    } else {
        console.log(stderr)
    }
})
exec_process.stdout.on('data',(data) => console.log(`${data}`))

// spawn 接口没有回调函数，只能利用返回的ChildProcess实例绑定监听数据函数拿到子进程的输出
const spawn_process = spawn('node',['child_process'], {})
spawn_process.stdout.on('data', (data) => console.log(`${data}`))

//fork 也可以利用返回的ChildProcess实例，注意配置项silent要设为true
const fork_process = fork('child_process.js', [], {'silent': true})
fork_process.stdout.on('data' ,(data) => console.log(`${data}`))    

其次， fork返回的ChildProcess实例有一个额外的内置的通信通道IPC，它允许消息在父进程和子进程之间来回传递。

// child_process.js
process.on('message', (data) => {
  console.log(`message from Parent: ${data}`);
})
setTimeout(() => {
  process.send('send from child');
}, 2000)

// parent.js
const { fork } = require("child_process")
const p = fork(
  'child_process.js', // 需要执行的脚本路径
  [], // 传递的参数
  {}
)
p.on('message', data => {                      //监听子进程消息
  console.log(`message from child: ${data}`)
})
p.send('send from parent')                     //发送消息给子进程

集群：Cluster 模块

cluster模块是对child_process模块的进一步封装，专用于解决单进程NodeJS Web服务器无法充分利用多核CPU的问题。使用该模块可以简化多进程服务器程序的开发，让每个核上运行一个工作进程，并统一通过主进程监听端口和分发请求。 ——七天学会node.js

const cluster = require('cluster');
const http = require('http');
const numCPUs = require('os').cpus().length;
console.log(numCPUs)

if (cluster.isMaster) {
  console.log(`主进程 ${process.pid} 正在运行`);

  // 衍生工作进程。
  for (let i = 0; i < numCPUs; i++) {
    cluster.fork();      // 调用了 child_process.fork()方法创建工作进程
  }

  cluster.on('exit', (worker, code, signal) => {
    console.log(`工作进程 ${worker.process.pid} 已退出`);
  });
} else {
  // 工作进程可以共享任何 TCP 连接。
  // 在本例子中，共享的是一个 HTTP 服务器。
  http.createServer((req, res) => {
    res.writeHead(200);
    res.end('你好世界\n');
  }).listen(8000);

  console.log(`工作进程 ${process.pid} 已启动`);
}
console.log("WOW")

// 输出（Mac OS）
4
主进程 55570 正在运行
WOW
4
工作进程 55571 已启动
WOW
4
工作进程 55572 已启动
WOW
4
工作进程 55573 已启动
WOW
4
工作进程 55574 已启动
WOW

//可以看到 fork 是异步创建的，调用时请求创建进程并立即返回，系统创建好进程后会加入到事件队列，执行到事件就调用回调函数，这个回调函数包括执行一遍这个文件

cluster.fork()实际调用了child_process.fork()，因此建立了IPC通道与父进程通信。它会创建一个进程并返回cluster.worker实例。创建的每个进程之间都是独立的，一个进程的开启和关闭不影响其他进程。只要有存活的进程，服务器就可以继续处理连接。

主进程负责监听端口，接收新连接后会自动将连接循环（默认）分发给cluster.fork()创建的工作进程来帮忙处理，因此可以使用cluster模块来实现简单的负载均衡。

注意：

• cluster.fork()返回cluster.worker实例可能会引起困惑，困惑的原因把主进程和工作进程做了master和worker的区分，这里不用这么区分，既然主进程也是进程，那么也可以看作worker，调用cluster.fork().send(message)就可以向子进程发送信息，同样监听信息也是cluster.fork().on('message', (data) => {...})。
• worker 和 process 都是相对的，如果当前执行进程是主进程就代表主进程，是工作进程就代表工作进程。
• cluster代表整个集群，也就是主进程和工作进程，随着当前执行进程的变化，cluster的属性也在变化。在cluster上面绑定的事件对每个进程都起作用。cluster有一些API 是只对于主进程或只对于工作进程的，例如只能在主进程而不能在工作进程中调用的：fork、cluster.workers等，只能在工作进程不能在主进程调用的：cluster.worker等。
• 跟上面child_process模块不一样的是，cluster.fork()只有增加进程环境变量的参数(一般是不带的)，没有要执行文件路径的参数，因此像上面代码那样主进程做的事和工作进程做的事写在同一文件(if-else语句里)是合理的。