EventEmitter 事件处理程序的延迟附件模式？

Question

There is a seemingly well-known problem with attaching event handlers after an event has already been generated. This is a problem mainly when invoking functions that follow the pattern of returning an EventEmitter , for example:

var EventEmitter = require('events').EventEmitter;

function    doSomethingAsync() {
    var ev = new EventEmitter(),
        something = null;

    // Caller will never see this event because its 
    // handler is bound after fact.

    if(!something) {
        ev.emit('error', 'Something is null!');
        return ev;
    }

    return ev;
}

var res = doSomethingAsync();

res.on('error', function(s) {
    console.log('Error returned: ' + s);
});

This will return an unhandled error exception, because at the time error is emitted, no handler for it is attached yet:

 sasha@peacock:~$ node test.js events.js:87 throw Error('Uncaught, unspecified "error" event.'); ^ Error: Uncaught, unspecified "error" event. at Error (native) at EventEmitter.emit (events.js:87:13) at doSomethingAsync (/home/sasha/test.js:11:6) at Object.<anonymous> (/home/sasha/test.js:18:11) at Module._compile (module.js:460:26) at Object.Module._extensions..js (module.js:478:10) at Module.load (module.js:355:32) at Function.Module._load (module.js:310:12) at Function.Module.runMain (module.js:501:10) at startup (node.js:124:16)

The only solution I've been able to come up with is to create an EventEmitter on the calling side, bind the handlers in advance, and pass it to the function:

 var EventEmitter = require('events').EventEmitter; function doSomethingAsync(ev) { var something = null; // Caller will never see this event because its // handler is bound after fact. if(!something) { ev.emit('error', 'Something is null!'); } }; var res = new EventEmitter(); res.on('error', function(s) { console.log('Error returned: ' + s); }); doSomethingAsync(res);

This seems inelegant and messy, though. The only reason event handlers on asynchronous operations that are applied via the first method work at all is because the operations in question usually take longer to complete than the function does to return. That gives the caller time to apply the event handlers to the returned EventEmitter .

Surely there is a preferred pattern, idiom, or hidden bit of JavaScript or Node functionality to handle this case better?

I suppose one approach is to not use EventEmitters to transmit validation errors or other errors that can occur instantaneously, but simply return something else. But I still think that's not a solution to the essential problem; this model, widely portrayed in Node documentation and elsewhere, relies on the assumption that the async operation will take longer to complete than the time it takes to bind the event handlers after the EventEmitter is returned. Most of the time, that's probably true, but it cannot be guaranteed to be true.

That's why I think there must be a better way. If there isn't, that would make Node documentation on best-practical use of EventEmitters very misleading. Surely there is a better way?

Answer 1

You can use process.nextTick to defer event emitting after current call stack being executed. For your example:

var EventEmitter = require('events').EventEmitter;

function doSomethingAsync() {
    var ev = new EventEmitter(),
        something = null;

    // Caller will see this event because it
    // will be emitted after current call stack

    if(!something) {
        process.nextTick(function() {
            ev.emit('error', 'Something is null!');
        });
        return ev;
    }

    return ev;
}

var res = doSomethingAsync();

res.on('error', function(s) {
    console.log('Error returned: ' + s);
});

Answer 2

(A very late answer hoping that it would help someone )

Do not rely on process.nextTick() and it may not guarantee the subsequent events emitted (and a little messy things may occur down the road), the best trick is to extend your emitter and push the deferred events to stack and resolve it by FIFO. Pass a callback to the extended emitter and receive response here's the working code,

var EventEmitter = require('events').EventEmitter;
const util = require('util');
const events = require('events');

const DeferredEventEmitter = function(next) {
   EventEmitter.call(this);
   this.defferedEvents = [];  // stack or cache those require deferred execution

   //resolve the events
   this.on('error', function(s) { 
    //console.log(this.defferedEvents)
    //console.log('Error returned: ' + s);
    if(next) 
        next(s)  //execute the callback if error
   })

   this.on('success', function(s) { 
    //console.log('Success!' + s)
    if(next)
        next(s)
   })
   
   //here add further events to be resolved
   //this.on('some_event', function().....

}
 //inherit and apply native event emitter to our 
util.inherits(DeferredEventEmitter , events.EventEmitter);  

// push to stack
DeferredEventEmitter.prototype.deferredEmit = function(name, payload) {
  this.defferedEvents.push({name, payload});
}

// resolve each deferred event (FIFO)
DeferredEventEmitter.prototype.broadcastDeferredEmit = function() {
if(!this.defferedEvents.length)
    return;
  while(this.defferedEvents.length) { 
    const event = this.defferedEvents.shift();
    this.emit(event.name, event.payload);
  }
}

// The caller
function   doSomethingAsync(callback) {
    var ev = new DeferredEventEmitter(callback),
        something = null, everything = "not null";
    // Caller will never see this event because its 
    // handler is bound after fact.
    if(!something) 
       //push to stack the deferredEmit to later resolve
       ev.deferredEmit('error', 'emitting because something is "null"!');  
    
    if(everything) 
        ev.deferredEmit('success', 'emitting because, everything is "not null"!')

    console.log(ev.defferedEvents)
    //now broadcast all deferred emits
    ev.broadcastDeferredEmit()
    return ev
}
//call function and receive deferred emits without calling for it.
var res = doSomethingAsync((res) => { 
    console.log(res)
});


//module.exports = DeferredEventEmitter ;

I hope this is what you're looking for.