中介者模式（Mediator）

Mediator.js

(function(factory) {
    var root = window || (typeof self == 'object' && self.self == self && self);
    var Mediator = factory(root);

    root.Mediator = new Mediator();
})(function(root) {

    function Mediator() {
        if (!this instanceof Mediator) {
            return new Mediator();
        } else {
            this._topics = new Topic('');
        }
    }

    Mediator.version = '1.0';

    Mediator.prototype = {
        getTopic: function(namespace) {
            var topic = this._topics;
            var namespaceArr = namespace.split(':');

            if (namespace == '') {
                return topic;
            }

            if (namespaceArr.length > 0) {
                for (var i = 0, j = namespaceArr.length; i < j; i++) {
                    if (!topic.hasTopic(namespaceArr[i])) {
                        topic.addTopic(namespaceArr[i]);
                    }
                    topic = topic.getTopic(namespaceArr[i]);
                }
            }

            return topic;
        },
        subscribe: function(topicName, fn, options, context) {
            var options = options || {},
                context = context || {},
                topic = this.getTopic(topicName);
            var sub = topic.addSubscriber(fn, options, context);

            return sub;
        },
        getSubscriber: function(topicName, id) {
            return this.getTopic(topicName || '').getSubscriber(id);
        },
        removeSubscriber: function(topicName, id) {
            this.getTopic(topicName).removeSubscriber(id);
        },
        publish: function(topicName) {
            var args = Array.prototype.slice.call(arguments, 1),
                topic = this.getTopic(topicName);

            args.push(topic);
            topic.publish(args);
        }
    };

    var getID = (function() {
        var i = 0;
        return function() {
            return i++;
        }
    })();

    function extend(prev, next) {
        if (typeof next != 'object' || typeof prev != 'object') {
            return {};
        }
        for (var i in next) {
            if (next.hasOwnProperty(i)) {
                prev[i] = next[i];
            }
        }
        return prev;
    }

    function Subscriber(fn, options, context) {
        if (!this instanceof Subscriber) {
            return new Subscriber(fn, options, context);
        } else {
            this.id = getID();
            this.fn = fn;
            this.options = extend(this.options, options);
            this.context = context;
            this.topic = null;
        }
    }

    function Topic(namespace) {
        if (!this instanceof Topic) {
            return new Topic(namespace);
        } else {
            this.namespace = namespace || '';
            this._callbacks = [];
            this._topics = {};
            this.stoped = false;
        }
    }

    Topic.prototype = {
        addSubscriber: function(fn, options, context) {
            var callback = new Subscriber(fn, options, context);
            this._callbacks.push(callback);
            callback.topic = this;
            return callback.id;
        },
        removeSubscriber: function(id) {
            if (!id) {
                this._callbacks = [];

                for (var x in this._topics) {
                    if (this._topics.hasOwnProperty(x)) {
                        this._topics[x].removeSubscriber(id);
                    }
                }
            }

            for (var y = 0, l = this._callbacks.length; y < l; y++) {
                if (this._callbacks[y].id == id || this._callbacks[y].fn == id) {
                    this._callbacks[y].topic = null;
                    this._callbacks.splice(y, 1);
                    y--;
                    l--;
                }
            }
        },
        stopPropagation: function(){
            this.stoped = true;
        },
        getSubscriber: function(id) {
            for (var x = 0, l = this._callbacks.length; x < l; x++) {
                var callback = this._callbacks[x];
                if (callback.id == id || callback.fn == id) {
                    return callback;
                }
            }

            for (var y in this._topics) {
                if (this._topics.hasOwnProperty(y)) {
                    var sub = this._topics[y].getSubscriber(id);
                    if (sub != undefined) {
                        return sub;
                    }
                }
            }
        },
        addTopic: function(topic) {
            this._topics[topic] = new Topic((this.namespace?this.namespace+':' : '') + topic);
            return this._topics[topic];
        },
        hasTopic: function(topic) {
            return this._topics.hasOwnProperty(topic);
        },
        getTopic: function(topic) {
            return this._topics[topic];
        },
        publish: function(data) {
            console.log('Published By: '+this.namespace);

            for (var x = 0, l = this._callbacks.length; x < l; x++) {
                var callback = this._callbacks[x];
                var len;

                callback.fn.apply(callback.context, data);

                if (this._callbacks.length < l) {
                    x--;
                    l = this._callbacks.length;
                }
            }

            for (var y in this._topics) {
                if (!this.stoped) {
                    if (this._topics.hasOwnProperty(y)) {
                        this._topics[y].publish(data);
                    }
                }
            }

            this.stoped = false;
        }
    }

    Mediator.prototype.Subscriber = Subscriber;
    Mediator.prototype.Topic = Topic;

    return Mediator;
});

index.html

<!DOCTYPE html>
<html lang="en">
<head>
    <meta content="text/html; charset=utf-8" http-equiv="Content-Type">
    <script type="text/javascript" src="./Mediator.js"></script>
</head>
<body>

<script type="text/javascript">

    Mediator.subscribe('new', function(data) {
        console.log(data);
        console.log('subscrib something. ---msg');
    }, {}, this);

    setTimeout(function() {
        Mediator.publish('new', 'text');
    }, 500);


    console.log('------------divider-----------');

    Mediator.subscribe('user:new', function(name, age) {
        console.log('name:'+name+', age:'+age);
    }, {}, this);

    Mediator.subscribe('user:new', function(name, age) {
        console.log('Log : Save a new User.');
    }, {}, this);

    Mediator.publish('user:new', 'Dong', '25');

    console.log('------------divider-----------');

    console.log(Mediator.getTopic('user:new'));

</script>

</body>
</html>