中介器模式与直接调用中间函数

Question

Mediator的设计模式如何，例如：

var mediator = (function(){
var _jobs = {};

function _extractedParams(arguments){
    var arr = [];
    if (arguments.length > 1){
        for (var i=1; i < arguments.length; i++) arr.push(arguments[i]);
    } 
    return arr;
}

function _defaultSubscribeCallback(){
    console.log("_defaultSubscribeCallback()");
}

return {
    subscribe: function(){
        var channel = arguments[0];
        if (!_jobs.hasOwnProperty(channel)) _jobs[channel] = [];
        _jobs[channel].push({
            originalParams: _extractedParams(arguments),
            callback: arguments[1] || _defaultSubscribeCallback
        });
    },
    publish: function(){
        var channel = arguments[0];
        if (!_jobs.hasOwnProperty(channel)) return 0;
        for (var i=0; i < _jobs[channel].length; i++){
            var subscription = _jobs[channel][i];
            subscription.callback.apply(this, subscription.originalParams);
        }
        return 1;  
    }
};
}());
var module1 = (function(){
    return {
        myFunction: function(){
           console.log(arguments[0]); //"Hello"
        }
    };
}());
mediator.subscribe("LOG_IN", module1.myFunction, "Hello");
var module2 = (function(){
    return {
        afterAuth: function(){
           mediator.publish("LOG_IN");
        }
    };
}());
//After user authentication
module2.afterAuth();

当一个模块想要与另一个模块通信时，比简单地调用一个中间函数要好，例如这样的事情？：

var mediator = (function(){
    return {
        runFunction: function(){
            var params;
            if (arguments.length > 1){
                params = [];
                for (var i=1; i < arguments.length; i++) params.push(arguments[i]);
            }
            if (arguments[0] && typeof arguments[0] === "function") arguments[0](params);
        }
    };
}());
var module1 = (function(){
    return {
        myFunction: function(){
           console.log(arguments[0]); //"Hello"
        }
    };
}());
var module2 = (function(){
    return {
        afterAuth: function(){
           mediator.runFunction(module1.myFunction, "Hello");
        }
    };
}());
//After user authentication
module2.afterAuth();

虽然这两种策略似乎都有相同的好处（解耦等），但第一个例子通过保留_jobs中的订阅产生了开销（虽然我没有包括它，但我会提供一个unsubscribe()方法来帮助缓解这种情况，但这仍然是一个问题）；比第二个例子复杂得多；将导致性能略有下降；并且更容易遇到问题。

我对Mediator模式有什么不了解的地方？为什么这看起来像是一种不必要的复杂方式来实现一个简单的结果？为什么我希望所有这些订阅都在_jobs中浮动？

Answer 1

第一种方法实际上是Observer Pattern的一个示例，其中publisher发布和订阅者侦听，而在Mediator Pattern中，所有模块相互通信另一个是通过调解人。两种模式都有相同的好处，即解耦。在第二接近模块1与模块2通信且未解耦（模块1直接指模块2）如果将来要对模块和他们的接口。最好不要让模块担心接口，让中介来做。关注点分离：）

Answer 2

我现在意识到，第一个和第二个例子之间的重要区别是，在第二个示例中，module2通过mediator.runFunction(module1.myFunction, "Hello");引用module1，而在第一个示例中module2没有引用module1，而是通过mediator.publish("LOG_IN");仅引用中介。很明显，正如@user943702所指出的，第二个实例"毫无用处"。