Ripetizione dell'errore nella cattura della promessa

Ho trovato il seguente codice in un tutorial:

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

Sono un po 'confuso: il richiamo ha qualcosa? Mi sembra che non abbia alcun effetto, poiché genera semplicemente lo stesso errore che è stato catturato. Baso questo su come funziona un try / catch regolare.

Non ha senso prendere e lanciare nudi mentre mostri. Non fa nulla di utile tranne che aggiungere codice e l'esecuzione lenta. Quindi, se hai intenzione di .catch()rilanciare, dovrebbe esserci qualcosa che vuoi fare in .catch(), altrimenti dovresti semplicemente rimuovere .catch()completamente.

Il punto normale per quella struttura generale è quando si desidera eseguire qualcosa .catch()come registrare l'errore o ripulire uno stato (come i file chiusi), ma si desidera che la catena di promesse continui come rifiutata.

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

In un tutorial, potrebbe essere lì solo per mostrare alle persone dove possono rilevare gli errori o per insegnare il concetto di gestire l'errore, quindi rilanciarlo.

Alcuni dei motivi utili per la cattura e il rilancio sono i seguenti:

1. Si desidera registrare l'errore , ma mantenere la catena di promesse rifiutata.
2. Volete trasformare l'errore in qualche altro errore (spesso per una più facile elaborazione degli errori alla fine della catena). In questo caso, rilanceresti un errore diverso.
3. Si desidera eseguire un po 'di elaborazione prima che la catena di promesse continui (come risorse chiuse / libere) ma si desidera che la catena di promesse rimanga rifiutata.
4. Si desidera un punto in cui inserire un punto di interruzione per il debugger a questo punto della catena di promesse se si verifica un errore.

Tuttavia, una semplice cattura e rilancio dello stesso errore senza altro codice nel gestore di cattura non fa nulla di utile per il normale funzionamento del codice.

Sia .then()e .catch()metodi restituiscono promesse, e se un'eccezione sia gestore, la promessa restituita è respinta e l'eccezione saranno catturati nella prossima rifiutano gestore.

Nel codice seguente, viene generata un'eccezione nel primo .catch(), che viene catturata nel secondo .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);
});

Il secondo .catch()restituisce una Promessa soddisfatta, il .then()gestore può essere chiamato:

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');
});

Riferimento utile: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Using_promises#Chaining_after_a_catch

Spero che sia di aiuto!

Non c'è differenza importante se si tralascia completamente la catchchiamata al metodo.

L'unica cosa che aggiunge è una microtask extra, che in pratica significa che noterai il rifiuto della promessa più tardi di quanto non sia il caso di una promessa che fallisce senza la catchclausola.

Lo snippet successivo lo dimostra:

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) );

Nota come il secondo rifiuto viene segnalato prima del primo. Questa è l'unica differenza.

Quindi sembra che la tua domanda sia: "Nella catena delle promesse, cosa fa il .catch()metodo?"

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

L'istruzione throw "si fermerà (le istruzioni dopo throw non verranno eseguite) e il controllo verrà passato al primo blocco catch nello stack di chiamate. Se non esiste alcun blocco catch tra le funzioni del chiamante, il programma terminerà."

Nella catena delle promesse, il .then()metodo restituirà un tipo di blocco di dati. Questo ritorno del pezzo completerà la promessa. La corretta restituzione dei dati completa la promessa. Puoi pensare al .catch()metodo allo stesso modo. .catch()tuttavia gestirà i recuperi di dati non riusciti. L'istruzione throw completa la promessa. Occasionalmente, vedrai l'uso da parte degli sviluppatori .catch((err) => {console.log(err))} che completerebbe anche la catena di promesse.

In realtà non è necessario rilanciarlo, basta lasciare vuoto Promise.catch altrimenti considererà come non gestire il rifiuto e quindi avvolgere il codice in un tentativo di cattura e catturerà automaticamente l'errore che viene trasmesso.

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
}

Nella catena delle promesse, è meglio usare .catch

ex nella funzione f2: .then (...). catch (e => respinge (e));

• test1 - con try catch
• test2 - senza 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);