Node之Event

一、重点

1. 事件循环
2. Events

二、内容

1.node事件循环（看之前需先自行了解下 线程、进程）
这里先说下node.js运行机制，node.js采用v8作为js的解析引擎，而在I/O处理方面采用了libuv。libuv库负责node api的执行，它将不同的任务分给不同的线程，形成一个Event Loop。以异步的方式将执行的结果返回给V8引擎。下面直接上图：

整体流程其实就是，V8引擎解析js代码传输给libuv库负责，libuv通过调用nodeApi去处理对应的事件,最后把处理完的事件再返回给v8引擎再输出。

了解了node运行机制后，咱们再来看libuv中的事件循环，其中 libuv 引擎中的事件循环分为 6 个阶段，它们会按照顺序反复运行。每当进入某一个阶段的时候，都会从对应的回调队列中取出函数去执行。

当队列为空或者执行的回调函数数量到达系统设定的阈值，就会进入下一阶段（为了避免函数在poll阶段阻塞）。下面看下对应的六个阶段的图：

（1）setTimeout 和 setImmediate

二者非常相似，区别主要在于调用时机不同。
setTimeout可能执行在前也可能在后，为什么这么说，因为进入事件循环也是需要成本的，如果在准备时候花费了大于 1ms 的时间，那么在 timer 阶段就会直接执行 setTimeout 回调。
但当二者在异步 i/o callback 内部调用时，总是先执行 setImmediate，再执行 setTimeout 结果如下：

const fs = require('fs')
fs.readFile(__filename, () => {
    setTimeout(() => {
        console.log('timeout');
    }, 0)
    setImmediate(() => {
        console.log('immediate')
    })
})
// immediate
// timeout

• setImmediate 设计在 poll 阶段完成时执行，即 check 阶段；
• setTimeout 设计在 poll 阶段为空闲时，且设定时间到达后执行，但它在 timer 阶段执行

（2）process.nextTick

这个函数其实是独立于 Event Loop 之外的，它有一个自己的队列，当每个阶段完成后，如果存在nextTick 队列，就会清空队列中的所有回调函数，并且优先于其他 microtask 执行。

setTimeout(() => {
 console.log('timer1')
 Promise.resolve().then(function() {
   console.log('promise1')
 })
}, 0)
process.nextTick(() => {
 console.log('nextTick')
 process.nextTick(() => {
   console.log('nextTick')
   process.nextTick(() => {
     console.log('nextTick')
     process.nextTick(() => {
       console.log('nextTick')
     })
   })
 })
})
// nextTick=>nextTick=>nextTick=>nextTick=>timer1=>promise1

2.Events
大多数 Node.js 核心 API 构建于惯用的异步事件驱动架构，其中某些类型的对象（又称触发器，Emitter）会触发命名事件来调用函数（又称监听器，Listener）。

类似观察者模式，举个现实生活中的例子，比如说一个视频网站要更新某一部电视剧的内容，它会通知所有订阅这部电视剧的用户，这些用户收到通知后想知道更新后电视剧的内容，这个更新就是一个事件（触发），发布也是一个事件（监听）。也就是说用户执行的动作。在node.js中是通过events模块来实现事件的，给我们返回一个类，这个类里面就包含事件发布订阅的功能，我们也可以创建自己的类去继承它，然后使用自己的类。

所有能触发事件的对象都是 EventEmitter 类的实例。当 EventEmitter 对象触发一个事件时，所有绑定在该事件上的函数都会被同步地调用。 被调用的监听器返回的任何值都将会被忽略并丢弃。

下面我例下events常见的方法、事件、属性：

方法：
1.on(), (为实列添加指定事件的监听器)
2.once() (顾名思义，添加相同事件的时候只执行第一次)
3.emit() (触发指定的事件)
4.eventNames() (返回已经注册事件监听的事件的数组)
5.listeners() (返回指定事件的监听器的数组的副本)
6.addListener() (给指定的事件添加监听器)
7.prependListener() (添加监听器到指定事件队列的头部)
8.prependOnceListener() (添加执行一次监听器到指定事件队列的头部)
9.removeListener() (给指定的事件移除指定的监听)
10.removeAllListener() (给指定的事件移除全部指定的监听)
11.getMaxListeners() （获取EventEmitter实列的最大监听数量限制）
12.setMaxListeners() （设置EventEmitter实列的最大监听数量限制）

事件:
1.newListener (EventEmitter实例被添加新的监听器时触发，就是注册newListener时，去判断是不是新的注册的事件，如果是的话会先触发此函数)
2.removeListener （EventEmitter实例监听器被移除时触发）
3.error (错误事件，当 EventEmitter 实例中发生错误时，会触发一个 ‘error’ 事件，如果没有会抛出错误，并退出nose.js进程。 防止 Node.js 进程崩溃，可以在 process 对象的 uncaughtException 事件上注册监听器)

属性：defaultMaxListeners （EventEmitter实例每个事件最多注册的监听器的个数）

简单举两个例子大家参照下：
1.绑定和触发、还有给事件传参：

const EventEmitter = require('events');
// 导入模块
class MyEmitter extends EventEmitter {}
// 继承EventEmitter类
const myEmitter = new MyEmitter();
// 创建新的实列
myEmitter.on('event', (a,b) => {   // 注册event事件
 console.log(a,b);
});
myEmitter.emit('event','a','b'); // 触发event事件并传参
 
 
//a b

2.EventListener 会按照监听器注册的顺序同步地调用所有监听器，监听器函数可以使用 setImmediate() 或 process.nextTick() 方法切换到异步操作模式：

const EventEmitter = require('events');
// 导入模块
class MyEmitter extends EventEmitter {}
// 继承EventEmitter类
const myEmitter = new MyEmitter();
// 创建新的实列
myEmitter.on('event', (a,b) => {   // 注册event事件
 setImmediate(()=>{   // 异步
        //异步触发
        console.log(a,b);
    })
    console.log("c");
});
myEmitter.emit('event','a','b'); // 触发event事件并传参
 
//c
//a b

3.获取和修改最大事件监听数量：

const EventEmitter = require('events');
// 导入模块
class MyEmitter extends EventEmitter {}
// 继承EventEmitter类
const myEmitter = new MyEmitter();
// 创建新的实列
console.log(EventEmitter.defaultMaxListeners);    //10   获取最大事件监听数量
 
//  myEmitter.setMaxListeners(13);   设置最大事件监听数量
 
for (let i = 0; i < 11; i++) {
    myEmitter.on("event", () => {  // 注册event事件
        console.log(i);
    });
}
myEmitter.emit('event','a','b'); // 触发event事件并传参

待续。。。。。。。。。。。。。