Can Multiple fs.write to append to the same file guarantee the order of execution?

asynchronous, fs, javascript, node.js

Solution

The docs say that

Note that it is unsafe to use `fs.write` multiple times on the same file without waiting for the callback. For this scenario, fs.createWriteStream is strongly recommended.

Using a stream works because streams inherently guarantee that the order of strings being written to them is the same order that is read out of them.

var stream = fs.createWriteStream("./same/path/file.txt");
stream.on('error', console.error);
arr.forEach((str) => { 
  stream.write(str + '\n'); 
});
stream.end();

Another way to still use `fs.write` but also make sure things happen in order is to use promises to maintain the sequential logic.

function writeToFilePromise(str) {
  return new Promise((resolve, reject) => {
    fs.write("./same/path/file.txt", str, {flag: "a"}}, (err) => {
      if (err) return reject(err);
      resolve();
    });
  });
}

// for every string, 
// write it to the file, 
// then write the next one once that one is finished and so on
arr.reduce((chain, str) => {
  return chain
   .then(() => writeToFilePromise(str));
}, Promise.resolve());

Problem

Assume we have such a program: ``` // imagine the string1 to string1000 are very long strings, which will take a while to be written to file system var arr = ["string1",...,"string1000"]; for (let i = 1; i < 1000; i++) { fs.write("./same/path/file.txt", arr[i], {flag: "a"}}); } ``` My question is, `will string1 to string1000 be gurantted to append to the same file in order?` Since fs.write is async function, I am not sure how each call to fs.write() is really executed. I assume the call to the function for each string should be put somewhere in `another thread` (like a `callstack`?) and once the previous call is done the next call can be executed. I'm not really sure if my understanding is accurate. Edit 1 As in comments and answers, I see `fs.write` is not safe for multiple write to same file without waiting for `callback`. But what about writestream? If I use the following code, would it guarantee the order of writing? ``` // imagine the string1 to string1000 are very long strings, which will take a while to be written to file system var arr = ["string1",...,"string1000"]; var fileStream = fs.createWriteFileStream("./same/path/file.txt", { "flags": "a+" }); for (let i = 1; i < 1000; i++) { fileStream.write(arr[i]); } fileStream.on("error", () => {// do something}); fileStream.on("finish", () => {// do something}); fileStream.end(); ``` Any comments or corrections will be helpful! Thanks!

Original source