¿Cómo evitar errores de deglución de promesas?

En este artículo, intentaremos comprender cómo podemos evitar los errores de deglución de promesas utilizando varias técnicas predefinidas proporcionadas por JavaScript.

Antes de sumergirnos en el tema principal de preocupación, comprendamos rápidamente cómo podemos declarar una promesa usando la siguiente sintaxis.

Sintaxis:

let promise = new Promise((resolve, reject) => {
    ...
});

Ejemplo 1: el siguiente fragmento de código nos ayudará a comprender la declaración de promesa de una manera mucho mejor:

let promise = new Promise((resolve, reject) =>{
    resolve("Hello GeeksforGeeks")
});
 
promise.then(result => console.log(result));

Producción:

Hello GeeksforGeeks

Ahora echemos un vistazo a nuestro enunciado del problema con el que tenemos que evitar que las promesas se traguen los errores. Considere el siguiente fragmento de código (ejemplo de código), en el que se ilustra un escenario (que se basa en el trabajo en tiempo real) en el que implementamos el enstringmiento del método .then() uno tras otro.

Ahora bien, si pasamos algún parámetro que, aunque no está declarado en ninguna parte del fragmento de código, nuestra promesa detectará el error (como un error de referencia) e inmediatamente descartará (o rechazará) la promesa y, además, provocará el bloqueo del código.

Ejemplo 2:  vea el fragmento de código a continuación

let promise = new Promise((resolve, reject) => {
    resolve();
});
promise
    .then(function () {
        console.log("GeeksforGeeks");
    })
    .then(function () {
        console.log("Hello ", someRandomText);
    });

Producción:

Ahora, como podemos ver en la salida de la imagen de arriba, el error se elimina y, por lo tanto, la promesa se rechaza, pero es posible que no queramos que eso suceda, por lo que uno de nuestros enfoques podría ser como usar una función de controlador que está enstringda. justo después del error que se recibe del método .then() anterior. 

Ejemplo 3: vea el fragmento de código a continuación

let promise = new Promise((resolve, reject) => {
    resolve();
})
 
promise
    .then(function () {
        console.log("GeeksforGeeks");
    })
    .then(function () {
        console.log("Hello ", someRandomText);
    }, function (error) {
        console.log("Promise rejected, error message : ", error);
    });

Producción:

Como podemos ver, este enfoque (de implementar una función de controlador) no parece darnos el resultado correcto, por lo tanto, es posible que tengamos que usar el método .catch() después de haber recibido el error.

Ejemplo 4: vea el fragmento de código a continuación

let promise = new Promise((resolve, reject) => {
    resolve();
})
 
promise
    .then(() => {
        console.log("GeeksforGeeks");
    })
    .then(() => {
        console.log("Hello", someRandomText);
    })
    .catch((error) => {
        console.log("Promise rejected,
            error message : ", error);
    });

Producción:

Este enfoque funciona bien y no rechaza la promesa que habíamos declarado para su ejecución, sino que en realidad cumple la promesa tal como está e imprime con éxito el mensaje de error sin bloquear el código.

Nota: Es posible que hayamos visto una prevención exitosa de las promesas de tragar errores (en el fragmento de código anterior), pero no es posible para nosotros enstringr .catch() cada vez que cada método .then() tenga un error. Por lo tanto, mientras trabajamos en un proyecto, primero tenemos que instalar Bluebird , una de las bibliotecas de Promise más populares que tiene un método incorporado (llamado onRejection handler) y también otro controlador predeterminado (llamado unhandledRejection) que nos ayuda a manejar el rechazo no controlado. sobre el fragmento de código completo y este fragmento de código, tenemos que implementarlo de inmediato y, después de implementarlo de inmediato, no debemos preocuparnos por las excepciones no controladas en absoluto.