für Versprechungen innen Promise.all Warten, bevor es der Lösung

Question

I zu beenden haben eine Promise.all, die auf einem Array-Eingang zugeordnet asynchrone Funktionen ausführt, wenn es nicht null ist, und dann werden Daten zu lösen, um eine vorher definierte Versprechen:

Promise.all((inputs || []).map(input => { 
    return new Promise((resolve, reject) => { 
    someAsyncFunc(input) 
    .then(intermediateOutput => { 
     someOtherAsyncFunc(intermediateOutput) 
     .then(output => { 
     return Promise.resolve(output) 
     }) 
     .catch(reason=> { 
     return Promise.reject(reason) 
     }) 
    }) 
    .catch(reason => { 
     return Promise.reject(reason); 
    }) 
    }) 
    .then(outputs => { 
    resolve(outputs) 
    }) 
    .catch(reason => { 
    reject(reason) 
    }) 
})) 

Ich bekomme nur leere Ausgaben, bevor sogar einige AsyncFunc seine Arbeit beendet. Wie kann Promise.all auf die Versprechungen im Inneren warten, um ihre asynchrone Arbeit zu beenden?

Answer 1

Siehe jfriend Kommentar.

someAsyncFunc und someOtherAsyncFunc sind Funktion, die richtig ein Versprechen mit etwas zurückgeben wie return new Promise(/*...*/);

das ist nutzlos:

.then(output => { 
    return Promise.resolve(output) 
}) 

the Promise Dokumentation

gleichen

lesen

.catch(reason=> { 
    return Promise.reject(reason) 
}) 

Das Versprechen ist bereits die Ablehnung, Sie brauchen nicht zu fangen und lehnen sich

sicher Versprechungen zu machen sind verkettbar Sie das Versprechen

// ... 
return new Promise((resolve, reject) => { 
    if(inputs == null) 
    resolve([]); 
    else { 
    Promise.all(inputs.map(input => { 
     return someAsyncFunc(input) 
     .then(someOtherAsyncFunc) 
    })) 
     .then(resolve) 
     .catch(reject) 
    } 
}); 

Notiz zurückzukehren brauchen würde ich lieber nicht die arry machen Promise.all inline, fügt sie visuelle Unordnung:

return new Promise((resolve, reject) => { 
    if(inputs == null) 
    resolve([]); 
    else { 
    const myPromises = inputs.map(input => { 
     return someAsyncFunc(input) 
     .then(someOtherAsyncFunc) 
    }); 
    Promise.all(myPromises) 
     .then(resolve) 
     .catch(reject) 
    } 
}); 

es immer noch fehlschlagen, wenn Sie andere Fehler gemacht.

Answer 2

Wäre das nicht nur

return Promise.all((inputs || []).map(input => 
somePromiseFunc(input).then(someOtherPromiseFunc) 
); 

Arbeit?

Sie verwenden nicht Promise.all gleich beim ersten Mal, da es eine Reihe von Versprechungen als Eingabe verwendet, und nicht (resolve, reject) => { ... }

Promise.all wird so schnell abgelehnt werden als eine der zugrunde liegenden Versprechen nicht, so dass Sie don ‚t müssen versuchen, etwas um catch(error => reject(error)

Beispiel zu tun:

const somePromiseFunc = (input) => new Promise((resolve, reject) => { 
    setTimeout(() => { 
    if (input === 0) { reject(new Error('input is 0')); } 
    resolve(input + 1); 
    }, 1000); 
}); 

const someOtherPromiseFunc = (intermediateOutput) => new Promise((resolve, reject) => { 
    setTimeout(() => { 
    if (intermediateOutput === 0) { reject(new Error('intermediateOutput is 0')); } 
    resolve(intermediateOutput + 1); 
    }, 1000); 
}); 

const f = inputs => { 
    const t0 = Date.now() 
    return Promise.all((inputs || []).map(input => somePromiseFunc(input).then(someOtherPromiseFunc))) 
    .then(res => console.log(`result: ${JSON.stringify(res)} (after ${Date.now() - t0}ms)`)) 
    .catch(e => console.log(`error: ${e} (after ${Date.now() - t0}ms)`)); 
}; 

f(null) 
// result: [] (after 0ms) 

f([1, 0]) 
// error: Error: input is 0 (after 1001ms) 

f([1, -1]) 
// error: Error: intermediateOutput is 0 (after 2002ms) 

f([1, 2]) 
// result: [3,4] (after 2002ms)