上章講了學習node，應該去學習什麽，對這些框架去進行學習現在咋們聊聊如何用原生來進行操作

主要來講一下events-事件觸發器

先來講一個簡單的實例

EventEmitter的實例，綁定一個監聽器。用eventEmitter.on（）的方法來進行註冊一個監聽器，eventEmitter.emit()方法來觸發引用事件。

const EventEmitter = require(‘events‘);

class MyEmitter extends EventEmitter {}
//合並
const myEmitter = new MyEmitter();
myEmitter.on(‘event‘, () => {
  console.log(‘觸發事件‘);
});
myEmitter.emit(‘event‘);

　來咋們來拆分下這段代碼，require什麽意思呢，可能是我不太懂，我找了一下 點擊我進行查看→→→→

EventEmitter 會按照監聽器註冊的順序同步地調用所有監聽器。 所以必須確保事件的排序正確，且避免競態條件。 可以使用 setImmediate() 或 process.nextTick() 切換到異步模式：

const myEmitter = new MyEmitter();
myEmitter.on(‘event‘, (a, b) => {
  setImmediate(() => {
    console.log(‘異步進行‘);
  });
});
myEmitter.emit(‘event‘, ‘a‘, ‘b‘);

　eventEmitter.on()與eventEmitter.onec()的區別，最明顯的區別就是，他們後面的拼寫不一樣，著實在的的，其實是他們的運行，其中一個能夠只要進行觸發就會一直運行下去，觸發一次運行一次，還有一個是不管你觸發多少次，他只運行第一次。用定時器很有意思，並且可以定義多個myEmitter，用newListener來插入。

const myEmitter = new MyEmitter();
let m = 0;

myEmitter.once(‘event‘, () => {
  console.log(++m);
});
myEmitter.emit(‘event‘);
// 打印: 1
myEmitter.emit(‘event‘);
// 不觸發

　　插入用法如下

myEmitter.once(‘newListener‘, (event, listener) => {
//插入的是event的，裏面也可以去判斷下，這個event是否全等另外一個event
      console.log(‘B‘);
});

　　node.js中事件的發射器 ，也就是調取的東西在這

class EventEmitter {
  // 返回正在監聽名為 eventName的事件的監聽器數量
  static listenerCount(emitter: EventEmitter, type: string | number): number;
  
  // 每個事件 默認可註冊監聽器的最大數量
  static defaultMaxListeners: number;


  // 修改事件 監聽器數量的限制
  setMaxListeners(n: number): this;
  
  // 調用指定名稱事件的 所有監聽器
  emit(type: string | number, ...args: any[]): boolean;
  
  // 添加listener 函數到名為 type 的事件監聽器數組末尾
  addListener(type: string | number, listener: Listener): this;
  // addListener 方法的別名
  on(type: string | number, listener: Listener): this;
  
  // 添加一個單次listener 函數到名為 eventName的事件。下次觸發eventName事件時，監聽器會被移除，然後調用
  once(type: string | number, listener: Listener): this;
  
  // 從type 的事件監聽器數組中移除指定的 listener
  removeListener(type: string | number, listener: Listener): this;
  
  // 移除全部或指定type的監聽器
  removeAllListeners(type?: string | number): this;
  
  // 返回type事件下的監聽器數組
  listeners(type: string | number): Listener[];
  
  // 返回type事件下監聽器數量
  listenerCount(type: string | number): number;
}

　　其實node的實例，在每個方法下都有限制要註冊多少個監聽器的，可以用

console.log(EventEmitter.defaultMaxListeners)
//默認值10

　　上面說了on和once的區別，現在又來了一個addListener，同樣是添加監聽事件的東西來看下他的使用方法

emitter.addListeners("add", ()=>{
  console.log(EventEmitter.defaultMaxListeners)

})
emitter.emit(‘add‘);
//10

　　可能細心的人發現了，這個方法和上面的又有什麽分別呢，我能告訴，沒有分別，就是拼的不一樣罷了，來驗證一下

console.log(emitter.on == emitter.addListener)
//true

　　現在添加監聽的事件有了，來看看刪除監聽事件

const EventEmitter = require(‘events‘);
const myEE = new EventEmitter();
const sss = () =>{
  console.log("aaa")
}
myEE.on(‘foo‘, sss);
myEE.on(‘bar‘, () => {});

myEE.removeListener(‘foo‘, sss)

console.log(myEE.listeners(‘foo‘))
//[]

　　上面的例子就是刪除掉了foo監聽裏的sss事件，看上面了例子發現一個不認識的方法，那就是console.log內的方法myEE.listeners（name）這又是啥東西，為啥打印他就能知道他方法內有沒有刪除呢

這個東西吧，其實就是node.js裏面給的一種方法，他返回的是事件監聽器裏的副本，也就是相當於方法之類的。和他對應的還有一個那就是myEE.listenerCount（name） 他返回的就是這個事件中有多少的監聽數量。

const EventEmitter = require(‘events‘);
const myEE = new EventEmitter();
myEE.on(‘bar‘, () => {});
myEE.on(‘bar‘, () => {});
myEE.on(‘bar‘, () => {});
myEE.listenerCount(‘bar‘)
console.log(myEE.listenerCount(‘bar‘))
//3
myEE.listeners(‘foo‘)
console.log(myEE.listeners(‘bar‘))
//[ [Function], [Function], [Function] ]

如過他要是多個不重名的方法應該怎麽辦呢，要怎麽把他查出來，那就要用到這個方法了myEE.eventNames() 這個方法他能夠直接的反應你代碼用都有那些方法。

const EventEmitter = require(‘events‘);
const myEE = new EventEmitter();
const sss = () =>{
  console.log("aaa")
}
myEE.on(‘foo‘, sss);
myEE.on(‘bar‘, () => {});
console.log(myEE.eventNames());
//[ ‘foo‘, ‘bar‘ ]

扯的有點遠了，回到剛才，移除監聽事件上面的移除事件，是根據條件來進行移除某一條，某一個監聽的，下面我們來把所有的監聽全部幹掉。

const EventEmitter = require(‘events‘);
const myEE = new EventEmitter();
const sss = () =>{
  console.log("aaa")
}
myEE.on(‘foo‘, sss);
myEE.on(‘bar‘, () => {});

myEE.removeAllListeners()

　　這樣你不管console.log哪個監聽他都是空的

這裏還有一個比較有意思的，看下案例

const myEmitter = new MyEmitter();

const callbackA = () => {
  console.log(‘A‘);
  myEmitter.removeListener(‘event‘, callbackB);
};

const callbackB = () => {
  console.log(‘B‘);
};

myEmitter.on(‘event‘, callbackA);

myEmitter.on(‘event‘, callbackB);

myEmitter.emit(‘event‘);
//？？？？

myEmitter.emit(‘event‘);
//？？？

 最後來說一下，封裝監聽器，其實理解了上面的這個就不是很難了主要還是一個方法的問題emitter.rawListeners(eventName)    這個方法的使用。。。

const emitter = new EventEmitter();
emitter.once(‘log‘, () => console.log(‘只記錄一次‘));

// 返回一個數組，包含了一個封裝了 `listener` 方法的監聽器。
const listeners = emitter.rawListeners(‘log‘);
const logFnWrapper = listeners[0];

// 打印 “只記錄一次”，但不會解綁 `once` 事件。
logFnWrapper.listener();

// 打印 “只記錄一次”，且移除監聽器。
logFnWrapper();

emitter.on(‘log‘, () => console.log(‘持續地記錄‘));
// 返回一個數組，只包含 `.on()` 綁定的監聽器。
const newListeners = emitter.rawListeners(‘log‘);

// 打印兩次 “持續地記錄”。
newListeners[0]();
emitter.emit(‘log‘);

node.js從入門到放棄（二）