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

Question

Hello,

I would like to clarify the difference and when to use each of the models of handling promises:

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

Considering the obj.promessa 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!

Answer 1

In general terms I would say so:

• uses .catch() 1 time per chain of files, to catch unforeseen errors
• uses the error function locally to correct errors and allow chaining to continue

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

Fixing 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 mistakes for the .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 chaining to recover uses the error function, and so "catch" and handle a possible error uses the error function
• to catch errors and code that leaves somewhere in the middle uses the .catch() at the end of a chain.

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!

Hence the .catch() also acts as the last resource to restart the whole chaining, or at least avoid N error functions at each chain node.