nodeJS之事件events

前面的话

　　events模块是node的核心模块，几乎所有常用的node模块都继承了events模块，比如http、fs等。本文将详细介绍nodeJS中的事件机制

EventEmitter

　　多数 Node.js 核心 API 都是采用惯用的异步事件驱动架构，其中某些类型的对象（称为触发器）会周期性地触发命名事件来调用函数对象（监听器）。例如，一个net.Server对象会在每次有新连接时触发一个事件；一个 fs.ReadStream 会在文件被打开时触发一个事件；一个 stream会在数据可读时触发事件。

【EventEmitter】

　　EventEmitter 类由 events 模块定义和开放的，所有能触发事件的对象都是 EventEmitter 类的实例

var EventEmitter = require(‘events‘);
/*
{ [Function: EventEmitter]
  EventEmitter: [Circular],
  usingDomains: false,
  defaultMaxListeners: [Getter/Setter],
  init: [Function],
  listenerCount: [Function] }
 */
console.log(EventEmitter);

　　events模块的EventEmitter属性指向该模块本身

var events = require(‘events‘);
console.log(events.EventEmitter === events);//true

　　EventEmitter是一个构造函数，可以用来生成事件发生器的实例emitter

var EventEmitter = require(‘events‘);
var emitter = new EventEmitter();
/*
EventEmitter {
  domain: null,
  _events: {},
  _eventsCount: 0,
  _maxListeners: undefined }
 */
console.log(emitter);

方法

【emitter.emit(eventName[, ...args])】

eventName <any>
...args <any>

　　该方法按监听器的注册顺序，同步地调用每个注册到名为eventName事件的监听器，并传入提供的参数。如果事件有监听器，则返回true，否则返回false

var EventEmitter = require(‘events‘);
var emitter = new EventEmitter();
emitter.on(‘test1‘,function(){});
console.log(emitter.emit(‘test1‘));//true
console.log(emitter.emit(‘test2‘));//false

【emitter.on(eventName, listener)】

　　该方法用于添加listener函数到名为eventName的事件的监听器数组的末尾

eventName <any> 事件名
listener <Function> 回调函数

　　[注意]不会检查listener是否已被添加。多次调用并传入相同的eventName和listener会导致listener被添加与调用多次

var EventEmitter = require(‘events‘);
var emitter = new EventEmitter();
emitter.on(‘test‘,function(){
    console.log(1);
});
emitter.on(‘test‘,function(){
    console.log(2);
});
emitter.emit(‘test‘);//1 2

　　该方法返回一个 EventEmitter 引用，可以链式调用

var EventEmitter = require(‘events‘);
var emitter = new EventEmitter();
emitter.on(‘test‘,function(){
    console.log(1);
}).on(‘test‘,function(){
    console.log(2);
});
emitter.emit(‘test‘);//1 2

【emitter.addListener(eventName, listener)】

　　emitter.on(eventName, listener) 的别名

var EventEmitter = require(‘events‘);
var emitter = new EventEmitter();
emitter.addListener(‘test‘,function(){
    console.log(1);
});
emitter.emit(‘test‘);//1

【emitter.prependListener()】

　　与on()方法不同，prependListener()方法可用于将事件监听器添加到监听器数组的开头

var EventEmitter = require(‘events‘);
var emitter = new EventEmitter();
emitter.on(‘test‘,function(){
    console.log(1);
}).prependListener(‘test‘,function(){
    console.log(2);
});
emitter.emit(‘test‘);//2 1

【emitter.once(eventName, listener)】

　　该方法添加一个单次 listener 函数到名为 eventName 的事件。 下次触发 eventName 事件时，监听器会被移除，然后调用

eventName <any> 事件名
listener <Function> 回调函数
var EventEmitter = require(‘events‘);
var emitter = new EventEmitter();
emitter.on(‘test‘,function(){
    console.log(1);
}).once(‘test‘,function(){
    console.log(2);
});
emitter.emit(‘test‘);//1 2
emitter.emit(‘test‘);//1

【emitter.prependOnceListener() 】

　　该方法用于将事件监听器添加到监听器数组开头。下次触发eventName事件时，监听器会被移除，然后调用

var EventEmitter = require(‘events‘);
var emitter = new EventEmitter();
emitter.on(‘test‘,function(){
    console.log(1);
}).prependOnceListener(‘test‘,function(){
    console.log(2);
});
emitter.emit(‘test‘);//2 1
emitter.emit(‘test‘);//1

【emitter.removeAllListeners([eventName])】

eventName <any>

　　移除全部或指定 eventName 的监听器，返回一个 EventEmitter 引用，可以链式调用

　　[注意]在代码中移除其他地方添加的监听器是一个不好的做法，尤其是当 EventEmitter 实例是其他组件或模块（如 socket 或文件流）创建的

var EventEmitter = require(‘events‘);
var emitter = new EventEmitter();
emitter.on(‘test‘,function(){
    console.log(1);
}).removeAllListeners(‘test‘);
emitter.emit(‘test‘);//‘‘

【emitter.removeListener(eventName, listener)】

eventName <any>
listener <Function>

　　从名为 eventName 的事件的监听器数组中移除指定的 listener

var EventEmitter = require(‘events‘);
var emitter = new EventEmitter();
function show(){
    console.log(1);
}
emitter.on(‘test‘,show).removeListener(‘test‘,show);
emitter.emit(‘test‘);//‘‘

　　[注意]removeListener最多只会从监听器数组里移除一个监听器实例。如果任何单一的监听器被多次添加到指定eventName的监听器数组中，则必须多次调用removeListener才能移除每个实例

var EventEmitter = require(‘events‘);
var emitter = new EventEmitter();
function show(){
    console.log(1);
}
emitter.on(‘test‘,show).on(‘test‘,show).removeListener(‘test‘,show);
emitter.emit(‘test‘);//‘1‘

　　[注意]一旦一个事件被触发，所有绑定到它的监听器都会按顺序依次触发。这意味着，在事件触发后、最后一个监听器完成执行前，任何 removeListener() 或 removeAllListeners() 调用都不会从 emit() 中移除它们。 随后的事件会像预期的那样发生

　　因为监听器是使用内部数组进行管理的，所以调用它会改变在监听器被移除后注册的任何监听器的位置索引。 虽然这不会影响监听器的调用顺序，但意味着由 emitter.listeners() 方法返回的监听器数组副本需要被重新创建

var EventEmitter = require(‘events‘);
var emitter = new EventEmitter();
function show1(){
    console.log(1);
    emitter.removeListener(‘test‘,show2);
}
function show2(){
    console.log(2);
}
emitter.on(‘test‘,show1).on(‘test‘,show2);
emitter.emit(‘test‘);//1 2
emitter.emit(‘test‘);//1

设置

【emitter.eventNames()】

　　返回一个列出触发器已注册监听器的事件的数组。 数组中的值为字符串或符号

var EventEmitter = require(‘events‘);
var emitter = new EventEmitter();
emitter.addListener(‘test1‘,function(){console.log(1);});
emitter.addListener(‘test2‘,function(){console.log(2);});
console.log(emitter.eventNames());//[ ‘test1‘, ‘test2‘ ]

【emitter.listenerCount(eventName)】

eventName <any> 正在被监听的事件名

　　返回正在监听名为 eventName 的事件的监听器的数量

var EventEmitter = require(‘events‘);
var emitter = new EventEmitter();
emitter.addListener(‘test‘,function(){console.log(1);});
emitter.addListener(‘test‘,function(){console.log(1);});
console.log(emitter.listenerCount(‘test‘));//2

【emitter.listeners(eventName)】

eventName <any>

　　返回名为 eventName 的事件的监听器数组的副本

var EventEmitter = require(‘events‘);
var emitter = new EventEmitter();
emitter.addListener(‘test‘,function(){console.log(1);});
emitter.addListener(‘test‘,function(){console.log(2);});
console.log(emitter.listeners(‘test‘));//[ [Function], [Function] ]
emitter.listeners(‘test‘)[0]();//1

【emitter.getMaxListeners()】

　　返回 EventEmitter 当前的最大监听器限制值

var EventEmitter = require(‘events‘);
var emitter = new EventEmitter();
console.log(emitter.getMaxListeners());//10

【emitter.setMaxListeners(n)】

　　默认情况下，如果为特定事件添加了超过 10 个监听器，则 EventEmitter 会打印一个警告。 此限制有助于寻找内存泄露。 但是，并不是所有的事件都要被限为 10 个。 emitter.setMaxListeners() 方法允许修改指定的 EventEmitter 实例的限制。 值设为 Infinity（或 0）表明不限制监听器的数量。返回一个 EventEmitter 引用，可以链式调用

var EventEmitter = require(‘events‘);
var emitter = new EventEmitter();
emitter.on(‘a‘,function(){}).on(‘a‘,function(){}).on(‘a‘,function(){}).on(‘a‘,function(){}).on(‘a‘,function(){}).on(‘a‘,function(){}).on(‘a‘,function(){}).on(‘a‘,function(){}).on(‘a‘,function(){}).on(‘a‘,function(){}).on(‘a‘,function(){});
/*
Warning: Possible EventEmitter memory leak detected. 11 a listeners added. Use emitter.setMaxListeners() to increase limit
 */
var EventEmitter = require(‘events‘);
var emitter = new EventEmitter();
emitter.setMaxListeners(11);
emitter.on(‘a‘,function(){}).on(‘a‘,function(){}).on(‘a‘,function(){}).on(‘a‘,function(){}).on(‘a‘,function(){}).on(‘a‘,function(){}).on(‘a‘,function(){}).on(‘a‘,function(){}).on(‘a‘,function(){}).on(‘a‘,function(){}).on(‘a‘,function(){});

【EventEmitter.defaultMaxListeners】
　　每个事件默认可以注册最多10个监听器。单个EventEmitter实例的限制可以使用emitter.setMaxListeners(n)方法改变。所有EventEmitter实例的默认值可以使用EventEmitter.defaultMaxListeners属性改变

　　[注意]设置 EventEmitter.defaultMaxListeners 要谨慎，因为会影响所有EventEmitter 实例，包括之前创建的。因而，调用 emitter.setMaxListeners(n) 优先于 EventEmitter.defaultMaxListeners

var EventEmitter = require(‘events‘);
var emitter = new EventEmitter();
EventEmitter.defaultMaxListeners = 11;
emitter.on(‘a‘,function(){}).on(‘a‘,function(){}).on(‘a‘,function(){}).on(‘a‘,function(){}).on(‘a‘,function(){}).on(‘a‘,function(){}).on(‘a‘,function(){}).on(‘a‘,function(){}).on(‘a‘,function(){}).on(‘a‘,function(){}).on(‘a‘,function(){});

事件

【‘newListener‘ 事件】

eventName <any> 要监听的事件的名称
listener <Function> 事件的句柄函数

　　EventEmitter 实例会在一个监听器被添加到其内部监听器数组之前触发自身的 ‘newListener‘ 事件

　　注册了 ‘newListener‘ 事件的监听器会传入事件名与被添加的监听器的引用。事实上，在添加监听器之前触发事件有一个微妙但重要的副作用： ‘newListener‘ 回调中任何额外的被注册到相同名称的监听器会在监听器被添加之前被插入

var EventEmitter = require(‘events‘);
var emitter = new EventEmitter();
emitter.on(‘newListener‘,function(){
    console.log(2);
})
emitter.on(‘test‘,function(){
    console.log(1);
})

emitter.emit(‘test‘);//2 1
var EventEmitter = require(‘events‘);
var emitter = new EventEmitter();
emitter.on(‘test‘,function(){
    console.log(1);
})
emitter.on(‘newListener‘,function(){
    console.log(2);
})
emitter.emit(‘test‘);//1

【‘removeListener‘ 事件】

eventName <any> 事件名
listener <Function> 事件句柄函数

　　‘removeListener‘ 事件在 listener 被移除后触发

var EventEmitter = require(‘events‘);
var emitter = new EventEmitter();
function show(){
    console.log(1);
}
emitter.on(‘removeListener‘,function(){
    console.log(2);//2
})
emitter.on(‘test‘,show).removeListener(‘test‘,show);
var EventEmitter = require(‘events‘);
var emitter = new EventEmitter();
function show(){
    console.log(1);
}
emitter.on(‘test‘,show).removeListener(‘test‘,show);
emitter.on(‘removeListener‘,function(){
    console.log(2);//‘‘
})
var EventEmitter = require(‘events‘);
var emitter = new EventEmitter();
function show(){
    console.log(1);
}
emitter.removeListener(‘test‘,show);
emitter.on(‘removeListener‘,function(){
    console.log(2);//‘‘
})
时间： 2024-07-31 10:40:59

nodeJS之事件events的相关文章

nodejs的事件

1    认识nodejs的事件 //声明事件对象 var EventEmitter = require('events').EventEmitter;var event = new EventEmitter(); //注册事件,new event就是事件名 event.on('new event',function(){ console.log('this is a evnet');}); //三秒后触发事件. setTimeout(function(){ event.emit('new ev

openwrt gstreamer实例学习笔记（七. gstreamer 缓冲区(Buffers)和事件(Events)）

1)概述 管道的数据流由一组缓冲区和事件组成,缓冲区包括实际的管道数据,事件包括控制信息,如寻找信息和流的终止信号.所有这些数据流在运行的时候自动的流过管道. 2) 缓冲区(Buffers) 缓冲区包含了你创建的管道里的数据流.通常一个source element会创建一个新的缓冲区,同时element还将会把缓冲区的数据传递给下一个element.当使用GStreamer底层构造来创建一个媒体管道的时候,你不需要自己来处理缓冲区,element将会为你处理这些缓冲区. 一个缓冲区主要由以下一个

[NodeJS]核心模块--Events

Events是Node中的一个很重要的核心模块,Stream, 网络,文件系统统统都是继承自这个模块. Streams模块就是继承自EventEmitter,所以说弄明白Events模块,特别是EventEmitter对象, 对于理解Node中的很多模块都是有好处的. Stream非常擅长处理数据,无论是读,写或者是转换.比如,你可以用Stream接收数据库中的数据,将其流出到csv的流中,导出成为csv格式. 接着你可以再传入一个http请求(也是一种流)将数据再流入到http流中,这样就可以

Backbone事件Events

说道Backbone的事件机制.自己也是逗逼了.敲了一遍Backbone的源码..居然是还不知道他的机制.. 先上Events On对象的源码 /** * Created by More on 2015/11/28. */var Events = Backbone.Events ={ /** * params: * events : 事件们 * callback : 回调函数 * context : 上下文,俗称的this * * **/ on: function(events,callback

js事件——Events

没有共产党就没有新中国,没有 events 就没有 scripts.每个包含 JavaScript 的页面中: 几乎所有的脚本都是由 event 触发的.原因很简单. JavaScript 可以增加交互性: user 做一些操作,页面给出响应.Events 是所有 JavaScript 应用的小心脏.本文介绍了事件处理机制,相关问题以及如何写出跨浏览器的 scripts.同时也展示了几个带有事件处理细节的页面. 因此JavaScript 检测用户的操作,以便知道何时做出反应,反应时执行哪个 fu

PhoneGap事件Events

参考官网:http://www.phonegap100.com/doc/cordova_events_events.md.html#Events 分析几个事件: 一. deviceready  事件 在使用 PhoneGap 开发应用时,deviceready 事件是非常常用的.这一事件在设备的本地 环境和页面完全加载完成之后才触发 注意:此事件一般晚于 jquery  的 ready 事件,jquery 的 ready 事件是在 DOM  完全加载 完成后触发,deviceready 则是设备

nodejs学习之events

在node里许多对象都发出事件:一个net.Server对象每次一个连接到来,都发出一个事件,一个fs.readStream对象在文件打开时放出一个事件.所有能放出事件的对象都是event.EventEmitter对象的实例.你可以这样做来访问这个模块:requre('events'); 代表性的事件命名都是一个驼峰标识的字符串,然而这并不是一个强制约束,任何字符串都可以被接受. 函数可以被附加在对象上,并且当一个事件发出时被执行.这样的函数叫做监听函数. Class:events.EventE

nodejs学习之events的使用

实用events做个小例子: var mysql = require("mysql"); var Event = require("events").EventEmitter; var user = "lubingjie"; var pass = "123456"; var db = mysql.createConnection({host:"localhost",user:"root"

nodejs基础 -- 事件循环

Node.js 事件循环 Node.js 是单进程单线程应用程序,但是通过事件和回调支持并发,所以性能非常高. Node.js 的每一个 API 都是异步的,并作为一个独立线程运行,使用异步函数调用,并处理并发. Node.js 基本上所有的事件机制都是用设计模式中观察者模式实现. Node.js 单线程类似进入一个while(true)的事件循环,直到没有事件观察者退出,每个异步事件都生成一个事件观察者,如果有事件发生就调用该回调函数. 事件驱动程序 Node.js 使用事件驱动模型,当web