Error al volver a lanzar en la captura de promesa

Encontré el siguiente código en un tutorial:

promise.then(function(result){
    //some code
}).catch(function(error) {
    throw(error);
});

Estoy un poco confundido: ¿la llamada de captura logra algo? Me parece que no tiene ningún efecto, ya que simplemente arroja el mismo error que se detectó. Baso esto en cómo funciona un intento / captura regular.

No tiene sentido atrapar y lanzar como muestra. No hace nada útil excepto agregar código y ejecución lenta. Por lo tanto, si va a .catch()volver a lanzar, debe haber algo que desee hacer en el .catch(), de lo contrario, debe eliminar por .catch()completo.

El punto habitual para esa estructura general es cuando desea ejecutar algo .catch()como registrar el error o limpiar algún estado (como cerrar archivos), pero desea que la cadena de promesa continúe como rechazada.

promise.then(function(result){
    //some code
}).catch(function(error) {
    // log and rethrow 
    console.log(error);
    throw error;
});

En un tutorial, puede estar ahí solo para mostrar a las personas dónde pueden detectar errores o para enseñar el concepto de cómo manejar el error y luego volver a lanzarlo.

Algunas de las razones útiles para atrapar y volver a lanzar son las siguientes:

1. Desea registrar el error , pero mantenga la cadena de promesa como rechazada.
2. Quieres convertir el error en otro error (a menudo para facilitar el procesamiento de errores al final de la cadena). En este caso, volvería a generar un error diferente.
3. Desea realizar un montón de procesamiento antes de que continúe la cadena de promesas (como recursos cerrados / libres) pero desea que la cadena de promesas permanezca rechazada.
4. Desea un lugar para colocar un punto de interrupción para el depurador en este punto de la cadena de promesa si hay una falla.

Pero, una simple captura y repetición del mismo error sin otro código en el controlador de captura no hace nada útil para la ejecución normal del código.

Ambos métodos .then()y .catch()devuelven Promesas, y si lanza una Excepción en cualquiera de los manejadores, la promesa devuelta se rechaza y la Excepción se capturará en el siguiente manejador de rechazo.

En el siguiente código, lanzamos una excepción en el primero .catch(), que se captura en el segundo .catch():

new Promise((resolve, reject) => {
    console.log('Initial');

    resolve();
})
.then(() => {
    throw new Error('Something failed');
        
    console.log('Do this'); // Never reached
})
.catch(() => {
    console.log('Something failed');
    throw new Error('Something failed again');
})
.catch((error) => {
    console.log('Final error : ', error.message);
});

El segundo .catch()devuelve un Promised que se cumple, .then()se puede llamar al manejador:

new Promise((resolve, reject) => {
    console.log('Initial');

    resolve();
})
.then(() => {
    throw new Error('Something failed');
        
    console.log('Do this'); // Never reached
})
.catch(() => {
    console.log('Something failed');
    throw new Error('Something failed again');
})
.catch((error) => {
    console.log('Final error : ', error.message);
})
.then(() => {
    console.log('Show this message whatever happened before');
});

Referencia útil: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Using_promises#Chaining_after_a_catch

¡Espero que esto ayude!

No hay una diferencia importante si omite completamente la catchllamada al método.

Lo único que agrega es una micro-tarea adicional, lo que en la práctica significa que notará el rechazo de la promesa más tarde que en el caso de una promesa que falla sin la catchcláusula.

El siguiente fragmento demuestra esto:

var p;
// Case 1: with catch
p = Promise.reject('my error 1')
       .catch(function(error) {
          throw(error);
       });

p.catch( error => console.log(error) );
// Case 2: without catch
p = Promise.reject('my error 2');

p.catch( error => console.log(error) );

Observe cómo se informa el segundo rechazo antes que el primero. Esa es la única diferencia.

Entonces parece que su pregunta es: "En la cadena de promesas, ¿qué hace el .catch()método?"

https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/throw

La instrucción throw "se detendrá (las instrucciones después de throw no se ejecutarán), y el control se pasará al primer bloque catch en la pila de llamadas. Si no existe un bloque catch entre las funciones del llamador, el programa terminará".

En la cadena de promesa, el .then()método devolverá algún tipo de fragmento de datos. Este regreso del trozo completará la promesa. La devolución exitosa de los datos completa la promesa. Puedes pensar en el .catch()método de la misma manera. .catch()sin embargo, manejará recuperaciones de datos fallidas. La declaración throw completa la promesa. De vez en cuando, verá que los desarrolladores usan .catch((err) => {console.log(err))} lo que también completaría la cadena de promesas.

En realidad, no necesita volver a lanzarlo, simplemente deje el Promise.catch vacío; de lo contrario, se considerará como no manejar el rechazo y luego envolverá el código en un intento de captura y detectará el error automáticamente que se está transmitiendo.

try{
  promise.then(function(result){
    //some code
  }).catch(function(error) {
    //no need for re throwing or any coding. but leave this as this otherwise it will consider as un handled
  });
}catch(e){
  console.log(e);
  //error can handle in here
}

En la cadena de promesas, es mejor usar .catch

ex en la función f2: .entonces (...). captura (e => rechazar (e));

• test1 - con try catch
• test2 - sin try o .catch
• test3 - con .catch

function f1() {
    return new Promise((resolve, reject) => {
        throw new Error('test');
    });
}

function f2() {
    return new Promise((resolve, reject) => {
        f1().then(value => {
            console.log('f1 ok ???');
        }).catch(e => reject(e));
    });
}

function test1() {
    console.log('test1 - with try catch - look in F12');
    try {
      f2().then(() => { // Uncaught (in promise) Error: test
        console.log('???'); });
    } catch (e) {
      console.log('this error dont catched');
    }
}

function test2() {
    console.log('test2 - without try or .catch - look in F12');
    f2(); // Uncaught (in promise) Error: test
}

function test3() {
  console.log('test3 - with .catch');
  f2().then(value => {
    console.log('??');
  }).catch(e => {
    console.log(' now its ok, error ', e);
  })
}

setTimeout(() => { test1(); 
  setTimeout(() => { test2(); 
    setTimeout(() => { test3(); 
    }, 100);
  }, 100);
}, 100);