Devrions-nous choisir l'attente asynchrone plutôt que la promesse en Javascript ?

Question

Je sais que la async await est le nouveau Promise dans la ville et c'est une nouvelle façon d'écrire du code asynchrone.

Nous n'avons pas eu à écrire .then créer une fonction anonyme pour gérer la réponse

Async/await permet enfin de gérer les erreurs synchrones et asynchrones avec la même construction, le bon vieux try/catch

La pile d'erreurs renvoyée par un promise ne donne aucune indication sur l'endroit où l'erreur s'est produite. Cependant, la pile d'erreurs de async/await pointe vers la fonction qui contient l'erreur

ET AINSI DE SUITE...

mais ici, j'ai fait un simple repère https://repl.it/repls/FormalAbandonedChimpanzee

Dans le benchmark, j'ai exécuté 2 boucles pendant 1 million de fois. Dans la première boucle, j'appelle une fonction qui renvoie 1 dans une autre fonction, j'appelle une fonction qui renvoie 1 en tant qu'exception.

le temps pris par la première boucle qui appelle une fonction qui renvoie 1 est presque la moitié du temps pris par la fonction qui renvoie 1 comme erreur.

Ce qui montre que le temps pris par throw est presque le double du temps pris par return

node v7.4 linux/amd64

return takes 1.233seconds
1000000
throw takes 2.128seconds
1000000

Code de référence ci-dessous

function f1() {
  return 1;
}

function f2() {
  throw 1;
}

function parseHrtimeToSeconds(hrtime) {
    var seconds = (hrtime[0] + (hrtime[1] / 1e9)).toFixed(3);
    return seconds;
}

var sum = 0;
var start = 0;
var i = 0;

start = process.hrtime();
for (i = 0; i < 1e6; i++) {
  try {
    sum += f1();
  } catch (e) {
    sum += e;
  }
}
var seconds = parseHrtimeToSeconds(process.hrtime(start));
console.log('return takes ' + seconds + 'seconds');
console.log(sum);

sum = 0;
start = process.hrtime();
for (i = 0; i < 1e6; i++) {
  try {
    sum += f2();
  } catch (e) {
    sum += e;
  }
}

seconds = parseHrtimeToSeconds(process.hrtime(start));
console.log('throw takes ' + seconds + 'seconds');
console.log(sum);