Soy nuevo en mecanografiar/javascript, así que no sé mucho sobre promesas. Aquí está mi caso de uso: estoy creando tres promesas diferentes dentro de mi función de nube y luego las devuelvo con Promise.all([promise1, promise2, promise3]). Cada una de estas promesas se crea dentro de una función con "return Promise...".
Mi pregunta es, cuando agrego ".catch" dentro de estas funciones, ¿seguirá funcionando Promise.all ? ¿Hace alguna diferencia devolver someServiceThatCreatesPromise() con y sin .catch() ?
export async function myCloudFirestoreFunction() { try { const myFirstPromise = createFirstPromise() const mySecondPromise = createSecondPromise() const thirdPromise = createThirdPromise() return Promise.all([ myFirstPromise, mySecondPromise, myThirdPromise ]); } catch (err) { functions.logger.err(`Something bad happened, See: ${(err as Error).message}` } } // Difference with and without `.catch`? function createFirstPromise() { return someServiceThatCreatesPromise().catch((err) => { // LOGGING }); } // Difference with and without `.catch`? function createSecondPromise() { return someServiceThatCreatesPromise().catch((err) => { // LOGGING }); } // Difference with and without `.catch`? function createThirdPromise() { return someServiceThatCreatesPromise().catch((err) => { // LOGGING }); }Agregar .catch dentro createNPromise no afectará nada suponiendo que todas sus Promise se resuelvan y no rechacen.
Sin embargo, si uno de los Promise s rechaza y lo detecta dentro del método .catch , entonces no funcionará como esperaba a menos que vuelva a generar ese error y lo detecte nuevamente dentro de try/catch en su función myCloudFirestoreFunction .
async function myCloudFirestoreFunction() { try { const result = await Promise.all([ createFirstPromise(), createSecondPromise() ]); } catch (error) { console.log({ error }); } } function createFirstPromise() { return Promise.reject("Oof").catch((e) => { // do work, eg log, then // pass the error forward so that it can be caught // inside the caller throw e; }); } function createSecondPromise() { return Promise.resolve("value"); } myCloudFirestoreFunction(); Alternativamente, simplemente catch errores dentro de la persona que llama ( myCloudFirestoreFunction ) en lugar de detectarlos por separado.
async function myCloudFirestoreFunction() { const result = await Promise.all([ createFirstPromise(), createSecondPromise() ]).catch((err) => console.log({ err })); } function createFirstPromise() { return Promise.reject("Oof"); } function createSecondPromise() { return Promise.resolve("value"); } myCloudFirestoreFunction();cuando agrego ".catch" dentro de estas funciones, ¿seguirá funcionando Promise.all?
Llamar a catch() en una promesa no cambia de ninguna manera la forma en que funciona la promesa original. Simplemente adjunta una devolución de llamada que se invoca cuando se rechaza la primera promesa, y también devuelve otra promesa que se resuelve después de que se cumple o se rechaza la promesa original.
¿Hace alguna diferencia devolver someServiceThatCreatesPromise() con y sin .catch()?
No haría ninguna diferencia en el código que depende de la promesa devuelta. Tanto la promesa original como la devuelta por catch() le dirán al código descendente cuándo se realiza el trabajo original al cumplirse.
Sugiero leer documentación completa sobre promesas, por ejemplo:
Allí hay un diagrama que puedes seguir para comprender lo que sucede en cada turno. También en ese documento, usted leerá:
El procesamiento continúa hasta el siguiente eslabón de la cadena incluso cuando .then() carece de una función de devolución de llamada que devuelve un objeto Promise. Por lo tanto, una cadena puede omitir con seguridad cada función de devolución de llamada de rechazo hasta el .catch() final.