目錄

簡介及資料

events是node.js 最重要的模組，events模組只提供了一個物件events.EventEmitter，EventEmitter 的核心是事件發射與事件監聽器。

Node.js中大部分的模組，都繼承自Event模組。

與DOM樹上事件不同，不存在事件冒泡、逐層捕獲等行為。

EventEmitter 支援若干個事件監聽器。當事件發射時，註冊到這個事件的事件監聽器被依次呼叫，事件引數作為回撥函式引數傳遞。 　　

　　如何訪問：

require('events');

emitter.on(event, listener)

/*
    呼叫events模組，獲取events.EventEmitter物件
*/
var EventEmitter = require('events').EventEmitter;   
var ee = new EventEmitter();

/*
    EventEmitter.on(event, listener) 為事件註冊一個監聽
    引數1：event  字串，事件名
    引數2：回撥函式
*/
ee.on('some_events', function(foo, bar) {
    console.log("第1個監聽事件,引數foo=" + foo + ",bar="+bar );
});

console.log(
 
'第一輪');
ee.emit('some_events', 'Wilson', 'Zhong');

console.log('第二輪');
ee.emit('some_events', 'Wilson', 'Z');

emitter.emit(event, [arg1], [arg2], [...])

var EventEmitter = require('events').EventEmitter;   
var ee = new EventEmitter();

ee.on(
 
'some_events', function(foo, bar) {         
    console.log("第1個監聽事件,引數foo=" + foo + ",bar="+bar );
});

/*
    EventEmitter.emit(event, [arg1], [arg2], [...])   觸發指定事件
    引數1：event  字串，事件名
    引數2：可選引數，按順序傳入回撥函式的引數
    返回值：該事件是否有監聽
*/
var isSuccess = ee.emit('some_events', 'Wilson', 'Zhong');

ee.on('some_events', function(foo, bar) {         
    console.log("第2個監聽事件,引數foo=" + foo + ",bar="+bar );
});

ee.emit('some_events', 'zhong', 'wei');

var isSuccess2 = ee.emit('other_events', 'Wilson', 'Zhong');

console.log(isSuccess);
console.log(isSuccess2);

示例進行了三次觸發事件操作，其中some_events註冊了監聽，呼叫時emit函式會返回一個true,而other_events並沒有註冊監聽，emit函式會返回一個false，表示該事件沒有監聽；當然也可以不用管這個返回值！

emitter.once(event, listener)

var EventEmitter = require('events').EventEmitter;   
var ee = new EventEmitter();

/*
    EventEmitter.once(event, listener)  為事件註冊一次性監聽，觸發一次後移除監聽
    引數1：event  字串，事件名
    引數2：回撥函式
*/
ee.once('some_events', function(foo, bar) {
    console.log("第1個監聽事件,引數foo=" + foo + ",bar="+bar );
});


console.log('第一輪');
ee.emit('some_events', 'Wilson', 'Zhong');

console.log('第二輪');
var isSuccess =  ee.emit('some_events', 'Wilson', 'Zhong');
console.log(isSuccess);

從上面示例程式碼執行結果可以看出，用emitter.once給some_events註冊一個監聽後，分兩輪呼叫emitter.emit觸發，第二輪會返回false；這表示用emitter.once註冊監聽和用前面講的emitter.on註冊監聽略有不同，

emitter.once註冊監聽是一次性監聽，當觸發一次後，會移除該監聽！當然，從名字上就看就比較明顯了^_^!

emitter.removeListener(event, listener)

 先來看一個失敗的場景~~~

var EventEmitter = require('events').EventEmitter;   
var ee = new EventEmitter();

ee.on('some_events', function(foo, bar) {
    console.log("第1個監聽事件,引數foo=" + foo + ",bar="+bar );
});

/*
    看到API中removeListener移除方法時，以為應該是這樣
    但是結果^_^!!!!!
*/
ee.removeListener('some_events', function(){
    console.log('成功移除事件some_events監聽!');        
});

console.log('第一輪');
ee.emit('some_events', 'Wilson', 'Zhong');

當我用emitter.on給some_events註冊了一個監聽後，我用emiiter.removeListener移除some_events的監聽，隨後再呼叫emitter.emit去觸發，最後發現不是按我想像的在進行！為什麼呢？

我理所當然的認為emiiter.removeListener第二個引數是個回撥函式，API還是要認真看清楚啊！！！

下面再看個成功的場景～～～

var EventEmitter = require('events').EventEmitter;   
var ee = new EventEmitter();

var listener = function(foo,bar)
{
    console.log("第1個監聽事件,引數foo=" + foo + ",bar="+bar );
}

var listener2= function(foo,bar)
{
    console.log("第2個監聽事件,引數foo=" + foo + ",bar="+bar );
}

var listener3= function(foo,bar)
{
    console.log("第3個監聽事件,引數foo=" + foo + ",bar="+bar );
}

ee.on('some_events', listener);

ee.on('some_events', listener2);

ee.on('some_events', listener3);
/*
    EventEmitter.removeListener(event, listener)  移除指定事件的監聽器
    注意：該監聽器必須是註冊過的
    PS：上一個例子之後以會失敗，很大原因就是忽略了監聽器，理所當然的認為傳個事件名就OK了，所以就悲劇了!
*/
ee.removeListener('some_events', listener);

ee.removeListener('some_events', listener3);

ee.emit('some_events', 'Wilson', 'Zhong');

我用示例中寫法，給some_events添加了三個監聽，又移除了第一個和第三個監聽，最後再用emitter.emit觸發some_events，輸出結果不難發現，用emitter.removeListener移除的第一個和第三個監聽都沒有再起作用，

想當然是害人地，原來emitter.removeListener的第二個引數是要移除的監聽，而非移除成功後的回撥函式……^_^!

emitter.removeAllListeners([event])

emitter.removeListener用過了，但一個事件可以有多個監聽，需要全部移除時，一個個移除明顯不是愉快的做法，不符合偷懶的天性！

讓我們來體驗一下emitter.removeAllListeners帶來的便捷!

var EventEmitter = require('events').EventEmitter;   
var ee = new EventEmitter();

var listener = function(foo,bar)
{
    console.log("第1個監聽事件,引數foo=" + foo + ",bar="+bar );
}

var listener2= function(foo,bar)
{
    console.log("第2個監聽事件,引數foo=" + foo + ",bar="+bar );
}

ee.on('some_events', listener);

ee.on('some_events', listener2);

ee.on('other_events',function(foo,bar)
{
    console.log("其它監聽事件,引數foo=" + foo + ",bar="+bar );
});

/*
    EventEmitter.removeAllListeners([event])   移除（批定事件）所有監聽器
    引數1：可選引數，event  字串，事件名
*/
ee.removeAllListeners('some_events');

ee.emit('some_events', 'Wilson', 'Zhong');

ee.emit('other_events', 'Wilson', 'Zhong');

看看上面的執行結果，你會發現給some_events註冊了兩個監聽；給other_events註冊了一個監聽；我呼叫emitter.removeAllListeners傳了some_events事件名；

最後使用emitter.on函式觸發some_events和other_events兩個事件，最後發現some_events註冊的兩個監聽都不存在，而other_events註冊的監聽還存在；

這表示當 emitter.removeAllListeners傳用事件名作為引數時，為移除傳入事件名的所有監聽，而不會影響其它事件監聽！

 emitter.removeAllListeners可以不傳用事件名引數；直接執行

var EventEmitter = require('events').EventEmitter;   
var ee = new EventEmitter();

var listener = function(foo,bar)
{
    console.log("第1個監聽事件,引數foo=" + foo + ",bar="+bar );
}

var listener2= function(foo,bar)
{
    console.log("第2個監聽事件,引數foo=" + foo + ",bar="+bar );
}

ee.on('some_events', listener);

ee.on('some_events', listener2);

ee.on('other_events',function(foo,bar)
{
    console.log("其它監聽事件,引數foo=" + foo + ",bar="+bar );
});

/*
    EventEmitter.removeAllListeners([event])   移除（批定事件）所有監聽器
    引數1：可選引數，event  字串，事件名
*/
ee.removeAllListeners();

ee.emit('some_events', 'Wilson', 'Zhong');

ee.emit('other_events', 'Wilson', 'Zhong');

示例程式碼和傳入引數時幾乎一樣，只是在呼叫emitter.removeAllListeners並沒有傳入指定事件名；

執行結果會發現some_events和other_events所有監聽都不存在了，它會移除所有監聽！（比較暴力的方法一般要慎用~~）

emitter.listeners(event)

var EventEmitter = require('events').EventEmitter;   
var ee = new EventEmitter();

var listener = function(foo,bar)
{
    console.log("第1個監聽事件,引數foo=" + foo + ",bar="+bar );
}

var listener2= function(foo,bar)
{
    console.log("第2個監聽事件,引數foo=" + foo + ",bar="+bar );
}

ee.on('some_events', listener);

ee.on('some_events', listener2);

ee.on('other_events',function(foo,bar)
{
    console.log("其它監聽事件,引數foo=" + foo + ",bar="+bar );
});

/*
    EventEmitter.listeners(event)   //返回指定事件的監聽陣列
    引數1：event  字串，事件名    
*/
var listenerEventsArr = ee.listeners('some_events');

console.log(listenerEventsArr.length)

for (var i = listenerEventsArr.length - 1; i >= 0; i--) {
    console.log(listenerEventsArr[i]); 
};

給some_events註冊兩個監聽，呼叫emitter.listeners函式，傳入some_events事件名，接收函式返回值；

從結果可以看出，返回值接收到some_events所有註冊監聽的集合！

emitter.setMaxListeners(n)

 一個事件可以新增多個監聽是沒錯，但Nodejs預設最大值是多少呢？

var EventEmitter = require('events').EventEmitter;   
var ee = new EventEmitter();

/*
     給EventEmitter 新增11個監聽
*/
for (var i = 10; i >= 0; i--) {
    ee.on('some_events',function()
    {
        console.log('第'+ (i +1) +'個監聽');
    });
};

上面示例中我用個迴圈給some_events新增11個監聽，執行程式碼，發現warning資訊出現，並且提示的比較詳細了，需要用emitter.setMaxListeners()去提升限值

var EventEmitter = require('events').EventEmitter;   
var ee = new EventEmitter();

/*
    EventEmitter.setMaxListeners (n)   給EventEmitter設定最大監聽
    引數1： n 數字型別，最大監聽數
    
    超過10個監聽時，不設定EventEmitter的最大監聽數會提示：
    (node) warning: possible EventEmitter memory leak detected. 11 listeners added.
     Use emitter.setMaxListeners() to increase limit.
    設計者認為偵聽器太多，可能導致記憶體洩漏，所以存在這樣一個警告
*/
ee.setMaxListeners(15);

/*
     給EventEmitter 新增11個監聽
*/
for (var i = 10; i >= 0; i--) {
    ee.on('some_events',function()
    {
        console.log('第'+ (i +1) +'個監聽');
    });
};

當我呼叫emitter.setMaxListeners傳入15時，執行程式碼，warning資訊不再出現；

emitter.setMaxListeners的作用是給EventEmitter設定最大監聽數，感覺一般是不需要設定這個值，10個還不夠用的情況應該是比較少了！

設計者認為偵聽器太多會導致記憶體洩漏，所有就給出了一個警告！

其它...

 用的比較少的就不詳細說了

EventEmitter.defaultMaxListeners

EventEmitter.defaultMaxListeners功能與setMaxListeners類似，
給所有EventEmitter設定最大監聽
setMaxListeners優先順序大於defaultMaxListeners

EventEmitter.listenerCount(emitter, event)

返回指定事件的監聽數

 特殊的事件Error

引用自Node.js開發指南：EventEmitter 定義了一個特殊的事件 error，它包含了“錯誤”的語義，我們在遇到 異常的時候通常會發射 error 事件。當 error 被髮射時，EventEmitter 規定如果沒有響 應的監聽器，Node.js 會把它當作異常，退出程式並列印呼叫棧。我們一般要為會發射 error 事件的物件設定監聽器，避免遇到錯誤後整個程式崩潰。

事件的繼承