What are the proper use cases for process.nextTick in Node.js?

I have seen process.nextTick used in a few places and can’t quite tell what it’s being used for.

• https://github.com/andrewvc/node-paperboy/blob/master/lib/paperboy.js#L24
• https://github.com/substack/node-browserify/blob/master/index.js#L95

What are the main/proper use cases of process.nextTick in Node.js? The docs basically say it’s a more optimized way of doing setTimeout, but that doesn’t help much.

I used to do a lot of ActionScript, so the idea of “waiting until the next frame” to execute code makes sense on some level – if you’re running an animation you can have it update every frame rather than every millisecond for example. It also makes sense when you want to coordinate setting a bunch of variables – you change the variables in frame 1, and apply the changes in frame 2. Flex implemented something like this in their component lifecycle.

My question is, what should I be using this for in server-side JavaScript? I don’t see any places right off the bat where you’d need this kind of fine-tuned performance/flow control. Just looking for a point in the right direction.

Answer

process.nextTick puts a callback into a queue. Every callback in this queue will get executed at the very beginning of the next tick of the event loop. It’s basically used as a way to clear your call stack. When the documentation says it’s like setTimeout, it means to say it’s like using setTimeout(function() { ... }, 1) in the browser. It has the same use cases.

One example use case would be, you create a constructor for some object that needs events bound to it. However, you can’t start emitting events right away, because the code instantiating it hasn’t had time to bind to events yet. Your constructor call is above them in the call stack, and if you continue to do synchronous things, it will stay that way. In this case, you could use a process.nextTick before proceeding to whatever you were about to do. It guarantees that the person using your constructor will have time enough to bind events.

Example:

var MyConstructor = function() {
  ...
  process.nextTick(function() {
    self._continue();
  });
};

MyConstructor.prototype.__proto__ = EventEmitter.prototype;

MyConstructor.prototype._continue = function() {
  // without the process.nextTick
  // these events would be emitted immediately
  // with no listeners. they would be lost.
  this.emit('data', 'hello');
  this.emit('data', 'world');
  this.emit('end');
};

Example Middleware using this constructor

function(req, res, next) {
  var c = new MyConstructor(...);
  c.on('data', function(data) {
    console.log(data);
  });
  c.on('end', next);
}