Douglas Crockford's "Javascript: The Good Parts" Chapter 5.5

Question

I was reading Ch 5.5 of the book in title. I have still have trouble in seeing how "We can compose objects out of sets of parts" using the eventuality function in the chapter.

Are objects to be composed by a event system with the "on" and "fire" functions ?

Code from the section of the book below:

var eventuality = function (that) {
    var registry = {};
    that.fire = function (event) {
// Fire an event on an object. The event can be either
// a string containing the name of the event or an
// object containing a type property containing the
// name of the event. Handlers registered by the 'on'
// method that match the event name will be invoked.
        var array,
            func,
            handler,
            i,
            type = typeof event === 'string' ?
                    event : event.type;
// If an array of handlers exist for this event, then
// loop through it and execute the handlers in order.
        if (registry.hasOwnProperty(type)) {
            array = registry[type];
            for (i = 0; i < array.length; i += 1) {
                handler = array[i];
// A handler record contains a method and an optional
// array of parameters. If the method is a name, look
// up the function.
                func = handler.method;
                if (typeof func === 'string') {
                    func = this[func];
                }
// Invoke a handler. If the record contained
// parameters, then pass them. Otherwise, pass the
// event object.
                func.apply(this,
                    handler.parameters || [event]);
            }
        }
        return this;
    };
    that.on = function (type, method, parameters) {
// Register an event. Make a handler record. Put it
// in a handler array, making one if it doesn't yet
// exist for this type.
        var handler = {
            method: method,
            parameters: parameters
        };
        if (registry.hasOwnProperty(type)) {
            registry[type].push(handler);
        } else {
            registry[type] = [handler];
        }
        return this;
    };
    return that;
}

Answer 1

What Mr. Crockford means here is that you can implement specific functionality such as the on and fire functions that add event processing to any object by calling the function object that creates them (eventuality in this case) with that object as parameter.

The "part" here is an "event processing part" embodied in the eventuality function object. You could imagine different parts that add other functions. The idea here is that you can use this system to add this functionality to individual objects where you need it. This concept is called a Mixin(1).

Also read the final paragraph of chapter 5:

In this way a constructor could assemble objects from a set of parts. JavaScript's loose typing is a big benefit here because we are not burdened with a type system that is concerned about the lineage of classes.

(1) Thank you Zecc.

Answer 2

As I understand it, the point of this section of the book is to illustrate the power of JavaScript - in that you could build an object with all the various 'powerful components of JavaScript' easily.

As he says

For example, we can make a function that can add simple event processing features to any object. It adds an on method, a fire method, and a private event registry