javascript - Node Js 中不同的类是否可以相互检测 'emits' ？

Question

我正在努力解决一个看似简单的概念，这让我觉得我正在做的事情无法完成。

在nodejs中，如果class objectA.emits('heythere')，class objectB.on('heythere')可以回复'yo'吗？

对象 A 和 B 彼此没有任何关系，只是它们都扩展了 EventEmitter 并且位于同一个 Nodejs 应用程序中。

抱歉，如果以前有人问过这个问题，我找不到它。

Answer 1

1. 是
2. 差不多就是这样了。

在处理观察者/发布者-订阅者模式(或中介者模式)时，重点是，执行“发射”的类类型实际上并不重要。

假设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。
如果您希望 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 在这里根本不必是同一个类。
现在它们确实按照您想象的方式工作。
两者都使用依赖注入(inject)(“控制反转”)来指向同一个发射器(Moderator)，因此它们都在相同的事件列表上工作，甚至不知道它，并使用他们自己的方法来订阅主持人的事件。