Skip to content
Find file
Fetching contributors…
Cannot retrieve contributors at this time
112 lines (89 sloc) 4.63 KB

Copyright 2011 by Steven Littiebrant under a slightly modified MIT license, which is more amenable to minification. See LICENSE / PubSub.js for details.

Reasons to use over HigginsForPresident's pubsub.js:

  • Regularly performs 20%-100% faster on all browsers!
  • Hierarchical events, instead of single-depth!
  • Correct unsubscribing code! HFP's does not unsubscribe an event if it is subscribed twice in a row.
  • No jQuery dependency!

Reasons to use over jQuery's .bind and .trigger:

  • Regularly performs 30x-100x faster (or more)!
  • Hierarchical events, instead of "namespaces" (which mimic CSS classes, so really aren't namespaces at all)!
  • No jQuery dependency!

Downsides compared HFP's:

  • None!
  • Literally.
  • Well, one. It auto-attaches to jQuery and then disappears. But you can do that with mine, too. PubSub(jQuery); delete PubSub;

Downsides compared to jQuery:

  • No DOM-based bubbling, so it can't replace .click or any events which rely on the DOM tree.

Other reasons it rocks:

  • Nearly-agnostic parameters: .publish("e", 1, 2, 3) is the same as .publish("e", [1, 2, 3]). Note that this means .publish("e", [1, 2, 3]) gets expanded to call subscribed_function(1, 2, 3) and not subscribed_function([1, 2, 3]). Pass .publish("e", [[1, 2, 3]]) if that's desired.
  • * Don't like this? Breaks your code? Let me know, I may change it to only handle params-in-array.
  • Event-bubbling halting: similar to jQuery, return false to prevent an event from bubbling. All events at that level will still be called.
  • Global subscriber storage: .subscribe("", function(){}) will be called on every .publish (unless prevented, see above)
  • Lightning fast. Fast enough to base an entire project around it. You almost can't get faster than this.
  • No dependencies of any kind, works in all browsers (tested so far. Help me test!)!
  • Clutters your namespace as minimally as possible. Only publish, subscribe, and unsubscribe are added.
  • Dogfooded! I'm using this heavily in one of my current projects, and plan to on others in the future.

Why am I picking on HFP's implementation? It's the one I found when I was looking for eventing systems. No other reason! They even admit it was "Rewritten blindly." so this is meant in no way to be a dig at their skills.

Example use (colored):

// --------
// Get it ready
// --------

// Bind to an object
var o = {};

// Or construct a new one
var c = new PubSub();

// Or even to jQuery!

// Want the published path passed to each handler?
PubSub(o, true);

// Want to specify a different internally-unique handler (in case you want to use an event named "_sub")?
PubSub(o, true, "unique_string_here_52434675");

// Mix and match parameters!
PubSub(true, "uniq");
PubSub(o, "uniq");

// ------
// Use it
// ------

// Handle an event
x.subscribe("e", function(){
x.publish("e"); // "e!"

// Initialized with `true`?  You've got the path, as parsed, as the last parameter!
x.subscribe("nested.event", function(){
    var path = arguments[arguments.length-1];
    console.log("Path: " + path.join("."));
x.publish("nested.event"); // "Path: nested.event"
// Bubbles up the hierarchy, too!
x.publish("nested.event.even.deeper.yet!"); // "Path: nested.event.even.deeper.yet!"
// Stop the bubbling at any time!
x.subscribe("nested.event.even", function() {
    return false;
x.publish("nested.event.even.deeper.yet!"); // nothing happens!

// Global event listeners!
x.subscribe("", function(){
    console.log("Event fired: " + arguments[arguments.length-1].join("."));
x.publish("an.event"); // "Event fired: an.event"

// Unsubscribe by handler!
var hand = function(){
    console.error("failed to remove");
x.subscribe("", hand);
x.unsubscribe("", hand);
x.publish("") // nothing happens!

// Unsubscribe by path!
x.subscribe("", hand);
x.publish("") // nothing happens!

// Unsubscribe recursively!
x.subscribe("", hand);
x.unsubscribe("remove", hand, true);
x.publish("") // nothing happens!

// Unsubscribe everything!
x.subscribe("remove", hand).subscribe("another.hierarchy", hand);
x.unsubscribe("", true);
x.publish("remove").publish("another.hierarchy"); // nothing happens!
Something went wrong with that request. Please try again.