Ich verwende die async.eachLimit
Funktion, um die maximale Anzahl von Operationen gleichzeitig zu steuern.
const { eachLimit } = require("async");
function myFunction() {
return new Promise(async (resolve, reject) => {
eachLimit((await getAsyncArray), 500, (item, callback) => {
// do other things that use native promises.
}, (error) => {
if (error) return reject(error);
// resolve here passing the next value.
});
});
}
Wie Sie sehen, kann ich die myFunction
Funktion nicht als asynchron deklarieren, da ich im zweiten Rückruf der eachLimit
Funktion keinen Zugriff auf den Wert habe .
javascript
node.js
asynchronous
async-await
Alexis Tyler
quelle
quelle
Antworten:
Sie verwenden Versprechen effektiv innerhalb der Executor-Konstruktor-Executor-Funktion, also das Anti-Muster des Promise-Konstruktors .
Ihr Code ist ein gutes Beispiel für das Hauptrisiko: Nicht alle Fehler sicher zu verbreiten. Lesen Sie warum dort .
Darüber hinaus kann die Verwendung von
async
/await
die gleichen Fallen noch überraschender machen. Vergleichen Sie:let p = new Promise(resolve => { ""(); // TypeError resolve(); }); (async () => { await p; })().catch(e => console.log("Caught: " + e)); // Catches it.
mit einem naiven (falschen)
async
Äquivalent:let p = new Promise(async resolve => { ""(); // TypeError resolve(); }); (async () => { await p; })().catch(e => console.log("Caught: " + e)); // Doesn't catch it!
Suchen Sie in der Webkonsole Ihres Browsers nach der letzten.
Die erste funktioniert, weil jede unmittelbare Ausnahme in einer Promise-Konstruktor-Executor-Funktion das neu erstellte Versprechen bequem ablehnt (aber in jeder, die
.then
Sie alleine sind).Die zweite Funktion funktioniert nicht, da jede unmittelbare Ausnahme in einer
async
Funktion das implizite Versprechenasync
ablehnt, das von der Funktion selbst zurückgegeben wird .Da der Rückgabewert einer Versprechen-Konstruktor-Executor-Funktion nicht verwendet wird, sind das schlechte Nachrichten!
Dein Code
Es gibt keinen Grund, den Sie nicht definieren können
myFunction
alsasync
:async function myFunction() { let array = await getAsyncArray(); return new Promise((resolve, reject) => { eachLimit(array, 500, (item, callback) => { // do other things that use native promises. }, error => { if (error) return reject(error); // resolve here passing the next value. }); }); }
Aber warum sollten Sie veraltete Parallelitätskontrollbibliotheken verwenden, wenn Sie haben
await
?quelle
return await
:return new Promise
ist ausreichend.Ich stimme den oben gegebenen Antworten zu und trotzdem ist es manchmal besser, Asynchronität in Ihrem Versprechen zu haben, besonders wenn Sie mehrere Operationen verketten möchten, die Versprechen zurückgeben, und die
then().then()
Hölle vermeiden möchten . Ich würde in Betracht ziehen, in dieser Situation so etwas zu verwenden:const operation1 = Promise.resolve(5) const operation2 = Promise.resolve(15) const publishResult = () => Promise.reject(`Can't publish`) let p = new Promise((resolve, reject) => { (async () => { try { const op1 = await operation1; const op2 = await operation2; if (op2 == null) { throw new Error('Validation error'); } const res = op1 + op2; const result = await publishResult(res); resolve(result) } catch (err) { reject(err) } })() }); (async () => { await p; })().catch(e => console.log("Caught: " + e));
Promise
Konstruktor übergebene Funktion ist nicht asynchron, sodass Linters keine Fehler anzeigen.await
.Ein Nachteil ist jedoch, dass Sie sich daran erinnern müssen,
try/catch
es anzubringen und anzubringenreject
.quelle
static getPosts(){ return new Promise( (resolve, reject) =>{ try { const res = axios.get(url); const data = res.data; resolve( data.map(post => ({ ...post, createdAt: new Date(post.createdAt) })) ) } catch (err) { reject(err); } }) }
entfernen warten und asynchron wird dieses Problem lösen. Da Sie das Promise-Objekt angewendet haben, reicht dies aus.
quelle
axios.get(url)
Funktioniert in Ihrem Beispiel also so, als ob es so heißtawait axios.get(url)
?