events: optimize adding and removing of listeners

These optimizations result in >2x speedup in the ee-add-remove
benchmark:
* Don't mutate array.length when removing the last listener for
an event
* Don't bother checking max listeners if listeners isn't an array
* Don't call delete when removing the last event in _events, just
re-assign a new object instead
PR-URL: #785
Reviewed-By: Ben Noordhuis <info@bnoordhuis.nl>
Reviewed-By: Evan Lucas <evanlucas@me.com>

Author: mscdex

lib/events.js

@@ -30,8 +30,10 @@ EventEmitter.init = function() {
 }
 }
 
-if(!this._events||this._events===Object.getPrototypeOf(this)._events)
+if(!this._events||this._events===Object.getPrototypeOf(this)._events){
 this._events={};
+this._eventsCount=0;
+}
 
 this._maxListeners=this._maxListeners||undefined;
 };
@@ -115,15 +117,18 @@ function emitMany(handler, isFn, self, args) {
 EventEmitter.prototype.emit=functionemit(type){
 varer,handler,len,args,i,events,domain;
 varneedDomainExit=false;
+vardoError=(type==='error');
 
 events=this._events;
-if(!events)
-events=this._events={};
+if(events)
+doError=(doError&&events.error==null);
+elseif(!doError)
+returnfalse;
 
 domain=this.domain;
 
 // If there is no 'error' event listener then throw.
-if(type==='error'&&!events.error){
+if(doError){
 er=arguments[1];
 if(domain){
 if(!er)
@@ -189,39 +194,47 @@ EventEmitter.prototype.addListener = function addListener(type, listener) {
 thrownewTypeError('listener must be a function');
 
 events=this._events;
-if(!events)
+if(!events){
 events=this._events={};
-else{
+this._eventsCount=0;
+}else{
 // To avoid recursion in the case that type === "newListener"! Before
 // adding it to the listeners, first emit "newListener".
 if(events.newListener){
 this.emit('newListener',type,
-typeoflistener.listener==='function' ?
-listener.listener : listener);
+listener.listener ? listener.listener : listener);
+
+// Re-assign `events` because a newListener handler could have caused the
+// this._events to be assigned to a new object
+events=this._events;
 }
 existing=events[type];
 }
 
-if(!existing)
+if(!existing){
 // Optimize the case of one listener. Don't need the extra array object.
 existing=events[type]=listener;
-elseif(typeofexisting!=='function')
-// If we've already got an array, just append.
-existing.push(listener);
-else
-// Adding the second element, need to change to array.
-existing=events[type]=[existing,listener];
-
-// Check for listener leak
-if(typeofexisting!=='function'&&!existing.warned){
-m=$getMaxListeners(this);
-if(m&&m>0&&existing.length>m){
-existing.warned=true;
-console.error('(node) warning: possible EventEmitter memory '+
-'leak detected. %d %s listeners added. '+
-'Use emitter.setMaxListeners() to increase limit.',
-existing.length,type);
-console.trace();
+++this._eventsCount;
+}else{
+if(typeofexisting==='function'){
+// Adding the second element, need to change to array.
+existing=events[type]=[existing,listener];
+}else{
+// If we've already got an array, just append.
+existing.push(listener);
+}
+
+// Check for listener leak
+if(!existing.warned){
+m=$getMaxListeners(this);
+if(m&&m>0&&existing.length>m){
+existing.warned=true;
+console.error('(node) warning: possible EventEmitter memory '+
+'leak detected. %d %s listeners added. '+
+'Use emitter.setMaxListeners() to increase limit.',
+existing.length,type);
+console.trace();
+}
 }
 }
 
@@ -254,7 +267,7 @@ EventEmitter.prototype.once = function once(type, listener) {
 // emits a 'removeListener' event iff the listener was removed
 EventEmitter.prototype.removeListener=
 functionremoveListener(type,listener){
-varlist,events,position,length,i;
+varlist,events,position,i;
 
 if(typeoflistener!=='function')
 thrownewTypeError('listener must be a function');
@@ -267,17 +280,18 @@ EventEmitter.prototype.removeListener =
 if(!list)
 returnthis;
 
-length=list.length;
-position=-1;
-
-if(list===listener||
-(typeoflist.listener==='function'&&list.listener===listener)){
-deleteevents[type];
-if(events.removeListener)
-this.emit('removeListener',type,listener);
-
+if(list===listener||(list.listener&&list.listener===listener)){
+if(--this._eventsCount===0)
+this._events={};
+else{
+deleteevents[type];
+if(events.removeListener)
+this.emit('removeListener',type,listener);
+}
 }elseif(typeoflist!=='function'){
-for(i=length;i-->0;){
+position=-1;
+
+for(i=list.length;i-->0;){
 if(list[i]===listener||
 (list[i].listener&&list[i].listener===listener)){
 position=i;
@@ -289,8 +303,12 @@ EventEmitter.prototype.removeListener =
 returnthis;
 
 if(list.length===1){
-list.length=0;
-deleteevents[type];
+list[0]=undefined;
+if(--this._eventsCount===0){
+this._events={};
+returnthis;
+}else
+deleteevents[type];
 }else{
 spliceOne(list,position);
 }
@@ -312,10 +330,15 @@ EventEmitter.prototype.removeAllListeners =
 
 // not listening for removeListener, no need to emit
 if(!events.removeListener){
-if(arguments.length===0)
+if(arguments.length===0){
 this._events={};
-elseif(events[type])
-deleteevents[type];
+this._eventsCount=0;
+}elseif(events[type]){
+if(--this._eventsCount===0)
+this._events={};
+else
+deleteevents[type];
+}
 returnthis;
 }
 
@@ -329,19 +352,20 @@ EventEmitter.prototype.removeAllListeners =
 }
 this.removeAllListeners('removeListener');
 this._events={};
+this._eventsCount=0;
 returnthis;
 }
 
 listeners=events[type];
 
 if(typeoflisteners==='function'){
 this.removeListener(type,listeners);
-}elseif(Array.isArray(listeners)){
+}elseif(listeners){
 // LIFO order
-while(listeners.length)
+do{
 this.removeListener(type,listeners[listeners.length-1]);
+}while(listeners[0]);
 }
-deleteevents[type];
 
 returnthis;
 };