web-dev-qa-db-fra.com

ES6 Promises - Appel de fonctions synchrones dans la chaîne de promesses

J'expérimente actuellement avec des promesses et j'ai une question vraiment basique!

Dans une chaîne de promesses, serait-ce une mauvaise pratique d'appeler une fonction synchrone? Par exemple:

.then(function(results) {

    if(checkIfResultInMemory(results) === true){
       return getTotalFromMemory()
    }

   return results;

  })

Ou mes fonctions de synchronisation devraient-elles être refactorisées pour renvoyer des promesses également?

node.jsasynchronouspromisees6-promise
15
Ben

Dans une chaîne de promesses, serait-ce une mauvaise pratique d'appeler une fonction synchrone?

Non, ce n'est pas du tout une mauvaise pratique. C'est l'une des nombreuses pratiques attendues et utiles.

Vous êtes parfaitement libre d'appeler des fonctions synchrones au sein de la chaîne de promesses (à partir des gestionnaires .then()) ou des fonctions asynchrones qui renvoient ensuite une nouvelle promesse.

Lorsque vous renvoyez quelque chose à partir d'un gestionnaire .then(), vous pouvez renvoyer une valeur (qui devient la valeur résolue de la promesse parent) ou vous pouvez renvoyer une autre promesse (qui enchaîne sur la promesse précédente) ou vous pouvez lancer qui fonctionne comme retourner une promesse rejetée (la chaîne de promesses est rejetée).

Ainsi, cela signifie que vous pouvez appeler une fonction synchrone et en obtenir une valeur ou appeler une fonction asynchrone et obtenir une autre promesse, puis revenir à partir du gestionnaire .then().

Toutes ces choses synchrones sont parfaitement légales et ont chacune leur propre objectif. Voici quelques événements synchrones dans le gestionnaire .then():

// modify resolved value
someAsync().then(function(val) {
    return val + 12;
});

// modify resolved value by calling some synchronous function to process it
someAsync().then(function(val) {
    return someSynchronousFunction(val);
});

// synchronously check the value and throw to change the promise chain
// to rejected
someAsync().then(function(val) {
    if (val < 0) {
        throw new Error("value can't be less than zero");
    }
    return val;
});

// synchronously check the value and return a rejected promise 
// to change the promise chain to rejected
someAsync().then(function(val) {
    if (val < 0) {
        return Promise.reject("value can't be less than zero");
    }
    return val;
});

Voici un petit exemple d'une opération asynchrone qui renvoie une promesse suivie de trois gestionnaires .then() synchrones, puis la sortie de la valeur finale:

function delay(t, val) {
    return new Promise(function(resolve) {
        setTimeout(function() {
            resolve(val);
        }, t);
    });
}

function increment5(val) {
    return val + 5;
}

delay(500, 10).then(increment5).then(function(val) {
    return val - 3;
}).then(function(final) {
    document.write(final);
});

Remarque: Vous ne souhaitez généralement utiliser des promesses que lorsque vous avez ou pouvez avoir des opérations asynchrones car si tout est synchrone, le code synchrone pur est à la fois plus rapide à exécuter et plus facile à écrire. Mais, si vous avez déjà au moins une opération asynchrone, vous pouvez certainement mélanger des opérations synchrones avec cette opération asynchrone et utiliser des promesses pour aider à structurer le code.

27
jfriend00

Une fonction de rappel then devrait:

  • retourner une autre promesse
  • retourne une valeur synchrone (ou non définie)
  • lancer une erreur synchrone
2
trquoccuong