Lösen Sie das Problem, dass await in forEach nicht funktioniert

const _ = erfordern('lodash');
const echo = async (i) => {
  setzeTimeout(() => {
    Konsole.log('i===>', i);
  }, 5000);
}
sei arrs = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
const task = async () => {
  _.forEach(arrs, async (i) => {
    warte auf Echo(i);
  })
}
const run = async () => {
  Konsole.log('run-start====>date:', neues Date().toLocaleDateString())
  warte auf Aufgabe();
  Konsole.log('run-end====>date:', neues Date().toLocaleDateString())
}
(asynchron () => {
  console.log('starten...')
  warte auf Ausführung();
  console.log('Ende ...')
})()
// Start...
// Lauf-Start====>Datum: 25.08.2018
// Laufende====>Datum: 25.08.2018
// Ende...
// ich ===> 1
// ich ===> 2
// ich ===> 3
// ich ===> 4
// ich ===> 5
// ich ===> 6
// ich ===> 7
// ich ===> 8
// ich ===> 9

const _ = erfordern('lodash');
const echo = async (i) => {
  returniere neues Promise((lösen,ablehnen)=>{
    setzeTimeout(() => {
      console.log('i===>', i, neues Date().toLocaleTimeString());
      Entschlossenheit (i);
    }, 2000);
  })
}
sei arrs = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
const task = async () => {
  // _.forEach(arrs, async (i) => {
  // warte auf echo(ji);
  // })
  // arrs.forEach(async (i)=> {
  // warte auf echo(i);
  // });
  für (const i von arrs) {
    warte auf Echo(i);
  }
}
const run = async () => {
  Konsole.log('run-start====>date:', neues Date().toLocaleDateString())
  warte auf Aufgabe();
  Konsole.log('run-end====>date:', neues Date().toLocaleDateString())
}
(asynchron () => {
  console.log('starten...')
  warte auf Ausführung();
  console.log('Ende ...')
})()
// Ausgabe starten...
Lauf-Start====>Datum: 26.8.2018
ich===> 1 20:51:29
ich===> 2 20:51:31
ich===> 3 20:51:33
ich===> 4 20:51:35
ich===> 5 20:51:37
ich===> 6 20:51:39
ich===> 7 20:51:42
ich===> 8 20:51:44
ich===> 9 20:51:46
ich===> 10 20:51:48
Laufende====>Datum: 26.8.2018
Ende...

// Daten generieren const getNumbers = () => {
 returniere Promise.resolve([1, 2, 3])
}
// Asynchrone Verarbeitung const doMulti = num => {
 returniere neues Promise((lösen, ablehnen) => {
  setzeTimeout(() => {
   wenn (Zahl) {
    auflösen(Zahl * Zahl)
   } anders {
    ablehnen(neuer Fehler('Nummer nicht angegeben'))
   }
  }, 2000)
 })
}
// Hauptfunktion const main = async () => {
 Konsole.log('Start');
 Konstantennummern = [1, 2, 3];
 nums.forEach(async (x) => {
  const res = warte auf doMulti(x);
  konsole.log(res);
 });
 konsole.log('Ende');
};
// main() ausführen;

const main = async () => {
 Konsole.log('Start');
 const nums = warte auf getNumbers();
 für (const x von Nums) {
  const res = warte auf doMulti(x);
  konsole.log(res);
 }
 konsole.log('Ende');
};

// Produktionsschritte von ECMA-262, Ausgabe 5, 15.4.4.18
// Referenz: http://es5.github.io/#x15.4.4.18
wenn (!Array.prototype.forEach) {
 Array.prototype.forEach = Funktion(Rückruf, diesesArg) {
  var T, k;
  wenn (dies == null) {
   throw new TypeError('dies ist null oder nicht definiert');
  }
  // 1. O sei das Ergebnis des Aufrufs von toObject() und übergibt die
  // |diesen| Wert als Argument.
  var O = Objekt(dieses);
  // 2. Lassen Sie lenValue das Ergebnis des Aufrufs von Get() internal sein.
  // Methode von O mit dem Argument „Länge“.
  // 3. Lass len toUint32(lenValue) sein.
  var len = O.Länge >>> 0;
  // 4. Wenn isCallable(callback) false ist, werfen Sie eine TypeError-Ausnahme. 
  // Siehe: http://es5.github.com/#x9.11
  wenn (Typ des Rückrufs !== "Funktion") {
   throw new TypeError(callback + ' ist keine Funktion');
  }
  // 5. Wenn thisArg angegeben wurde, lass T thisArg sein; sonst lass
  // T ist nicht definiert.
  if (Argumente.Länge > 1) {
   T = diesesArg;
  }
  // 6. Sei k 0
  k = 0;
  // 7. Wiederholen, solange k < len
  während (k < Länge) {
   var kWert;
   // a. Lassen Sie Pk ToString(k) sein.
   // Dies ist implizit für LHS-Operanden des in-Operators
   // b. Lassen Sie kPresent das Ergebnis des Aufrufs von HasProperty sein
   // interne Methode von O mit Argument Pk.
   // Dieser Schritt kann mit c kombiniert werden
   // c. Wenn kPresent wahr ist, dann
   wenn (k in O) {
    // i. Lassen Sie kValue das Ergebnis des Aufrufs von Get internal sein.
    // Methode von O mit Argument Pk.
    kWert = O[k];
    // ii. Rufen Sie die interne Callback-Methode mit T als
    // dieser Wert und die Argumentliste, die kValue, k und O enthält.
    Rückruf.call(T, kValue, k, O);
   }
   // d. Erhöhe k um 1.
   k++;
  }
  // 8. Rückgabe undefiniert
 };
}

Array.prototype.forEach = Funktion (Rückruf) {
 // dies stellt unser Array dar
 für (let index = 0; index < this.length; index++) {
  // Wir rufen den Callback für jeden Eintrag auf
  Rückruf(dies[Index], Index, dies);
 };
};

const main = async () => {
 Konsole.log('Start');
 const nums = warte auf getNumbers();
 // nums.forEach(async (x) => {
 // const res = warte auf doMulti(x);
 // konsole.log(res);
 // });
 für (let index = 0; index < nums.length; index++) {
  (async x => {
   const res = warte auf doMulti(x)
   Konsole.log(res)
  })(Zahlen[Index])
 }
 konsole.log('Ende');
};

const asyncForEach = async (Array, Rückruf) => {
 für (let index = 0; index < array.length; index++) {
  warte auf Rückruf (Array[Index], Index, Array);
 }
}
const main = async () => {
 Konsole.log('Start');
 const nums = warte auf getNumbers();
 warte auf asyncForEach(nums, async x => {
  const res = warte auf doMulti(x)
  Konsole.log(res)
 })
 konsole.log('Ende');
};
hauptsächlich();

asynchrone Funktion foo(Dinge) {
 const Ergebnisse = [];
 für (const Ding von Dingen) {
  // Gut: Alle asynchronen Operationen werden sofort gestartet.
  Ergebnisse.push(Bar(Ding));
 }
 // Da nun alle asynchronen Vorgänge ausgeführt werden, warten wir hier, bis sie alle abgeschlossen sind.
 returniere baz(warte auf Promise.all(Ergebnisse));
}

asynchrone Funktion foo(Dinge) {
 const Ergebnisse = [];
 für (const Ding von Dingen) {
  // Schlecht: jede Schleifeniteration wird verzögert, bis der gesamte asynchrone Vorgang abgeschlossen ist
  Ergebnisse.push(warte auf Balken(Ding));
 }
 gib baz(Ergebnisse) zurück;
}