effiziente Verwendung von async/erwarten

Question

Ich weiß, await in Schleifen wird dringend abgeraten. Aber ich stecke in einem bestimmten Fall fest, ich kann nicht herausfinden, wie man es effizient macht. Ich möchte eine endgültige Ausgabe variabler values wie diese

{ 
    jobId1: [[..], [..], [..], [..]], 
    jobId2: [[..], [..], [..], [..]] // list goes on 
} 

Das unten Snippet meiner aktuellen Implementierung darstellen.

for (let jb of jobList) { 
    const subArray = [] 
    const rel1 = new Parse.Relation(jb, 'applicants') 
    const rel2 = new Parse.Relation(jb, 'shortlisted') 
    const rel3 = new Parse.Relation(jb, 'hired') 
    const rel4 = new Parse.Relation(jb, 'rejected') 
    subArray.push(rel1.query().containedIn('objectId', uniqUserIds).select('objectId').find()) 
    subArray.push(rel2.query().containedIn('objectId', uniqUserIds).select('objectId').find()) 
    subArray.push(rel3.query().containedIn('objectId', uniqUserIds).select('objectId').find()) 
    subArray.push(rel4.query().containedIn('objectId', uniqUserIds).select('objectId').find()) 

    values[jb.id] = await Promise.all(subArray) 
} 

Ich kann alle Versprechen in ein einziges Array schieben und auf alle warten. aber ich würde die Spur verlieren, deren Versprechen Wert zu dem Job ID gehört. Obwohl das Aufteilen des ganzen Array auf jeden 4. Index mich dazu bringen wird, was ich will, suche ich nach noch besseren Alternativen.

Answer 1

Wenn Sie alle Ihre Anfragen parallel laufen zu lassen, würden Sie in der Tat nicht await in der Schleife verwenden. Sie müssen jedoch nicht alle Ihre Versprechen im selben Array ablegen und dann auf alle 4 Werte aufteilen - verwenden Sie einfach eine entsprechend verschachtelte Struktur!

function query(jb, name) { 
    const rel = new Parse.Relation(jb, name); 
    return rel.query().containedIn('objectId', uniqUserIds).select('objectId').find(); 
} 
async function getValues(jobList) { 
    const promises = jobList.map(jb => 
    Promise.all([ 
     jb.id, 
     query(jb, 'applicants'), 
     query(jb, 'shortlisted'), 
     query(jb, 'hired'), 
     query(jb, 'rejected'), 
    ]) 
); 
    const results = await Promise.all(promises); 
    const values = {}; 
    for (const [id, ...res] of results) 
    values[id] = res; 
    return values; 
} 

Answer 2

Vielleicht können Sie die Q-Bibliothek für Ihre Versprechen verwenden here. Mit dieser Bibliothek können Sie Ihre Versprechen einfach kombinieren und verketten.

Hoffe, das hilft!

Mit freundlichen Grüßen.

Answer 3

Ich denke, die Art, wie Sie tun, ist effizient. Sie nutzen das asynchrone Potenzial aus. Ich glaube nicht, dass es effizienter wäre, wenn Sie alle Versprechen in ein Array zusammenfügen und auf alle zusammen warten. In diesem Fall sehe ich keine Möglichkeit, die Verbindung zwischen der Job-ID und dem Ergebnis jedes Versprechens wiederherzustellen. Es ist wahr, dass Sie alle wiederholten Zeilen umgestalten können, aber das ist über sauberen Code, nicht über Effizienz. Dies könnte ein erster Ansatz sein:

var executeQuery = function(list) { 
    const subArray = []; 
    for(let element of list) { 
     const rel = new Parse.Relation(jb, element); 
     subArray.push(rel.query().containedIn('objectId', uniqUserIds).select('objectId').find()) 
    }; 
    return subArray; 
} 

for (let jb of jobList) { 
    values[jb.id] = values[jb.id] || {}; 
    var subArray = executeQuery(['applicants', 'shortlisted', 'hired', 'rejected']); 
    values[jb.id] = await Promise.all(subArray); 
}