node.js - How to 'order' your callbacks without using a blocking structure

Question

I'm new to node.js and stackoverflow and I'm having a little trouble : I want to read two files and do something with them in a specific order. Problem being that i don't know wich one will finish being read first so I don't know how to make sure they will trigger in the right order.

To give an example let's say that I want to read two files and write them in the response :

fs.readFile('./file1',(err,data) => {
    res.write(data);
})
fs.readFile('./file2',(err,data) => {
    res.write(data);
})

How could I make sure the first file will be writen before the second even if the second file is smaller than the first one ?

I could do that :

fs.readFile('./file1',(err,data) => {
    res.write(data);
    fs.readFile('./file2',(err,data) => {
        res.write(data);
    })
})

But it would act like a blocking structure : the second one couldn't start being read before the end of the first one and that's not the point of Node.js... Am I right ?

PS : Sorry if the question is dumb or for my poor english

Answer 1

One of the reason (out of several) Promise and async/await exists is to solve exactly this kind of issue.

You can create a wrapper to return Promise:

function readSomething(filePath) {
  return new Promise((resolve, reject) => {
    fs.readFile(filePath, (err, data) => {
      if (err) reject(err);
      else resolve(data);
    });
}

Then you can call like,

// called in parallel
const result1 = readSomething('./file1');
const result2 = readSomething('./file2');

result1.then((data) => {
  res.write(data) // or anything
  // to order, chaining promise
  return result2;
})
.then(data => res.write(data))

With async/await you can do (await is valid only inside async function):

async function handleResults() {
  res.write(await result1)
  res.write(await result2)
}

Note: Watch out for error (reject cases). They become a little tricky in this situation. (I'm you can figure it out)

In nodejs you can utilise the power of EventEmitter as well. You can also check out reactive programming implemented by rxjs library for Observer pattern.