【原创】Node核心API（二）Events

Events模块是Node对“发布/订阅”模式（publish/subscribe）的实现，一个对象通过这个模块，向另一个对象传递消息，几乎所有常用的node模块都继承了events模块，比如http、fs等。
Node中的Event模块仅仅提供了一个对象: EventEmitter, EventEmitter 的核心就是事件触发与事件监听器功能的封装。

1、订阅发布模式(Subscribe/Publish)

订阅发布模式（又称事件监听器模式）广泛用于异步编程中。events模块是订阅发布模式的一个简单实现。订阅发布模式定义了一种一对多的依赖关系,在Node中EventEmitter 对象上开放了一个可以用于监听的on(eventName,callback)函数,允许将一个或多个函数绑定到对应的事件上。当 EventEmitter 对象触发一个事件时,所有绑定在该事件上的函数都被同步地调用！

2、Events的API

Events API概览

大多数时候我们不会直接使用 EventEmitter，而是在对象中继承它。包括 fs、net、 http 在内的，只要是支持事件响应的核心模块都是 EventEmitter 的子类。
原因有两点:

• 具有某个实体功能的对象实现事件符合语义， 事件的监听和发射应该是一个对象的方法。
• JavaScript 的对象机制是基于原型的，支持 部分多重继承，继承 EventEmitter 不会打乱对象原有的继承关系。

3、方法

3.1 创建监听器

• emitter.on(eventName, listener)：添加 listener 函数到名为 eventName 的事件的监听器数组的末尾。 不会检查 listener 是否已被添加。 多次调用并传入相同的 eventName 与 listener 会导致 listener 会被添加多次。
• emitter.addListener(eventName, listener)：emitter.on(eventName, listener)的别名。

//引入events模块
const EventEmitter = require('events');
let count = 0;
//创建一个新实例
const myEmitter = new EventEmitter();
//给“去逛街”创建一个监听
myEmitter.on('去逛街', () => {
    console.log(`买了${++count}件衣服`);
});
// 再次给“去逛街”创建一个监听，不会检查 listener 是否已被添加，依然被放到监听器数组后面。
myEmitter.on('去逛街', () => {
    console.log(`买了${++count}条裤子`);
});
//触发监听“去逛街”这个事件
myEmitter.emit('去逛街');
myEmitter.emit('去逛街');
/** 输出结果:
 * 买了1件衣服
 * 买了2条裤子
 * 买了3件衣服
 * 买了4条裤子*/

• emitter.once(eventName, listener)：添加单次监听器 listener 到名为 eventName 的事件。 当 eventName 事件下次触发时，监听器会先被移除，然后再调用。

//引入events模块
const EventEmitter = require('events');
let count = 0;

//创建一个新实例
const myEmitter = new EventEmitter();
//给“去逛街”创建一个监听
myEmitter.once('去逛街', () => {
    console.log(`买了${++count}件衣服`);
});
//触发监听“去逛街”这个事件
myEmitter.emit('去逛街'); // 买了1件衣服

myEmitter.emit('去逛街'); // 没有被触发

• emitter.prependListener(eventName, listener)：添加 listener 函数到名为 eventName 的事件的监听器数组的开头。 不会检查 listener 是否已被添加。 多次调用并传入相同的 eventName 和 listener 会导致 listener 被添加多次。
• emitter.prependOnceListener(eventName, listener)：添加单次监听器 listener 到名为 eventName 的事件的监听器数组的开头。 当 eventName 事件下次触发时，监听器会先被移除，然后再调用。

//引入events模块
const EventEmitter = require('events');
//创建一个新实例
const myEmitter = new EventEmitter();
//给“去逛街”创建一个监听
myEmitter.on('去逛街', () => {
    console.log(`买衣服`);
});
// 添加 listener 函数到名为 eventName 的事件的监听器数组的开头。
myEmitter.prependListener('去逛街', () => {
    console.log(`买裤子`);
});
// 添加单次监听器 listener 到名为 eventName 的事件的监听器数组的开头
myEmitter.prependOnceListener('去逛街', () => {
    console.log(`买鞋子`);
});
//触发监听“去逛街”这个事件
myEmitter.emit('去逛街'); // 输出结果：买鞋子 买裤子 买衣服
myEmitter.emit('去逛街'); // 输出结果：买裤子 买衣服

3.2 调用监听器

• emitter.emit(eventName[, ...args])：按照监听器注册的顺序，同步地调用每个注册到名为 eventName 的事件的监听器，并传入提供的参数。

3.3 移除监听器

• emitter.removeListener(eventName, listener)：从名为 eventName 的事件的监听器数组中移除指定的 listener。每次只会从监听器数组中移除一个监听器。 如果监听器被多次添加到指定 eventName 的监听器数组中，则必须多次调用 removeListener() 才能移除所有实例。
• emitter.removeAllListeners([eventName])：移除全部监听器或指定的 eventName 事件的监听器。
• emitter.off(eventName, listener)：emitter.removeListener() 的别名。

//引入events模块
const EventEmitter = require('events');
//创建一个新实例
const myEmitter = new EventEmitter();
const buyClothes = () => {
    console.log(`买衣服`);
    myEmitter.removeListener('去逛街', buyPants);
}
const buyPants = () => {
    console.log(`买裤子`);
}
myEmitter.on('去逛街', buyClothes);
myEmitter.on('去逛街', buyPants);
// buyClothes 移除了监听器 buyPants，但它依然会被调用。
// 触发时内部的监听器数组为 [buyClothes, buyPants]
myEmitter.emit('去逛街'); // 买衣服 买裤子
// buyPants 现已被移除。
// 内部的监听器数组为 [buyClothes]
myEmitter.emit('去逛街'); // 买衣服

4、事件

• 'newListener' 事件: EventEmitter 实例在新的监听器被添加到其内部监听器数组之前，会触发自身的 'newListener' 事件。在 'newListener' 回调中注册到相同 eventName的任何其他监听器将插入到正在添加的监听器之前。

const EventEmitter = require('events');
const myEmitter = new EventEmitter();
// EventEmitter 实例会在一个监听器被添加到其内部监听器数组之前触发自身的 'newListener' 事件；
// 只处理一次，避免无限循环。
myEmitter.once('newListener', (event, listener) => {
    if (event === '去逛街') {
        console.log('逛街前的准备');
        myEmitter.on('去逛街', () => {
            console.log('涂防晒霜');
        });
    }
});
myEmitter.on('去逛街', () => {
    console.log('买护肤品');
});
myEmitter.emit('去逛街'); // 逛街前的准备 涂防晒霜 买护肤品
myEmitter.emit('去逛街'); // 涂防晒霜 买护肤品

注意：对'newListener' 事件的监听要放在普通监听前面。如下'newListener' 事件不起作用。

const EventEmitter = require('events');
const myEmitter = new EventEmitter();
myEmitter.on('去逛街', () => {
    console.log('买护肤品');
});
myEmitter.once('newListener', (event, listener) => {
    if (event === '去逛街') {
        console.log('逛街前的准备');
        myEmitter.on('去逛街', () => {
            console.log('涂防晒霜');
        });
    }
});
myEmitter.emit('去逛街'); // 买护肤品
myEmitter.emit('去逛街'); // 买护肤品

• 'removeListener' 事件：'removeListener' 事件在 listener 被移除后触发

const EventEmitter = require('events');
const myEmitter = new EventEmitter();
const buySkinProd = () => {
    console.log('买护肤品');
    myEmitter.removeListener('去逛街', buySkinProd);
}
myEmitter.once('removeListener', (event, listener) => {
    if (event === '去逛街') {
        console.log('逛街结束');
    }
});
myEmitter.on('去逛街', buySkinProd);
myEmitter.emit('去逛街'); // 买护肤品 逛街结束

5、自定义的类继承 events

// blog.js
const EventEmitter=require('events');

class Base extends EventEmitter {
    constructor() {
        super();
    }
    onEvent(eventName,callback){
        super.on(eventName,callback);
    }
    emitEvent(eventName,arg){
        super.emit(eventName,arg);
    }
};

class BlogInfo extends Base {
    constructor() {
        super();
    }
    onSave() {
        super.onEvent('saveStart',function(blog){
            console.log('saveStart',blog);
        });

        super.onEvent('blogCount',function(blog){
            console.log('blogCount',blog.length);
        });

        super.onEvent('saveEnd',function(blog){
            console.log('saveEnd',blog);
        });
    }
    emitEvent(blog) {
        super.emitEvent('saveStart',blog);

        super.emitEvent('blogCount',blog);

        super.emitEvent('saveEnd',blog);
    }
}

exports.blogSave=function(newblog){
    console.log(BlogInfo.__proto__.__proto__ === EventEmitter); // true
    console.log(BlogInfo.__proto__ === Base); // true
    const blogInfo=new BlogInfo();
    blogInfo.onSave(newblog);
    blogInfo.emitEvent(newblog);
};

// index.js
const http = require('http');
const blog = require('./blog');
const serve = http.createServer((req, res) => {
    if (req.url === '/') {
        const newblog = {title: "标题", content: "内容"};
        blog.blogSave(newblog);
        res.writeHead(200, {'Content-Type': 'text/html;charset=utf-8'});
        res.write('<html><body>');
        res.write('<h2>Hello World!</h2>');
        res.end('</body></html>');
    }
});
serve.listen(8000);
console.log('listen 8000');
/** 运行index.js结果
 * listen 8000
 * true
 * true
 * saveStart [ { title: '标题', content: '内容' } ]
 * saveEnd [ { title: '标题', content: '内容' } ]
 */

参考文章：
https://www.jb51.net/article/124799.htm
https://www.jianshu.com/p/fd1f8c998a2c
https://www.jianshu.com/p/152fddf0628c