en utilisant des gestionnaires de routes express et promesses-quelles sont les meilleures pratiques?

Question

Je travaille actuellement sur un projet web et j'essaie de comprendre Node.js et express. Je sais à ce sujet pour obtenir le code asynchrone facile à maintenir que nous devrions utiliser promesses, mais je suis confus sur le scénario suivant: J'ai un gestionnaire d'itinéraire pour l'API REST, devrais-je retourner une promesse? même s'il n'y a pas de travail async fait là? i.e.:

dummy_router.post("/", passport.authenticationMiddleware(), (req, res) => { 
    return new Promise((fulfill, reject) => { 
     var result = some_simple_functionality(); 
     if (result) { 
      fulfill(result) 
     } else { 
      reject(err) 
     } 

    }).catch(function (error) { 
     res.status(400).send('400: failed t :: ' + error + '\n'); 
    }); 
}); 

également deuxième question sur la même question. Si j'effectue des tâches asynchrones et que j'ai des promesses de les contenir, est-ce une bonne pratique?

dummy_router.post("/", passport.authenticationMiddleware(), (req, res) => { 
    some_promise().then((result) => { 

    }, (err) => { 

    }).catch(function (error) { 
    res.status(400).send('400: failed t :: ' + error + '\n'); 
    }); 
}); 

Answer 1

Tournant commentaires dans une réponse:

Votre premier exemple est la fabrication d'une promesse lorsqu'aucune est nécessaire. Il n'y a aucune raison d'emballer le code synchrone dans une promesse. Cela ajoute simplement de la complexité qui n'est pas nécessaire et n'apporte aucun avantage. Express ne fait rien avec la valeur de retour d'un gestionnaire de requêtes, il n'y a donc aucune utilité à renvoyer une promesse de cela.

Votre deuxième exemple semble utiliser une opération asynchrone réelle qui renvoie une promesse. Cela semble généralement correct, mais il n'est pas clair pourquoi vous avez à la fois un gestionnaire d'erreurs sur votre .then() et un .catch(). Choisissez l'un ou l'autre et sachez qu'un gestionnaire de rejet qui ne renverra pas ou ne renverra pas une promesse rejetée changera la promesse en une promesse remplie (dépassant le rejet).

Alors, quand vous faites ceci:

some_promise().then((result) => { 

    }, (err) => { 
     // unless you rethrow here, this will "handle" the error 
     // and the promise will become fulfilled, not rejected 
    }).catch(function (error) { 
     res.status(400).send('400: failed t :: ' + error + '\n'); 
    }); 

Le gestionnaire (err) => {} est la cause de votre refus de promesse de se faire manger à moins que vous réémettre ou de retourner une promesse rejetée de cela.

Donc, probablement tout ce que vous voulez est ceci:

some_promise().then((result) => { 
     // code to process result here 
     res.send(...); 
    }).catch(function (error) { 
     res.status(400).send('400: failed t :: ' + error + '\n'); 
    }); 

Il est rarement une raison d'utiliser à la fois un .then() rejet gestionnaire (2ème argument .then() et un gestionnaire .catch() après

.

Existe-t-il une justification pour utiliser à la fois le gestionnaire de rejet et le catch() alors?

Non. Il y a quelques situations inhabituelles pour lesquelles vous pourriez vouloir les deux, mais dans ce cas (et dans la plupart des cas), il vous suffit d'avoir le gestionnaire .catch().