con la siguiente cadena

 <...>.get().then().then().catch().finally()

El método catch manejará el rechazo de todas las promesas anteriores en la cadena, mientras que con la siguiente cadena

 <...>.get().then().catch().then().finally()

El método catch no manejará el rechazo de la promesa devuelta por el método last then .

Este tipo de cadena es útil cuando desea manejar el rechazo de una promesa y convertirlo en el cumplimiento de la promesa devuelta por el método catch para permitir que la cadena de promesa continúe.

Si la promesa resultante de la segunda cadena se usa en alguna parte o si está devolviendo la promesa al final de esta cadena desde una función como se muestra a continuación,

 function foo() { return <...>.get().then().then().catch().finally(); }

entonces no usar otro método de catch está bien porque en ese caso, el código que llama a esta función puede manejar el rechazo de la promesa que no fue capturado y manejado por la propia cadena de promesa.

Sin embargo, si ese no es el caso, entonces definitivamente debería tener un segundo método de catch then de la última llamada al método.

Sí, son diferentes.

Digamos que tienes esto:

 <...>.get().then(() => A()).then(() => B()).catch(() => ErrorHandling()).finally(() => D()) <...>.then(() => A()).catch(() => ErrorHandling()).then(() => B()).finally(() => D())

Podría traducir esto a una representación de await / async :

 // <...>.get().then(() => A()).then(() => B()).catch(() => ErrorHandling()).finally(() => D()) try { await get(); await A(); await B(); } catch( ) { await ErrorHandling() } finally { await D(); } // <...>.then(() => A()).catch(() => ErrorHandling()).then(() => B()).finally(() => D()) try { try { await get(); await A(); } catch( ) { await ErrorHandling() } await B(); } finally { await D(); }

En el primer caso, B no se ejecutará si get o A dan como resultado un error. En el segundo caso, B se ejecutará incluso si get o A dan como resultado un error, el único caso en el que no se ejecutará es si ErrorHandling da como resultado un error.

Entonces, el primero se usa si B depende de get y A para ejecutarse con éxito. El segundo caso se usa, por ejemplo, si B debe get algo sin importar si A fue exitoso.