If you want to avoid creating a DOM object, you can easily instantiate a new EventTarget following some suggestions:

const target = new EventTarget();
target.addEventListener('customEvent', console.log);
target.dispatchEvent(new Event('customEvent'));

By using this method, you still have access to all the features of DOM events without needing to create an empty document element or node.

To learn more about this topic, check out the Mozilla Developer Guide at: https://developer.mozilla.org/en-US/docs/Web/API/EventTarget

Update: It has come to my attention that this method may only work with older browsers. For newer browsers, it is recommended to utilize the EventTarget class instead. Check out Nadeem Douba's response for more information.

If you're looking for a simpler way to handle events without creating your own mechanisms, you might find my approach useful. You can still access all the familiar features of standard DOM Events (such as preventDefault()) and it is more lightweight since it leverages the built-in capabilities of the browser for event handling.

To implement this method, simply create a regular DOM EventTarget object within your object constructor and delegate all EventTarget interface calls to it:

var MyEventTarget = function(options) {
    // Create a DOM EventTarget object
    var target = document.createTextNode(null);

    // Delegate EventTarget interface calls to the DOM EventTarget object
    this.addEventListener = target.addEventListener.bind(target);
    this.removeEventListener = target.removeEventListener.bind(target);
    this.dispatchEvent = target.dispatchEvent.bind(target);

    // Add any additional constructor code here
}

// Instantiate your custom event target
myTarget = new MyEventTarget();
// Attach an event listener to your custom event target
myTarget.addEventListener("myevent", function(){alert("hello")});
// Trigger an event from your custom event target
var evt = new Event('myevent');
myTarget.dispatchEvent(evt);

You can also try out a JSFiddle demo to test this method in action on your browser.

Reviving an old discussion here, but I recently created something similar to this concept - very straightforward and inspired by the Backbone.js Events module:

EventDispatcher = {

    events: {},

    on: function(event, callback) {
        var handlers = this.events[event] || [];
        handlers.push(callback);
        this.events[event] = handlers;
    },

    trigger: function(event, data) {
        var handlers = this.events[event];

        if (!handlers || handlers.length < 1)
            return;

        [].forEach.call(handlers, function(handler){
            handler(data);
        });
    }
};

This method is incredibly easy to use and flexible, allowing you to develop a more advanced event system based on it if necessary.

Implementing the EventDispatcher is as simple as:

function setupListeners() {
    EventDispatcher.on('ignite', ignite); // ignite.bind(this) -- if needed
}

function ignite(y) {
    console.log(y);
}

function actionOccurred(action) {
    EventDispatcher.trigger('ignite', action);
}

By utilizing some basic namespacing, you can effortlessly communicate basic events between different modules!

You have the ability to achieve this using JQuery.

To subscribe to a custom event:

$(device.keyboard).on('keyEscape', function(e){
    //Code for handling the event
});

To trigger your custom event:

$(device.keyboard).trigger('keyEscape', {keyCode:'Example value'});

While it may not be the most elegant solution, you can also create functions within your method (addEventListener, dispatchEvent,...) that encapsulate JQuery functionality, catering to both native and JQuery API preferences.

If you find yourself in a situation where multiple objects need to communicate with each other, an event mechanism can be the solution.

Here is a way to implement this:

/**
 * EventfulObject constructor/base.
 * @type EventfulObject_L7.EventfulObjectConstructor|Function
 */
var EventfulObject = function() {
  /**
   * Map from event name to a list of subscribers.
   * @type Object
   */
  var event = {};
  /**
   * List of all instances of the EventfulObject type.
   * @type Array
   */
  var instances = [];
  /**
   * @returns {EventfulObject_L1.EventfulObjectConstructor} An `EventfulObject`.
   */
  var EventfulObjectConstructor = function() {
    instances.push(this);
  };
  EventfulObjectConstructor.prototype = {
    /**
     * Broadcasts an event of the given name.
     * All instances that wish to receive a broadcast must implement the `receiveBroadcast` method, the event that is being broadcast will be passed to the implementation.
     * @param {String} name Event name.
     * @returns {undefined}
     */
    broadcast: function(name) {
      instances.forEach(function(instance) {
        (instance.hasOwnProperty("receiveBroadcast") && typeof instance["receiveBroadcast"] === "function") &&
        instance["receiveBroadcast"](name);
      });
    },
    /**
     * Emits an event of the given name only to instances that are subscribed to it.
     * @param {String} name Event name.
     * @returns {undefined}
     */
    emit: function(name) {
      event.hasOwnProperty(name) && event[name].forEach(function(subscription) {
        subscription.process.call(subscription.context);
      });
    },
    /**
     * Registers the given action as a listener to the named event.
     * This method will first create an event identified by the given name if one does not exist already.
     * @param {String} name Event name.
     * @param {Function} action Listener.
     * @returns {Function} A deregistration function for this listener.
     */
    on: function(name, action) {
      event.hasOwnProperty(name) || (event[name] = []);
      event[name].push({
        context: this,
        process: action
      });

      var subscriptionIndex = event[name].length - 1;

      return function() {
        event[name].splice(subscriptionIndex, 1);
      };
    }
  };

  return EventfulObjectConstructor;
}();

var Model = function(id) {
  EventfulObject.call(this);
  this.id = id;
  this.receiveBroadcast = function(name) {
    console.log("I smell another " + name + "; and I'm model " + this.id);
  };
};
Model.prototype = Object.create(EventfulObject.prototype);
Model.prototype.constructor = Model;

// ---------- TEST AND USAGE (hopefully it's clear enough...)
// ---------- note: I'm not testing event deregistration.

var ob1 = new EventfulObject();
ob1.on("crap", function() {
  console.log("Speaking about craps on a broadcast? - Count me out!");
});

var model1 = new Model(1);

var model2 = new Model(2);
model2.on("bust", function() {
  console.log("I'm model2 and I'm busting!");
});

var ob2 = new EventfulObject();
ob2.on("bust", function() {
  console.log("I'm ob2 - busted!!!");
});
ob2.receiveBroadcast = function() {
  console.log("If it zips, I'll catch it. - That's me ob2.");
};

console.log("start:BROADCAST\n---------------");
model1.broadcast("crap");
console.log("end  :BROADCAST\n---------------\n-\n-\n");
console.log("start:EMIT\n---------------");
ob1.emit("bust");
console.log("end:EMIT\n---------------");

<h1>...THE SHOW IS ON YOUR CONSOLE!</h1>

After stumbling upon this question nearly a decade later, I've noticed significant changes in the realm of browser and JavaScript compared to when most responses were provided.

Here are my insights for those utilizing JavaScript module imports/exports:

// eventbus.js

class EventBus {
    constructor() {
        this.events = {};
    }

    on(type, callback) {
        if (!this.events[type]) {
            this.events[type] = [];
        }

        this.events[type].push(callback);
    }

    off(type, callback) {
        if (!this.events[type]) {
            return;
        }

        this.events[type] = this.events[type].filter(listener => listener !== callback);
    }

    dispatch(type, data) {
        if (!this.events[type]) {
            return;
        }

        this.events[type].forEach(listener => listener(data));
    }
}

export const eventbus = new EventBus();

// somefile.js
import {eventbus} from './eventbus';

// Somewhere in a method/click callback/etc..
eventbus.dispatch('fire', {message: 'Fire in the hole!'});

// otherfile.js
import {eventbus} from './eventbus';

eventbus.on('fire', data => {
    console.log(data.message); // logs 'Fire in the hole!'
});