Difference between promise.then (sucess, error) and promise.then () .catch ()?

Navigation
8

Hello,

I would like to clarify the difference and when to use each of the promising treatment templates: 

obj.promessa( parametro ).then( function ( resposta ) {
    console.log("Resposta: " + resposta);
}, function ( erro ) {
    console.log("Erro: " + erro);
});

and 

obj.promessa( parametro ).then( function ( resposta ) {
    console.log("Resposta: " + resposta);
}).catch( function ( erro ) {
    console.log("Erro: " + erro);
});

Whereas the obj.promess method was something like: 

promessa: function( parametro ) {
   var deferred = q.defer();
   if ( fun_assincrona(parametro) ) {
      return deffered.resolve("sucesso");
   } else {
      return deferred.reject("error");
   }
   return deferred.promise;
}

Hugs!

    
asked by anonymous 24.05.2017 / 21:59

1 answer

4

In general terms I would say this:

  • uses .catch() 1 times per promising thread, to catch unforeseen errors
  • locally use the error function to fix errors and allow the thread to continue

I will give two examples, one that suffers an error, but that is corrected, another that suffers an error, without correcting it:

Correcting errors locally with error function. 

function resolve(contador) {
    contador++
    console.log('Iteração', contador);
    return new Promise((res, rej) => {
        setTimeout(() => res(contador), 200);
    });
}

function falha(contador) {
    contador++;
    console.log('Eu vou falhar na iteração', contador);
    return new Promise((res, rej) => {
        setTimeout(() => rej(contador), 200);
    });
}
resolve(0)
    .then(resolve)
    .then(falha) // <-----------------
    .then(function() {
        // esta função é do success e não vai ser chamada
    }, function(nr) {
        console.log('Houve um erro, mas eu vou dar sinal para continuar...');
        return resolve(nr)
    })
    .then(resolve)
    .catch(e => console.log(e));

Leaving errors for .catch() 

function resolve(contador) {
  contador++
  console.log('Iteração', contador);
  return new Promise((res, rej) => {
    setTimeout(() => res(contador), 200);
  });
}

function falha(contador) {
  contador++;
  console.log('Eu vou falhar na iteração', contador);
  return new Promise((res, rej) => {
    setTimeout(() => rej(contador), 200);
  });
}

resolve(0)
  .then(resolve)
  .then(falha) // <-----------------
  .then(resolve) // nunca é chamada
  .catch(e => console.log('Erro no encadeamento!', e));

Therefore:

  • to allow a thread to recompose uses the error function, and so "catch" and handle a possible error uses function error
  • to catch errors and code that starts somewhere in the middle uses .catch() at the end of a thread.

The .catch() is not called if the error is "handled" and there is no new Promise as a return of this error function: 

function resolve(contador) {
  contador++
  console.log('Iteração', contador);
  return new Promise((res, rej) => {
    setTimeout(() => res(contador), 200);
  });
}

function falha(contador) {
  contador++;
  console.log('Eu vou falhar na iteração', contador);
  return new Promise((res, rej) => {
    setTimeout(() => rej(contador), 200);
  });
}

resolve(0)
  .then(resolve)
  .then(falha) // <-----------------
  .then(resolve) // nunca é chamada
  .then(function() {
    console.log('Serei chamado?');
  }, function(err) {
    console.log('Houve erro?', err);
  })
  .catch(e => console.log('Erro no encadeamento!', e)); // não é chamado!

So .catch() also works as the last resource to restart the whole thread, or at least avoid N error functions on each thread node.

    
25.05.2017 / 00:17
Unit test is a generic term? What types are there? And what ways to apply? Element removal with Javascript