Question

Nodejs has a method process.nextTick(fn) which delays the execution of a function until the next tick. According to this article this can be used to emit events in the constructor of an object like this (copied from the artice):

function StreamLibrary(resourceName) {      
    var self = this;

    process.nextTick(function() {
        self.emit('start');
    });

}

var stream = new StreamLibrary('fooResource');

stream.on('start', function() {
    console.log('Reading has started');
});

Without process.nextTick this wouldn’t have worked because the event would’ve been emitted before you had the chance to listen for events. However, how can you be certain that the event won’t be emitted before you added an event listener? If it’s fully asynchronous then there would be a chance that the next tick is executed before the end of the constructor, hence ignoring the event listener. So what are the rules behind this process? When does node executes a nextTick?

Answer 1

The next tick is executed on… the next tick. I think the confusion here is what you mean by “fully asynchronous”.

With Node.js, all of your code runs on a single thread. No code scheduled for the next tick will be executed until the current tick is finished.

Therefore, when you emit events from the next tick within the constructor, the code that may attach handlers will all be finished executing before that next tick occurs.

The asynchronous and multi-threaded part of Node is with handling operations such as network and IO. Those function calls run while your JavaScript code is running, but when data is passed back to your code, it won’t run until that next tick.