使用异步/等待foreach循环

Question

在 foreach 循环中，使用 async /是否有任何问题？我正在尝试在每个文件的内容上循环浏览一系列文件和等待。

import fs from 'fs-promise'

async function printFiles () {
  const files = await getFilePaths() // Assume this works fine

  files.forEach(async (file) => {
    const contents = await fs.readFile(file, 'utf8')
    console.log(contents)
  })
}

printFiles()

此代码确实有效，但是这可能会出现问题吗？我有人告诉我，您不应该在这样的高阶函数中使用 async /等待，所以我只想问是否有任何问题与此。

Answer 1

当然，代码确实有效，但是我敢肯定，它不会执行您期望的事情。它只是启动了多个异步调用，但是 printfiles 函数在此之后立即返回。

按顺序读取，

如果您想按顺序读取文件，确实不能使用 foreach 。只需使用现代来取... 循环，其中等待就可以按预期工作：

async function printFiles () {
  const files = await getFilePaths();

  for (const file of files) {
    const contents = await fs.readFile(file, 'utf8');
    console.log(contents);
  }
}

阅读

如果您想并行读取文件，则并行 ，您不能确实使用 确实使用。每个 async 回调函数呼叫确实会返回承诺，但是您将它们扔掉而不是等待它们。只需使用 MAP ，您就可以等待您将通过 Promise.all ：

async function printFiles () {
  const files = await getFilePaths();

  await Promise.all(files.map(async (file) => {
    const contents = await fs.readFile(file, 'utf8')
    console.log(contents)
  }));
}

Answer 2

借助ES2018，您可以大大简化上述所有答案：

async function printFiles () {
  const files = await getFilePaths()

  for await (const contents of files.map(file => fs.readFile(file, 'utf8'))) {
    console.log(contents)
  }
}

参见规格：

简化：

  for await (const results of array) {
    await longRunningTask()
  }
  console.log('I will wait')

---

2018-09-10：这个答案最近引起了很多关注，请参阅 Axel Rauschmayer的博客文章有关异步迭代的更多信息。

Answer 3

而不是 promise.all 与 array.prototype.map 结合使用（不保证解决 Promise 解决的顺序），我使用 array.prototype.reduce ，以解决的 Promise ：

async function printFiles () {
  const files = await getFilePaths();

  await files.reduce(async (promise, file) => {
    // This line will wait for the last async function to finish.
    // The first iteration uses an already resolved Promise
    // so, it will immediately continue.
    await promise;
    const contents = await fs.readFile(file, 'utf8');
    console.log(contents);
  }, Promise.resolve());
}

Answer 4

  files.foreach（async（file）=＆gt; {
    const contents =等待fs.ReadFile（文件，'utf8'）
}））
 

问题是，迭代功能返回的承诺被 foreach（）忽略。 foreach 在完成每个异步代码执行后，不等待移至下一个迭代。所有 fs.ReadFile 功能
将在同一事件循环中调用，这意味着它们是并行启动的，而不是连续启动，并且执行在调用foreach（）之后立即继续
等待所有 fs.ReadFile 操作完成。由于Foreach不等待每个承诺解决，因此循环实际上在解决承诺之前完成了迭代。您期望 foreach 完成后，所有异步代码已经执行，但事实并非如此。您最终可能会尝试访问尚不可用的值。

您可以使用此示例代码测试行为

const array = [1, 2, 3];

const sleep = (ms) => new Promise(resolve => setTimeout(resolve, ms));
const delayedSquare = (num) => sleep(100).then(() => num * num);

const testForEach = (numbersArray) => {
  const store = [];
  // this code here treated as sync code
  numbersArray.forEach(async (num) => {
    const squaredNum = await delayedSquare(num);
    // this will console corrent squaredNum value
    // console.log(squaredNum) will log after console.log("store",store)
    console.log(squaredNum);
    store.push(squaredNum);
  });
  // you expect that store array is populated as [1,4,9] but it is not
  // this will return []
  console.log("store",store);
};
testForEach(array);
// Notice, when you test, first "store []" will be logged
// then squaredNum's inside forEach will log

该解决方案使用的是循环。

for (const file of files){
    const contents = await fs.readFile(file, 'utf8')
}

Answer 5

图片价值1000个字 - 仅用于顺序方法

---

背景：我昨晚处于类似情况。我将异步函数用作for for for for Angrage。结果是不可预测的。当我对代码进行了3次测试时，它没有问题2次，失败了1次。 （有些奇怪的是）

终于我四处走动＆amp;进行了一些刮擦测试。

中，它可以使用异步添加效率。

方案1-在foreach

const getPromise = (time) => { 
  return new Promise((resolve, reject) => {
    setTimeout(() => {
      resolve(`Promise resolved for ${time}s`)
    }, time)
  })
}

const main = async () => {
  const myPromiseArray = [getPromise(1000), getPromise(500), getPromise(3000)]
  console.log('Before For Each Loop')

  myPromiseArray.forEach(async (element, index) => {
    let result = await element;
    console.log(result);
  })

  console.log('After For Each Loop')
}

main();

方案2-使用 for -of -of loop as @bergi as @bergi as @bergi建议

const getPromise = (time) => { 
  return new Promise((resolve, reject) => {
    setTimeout(() => {
      resolve(`Promise resolved for ${time}s`)
    }, time)
  })
}

const main = async () => {
  const myPromiseArray = [getPromise(1000), getPromise(500), getPromise(3000)]
  console.log('Before For Each Loop')

  // AVOID USING THIS
  // myPromiseArray.forEach(async (element, index) => {
  //   let result = await element;
  //   console.log(result);
  // })

  // This works well
  for (const element of myPromiseArray) {
    let result = await element;
    console.log(result)
  }

  console.log('After For Each Loop')
}

main();

i.sstatic.net/qwbri.png“ rel =“ noreferrer 像我一样小的老派，您可以简单地将经典循环使用，也可以使用:)

const getPromise = (time) => { 
  return new Promise((resolve, reject) => {
    setTimeout(() => {
      resolve(`Promise resolved for ${time}s`)
    }, time)
  })
}

const main = async () => {
  const myPromiseArray = [getPromise(1000), getPromise(500), getPromise(3000)]
  console.log('Before For Each Loop')

  // AVOID USING THIS
  // myPromiseArray.forEach(async (element, index) => {
  //   let result = await element;
  //   console.log(result);
  // })

  // This works well too - the classic for loop :)
  for (let i = 0; i < myPromiseArray.length; i++) {
    const result = await myPromiseArray[i];
    console.log(result);
  }

  console.log('After For Each Loop')
}

main();

我希望这对某人有帮助，美好的一天，欢呼！

Answer 6

p-titeration npm上的模块实现了数组迭代方法，因此可以在非常直接的情况下使用它们与异步/等待的方式。

您的案件的一个例子：

const { forEach } = require('p-iteration');
const fs = require('fs-promise');

(async function printFiles () {
  const files = await getFilePaths();

  await forEach(files, async (file) => {
    const contents = await fs.readFile(file, 'utf8');
    console.log(contents);
  });
})();

Answer 7

这是一些 foreachAsync 原型。请注意，您需要等待他们：

Array.prototype.forEachAsync = async function (fn) {
    for (let t of this) { await fn(t) }
}

Array.prototype.forEachAsyncParallel = async function (fn) {
    await Promise.all(this.map(fn));
}

Note ，您可能将其包含在您自己的代码中，但您不应将其包含在将其分发给他人的库中（以避免污染他们的代码全球）。

要使用：

await myArray. forEachAsyncParallel( async (item) => { await myAsyncFunction(item) })

请注意，您也需要一个现代化的 esrun 才能在打字稿中的最高级别使用。

Answer 8

@Bergi已经给出了有关如何正确处理此特定情况的答案。我不会在这里复制。

我想解决 for 和循环的之间的

区别strong> <代码> foreach works

让我们看一下 foreach 的工作方式。根据 ecmascript Specificity a href =“ https://developer.mozilla.org/en-us/docs/web/javascript/reference/reference/global_objects/array/aray/foreach#polyfill” rel =“ noreferrer”>多填充。我将其复制并在此处粘贴，并删除评论。

Array.prototype.forEach = function (callback, thisArg) {
  if (this == null) { throw new TypeError('Array.prototype.forEach called on null or undefined'); }
  var T, k;
  var O = Object(this);
  var len = O.length >>> 0;
  if (typeof callback !== "function") { throw new TypeError(callback + ' is not a function'); }
  if (arguments.length > 1) { T = thisArg; }
  k = 0;
  while (k < len) {
    var kValue;
    if (k in O) {
      kValue = O[k];
      callback.call(T, kValue, k, O); // pay attention to this line
    }
    k++;
  }
};

让我们回到您的代码，让我们将回调作为函数提取。

async function callback(file){
  const contents = await fs.readFile(file, 'utf8')
  console.log(contents)
}

因此，基本上是回调返回承诺，因为它用 async 声明。内部 foreach ，回调只是以正常方式调用，如果回调本身返回承诺，则JavaScript引擎将不等待其解决或拒绝。相反，它将 Promise 放在作业队列中，并继续执行循环。

等待fs.ReadFile（file，'utf8'）在回调>回调？

基本上，当您的async callback 有机会被执行，JS引擎将暂停，直到 fs.ReadFile（file，'utf8'）被解析或拒绝，并在实现后恢复执行异步功能。因此，内容变量存储 fs.ReadFile 的实际结果，而不是 Promise 。因此， console.log（contents）记录文件内容而不是 Promise

为什么 for ... of 有效？

当我们为Of 循环编写通用时，我们将获得比 的控制权更多。让我们重构 printfiles 。

async function printFiles () {
  const files = await getFilePaths() // Assume this works fine

  for (const file of files) {
    const contents = await fs.readFile(file, 'utf8')
    console.log(contents)
    // or await callback(file)
  }
}

当评估循环时，我们有等待保证 async 函数，执行将暂停，直到等待已解决。因此，您可以认为文件是按确定的顺序逐一读取的。

有时会顺序执行

，我们确实需要以顺序执行的异步函数。例如，我有一些存储在数组中的新记录要保存到数据库中，我希望它们以顺序保存，这意味着应该先保存数组中的第一个记录，然后再保存，然后再保存，直到最后一个记录。

这是一个示例：

const records = [1, 2, 3, 4];

async function saveRecord(record) {
  return new Promise((resolved, rejected) => {
    setTimeout(()=> {
      resolved(`record ${record} saved`)
    }, Math.random() * 500)
  });
}

async function forEachSaveRecords(records) {
  records.forEach(async (record) => {
    const res = await saveRecord(record);
    console.log(res);
  })
}

async function forofSaveRecords(records) {
  for (const record of records) {
    const res = await saveRecord(record);
    console.log(res);
  }
}
(async () => {
  console.log("=== for of save records ===")
  await forofSaveRecords(records)
  
  console.log("=== forEach save records ===")
  await forEachSaveRecords(records)
})()

我使用 settimeout 来模拟将记录保存到数据库的过程 - 它是异步的，并且花费了随机的时间。使用 foreach ，记录以不确定的顺序保存，但使用 使用，它们被顺序保存。

Answer 9

该解决方案还进行了内存优化，因此您可以在 10,000 个数据项和请求上运行它。这里的一些其他解决方案会使服务器在大型数据集上崩溃。

在 TypeScript 中：

export async function asyncForEach<T>(array: Array<T>, callback: (item: T, index: number) => Promise<void>) {
        for (let index = 0; index < array.length; index++) {
            await callback(array[index], index);
        }
    }

如何使用？

await asyncForEach(receipts, async (eachItem) => {
    await ...
})

Answer 10

替换不起作用的 forEach() wait 循环的一个简单的嵌入式解决方案是将 forEach 替换为 map 并添加 Promise .all( 到开头。

例如：

await y.forEach(async (x) => {

到

await Promise.all(y.map(async (x) ）=> {

最后需要额外的 )。

Answer 11

除了@Bergi的回答之外，我还想提供第三种选择。它与 @Bergi 的第二个示例非常相似，但您不是单独等待每个 readFile ，而是创建一个承诺数组，每个承诺都在最后等待。

import fs from 'fs-promise';
async function printFiles () {
  const files = await getFilePaths();

  const promises = files.map((file) => fs.readFile(file, 'utf8'))

  const contents = await Promise.all(promises)

  contents.forEach(console.log);
}

请注意，传递给 .map() 的函数不需要是 async，因为 fs.readFile 无论如何都会返回一个 Promise 对象。因此，promises 是一个 Promise 对象数组，可以将其发送到 Promise.all()。

在@Bergi 的回答中，控制台可能会按照读取的顺序记录文件内容。例如，如果一个非常小的文件在一个非常大的文件之前完成读取，那么它将首先被记录，即使在 files 数组中小文件位于大文件之后。但是，在我上面的方法中，可以保证控制台将以与提供的数组相同的顺序记录文件。

Answer 12

在文件中弹出几个方法非常轻松，这些方法将以序列化顺序处理异步数据，并为您的代码提供更传统的风格。例如：

module.exports = function () {
  var self = this;

  this.each = async (items, fn) => {
    if (items && items.length) {
      await Promise.all(
        items.map(async (item) => {
          await fn(item);
        }));
    }
  };

  this.reduce = async (items, fn, initialValue) => {
    await self.each(
      items, async (item) => {
        initialValue = await fn(initialValue, item);
      });
    return initialValue;
  };
};

现在，假设保存在“./myAsync.js”中，您可以在相邻文件中执行类似于以下操作的操作：

...
/* your server setup here */
...
var MyAsync = require('./myAsync');
var Cat = require('./models/Cat');
var Doje = require('./models/Doje');
var example = async () => {
  var myAsync = new MyAsync();
  var doje = await Doje.findOne({ name: 'Doje', noises: [] }).save();
  var cleanParams = [];

  // FOR EACH EXAMPLE
  await myAsync.each(['bork', 'concern', 'heck'], 
    async (elem) => {
      if (elem !== 'heck') {
        await doje.update({ $push: { 'noises': elem }});
      }
    });

  var cat = await Cat.findOne({ name: 'Nyan' });

  // REDUCE EXAMPLE
  var friendsOfNyanCat = await myAsync.reduce(cat.friends,
    async (catArray, friendId) => {
      var friend = await Friend.findById(friendId);
      if (friend.name !== 'Long cat') {
        catArray.push(friend.name);
      }
    }, []);
  // Assuming Long Cat was a friend of Nyan Cat...
  assert(friendsOfNyanCat.length === (cat.friends.length - 1));
}

Answer 13

当 fs 基于 Promise 时，Bergi 的解决方案效果很好。
为此，您可以使用 bluebird、fs-extra 或 fs-promise。

但是，节点原生fs库的解决方案如下：

const result = await Promise.all(filePaths
    .map( async filePath => {
      const fileContents = await getAssetFromCache(filePath, async function() {

        // 1. Wrap with Promise    
        // 2. Return the result of the Promise
        return await new Promise((res, rej) => {
          fs.readFile(filePath, 'utf8', function(err, data) {
            if (data) {
              res(data);
            }
          });
        });
      });

      return fileContents;
    }));

注意：
require('fs') 强制将函数作为第三个参数，否则抛出错误：

TypeError [ERR_INVALID_CALLBACK]: Callback must be a function

Answer 14

从循环中调用异步方法并不好。这是因为每次循环迭代都会被延迟，直到整个异步操作完成。这不是很高效。它还避免了 async/await 的并行化优势。

更好的解决方案是一次创建所有 Promise，然后使用 Promise.all() 访问结果。否则，在前一个操作完成之前，每个后续操作都不会开始。

因此，代码可以重构如下；

const printFiles = async () => {
  const files = await getFilePaths();
  const results = [];
  files.forEach((file) => {
    results.push(fs.readFile(file, 'utf8'));
  });
  const contents = await Promise.all(results);
  console.log(contents);
}

Answer 15

一个重要的警告是：await + for .. of 方法和 forEach + async 方法实际上具有不同的效果。

在真正的 for 循环中使用 await 将确保所有异步调用都一一执行。 forEach + async 方式会同时触发所有的 Promise，这种方式速度更快，但有时会不知所措（如果你进行一些数据库查询或访问一些有流量限制的 Web 服务 并且不想一次发出 100,000 个呼叫）。

如果您不使用 async/await 并且希望确保文件被一个接一个地读取reduce + Promise（不太优雅） >。

files.reduce((lastPromise, file) => 
 lastPromise.then(() => 
   fs.readFile(file, 'utf8')
 ), Promise.resolve()
)

或者您可以创建一个 forEachAsync 来帮助但基本上使用相同的 for 循环底层。

Array.prototype.forEachAsync = async function(cb){
    for(let x of this){
        await cb(x);
    }
}

Answer 16

您可以使用 array.prototype.foreach ，但是异步/等待不是那么兼容。这是因为从异步回调返回的承诺期望得到解决，但是 array.prototype.foreach 无法从执行其回调中解决任何承诺。因此，您可以使用foreach，但是您必须自己处理承诺解决方案。

串联读取和打印每个文件的方法

async function printFilesInSeries () {
  const files = await getFilePaths()

  let promiseChain = Promise.resolve()
  files.forEach((file) => {
    promiseChain = promiseChain.then(() => {
      fs.readFile(file, 'utf8').then((contents) => {
        console.log(contents)
      })
    })
  })
  await promiseChain
}

这是一种使用 array.prototype.foreach 并行文件

async function printFilesInParallel () {
  const files = await getFilePaths()

  const promises = []
  files.forEach((file) => {
    promises.push(
      fs.readFile(file, 'utf8').then((contents) => {
        console.log(contents)
      })
    )
  })
  await Promise.all(promises)
}

Answer 17

只是添加到原始答案

• 原始答案中的并行读取语法有时令人困惑且难以阅读，也许我们可以用不同的方法编写它

async function printFiles() {
  const files = await getFilePaths();
  const fileReadPromises = [];

  const readAndLogFile = async filePath => {
    const contents = await fs.readFile(file, "utf8");
    console.log(contents);
    return contents;
  };

  files.forEach(file => {
    fileReadPromises.push(readAndLogFile(file));
  });

  await Promise.all(fileReadPromises);
}

• 对于顺序操作，而不仅仅是for...of，普通的 for 循环也可以工作

async function printFiles() {
  const files = await getFilePaths();

  for (let i = 0; i < files.length; i++) {
    const file = files[i];
    const contents = await fs.readFile(file, "utf8");
    console.log(contents);
  }
}

Answer 18

OP的原始问题

在foreach循环中使用异步/等待异步有什么问题？ ...

在 @bergi的

1. 顺序 - @chharvey

例如，如果一个非常小的文件在一个非常大的文件之前完成读数，即使小文件是在文件数组中的大文件之后出现的。

。

2. 可能一次打开太多文件 - Bergi在另一个答案

一次打开​​数千个文件以同时读取它们也不好。始终必须进行评估，无论是顺序，平行还是混合方法更好。

因此，让我们讨论这些问题，显示了简短和简洁的实际代码，并且 使用第三方库。易于切割，粘贴和修改的东西。

并行阅读（一次），以序列形式打印（尽可能尽早）。

最简单的改进是像@bergi的答案，但是进行一个小的更改以使每个文件是在保留订单时尽快打印。

async function printFiles2() {
  const readProms = (await getFilePaths()).map((file) =>
    fs.readFile(file, "utf8")
  );
  await Promise.all([
    await Promise.all(readProms),                      // branch 1
    (async () => {                                     // branch 2
      for (const p of readProms) console.log(await p);
    })(),
  ]);
}

上面，同时运行两个单独的分支。

• 分支1：同时同时读取，
• 分支2：以序列为止读取序列，但等待不超过必要的时间

很容易。

与并发限制并行读取，以串行打印（尽可能尽早）。

“并发限制”意味着不超过 n 文件。
就像一家仅允许一次允许如此多客户（至少在Covid期间）的商店。

首先，引入了辅助功能

function bootablePromise(kickMe: () => Promise<any>) {
  let resolve: (value: unknown) => void = () => {};
  const promise = new Promise((res) => { resolve = res; });
  const boot = () => { resolve(kickMe()); };
  return { promise, boot };
}

-Code> Bootable Promise（Kickme :(）=＆gt; promise＆lt; any＆gt;）
函数 kickme 作为启动任务的参数（在我们的情况下 readfile ），但没有立即启动。

Bootable Promise 返回一个属性

• promise type promise
• boot type function type function （）=＆gt; void

promise 在生活中有两个阶段

1. 是启动任务的承诺
2. ，成为承诺完成已经开始的任务。

Promise 在调用 boot（）时从第一个状态到第二个状态。

bootable Promise 在 printfiles 中使用，

async function printFiles4() {
  const files = await getFilePaths();
  const boots: (() => void)[] = [];
  const set: Set<Promise<{ pidx: number }>> = new Set<Promise<any>>();
  const bootableProms = files.map((file,pidx) => {
    const { promise, boot } = bootablePromise(() => fs.readFile(file, "utf8"));
    boots.push(boot);
    set.add(promise.then(() => ({ pidx })));
    return promise;
  });
  const concurLimit = 2;
  await Promise.all([
    (async () => {                                       // branch 1
      let idx = 0;
      boots.slice(0, concurLimit).forEach((b) => { b(); idx++; });
      while (idx<boots.length) {
        const { pidx } = await Promise.race([...set]);
        set.delete([...set][pidx]);
        boots[idx++]();
      }
    })(),
    (async () => {                                       // branch 2
      for (const p of bootableProms) console.log(await p);
    })(),
  ]);
}

就像之前有两个分支

• 分支1：用于运行和处理并发。
• 分支2：

现在要打印差异，不得超过共同限制承诺可以同时运行。

重要的变量是

• boots ：呼吁强制其相应过渡的函数的数组。它仅在分支1中使用。
• set ：随机访问容器中有保证，以便一旦实现，它们就可以轻松删除。该容器仅在分支1中使用。
• BootableProm ：这些与最初的承诺相同。它仅在分支2中使用。

使用模拟 fs.ReadFile 运行，该需要以下时间（文件名与MS中的时间）。

const timeTable = {
  "1": 600,
  "2": 500,
  "3": 400,
  "4": 300,
  "5": 200,
  "6": 100,
};

test run times such as this are seen, showing the concurrency is working --

[1]0--0.601
[2]0--0.502
[3]0.503--0.904
[4]0.608--0.908
[5]0.905--1.105
[6]0.905--1.005

Available as executable in the typescript playground sandbox

Answer 19

您可以将简单的传统用于这样的循环

for(let i = 0; i< products.length; i++){
    await <perform some action like database read>
}

Answer 20

但是，上述解决方案的两种解决方案都可以用更少的代码来完成这项工作，这是它如何帮助我从数据库，几个不同的儿童refs解决数据，然后将它们全部推入数组，然后将其置于诺言中，毕竟是完毕：

Promise.all(PacksList.map((pack)=>{
    return fireBaseRef.child(pack.folderPath).once('value',(snap)=>{
        snap.forEach( childSnap => {
            const file = childSnap.val()
            file.id = childSnap.key;
            allItems.push( file )
        })
    })
})).then(()=>store.dispatch( actions.allMockupItems(allItems)))

Answer 21

就像 @Bergi的回应一样，但有一个区别。

Promise.All 如果被拒绝，则拒绝所有承诺。

因此，使用递归。

const readFilesQueue = async (files, index = 0) {
    const contents = await fs.readFile(files[index], 'utf8')
    console.log(contents)

    return files.length <= index
        ? readFilesQueue(files, ++index)
        : files

}

const printFiles async = () => {
    const files = await getFilePaths();
    const printContents = await readFilesQueue(files)

    return printContents
}

printFiles()

ps

readfilesqueue 在 printfiles 之外导致副作用*由 console.log 引入，最好模拟，测试和或间谍因此，拥有返回内容的函数（Sidenote）并不酷。

因此，可以简单地设计代码：“纯” **的三个分离功能，并且不引入副作用，处理整个列表并可以轻松修改以处理失败的情况。

const files = await getFilesPath()

const printFile = async (file) => {
    const content = await fs.readFile(file, 'utf8')
    console.log(content)
}

const readFiles = async = (files, index = 0) => {
    await printFile(files[index])

    return files.lengh <= index
        ? readFiles(files, ++index)
        : files
}

readFiles(files)

未来编辑/当前状态

节点支持顶级等待（这还没有插件，还没有和可以通过Harmony标志启用），很酷，但不能解决一个问题（从策略上我仅在LTS版本上工作）。如何获取文件？

使用构图。鉴于代码，我的原因是它在模块内部，因此应该具有执行功能的函数。如果没有，则应使用IIFE将角色代码包装到异步函数中，创建简单的模块，该模块为您全部完成，或者可以采用正确的方式，有构图。

// more complex version with IIFE to a single module
(async (files) => readFiles(await files())(getFilesPath)

请注意，可变的名称由于语义而变化。您通过函数（可以通过另一个函数调用的函数），并在内存上收回一个指针，其中包含应用程序逻辑的初始块。

但是，如果不是模块，您需要导出逻辑？

将功能包裹在异步函数中。

export const readFilesQueue = async () => {
    // ... to code goes here
}

或更改变量的名称，无论如何...

---

* by Side效果Menans的应用程序效果可以更改应用程序中的雕像/行为或Intouce错误，例如IO。

** by“纯”，它在撇号中，因为函数不是纯净的，并且当没有控制台输出时，只有数据操作就可以将代码收集到纯版本。

除此之外，要纯粹，您需要使用处理副作用的单子，这些副作用容易出错，并分别处理该应用程序的错误。

Answer 22

目前 Array.forEach 原型属性不支持异步操作，但我们可以创建自己的 Poly-fill 来满足我们的需求。

// Example of asyncForEach Array poly-fill for NodeJs
// file: asyncForEach.js
// Define asynForEach function 
async function asyncForEach(iteratorFunction){
  let indexer = 0
  for(let data of this){
    await iteratorFunction(data, indexer)
    indexer++
  }
}
// Append it as an Array prototype property
Array.prototype.asyncForEach = asyncForEach
module.exports = {Array}

就是这样！现在，您可以在这些 to 操作之后定义的任何数组上使用 async forEach 方法。

让我们测试一下...

// Nodejs style
// file: someOtherFile.js

const readline = require('readline')
Array = require('./asyncForEach').Array
const log = console.log

// Create a stream interface
function createReader(options={prompt: '>'}){
  return readline.createInterface({
    input: process.stdin
    ,output: process.stdout
    ,prompt: options.prompt !== undefined ? options.prompt : '>'
  })
}
// Create a cli stream reader
async function getUserIn(question, options={prompt:'>'}){
  log(question)
  let reader = createReader(options)
  return new Promise((res)=>{
    reader.on('line', (answer)=>{
      process.stdout.cursorTo(0, 0)
      process.stdout.clearScreenDown()
      reader.close()
      res(answer)
    })
  })
}

let questions = [
  `What's your name`
  ,`What's your favorite programming language`
  ,`What's your favorite async function`
]
let responses = {}

async function getResponses(){
// Notice we have to prepend await before calling the async Array function
// in order for it to function as expected
  await questions.asyncForEach(async function(question, index){
    let answer = await getUserIn(question)
    responses[question] = answer
  })
}

async function main(){
  await getResponses()
  log(responses)
}
main()
// Should prompt user for an answer to each question and then 
// log each question and answer as an object to the terminal

我们可以对其他一些数组函数（例如map

async function asyncMap(iteratorFunction){
  let newMap = []
  let indexer = 0
  for(let data of this){
    newMap[indexer] = await iteratorFunction(data, indexer, this)
    indexer++
  }
  return newMap
}

Array.prototype.asyncMap = asyncMap

......等等）做同样的事情:)

需要注意的一些事情：

• 您的iteratorFunction必须是一个异步函数或promise
• 在<之前创建的任何数组代码>Array.prototype. = 将不提供此功能

Answer 23

今天我遇到了多种解决方案。在 forEach 循环中运行 async wait 函数。通过构建包装器，我们可以实现这一点。

有关其工作原理的更详细说明在内部，对于本机 forEach 以及为什么它无法进行异步函数调用，以及有关各种方法的其他详细信息，请在此处的链接中提供

的多种方式如下：

可以完成此操作 1：使用包装纸。

await (()=>{
     return new Promise((resolve,reject)=>{
       items.forEach(async (item,index)=>{
           try{
               await someAPICall();
           } catch(e) {
              console.log(e)
           }
           count++;
           if(index === items.length-1){
             resolve('Done')
           }
         });
     });
    })();

方法 2：使用与 Array.prototype 的泛型函​​数相同的方法

Array.prototype.forEachAsync.js

if(!Array.prototype.forEachAsync) {
    Array.prototype.forEachAsync = function (fn){
      return new Promise((resolve,reject)=>{
        this.forEach(async(item,index,array)=>{
            await fn(item,index,array);
            if(index === array.length-1){
                resolve('done');
            }
        })
      });
    };
  }

用法：

require('./Array.prototype.forEachAsync');

let count = 0;

let hello = async (items) => {

// Method 1 - Using the Array.prototype.forEach 

    await items.forEachAsync(async () => {
         try{
               await someAPICall();
           } catch(e) {
              console.log(e)
           }
        count++;
    });

    console.log("count = " + count);
}

someAPICall = () => {
    return new Promise((resolve, reject) => {
        setTimeout(() => {
            resolve("done") // or reject('error')
        }, 100);
    })
}

hello(['', '', '', '']); // hello([]) empty array is also be handled by default

方法 3：

使用 Promise.all

  await Promise.all(items.map(async (item) => {
        await someAPICall();
        count++;
    }));

    console.log("count = " + count);

方法 4：传统 for 循环或现代 for 循环

// Method 4 - using for loop directly

// 1. Using the modern for(.. in..) loop
   for(item in items){

        await someAPICall();
        count++;
    }

//2. Using the traditional for loop 

    for(let i=0;i<items.length;i++){

        await someAPICall();
        count++;
    }


    console.log("count = " + count);

Answer 24

要查看如何出错，请在方法末尾打印Console.log。

一般可能出错的事情：

• 任意顺序。
• PrintFiles可以在打印文件之前完成运行。
• 性能不佳。

这些并不总是错的，但在标准用例中经常是错误的。

通常，使用foreach将导致除最后一个。它将调用每个函数，而无需等待功能，这意味着它告诉所有功能启动，然后在不等待函数完成的情况下完成。

import fs from 'fs-promise'

async function printFiles () {
  const files = (await getFilePaths()).map(file => fs.readFile(file, 'utf8'))

  for(const file of files)
    console.log(await file)
}

printFiles()

这是本机JS中的一个示例，它将保留顺序，防止函数过早返回，从理论上讲，该功能保留了最佳性能。

这将：

• 启动所有文件读取的所有文件都在并行发生。
• 通过使用地图将文件名映射到保证等待的订单。
• 在数组定义的顺序中等待每个承诺。

使用此解决方案，第一个文件将在可用的情况下立即显示，而无需等待其他文件首先可用。

它还将同时加载所有文件，而不必等待第一个文件才能完成，才能启动第二个文件读取。

唯一的回报和原始版本是，如果一次启动了多个读数，那么由于有更多的错误可能发生的错误，因此很难处理错误。

使用一次读取文件的版本，然后将停止故障，而不会浪费时间尝试读取更多文件。即使有了精心设计的取消系统，也很难避免在第一个文件上失败，但也已经读取了其他大多数文件。

性能并非总是可以预见的。尽管许多系统将使用并行文件读取速度更快，但有些系统更喜欢顺序。有些是动态的，可能会在负载下转移，提供潜伏期的优化并不总是在重大争论下产生良好的吞吐量。

在该示例中也没有错误处理。如果某事要求它们成功地显示或根本不表现出来，则不会做到这一点。

在每个阶段，建议使用Console.Log进行深入的实验，然后假文件读取解决方案（而随机延迟）。尽管许多解决方案在简单的情况下似乎都具有相同的作用，所有解决方案都具有微妙的差异，需要进行一些额外的审查。

使用此模拟来帮助分辨解决方案之间的区别：

(async () => {
  const start = +new Date();
  const mock = () => {
    return {
      fs: {readFile: file => new Promise((resolve, reject) => {
        // Instead of this just make three files and try each timing arrangement.
        // IE, all same, [100, 200, 300], [300, 200, 100], [100, 300, 200], etc.
        const time = Math.round(100 + Math.random() * 4900);
        console.log(`Read of ${file} started at ${new Date() - start} and will take ${time}ms.`)
        setTimeout(() => {
          // Bonus material here if random reject instead.
          console.log(`Read of ${file} finished, resolving promise at ${new Date() - start}.`);
          resolve(file);
        }, time);
      })},
      console: {log: file => console.log(`Console Log of ${file} finished at ${new Date() - start}.`)},
      getFilePaths: () => ['A', 'B', 'C', 'D', 'E']
    };
  };

  const printFiles = (({fs, console, getFilePaths}) => {
    return async function() {
      const files = (await getFilePaths()).map(file => fs.readFile(file, 'utf8'));

      for(const file of files)
        console.log(await file);
    };
  })(mock());

  console.log(`Running at ${new Date() - start}`);
  await printFiles();
  console.log(`Finished running at ${new Date() - start}`);
})();

Answer 25

使用 Task、futurize 和可遍历列表，您可以简单地执行

async function printFiles() {
  const files = await getFiles();

  List(files).traverse( Task.of, f => readFile( f, 'utf-8'))
    .fork( console.error, console.log)
}

以下操作：这是您的设置方式

import fs from 'fs';
import { futurize } from 'futurize';
import Task from 'data.task';
import { List } from 'immutable-ext';

const future = futurizeP(Task)
const readFile = future(fs.readFile)

另一种构建所需代码的方法是

const printFiles = files => 
  List(files).traverse( Task.of, fn => readFile( fn, 'utf-8'))
    .fork( console.error, console.log)

或者甚至更面向功能

// 90% of encodings are utf-8, making that use case super easy is prudent

// handy-library.js
export const readFile = f =>
  future(fs.readFile)( f, 'utf-8' )

export const arrayToTaskList = list => taskFn => 
  List(files).traverse( Task.of, taskFn ) 

export const readFiles = files =>
  arrayToTaskList( files, readFile )

export const printFiles = files => 
  readFiles(files).fork( console.error, console.log)

然后从父函数开始

async function main() {
  /* awesome code with side-effects before */
  printFiles( await getFiles() );
  /* awesome code with side-effects after */
}

如果您确实想要更大的灵活性在编码中，你可以这样做（为了好玩，我正在使用建议的 Pipe Forward运算符 )

import { curry, flip } from 'ramda'

export const readFile = fs.readFile 
  |> future,
  |> curry,
  |> flip

export const readFileUtf8 = readFile('utf-8')

PS - 我没有在控制台上尝试此代码，可能有一些拼写错误...“直接自由泳，离开圆顶顶部！”正如90后的孩子们会说的。 :-p

Answer 26

正如其他答案所提到的，您可能希望它按顺序而不是并行执行。 IE。运行第一个文件，等待它完成，然后完成后运行第二个文件。那不会发生什么。

我认为解决为什么这种情况没有发生很重要。

想想 forEach 是如何工作的。我找不到源代码，但我认为它的工作原理是这样的：

const forEach = (arr, cb) => {
  for (let i = 0; i < arr.length; i++) {
    cb(arr[i]);
  }
};

现在想想当你执行这样的操作时会发生什么：

forEach(files, async logFile(file) {
  const contents = await fs.readFile(file, 'utf8');
  console.log(contents);
});

在 forEach 的 for 循环中，我们正在调用 cb(arr[i])，最终成为 logFile(file)。 logFile 函数内部有一个 await，因此 for 循环可能会在继续之前等待这个 await i++？

不，不会的。令人困惑的是，这并不是 await 的工作原理。来自文档：

await 分割执行流程，允许异步函数的调用者恢复执行。在等待推迟异步函数的继续之后，随后执行后续语句。如果此等待是其函数执行的最后一个表达式，则通过向函数的调用者返回一个待完成的 Promise 来继续执行等待的函数并恢复该调用者的执行。

因此，如果您有以下内容，则不会在 "b" 之前记录数字：

const delay = (ms) => {
  return new Promise((resolve) => {
    setTimeout(resolve, ms);
  });
};

const logNumbers = async () => {
  console.log(1);
  await delay(2000);
  console.log(2);
  await delay(2000);
  console.log(3);
};

const main = () => {
  console.log("a");
  logNumbers();
  console.log("b");
};

main();

循环回到 forEach，forEach 就像 >main 和 logFile 就像 logNumbers 一样。 main 不会仅仅因为 logNumbers 做了一些 await 操作而停止，并且 forEach 不会仅仅因为 logNumbers 停止 < code>logFile 做了一些await操作。

Answer 27

类似于Antonio Val的 p-titeration ，替代NPM模块是 async-af ：

const AsyncAF = require('async-af');
const fs = require('fs-promise');

function printFiles() {
  // since AsyncAF accepts promises or non-promises, there's no need to await here
  const files = getFilePaths();

  AsyncAF(files).forEach(async file => {
    const contents = await fs.readFile(file, 'utf8');
    console.log(contents);
  });
}

printFiles();

or async-af 具有静态方法（log/logaf），可log ：

const AsyncAF = require('async-af');
const fs = require('fs-promise');

function printFiles() {
  const files = getFilePaths();

  AsyncAF(files).forEach(file => {
    AsyncAF.log(fs.readFile(file, 'utf8'));
  });
}

printFiles();

但是，库的主要优点是您可以链接异步方法来执行以下操作：

const aaf = require('async-af');
const fs = require('fs-promise');

const printFiles = () => aaf(getFilePaths())
  .map(file => fs.readFile(file, 'utf8'))
  .forEach(file => aaf.log(file));

printFiles();

> > ASYNC-AF

Answer 28

这是在 forEach 循环中使用异步的一个很好的例子。

编写自己的asyncForEach

async function asyncForEach(array, callback) {  
    for (let index = 0; index < array.length; index++) {
        await callback(array[index], index, array)
    }
}

你可以像这样使用它

await asyncForEach(array, async function(item,index,array){
     //await here
   }
)

Answer 29

如果您想同时迭代所有元素：

async function asyncForEach(arr, fn) {
  await Promise.all(arr.map(fn));
}

如果您想非同时迭代所有元素（例如，当您的映射函数有副作用或一次在所有数组元素上运行映射器将过于耗费资源）：

选项 A：Promise

function asyncForEachStrict(arr, fn) {
  return new Promise((resolve) => {
    arr.reduce(
      (promise, cur, idx) => promise
        .then(() => fn(cur, idx, arr)),
      Promise.resolve(),
    ).then(() => resolve());
  });
}

选项 B：异步/等待

async function asyncForEachStrict(arr, fn) {
  for (let idx = 0; idx < arr.length; idx += 1) {
    const cur = arr[idx];

    await fn(cur, idx, arr);
  }
}

Answer 30

的包装器

• 对于打字稿用户，a Promise.all（array.map（iterator））使用 Promise.all（array.map（iterator））具有正确类型 ，因为打字稿的STDLIB支持已经处理通用。
• 但是，复制粘贴 promise.all（array.map（iterator））每次需要async映射显然是次优的， promise.all（array.map（iterator））不能很好地传达代码的意图 - 因此，大多数开发人员都会将其包装到 asyncmap（）包装器函数中。但是，这样做需要使用仿制药来确保以 start value设置的值=等待asyncmap（）具有正确的类型。

export const asyncMap = async <ArrayItemType, IteratorReturnType>(
  array: Array<ArrayItemType>,
  iterator: (
    value: ArrayItemType,
    index?: number
  ) => Promise<IteratorReturnType>
): Promise<Array<IteratorReturnType>> => {
  return Promise.all(array.map(iterator));
};

和快速测试：

it(`runs 3 items in parallel and returns results`, async () => {
  const result = await asyncMap([1, 2, 3], async (item: number) => {
    await sleep(item * 100);
    return `Finished ${item}`;
  });
  expect(result.length).toEqual(3);
  // Each item takes 100, 200 and 300ms
  // So restricting this test to 300ms plus some leeway
}, 320);

sleep（）只是：

const sleep = async (timeInMs: number): Promise<void> => {
  return new Promise((resolve) => setTimeout(resolve, timeInMs));
};