I was recently reading a bit about the internals of the Nodejs event loop (check out the official docs). I won’t get into the details of how the event loop works, but the official docs linked above and a nice blog post (check it out here) provide a high-level explanation of the main concepts and the way the event loop works.

I wanted to share an example of a subtle difference in the execution order of different things (macrotasks, microtasks, etc) that I found interesting. Here is the code:

1
const { createHash } = require('node:crypto')
2

3
function main() {
4
  console.log('In main function (1)')
5

6
  // A macro task
7
  setTimeout(() => {
8
    console.log('In timeout')
9
  }, 0)
10

11
  // A promise (micro task)
12
  const p = new Promise((resolve, _) => {
13
    const secret = createHash('sha256').update('supersecret').digest()
14
    resolve(secret)
15
  })
16
  p.then((_) => console.log('Promise resolved'))
17

18
  // Next tick callbacks
19
  process.nextTick(() => {
20
    console.log('Next tick')
21
  })
22

23
  process.nextTick(() => {
24
    console.log('Another Next tick callback')
25
  })
26

27
  console.log('In main function (2)')
28
}
29

30
main()

The output of this code when running node <filename.js> is:

In main function (1)
In main function (2)
Next tick
Another Next tick callback
Promise resolved
In timeout

This is what I expected, too: the main function is executed, then next tick callbacks (find out more about it here), the promise callbacks and finally the timeout callback. In general, the order of execution is: the oldest macrotask in the macrotask queue, then next tick callbacks, then all the microtasks, then the oldest macrotask and so on.

So far, so good. Let’s now make a small change and switch to ES modules instead of commonjs. We’ll only need to change the first line of the script to this:

import { createHash } from 'node:crypto'

When we run the script again, the output changes to this:

In main function (1)
In main function (2)
Promise resolved
Next tick
Another Next tick callback
In timeout

Promise callbacks get executed first and next tick callbacks afterwards! Why is that? Searching for an answer, the official docs explain it very well (check the documentation for more details):

So in CJS modules process.nextTick() callbacks are always run before queueMicrotask() ones. However since ESM modules are processed already as part of the microtask queue, there queueMicrotask() callbacks are always executed before process.nextTick() ones since Node.js is already in the process of draining the microtask queue.