Mit async/await-mit einer forEach-Schleife

Sicher, dass der code funktioniert, aber ich bin mir ziemlich sicher, dass es nicht das tun, was Sie erwarten, es zu tun. Es ist einfach feuert mehrere asynchrone Aufrufe, aber die printFiles Funktion nicht sofort zurück nach.

Wenn Sie möchten, Lesen Sie die Dateien in der Reihenfolge, Sie nicht verwenden forEach in der Tat. Nur mit einem modernen for … of Schleife statt, in denen await funktioniert wie erwartet:

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

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

Wenn Sie wollen, um die Dateien Lesen, die in parallel, Sie nicht verwenden forEach in der Tat. Jeder der async callback-Funktion ruft nicht zurück ein Versprechen, aber Sie werfen Sie Weg, anstatt auf Sie warten. Verwenden Sie einfach map statt, und Sie können erwarten, die das array von Versprechungen, die Sie erhalten mit 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)
  }));
}

InformationsquelleAutor Bergi

Statt Promise.all in Verbindung mit Array.prototype.map (die keine Garantie für die Reihenfolge, in der die Promises behoben sind), benutze ich Array.prototype.reduce, beginnend mit einer abgeschlossenen 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());
}

InformationsquelleAutor Timothy Zorn

Hier sind einige forEachAsync Prototypen. Hinweis: Sie müssen await Sie:

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

Hinweis, während Sie können diese in Ihrem eigenen code, sollten Sie nicht diese in Bibliotheken verteilen Sie an andere (um zu vermeiden verschmutzen Ihre globals).

InformationsquelleAutor Matt

es ist ziemlich schmerzlos zu pop ein paar Methoden in eine Datei verarbeiten asynchroner Daten in serialisierter Ordnung und geben einem eher konventionellen Geschmack, um Ihren code. Zum Beispiel:

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

nun, vorausgesetzt, die gespeichert bei './myAsync.js' Sie können tun, etwas ähnliches wie die unten in einem angrenzenden Datei:

...
/* 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));
}

InformationsquelleAutor Jay Edwards

Durch die Aufgabe, futurize und eine begehbare Liste, können Sie einfach tun

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

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

Hier ist, wie würden Sie diese Einrichtung,

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)

Anderen Weg, um strukturiert den gewünschten code wäre

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

Oder vielleicht sogar mehr funktional orientierte

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

Dann von der übergeordneten Funktion

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

Wenn Sie wirklich wollten, mehr Flexibilität bei der Codierung, können Sie einfach diesen (für Spaß, ich bin mit den vorgeschlagenen Rohr-Forward-operator )

import { curry, flip } from 'ramda'

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

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

PS - ich habe nicht versucht, diesen code auf der Konsole, vielleicht haben einige Tippfehler... "straight freestyle, aus der Spitze der Kuppel!", als die 90er-Jahre Kinder sagen würden. :-p

InformationsquelleAutor Babakness

Derzeit das Array.forEach prototype-Eigenschaft nicht unterstützt asynchrone Operationen, aber wir können unsere eigene poly-fill für unsere Bedürfnisse.

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

Und das ist es! Sie haben jetzt eine asynchrone forEach-Methode zur Verfügung, die auf beliebige arrays definiert sind, die nach diesen Operationen.

Let ' s test...

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

Könnten wir das gleiche tun für einige andere array-Funktionen wie 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

... und so weiter 🙂

Einige Dinge zu beachten:

• Ihre iteratorFunction muss eine async-Funktion oder Versprechen
• Alle arrays erstellt, bevor Array.prototype.<yourAsyncFunc> = <yourAsyncFunc> verfügen nicht über diese Funktion zur Verfügung

InformationsquelleAutor Beau

Bergi ' s Lösung funktioniert gut, wenn fs ist Versprechen basiert.
Sie können bluebird, fs-extra oder fs-promise.

Jedoch die Lösung für Knoten nativen fs Bibliothek ist wie folgt:

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

Hinweis:
require('fs') zwangsweise nimmt die Funktion als 3. Argumente, sonst wirft Fehler:

TypeError [ERR_INVALID_CALLBACK]: Callback must be a function

InformationsquelleAutor myDoggyWritesCode