Question

我正在努力寻找一个简单的概念，让我觉得我在做什么是不可能完成的。

在nodejs中，如果类objectA.emits（'嘿那里'），可以将objectB.on（'嘿那里'）类用'yo'代表？

对象A和B除了扩展EventEmitter并且位于同一个nodejs应用程序之外，彼此无关。

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

Answer 1

是
这就是它。

在处理观察者/发布者 - 订阅者模式（或中介模式）时，关键在于它正在做“发射”的类是什么并不重要。

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

或者，你应该研究一个Mediator模式（它也是“发出”的，但是它应该是一个对象，它介于许多彼此不认识的对象之间，但是使用相同的事件名称并且通过 - 定义的数据结构，就像一个好的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个彼此一无所知的课程，每个课程都有自己的特殊目的，他们对“彼此”的唯一期望是事件名称和数据类型是合适的。 / p>

他们所有了解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根本不必是同一个班级现在，他们 DO 以您想象的方式工作。
两者都使用依赖注入（“控制反转”）指向相同的发射器（Moderator），因此它们都在同一个事件列表中工作，甚至不知道它，并使用自己的方法订阅Moderator个活动。

在Nodejs中，不同的类是否可以检测到彼此“发出”？

1 个答案: