No tiene sentido atrapar y lanzar desnudo como lo demuestras. No hace nada útil excepto agregar código y una ejecución lenta. Entonces, si va a .catch() y vuelve a lanzar, debe haber algo que quiera hacer en .catch() , de lo contrario, debe eliminar .catch() por completo.

El punto habitual para esa estructura general es cuando desea ejecutar algo en .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 allí solo para mostrar a las personas dónde pueden detectar errores o para enseñar el concepto de 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 mantener la cadena de promesa como rechazada.
2. Desea 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 cerrar/liberar recursos), 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.
5. Desea manejar un error específico o un conjunto de errores , pero volver a generar otros para que se propaguen a la persona que llama.

Sin embargo, una captura simple y un nuevo lanzamiento del mismo error sin ningún otro código en el controlador de captura no hace nada útil para la ejecución normal del código.

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

En el siguiente código, lanzamos una excepción en el primer .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, se puede llamar al controlador .then() :

 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 por completo la llamada al método catch .

Lo único que agrega es una microtarea 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 cláusula catch .

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.