节点Async / Await / Promise.All不等待其他人完成

Question

I have 3 functions which I need to run in order and one needs to finish before the other runs so I've done this:

var fs = require('fs');

async function create() {

    fs.writeFile('newfile.txt', 'some text here', (err) => {
        if (err) throw err;
        console.log('File is created successfully.');
        return ('File is created successfully.');
    }); 

}

async function waitt() {
    setTimeout(() => { return 'waited!' }, 10000);
}

async function read() {

    fs.readFile('newfile.txt', {encoding: 'utf-8'}, (err,data) => {
        if (!err) {
            console.log('received data: ' + data);
            return ('received data: ' + data);
        } else {
            console.log(err);
        }
    });

}

async function process() {

    let [r1, r2, r3] = await Promise.all([create(), waitt(), read()]);

    console.log(r1 + ' ' + r2 + ' ' + r3);

}


process();

So, process() runs create() which creates a file, then run waitt() which just pauses and finally read() shows the contents of the file.

The issue I'm having is that it's running in this order:

create()
read()
and then waitt()

instead of

create()
waitt()
read()

which is what I want.

How can I fix this?

Answer 1

This won't work:

async function waitt() {
  setTimeout(() => { return 'waited!' }, 10000);
}

Because, you're return -ing from within the setTimeout callback, not the async -marked wait function.

To mix callback-style code and async/await you must first convert callback style code to use Promises , or use fs-extra which already provides fs functions returning promises.

Something like this:

function waitt() {
  return new Promise((resolve) => {
    setTimeout(() => {
      resolve('waited...')
    }, 10000)
  })
}

The same applies to the rest of your functions.

Also note that if a function explicitly returns a Promise, it doesn't need to be marked as async to be awaited, since await essentially works with Promises.

Now for the order:

Promise.all doesn't guarantee order, for that you might be able to get away with a simple for..of , or just call the functions yourself.

 function wait() { return new Promise((resolve, reject) => { setTimeout(() => { console.log('waited...') resolve('foo') }, 500) }) } // Assume this is your promisified read function. function read() { return new Promise((resolve, reject) => { setTimeout(() => { console.log('read...') resolve('bar') }, 500) }) } // Assume this is your promisified create function. function create() { return new Promise((resolve, reject) => { setTimeout(() => { console.log('created...') resolve('baz') }, 500) }) } ;(async () => { try { await create() await wait() await read() } catch (err) { console.error(err) } })() 

Answer 2

Your problem is that Promise.all does not guarantee the order of processing, just that all the promises in the list are processed.

Can you not just say:

await create();
await read();
await waitt();