So identifizieren Sie Ergebnisse in Promise.all()

Question

Ich bin ein Modul erstellen, die Aufgaben basierend auf einer Konfiguration ausführt, die es empfängt. Diese Aufgaben sind asynchron und geben ein Versprechen zurück. Momentan gibt es nur zwei Aufgaben zu bewältigen, aber wenn es mehr gibt, werde ich auf ein Problem stoßen, welches Ergebnis von Promise.all() zu welcher Aufgabe gehört. Hier

ist ein Kinderspiel meines aktuellen Code:

let asyncTasks = []; 
let result = {}; 

if (config.task0) { 
    asyncTasks.push(task0(param)); 
} 

if (config.task1) { 
    asyncTasks.push(task1(param)); 
} 

Promise.all(asyncTasks) 
    .then(results => { 

     // TODO: There has to be a prettier way to do this.. 
     if (config.task0) { 
      result.task0 = results[0]; 
      result.task1 = config.task1 ? results[1] : {}; 
     } else if (config.task1) { 
      result.task0 = {}; 
      result.task1 = results[0]; 
     } else { 
      result.task0 = {}; 
      result.task1 = {}; 
     } 

     this.sendResult(result) 
    }); 

Die Config wie folgt aussehen:

const config = { 
    task0: true, 
    task1: true 
}; 

Wie im Code erwähnt, hat es eine schöne und skalierbare Art und Weise zu sein, Identifizieren Sie, welches Ergebnis von welcher Aufgabe kommt, aber ich kann nichts über Promise.all() finden, das dabei helfen könnte.

Wie kann ich feststellen, welcher Wert zu welchem ​​Versprechen gehört, wenn Promise.all() verrechnet wird?

Answer 1

Es ist wirklich nicht notwendig, etwas anderes als Promise.all zu verwenden. Sie haben Schwierigkeiten, weil die andere Struktur Ihres Programms (config, und willkürliche Verbindung des Config-Schlüssels zur Funktion) ziemlich unordentlich ist. Sie könnten den Code ganz

const config = { 
    task0: true, 
    task1: true, 
    task2: false 
} 

// tasks share same keys as config variables 
const tasks = { 
    task0: function(...) { ... }, 
    task1: function(...) { ... }, 
    task2: function(...) { ... } 
} 

// tasks to run per config specification 
let asyncTasks = Object.keys(config).map(prop => 
    config[prop] ? tasks[prop] : Promise.resolve(null)) 

// normal Promise.all call 
// map/reduce results to a single object 
Promise.all(asyncTasks) 
    .then(results => { 
    return Object.keys(config).reduce((acc, task, i) => { 
     if (config[task]) 
     return Object.assign(acc, { [prop]: results[i] }) 
     else 
     return Object.assign(acc, { [prop]: {} }) 
    }, {}) 
    }) 

// => Promise({ 
//  task0: <task0 result>, 
//  task1: <task1 result>, 
//  task2: {} 
// }) 

Hinweis berücksichtigen wollen Umstrukturierung: Wir können in der Größenordnung von results abhängig, weil wir Object.keys(config) verwendet, um den Eingangs-Array von Versprechungen zu schaffen und Object.keys(config) wieder das Ausgangsobjekt zu erstellen.

Answer 2

Promise.all löst mit einer Reihe von Werten, wobei jeder Indexwert in der Anordnung ist die gleiche wie der Index des Versprechens in der ursprünglichen Anordnung zu Promise.all geben, die diesen Wert erzeugt.

Wenn Sie etwas ausgefalleneres brauchen, müssen Sie es selbst verfolgen oder eine andere Bibliothek verwenden, die solche Funktionalität bietet (wie Bluebird).