深刻nodejs-核心模块Events详解（事件驱动）

时间 2019-11-06

标签深刻 nodejs 核心模块 events 详解事件驱动繁體版

原文原文链接

事件驱动

Node.js 是一个基于 Chrome V8 引擎的 JavaScript 运行环境。Node.js 使用了一个事件驱动、非阻塞式 I/O的模型，使其轻量又高效。Allows you to build scalable network applications usingJavaScript on the server-side.

对于上面这段官方的引用你们应该都看过，nodejs是基于事件驱动和非阻塞I/O的方式来设计运行的，那么做为实现事件驱动的核心模块Events就成了深刻学习node.js的关键。在node中大部分的模块的实现都继承了Events类。好比，文件操做中的fs事件流，网络编程所用到的tcp，http模块等，当你回想本身写的程序后，会发现不少操做都基于事件驱动，Events类。node

那么问题是什么是事件驱动呢？

简单来讲，就是经过监听事件的状态变化来作出相应的操做。好比读取一个文件，文件读取完毕，或者文件读取错误，那么就触发对应的状态，而后调用对应的回掉函数来进行处理。编程

咱们来简单的看几段代码来回忆一下：数组

const fs = require('fs');
    
    let rs = fs.createReadStream('1.txt');
    
    // 监听文件打开操做
    rs.on('open', function() {
      console.log('open');
    });
    
    // 监听数据流读取
    rs.on('data', function(data) {
      console.log(data);
    });
    
    // 监听错误
    rs.on('error', function() {
      console.log('error');
    });
    
    // 监听读取结束操做
    rs.on('end', function() {
      console.log('end');
    });
    
    
    // 监听文件关闭操做
    rs.on('close', function() {
      console.log('close');
    });

上面这段在建立文件读取流的操做上，针对文件的打开，数据，错误，结束，关闭等几个状态进行了监听的回调处理，这也应征了咱们上面的定义经过监听事件的状态变化来作出相应的操做。
那么这些监听事件又是如何触发的呢？它是经过Events类中的emit方法去发射事件的。那么下面咱们来看一下Events是如何实现这样的监听操做的。微信

Events类

主要的几个核心API

on(eventName, listener)和emitter.addListener(eventName, listener)：对指定事件绑定事件处理函数
once(eventName, listener)：对指定事件指定只执行一次的事件处理函数
emit(eventName[, ...args])：触发指定事件
removeListener(eventName, listener)：对指定事件解除事件处理函数
removeAllListeners([event])：对指定的事件接触全部的事件处理函数
setMaxListeners 设置最大队列的长度

下面来看一下代码，看看是怎么使用的网络

const events = require('events');
    
    const EventsEmitter = new events();
    
    //===============事件监听部分===============
    EventsEmitter.on('open', function() {
      console.log('open');
    });
    
    EventsEmitter.on('data', function(data) {
      console.log(data);
    });
    
    EventsEmitter.on('error', function() {
      console.log('error');
    });
    
    EventsEmitter.on('end', function() {
      console.log('end');
    });
    
    EventsEmitter.on('close', function() {
      console.log('close');
    });
    
    //=============事件触发部分=================
    
    // 触发open事件
    EventsEmitter.emit('open');
    // 触发data事件,并传递一个字符串参数'test'
    EventsEmitter.emit('data','test');
    // 触发error事件
    EventsEmitter.emit('error');
    // 触发end事件
    EventsEmitter.emit('end');
    // 触发close事件
    EventsEmitter.emit('close');

看完上面这段代码是否是更进一步的理解了呢。咱们回顾最最上面的那段文件流监听的代码，其实就是文件在不一样的状态下去发射相应的emit事件。而在那段代码中咱们并无去引入events这个node提供的模块，是由于文件流中继承了events模块，因此rs这个变量也就拥有了相应的rs.on()这个方法了。app

看到这里我想应该都了解的差很少了。那么下面来试着实现一下Events这个类，加深理解。tcp

初始化Events模块

建立一个Events类
初始化this.events用来保存咱们须要监听的事件
将模块导出

class Events {
  constructor() {
    this.events = {};
  }
}

module.exports = Events;

实现Events.on方法

on方法接收两个参数：ide
- type：监听的事件类型
- listener：回调函数
将对应的事件先存放在一个对象中，分两种状况：函数
- 该事件对象不存在，那么以type为key，[listener]为值存放在实现初始化好的this.events对象中（注意这里存的是一个数组,例如data事件，this.events = {data:[callback]}）
- 若是该事件已经存在则直接push
- 监听函数就这么简单的实现了，接下来就是等着被emit触发了。

/**
   * 事件监听
   * @param {*} type        监听的事件类型
   * @param {*} listener    回调函数
   */
  on(type, listener) {
    if (this.events[type]) {
      this.events[type].push(listener);
    } else {
      this.events[type] = [listener];
    }
  }

这里在补充一下，同一个监听事件是能够添加多个的，因此这里才会this.events[type]才会给一个数组来存储学习

实现Events.emit方法

接收两个参数：
- type：要触发的事件类型
- ...rest：若干个参数，传递给对应事件的回调函数
经过type，在this.events里找到相应的事件，这里咱们上面是存成了一个数组，里面对应的是事件的回调好书。
循环数组，执行全部对应事件的回调。

/**
   * 事件触发
   * @param {*} type        要触发的事件类型
   * @param  {...any} rest  接收到的若干个参数，这个参数会做为参数被传递到对应事件的回调函数中
   */
  emit(type, ...rest) {
    if (this.events[type]) {
      this.events[type].forEach(listener => {
        listener.apply(this, rest);
      });
    }
  }

写到这里，咱们以前的代码就可以引入本身写的这个Events模块来执行了

实现Events.removeListener方法

这个方法是用来删除对应事件的某个监听函数，那么咱们只须要把该事件从this.events[type]中删除便可

接收两个参数：
- type：事件类型
- listener：要删除的监听函数
经过this.events[type]找到对应的事件监听函数数组
经过filter对要删除的监听函数进行过滤

/**
   * 删除指定事件中的监听函数
   * @param {*} type      对应的事件 
   * @param {*} listener  要删除的监听函数
   */
  removeListener(type, listener) {
    if (this.events[type]) {
      this.events[type].filter(l => l !== listener);
    }
  }

实现Events.once方法

这个方法和on同样，惟一的区别就是它只会执行一次，即使屡次调用emit去触发相同的事件监听，它也只会执行一次。

实现方式其实就是对on()方法作了一层封装，将一个封装好的wraper代替listener传递给on()方法
wraper内部会执行一次监听回调函数，而后再调用this.removeListern对该回调进行删除。

/**
   * 事件监听，可是只执行一次
   * @param {*} type        监听的事件类型
   * @param {*} listener    回调函数
   */
  once(type, listener) {
    const wraper = (...rest) => {
      listener.apply(this, rest);
      this.removeListener(type, wraper);
    };
    this.on(type, wrapper);
  }

完整代码

class Events {
  constructor() {
    this.events = {};
  }
  /**
   * 事件监听
   * @param {*} type        监听的事件类型
   * @param {*} listener    回调函数
   */
  on(type, listener) {
    if (this.events[type]) {
      this.events[type].push(listener);
    } else {
      this.events[type] = [listener];
    }
  }

  /**
   * 事件监听，可是只执行一次
   * @param {*} type        监听的事件类型
   * @param {*} listener    回调函数
   */
  once(type, listener) {
    const wraper = (...rest) => {
      listener.apply(this, rest);
      this.removeListener(type, wraper);
    };
    this.on(type, wrapper);
  }

  /**
   * 事件触发
   * @param {*} type        要触发的事件类型
   * @param  {...any} rest  接收到的若干个参数，这个参数会做为参数被传递到对应事件的回调函数中
   */
  emit(type, ...rest) {
    if (this.events[type]) {
      this.events[type].forEach(listener => {
        listener.apply(this, rest);
      });
    }
  }

  /**
   * 删除指定事件中的监听函数
   * @param {*} type      对应的事件
   * @param {*} listener  要删除的监听函数
   */
  removeListener(type, listener) {
    if (this.events[type]) {
      this.events[type].filter(l => l !== listener);
    }
  }
}

module.exports = Events;

总结

Events模块是node很是核心的模块，它对你深刻去学习node有很大的帮助，上面我只写了几个方法，内部还有几个API以及一些很是细节的地方能够本身试着去扩展，我这里就不一个一个的去写了，文章有写很差的地方或者看不懂的地方均可以给我留言哦。

若是以为写的还行，方便的话帮忙点个赞哦，谢谢了。

如下个人新我的微信公众号，在里面也会为你们提供原创文章，欢迎你们关注，当关注用户量够了，我会在里面推出一些视频教程