Javascript 不同的类是否可以检测'；发射'；从Nodejs的对方那里？

我正在努力解决一个看似简单的概念，它让我觉得我正在做的事情是做不到的

在nodejs中，如果类objectA.emit（'hey-there'），那么类objectB.on（'hey-there'）是否可以用'yo'表示

对象A和B彼此无关，只是它们都扩展了EventEmitter并且在同一个nodejs应用程序中

对不起，如果以前有人问过这个问题，我找不到

对

差不多就是这样

在处理观察者/发布者订阅者模式（或中介者模式）时，重点是，真正执行“发出”操作的类的类型并不重要

假设

A

是发射器：

var B = { doStuff : function () { console.log("Yo!"); } };

A.addListener("someEvent", B.doStuff);
A.emit("someEvent");

如果你真的想让他们来回交谈，那么你需要手动将他们相互订阅

假设

A

和

B

都是发射器：

B.doStuff = function () { this.emit("B's event", "Yo!"); };
A.doThing = function (param) { console.log(param); };

B.addListener("B's event", A.doThing);
A.addListener("A's event", B.doStuff.bind(B));

A.emit("A's event");

或者，您应该研究一个中介模式（它也“发射”，但旨在成为一个对象，在许多彼此不认识的对象之间进行中介，但使用相同的事件名称并传递定义良好的数据结构，就像一个好的API应该做的那样）

假设

Mediator

是发射器，

A

，

B

和

C

不是：

var A = {
        getData : function (request) { /* network call */ this.dataCallback(data); },
        dataCallback : function (data) { Mediator.emit("data-recieved", data); }
    },
    B = {
        display  : document.getElementById("data-display"),
        showData : function (data) { /* make DOM representation */ }
    },
    C = {
        input : document.getElementById("request-input"),
        button : document.getElementById("request-button"),
        getRequest : function () {
            var request = this.input.value;
            this.requestData(request);
            this.disableButton();
        },
        requestData : function (request) { Mediator.emit("data-request", request); },
        disableButton : function () { this.button.disabled = true; },
        enableButton  : function () { this.button.disabled = false; }
    };


    Mediator.addListener("data-request", A.getData.bind(A));
    Mediator.addListener("data-received", B.showData.bind(B));
    Mediator.addListener("data-received", C.enableButton.bind(C));

    C.button.addEventListener("click", C.getRequest.bind(C), false);

现在有3个类彼此一无所知，每个类都有自己的特殊用途，它们对“彼此”的唯一期望是事件名称和数据类型是合适的

他们都知道

调解人

如果希望进一步抽象Mediator，则可以在创建类时传递对它的引用：

function A (param1, param2) {
    var emitter = null;
    this.setEmitter = function (myEmitter) { emitter = myEmitter; };
    this.emit = function (evt, data) {
        if (!emitter) { return; }
        emitter.emit(evt, data);
    };
    this.subscribe = function (evt, callback) {
        if (!emitter) { return; }
        emitter.addListener(evt, callback);
    };
    /* rest of the object */
};


var a = new A();
var b = new A();


a.setEmitter(Mediator);
a.subscribe("some-evt", a.doSomething.bind(a));

b.setEmitter(Mediator);
b.subscribe("other-evt", b.doSomethingElse.bind(b));

a.emit("other-evt", { /* data */ });

a
和
b
在这里根本不必是同一个类。

现在他们以你想象的方式工作。

两人都使用依赖注入（“控制反转”）指向同一个发射器（
主持人），因此他们都使用相同的事件列表，甚至不知道它，并使用自己的方法订阅主持人的事件。
objectB
如何响应“yo”？用另一个？或者应该
objectA
听
objectB
来接收“yo”？我猜我想象的方式是objectA做了一些事情，并向应用程序的其余部分释放一个emit。我希望其他实例化的对象能够监听它们，并通过做一些事情做出反应。这也可能是双向的，因为在objectA中也可能侦听来自应用程序其余部分的事件。@user1500053这意味着“应用程序其余部分”需要手动订阅
A
，使用
A
s
。on
或
.addListener
方法（做同样的事情）。更多细节见我的答案。