Issue 7202 - Add hasListeners method to EventEmitter

lib/events.js

Index: lib/events.js
===================================================================
--- a/lib/events.js
+++ b/lib/events.js
@@ -30,37 +30,46 @@
   /**
    * Adds a listener for the specified event name.
    *
    * @param {string}   name
    * @param {function} listener
    */
   on(name, listener)
   {
-    let listeners = this._listeners.get(name);
+    let listeners = this._listeners.size > 0 ? this._listeners.get(name) : null;

[hub, 2019/01/09 22:42:40]

I don't see how this is faster (since it is part of the "optimize all methods"
change) ? And given that we only check whether listener is falsey, it shouldn't
matter whether it is undefined or null.

[Manish Jethani, 2019/01/09 23:09:45]

This is not about null vs. undefined, this is about avoiding the lookup via
get() when there are no listeners for any event (as is the case with
lib/hitLogger.js in the extension most of the time because DevTools is not open
for any tab).

If you mean specifically about this instance in the on() function, then again
avoiding lookup for the first listener for an event might help.

I don't feel very strongly about on() and off() but I think it helps in the case
of emit() because an event is emitted for each filter hit.

[Manish Jethani, 2019/01/09 23:11:55]

Having said this, the "optimize all methods" part is not necessary for this
change, I can drop it if you think we should do it separately.

[Manish Jethani, 2019/01/10 03:50:13]

Alright, so I wrote this test:

  // test.js
  let {EventEmitter} = require("./lib/events");
  
  let eventEmitter = new EventEmitter();
    
  let start = Date.now();    
  for (let i = 0; i < 10000000; i++)
    eventEmitter.emit("foo");    
  console.log(Date.now() - start);

For me it's thrice as fast with the additional check for size.

I think we could skip the checks in on() and off() but keep them in listeners(),
hasListeners() and emit(). There is a cost (~10%) when the size is in fact
non-zero.

What do you think?

     if (listeners)
       listeners.push(listener);
     else
       this._listeners.set(name, [listener]);
   }
 
   /**
    * Removes a listener for the specified event name.
    *
    * @param {string}   name
    * @param {function} listener
    */
   off(name, listener)
   {
-    let listeners = this._listeners.get(name);
+    let listeners = this._listeners.size > 0 ? this._listeners.get(name) : null;
     if (listeners)
     {
-      let idx = listeners.indexOf(listener);
-      if (idx != -1)
-        listeners.splice(idx, 1);
+      if (listeners.length > 1)
+      {
+        let idx = listeners.indexOf(listener);
+        if (idx != -1)
+          listeners.splice(idx, 1);
+      }
+      else if (listeners[0] === listener)
+      {
+        // We must use strict equality above for compatibility with
+        // Array.prototype.indexOf
+        this._listeners.delete(name);
+      }
     }
   }
 
   /**
    * Adds a one time listener and returns a promise that
    * is resolved the next time the specified event is emitted.
    *
    * @param {string} name
@@ -83,27 +92,43 @@
   /**
    * Returns a copy of the array of listeners for the specified event.
    *
    * @param {string} name
    * @returns {Array.<function>}
    */
   listeners(name)
   {
-    let listeners = this._listeners.get(name);
+    let listeners = this._listeners.size > 0 ? this._listeners.get(name) : null;
     return listeners ? listeners.slice() : [];
   }
 
   /**
+   * Checks whether there are any listeners for the specified event.
+   *
+   * @param {string} [name] The name of the event. If omitted, checks whether
+   *   there are any listeners for any event.
+   * @returns {boolean}
+   */
+  hasListeners(name)
+  {
+    return this._listeners.size > 0 &&
+           (typeof name == "undefined" || this._listeners.has(name));
+  }
+
+  /**
    * Calls all previously added listeners for the given event name.
    *
    * @param {string} name
    * @param {...*}   [args]
    */
   emit(name, ...args)
   {
-    let listeners = this.listeners(name);
-    for (let listener of listeners)
-      listener(...args);
+    let listeners = this._listeners.size > 0 ? this._listeners.get(name) : null;
+    if (listeners)
+    {
+      for (let listener of listeners.slice())
+        listener(...args);
+    }
   }
 }
 
 exports.EventEmitter = EventEmitter;