深刻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;