Использование async / await с циклом forEach

Конечно, код работает, но я почти уверен, что он не делает то, что вы ожидаете. Он просто запускает несколько асинхронных вызовов, но функция printFiles сразу же возвращается после этого.

Чтение по порядку

Если вы хотите читать файлы последовательно, вы действительно не можете использовать forEach. Просто используйте вместо этого современный for … of цикл, в котором await будет работать должным образом:

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

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

Чтение параллельно

Если вы хотите читать файлы параллельно, вы действительно не можете использовать forEach. Каждый из вызовов функции обратного вызова 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)
  }));
}

С ES2018 вы можете значительно упростить все вышеперечисленные ответы на следующие вопросы:

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

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

См. Спецификацию: Предложение-асинхронная-итерация

2018-09-10: этот ответ в последнее время привлекает много внимания, см. Axel Сообщение в блоге Раушмайера для получения дополнительной информации об асинхронной итерации.

Вместо 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());
}

Модуль p-iteration в npm реализует методы итерации массива, поэтому их можно использовать в очень простых путь с async / await.

Пример с вашим случаем:

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);
  });
})();

Вот несколько forEachAsync прототипов. Обратите внимание, что вам нужно await их:

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));
}

Примечание, хотя вы можете включить это в свой собственный код, вам не следует включать это в библиотеки, которые вы распространяете другим (чтобы не загрязнять их глобальные файлы).

В дополнение к ответу @ 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. Однако в моем методе, описанном выше, вам гарантируется, что консоль будет регистрировать файлы в том же порядке, что и предоставленный массив.

довольно безболезненно добавить в файл пару методов, которые будут обрабатывать асинхронные данные в сериализованном порядке и придадут более традиционный вид вашему коду. Например:

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));
}

Это решение также оптимизировано для памяти, поэтому вы можете запускать его для 10 000 элементов данных и запросов. Некоторые другие решения приведут к сбою сервера при работе с большими наборами данных.

В TypeScript:

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

Как пользоваться?

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

Решение Берги прекрасно работает, когда fs основано на обещаниях. Вы можете использовать для этого 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

Оба решения выше работают, однако Антонио выполняет работу с меньшим количеством кода, вот как это помогло мне разрешить данные из моей базы данных из нескольких разных дочерних ссылок, а затем поместить их все в массив и разрешить его в обещании, в конце концов, сделано:

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)))

Картинка объемом 1000 слов - только для последовательного подхода

Предыстория. Прошлой ночью я был в похожей ситуации. Я использовал асинхронную функцию в качестве аргумента foreach. Результат был непредсказуемым. Когда я 3 раза тестировал свой код, он 2 раза работал без проблем и 1 раз не удался. (что-то странное)

Наконец я собрался с мыслями и провел несколько тестов с блокнотом.

Сценарий 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, как предложено выше @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();

Если вы немного олдскульный, как я, вы можете просто использовать классический цикл for, который тоже работает :)

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();

Надеюсь, это кому-то поможет, добрый день, ура!

Одно важное предостережение: метод await + for .. of и метод forEach + async на самом деле имеют разный эффект.

Наличие await внутри реального for цикла гарантирует, что все асинхронные вызовы выполняются один за другим. И способ forEach + async запустит все обещания одновременно, что быстрее, но иногда перегружает (если вы выполняете какой-либо запрос к БД или посещаете некоторые веб-службы с ограничениями по объему и не хотите отправлять 100 000 вызовов вовремя).

Вы также можете использовать reduce + promise (менее элегантно), если вы не используете async/await и хотите, чтобы файлы читались один за другим.

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

Или вы можете создать forEachAsync, чтобы помочь, но в основном использовать то же самое для цикла, лежащего в основе.

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

Просто добавив к исходному ответу

• Синтаксис параллельного чтения в исходном ответе иногда сбивает с толку и труден для чтения, возможно, мы можем написать его другим подходом.

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);
  }
}

Как ответ @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, лучше высмеивать, тестировать или шпионить, поэтому не круто иметь функцию, которая возвращает содержимое (примечание).

Следовательно, код может быть просто спроектирован таким образом: три отдельные функции, которые являются «чистыми» ** и не вызывают побочных эффектов, обрабатывают весь список и могут быть легко изменены для обработки неудачных случаев.

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)

Будущее изменение / текущее состояние

Узел поддерживает ожидание верхнего уровня (у него еще нет плагина, его не будет и его можно включить с помощью флагов гармонии), это круто, но не решает одну проблему (стратегически я работаю только над 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
}

Или поменять имена переменных, как угодно ...

* побочным эффектом означает любой совместный эффект приложения, который может изменить статус / поведение или вызвать ошибки в приложении, такие как ввод-вывод.

** "чистым", это апостроф, так как функции не чистые, и код может быть преобразован в чистую версию, когда нет вывода на консоль, только манипуляции с данными.

Помимо этого, чтобы быть чистым, вам нужно будет работать с монадами, которые обрабатывают побочные эффекты, подвержены ошибкам и обрабатывают эту ошибку отдельно от приложения.

Простое решение для замены неработающего цикла ожидания forEach() - замена forEach на map и добавление Promise.all( в начало.

Например:

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

to

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

В конце нужен дополнительный ).

Нецелесообразно вызывать асинхронный метод из цикла. Это связано с тем, что каждая итерация цикла будет откладываться до завершения всей асинхронной операции. Это не очень эффективно. Это также предотвращает преимущества распараллеливания _1 _ / _ 2_.

Лучшим решением было бы создать все обещания сразу, а затем получить доступ к результатам с помощью 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);
}

Используя Task, Futurize и Traversable List, вы можете просто сделать

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 */
}

Если вам действительно нужна большая гибкость в кодировании, вы можете просто сделать это (для удовольствия, я использую предлагаемый Оператор прямой переадресации)

import { curry, flip } from 'ramda'

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

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

PS - Я не пробовал этот код на консоли, могут быть опечатки ... "прямой фристайл, с вершины купола!" как сказали бы дети 90-х. :-п

В настоящее время свойство прототипа Array.forEach не поддерживает асинхронные операции, но мы можем создать нашу собственную поли-заливку в соответствии с нашими потребностями.

// 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}

Вот и все! Теперь у вас есть метод 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 должна быть асинхронной функцией или обещанием
• Для массивов, созданных до Array.prototype.<yourAsyncFunc> = <yourAsyncFunc>, эта функция недоступна.

Сегодня я нашел для этого несколько решений. Запуск функций async await в цикле forEach Loop. Создавая оболочку вокруг, мы можем добиться этого.

Более подробное объяснение того, как это работает внутренне, для собственного 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);

Вы можете использовать Array.prototype.forEach, но async / await несовместимы. Это связано с тем, что обещание, возвращаемое из асинхронного обратного вызова, ожидает разрешения, но Array.prototype.forEach не разрешает никаких обещаний из выполнения своего обратного вызова. Итак, вы можете использовать forEach, но вам придется самостоятельно обрабатывать разрешение обещаний.

Вот способ читать и распечатывать каждый файл последовательно, используя Array.prototype.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)
}

Чтобы увидеть, как это может пойти не так, напечатайте 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, который сохранит порядок, предотвратит преждевременный возврат функции и теоретически сохранит оптимальную производительность.

Это будет:

• Инициируйте параллельное чтение всех файлов.
• Сохраняйте порядок с помощью map для сопоставления имен файлов с обещаниями, которых нужно ждать.
• Дождитесь каждого обещания в порядке, определенном массивом.

С помощью этого решения первый файл будет отображаться, как только он станет доступен, не дожидаясь, пока сначала станут доступны другие.

Он также будет загружать все файлы одновременно, вместо того, чтобы ждать завершения первого, прежде чем можно будет начать чтение второго файла.

Единственный недостаток этого и исходной версии заключается в том, что если одновременно запускается несколько операций чтения, то обрабатывать ошибки труднее из-за того, что за один раз может произойти больше ошибок.

В версиях, которые читают файл за раз, тогда остановится в случае сбоя, не тратя время на попытки прочитать другие файлы. Даже с тщательно продуманной системой отмены может быть трудно избежать сбоя в первом файле, но уже при чтении большинства других файлов.

Производительность не всегда предсказуема. Хотя многие системы будут работать быстрее с параллельным чтением файлов, некоторые предпочтут последовательное. Некоторые из них являются динамическими и могут смещаться под нагрузкой. Оптимизация, предполагающая задержку, не всегда обеспечивает хорошую пропускную способность в условиях сильной конкуренции.

В этом примере также нет обработки ошибок. Если что-то требует, чтобы они были либо успешно показаны, либо не показывались вообще, этого не произойдет.

Рекомендуется поэкспериментировать с 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}`);
})();

Вот отличный пример использования async в цикле 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
   }
)

Подобно p-iteration Антонио Вала, альтернативным модулем npm является _ 2_:

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();

В качестве альтернативы async-af имеет статический метод (log / logAF), который регистрирует результаты. обещаний:

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

Как уже упоминалось в других ответах, вы, вероятно, хотите, чтобы он выполнялся последовательно, а не параллельно. Т.е. запустить для первого файла, дождаться завершения, затем, когда он будет завершен, запустить для второго файла. Этого не случится.

Я думаю, что важно выяснить, почему этого не происходит.

Подумайте, как работает 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 работает не так. Из документов:

Ожидание разделяет поток выполнения, позволяя вызывающей асинхронной функции возобновить выполнение. После того, как ожидание откладывает продолжение асинхронной функции, следует выполнение последующих операторов. Если это ожидание является последним выражением, выполненным его функцией, выполнение продолжается, возвращая вызывающей функции ожидающее обещание для завершения функции ожидания и возобновляя выполнение этого вызывающего.

Таким образом, если у вас есть следующее, номера не будут регистрироваться до "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 сделает какое-то awaiting, а forEach не остановится только потому, что logFile сделает какое-то await.

Если вы хотите перебирать все элементы одновременно:

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

Если вы хотите перебирать все элементы одновременно (например, когда ваша функция сопоставления имеет побочные эффекты или запуск сопоставителя сразу для всех элементов массива был бы слишком затратным по ресурсам):

Вариант А. Обещания

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

Вариант Б: асинхронный / ожидание

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

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

exports.getTat = async function () {
  for (const tatfcp of resp[0]) {
    const getProductResponcekey = params.pincode + '-' + tatfcp.productid + '-' + result[tatfcp.productid].reqQty + '-' + tatfcp.groups[0].dispatchwarehouseid;
    const redisResp = await redis.getRedis(getProductResponcekey);
    if (redisResp) {
      products.push(redisResp[0]);
      console.log('redis', redisResp[0]);
    } else {
      const getProductResponceData = await getProductResponce(resp[1], resp[2], params.pincode, tatfcp, data[1], data[2], data[8], gstandvendordata[1], data[9]);
      products.push(getProductResponceData);
      redis.setRedis(getProductResponcekey, getProductResponceData, config.redis.expiryTime1Day);
    }
  }
};

Это мое решение

Я бы использовал хорошо протестированные (миллионы загрузок в неделю) pify и async модули. Если вы не знакомы с асинхронным модулем, я настоятельно рекомендую вам ознакомиться с его документами. Я видел, как несколько разработчиков тратят время на воссоздание своих методов или, что еще хуже, на создание сложного в обслуживании асинхронного кода, когда асинхронные методы более высокого порядка упрощают код.

const async = require('async')
const fs = require('fs-promise')
const pify = require('pify')

async function getFilePaths() {
    return Promise.resolve([
        './package.json',
        './package-lock.json',
    ]);
}

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

  await pify(async.eachSeries)(files, async (file) => {  // <-- run in series
  // await pify(async.each)(files, async (file) => {  // <-- run in parallel
    const contents = await fs.readFile(file, 'utf8')
    console.log(contents)
  })
  console.log('HAMBONE')
}

printFiles().then(() => {
    console.log('HAMBUNNY')
})
// ORDER OF LOGS:
// package.json contents
// package-lock.json contents
// HAMBONE
// HAMBUNNY
```