Verwenden von async/erwarten innen für Schleife

Question

Wie kann ich Async/erwarten innerhalb einer for-Schleife?

Dies ist mein Code:

export default (req, callback) => { 
    // ... 
    compliance.forEach((rule, index) => { 
    let response = await waRuleOverview(req, run.id, rule.id); 
    // handle the response 
    }); 
} 

Dies ist, wie ich die waRuleOverview Funktion definieren:

export function waRuleOverview(req, runId, ruleId) { 
    var def = deferred(); 

    setTimeout(function() { 
    const apiToken = req.currentUser.apiToken; 
    const payload = { 
     'Authorization': 'api_key ' + apiToken 
    } 

    const options = { 
     'method': 'get', 
     'gzip': true, 
     'headers': payload, 
     'content-type': 'application/json', 
     'json': true, 
     'url': 'api-url' 
    } 

    request(options, (error, response, body) => { 
     def.resolve(body); 
    }); 
    }, 50); 

    return def.promise; 
} 

Es wirft diesen Fehler in der Konsole:

erwarten ein reserviert Wort

Diese Frage bezieht sich auf this die ich versuche herauszufinden, wie man es löst.

Answer 1

Es hängt davon ab, wie Ihr asynchroner Code ausgeführt werden soll: sequenziell oder parallel. Wie auch immer, Sie müssten async Stichwort hinzufügen, um await zu verwenden.

// sequential 
export default async (req, callback) => { 
    // ... 
    for(const [rule, index] of compliance.entries()) { 
    const response = await waRuleOverview(req, run.id, rule.id) 

    // handle the response 
    } 
} 

// parallel 
export default async (req, callback) => { 
    // ... 
    const responses = await Promise.all(compliance 
    .map((rule, index) => waRuleOverview(req, run.id, rule.id)) 
) 

    // handle responses 
    responses.forEach(response => { 
    // ... 
    // handle response here 
    }) 
} 

Und schließlich, wenn Sie nicht wirklich wollen, um Ihre Handler ein Versprechen zurück, sondern wollen nur es einige async Aktionen für Nebenwirkungen durchzuführen.

Aber dieser Ansatz ist eigentlich ein Anti-Pattern, da es die Versprechen-Ketten bricht: schlecht für die Zusammensetzbarkeit, Fehlerbehandlung und so.