0

我正在为似乎是一个简单的概念而苦苦挣扎，这让我认为我正在做的事情是无法完成的。

在nodejs中，如果class objectA.emits('hey there')，class objectB.on('hey there')可以用'yo'响应吗？

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

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

4

1 回答 1

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

在处理观察者/发布者-订阅者模式（或中介者模式）时，关键在于执行“发射”的类的类型实际上并不重要。

假设这A是一个发射器：

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

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

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

假设两个AANDB都是发射器：

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");

或者，您应该研究一种调解器模式（它也“发射”，但旨在成为 1 个对象，它在许多彼此不认识的对象之间进行调解，但使用相同的事件名称并传递明确定义的数据 -结构，就像一个好的 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根本不必是同一个班级。
现在他们确实以你想象的方式工作。两者都
使用依赖注入（“控制反转”）指向同一个发射器（ .ModeratorModerator

于 2012-11-06T15:02:20.717 回答