Question

我有一系列的诺言，我会尝试一个接一个地处理

function asyncInsertMagFromFile(file, resolve) {
            //some asynchronous processing with file
            resolve();
          }

let magRequests = fs.readdirSync(storeDir).map(function(file) {
            return new Promise(resolve => {
              asyncInsertMagFromFile(file, resolve);
            });
          });

我试图“同步”处理这些承诺（magRequests）而没有成功。存在关于该主题的许多问题，但我还没有找到适合我的问题的问题。我在https://stackoverflow.com/a/40329190/7531001尝试了一些Trincot解决方案，但我不知道如何处理文件参数。

例如，这不起作用（await仅在异步功能中有效）

(async function loop() {
            fs.readdirSync(storeDir).forEach(function(file) {
              await new Promise(resolve =>
                asyncInsertMagFromFile(file, resolve)
              );
            });

          })();

有什么主意我可以解决这个问题吗？

Answer 1

您可以尝试使用array.reduce获取先前的值（promise列表）并等待其完成，然后再调用asyncInserMagFromFile函数

(function loop() {
  fs.readdirSync(storeDir).reduce(async (previousPromise, file) => {
    await previousPromise;
    return new Promise(resolve =>
      asyncInsertMagFromFile(file, resolve);
    );
  },Promise.resolve());
})();

Answer 2

等待仅在异步功能中有效

使用.map代替.forEach，并将异步函数作为回调传递给它。

Answer 3

您可以将一些'then's一个又一个地链接。

function asyncInsertMagFromFile(file) {
    return new Promise((resolve, reject) => {
        //some asynchronous processing with file
        // call resolve when finished
        resolve();
    })
}

let chain = Promise.resolve();

fs.readdirSync(storeDir).forEach(function (file) {
    chain = chain.then(((file) => () => asyncInsertMagFromFile(file))(file));
});

chain.then(() => {
    //finished
}).catch((err) => {
   //error in chain
})

另一种方法是使用注释中提到的for语句：

function asyncInsertMagFromFile(file) {
    return new Promise((resolve, reject) => {
        //some asynchronous processing with file
        // call resolve when finished
        resolve();
    })
}

(async () => {
    const files = fs.readdirSync(storeDir);

    for (let i = 0; i < files.length; i++) {
        await asyncInsertMagFromFile(files[i]);
    }
})()

Answer 4

这可能会对您有所帮助；

async function asyncInsertMagFromFile(file) {
 // use await to gather results from processing or return a promise
 return result;
}

function mapRequests(storeDir) {
  return fs.readdirSync(storeDir).map(async function(file) {
    return await asyncInsertMagFromFile(file);
  });
}

mapRequests(storeDir).then((mapped) => {});

您的示例无法使用的原因是因为forEach处理函数使用了await，但未声明为异步。

Answer 5

如果要连续处理并处理结果，则可以使用递归：

const FAILED = {};
const processImages = (files) => {
  const recur=(files,result) => {
    if(files.length===0){
      return result;
    }
    return asyncInsertMagFromFile(files[0])
    .catch(error=>FAILED)//always resolve, place FAILED values when rejected
    .then(success=>recur(files.slice(1),result.concat(success)))
  }
  return recur(files,[])
}

processImages(fs.readdirSync(storeDir)).then(results=>{
  console.log('failed',results.filter(r=>r===FAILED).length)
});

对于并行处理，您可以使用Promise.all：

Promise.all(
  fs.readdirSync(storeDir).map((file)=> asyncInsertMagFromFile(file).catch(FAILED))
).then(results=>{
  console.log('failed',results.filter(r=>r===FAILED).length)
})

Javascript循环与其他参数同步承诺

5 个答案: