{}

In JavaScript {} is not a pure empty map, so one can't use it in a manner of lookupObj[key] and stay safe.

To overcome this you've used hasOwnProperty method, but check this one:

The error you'll get comes from addHandler function that uses in operator.

If you replace the in with hasOwnProperty call you'll still be in trouble when someone will deside that hasOwnProperty is a good name for an event:

All your this.eventHandlers.hasOwnProperty expressions will evaluate to array of handlers. See this:

To safely call hasOwnProperty on object with user provided property names you can use function from Object.prototype directly:

once method has one particular fail case when the same event is emitted directly from the event handler:

var handler = function() { /* handler code */ };
ev.on("foo", handler);
ev.off("foo", handler);
 
callback.toString() == this.eventHandlers[event][index].callback.toString()

You are comparing functions by their string representation. Actually, you can compare functions directly:

• I don't see any point in if (handler.hasOwnProperty('once')), consider if (handler.once) instead.
• index is a long name for a loop variable, how about plain old i?
• for (var i in arr) form is for iteration over object property names where iteration order is not guranteed. To iterate over arrays, use for (var i = 0; i < arr.length; i++) instead.

Caveats of {}

In JavaScript {} is often used as a map with user provided values being object property names. This can be a recipe for disaster. See this particular piece of code, that results in error:

The error we'll get comes from addHandler function that uses in operator.

When addHandler is called with event "toString" it checks if "toString" in this.eventHandlers. It finds one in Object.prototype since {} inherits from it. From now on we are in trouble.

If we replace the in with hasOwnProperty call we'll still be in trouble when someone desides that hasOwnProperty is a good name for an event:

After that all this.eventHandlers.hasOwnProperty expressions will evaluate to array of handlers:

To safely call hasOwnProperty on object with user provided property names we should use function from Object.prototype directly:

Actually same stands for any standard method we want to call.

once method has one particular fail case when same event is emitted directly from the event handler:

var handler = function() { /* handler code */ };
ev.on("foo", handler);
ev.off("foo", handler);

You are comparing functions by their string representation:

callback.toString() == this.eventHandlers[event][index].callback.toString()

Actually, you can compare functions directly:

• I don't see point in if (handler.hasOwnProperty('once')), consider if (handler.once) instead.
• index is a long name for a loop variable, how about plain old i?
• for (var i in arr) form is for iteration over object property names where iteration order is not guranteed. To iterate over arrays, use for (var i = 0; i < arr.length; i++) instead.

Your implementation fails on this:

Here we have two handlers for same event "foo". When the first handler is called it removes all "foo" handlers with delete this.eventHandlers[event]. But when it returns we'll still be in the very for loop trying to access next event handler in this.eventHandlers[event] which was recently deleted:

callback.toString() == this.eventHandlers[event][index].callback.toString()

However note:

var a = function() {
  console.log(Math.PI);
}

var b = function() {
  console.log(Math.PI);
}

var c = a;

console.log(a !== b);                       // different functions
console.log(a === c);                       // same function
console.log(a.toString() === b.toString()); // different functions,
                                            // but same body

The off method removes registered event handler. But what if we call it directly from an event handler:

Here we have two handlers for the same event "foo". When the first handler is called it removes all "foo" handlers with delete this.eventHandlers[event]. But when it returns we'll still be in the very for loop trying to access next event handler in this.eventHandlers[event] which was recently deleted:

Callbacks comparsion

The off method allows the following:

ev.on("foo", function() { /* handler code */ });
ev.off("foo", function() { /* handler code */ });

The right way to remove event handler involves storing the handler function and using it later with off method:

var handler = function() { /* handler code */ };
ev.on("foo", handler);
ev.off("foo", handler);

callback.toString() == this.eventHandlers[event][index].callback.toString()

Example:

var a = function() {
  console.log(Math.PI);
}

var b = function() {
  console.log(Math.PI);
}

var c = a;
   
console.log(function(){} !== function(){}); // different functions
console.log(a !== b);                       // different functions
console.log(a === c);                       // same function
console.log(a.toString() === b.toString()); // different functions,
                                            // but same body

Other notes

• I don't see any point in if (handler.hasOwnProperty('once')), consider if (handler.once) instead.
• index is a long name for a loop variable, how about plain old i?
• for (var i in arr) form is for iteration over object property names where iteration order is not guranteed. To iterate over arrays, use for (var i = 0; i < arr.length; i++) instead.