L'application Simple Node / Express, la manière de programmation fonctionnelle (Comment gérer les effets secondaires en JavaScript?)

Vous ne pourrez pas éviter les effets secondaires, mais vous pouvez faire un effort pour les abstraire au maximum, dans la mesure du possible.

Par exemple, le cadre Express est intrinsèquement impératif. Vous exécutez des fonctions comme res.send() entièrement pour leurs effets secondaires (vous ne vous souciez même pas de sa valeur de retour la plupart du temps).

Ce que vous pourriez faire (en plus d'utiliser const pour toutes vos déclarations, en utilisant les structures de données Immutable.js , Ramda , en écrivant toutes les fonctions comme const fun = arg => expression; au lieu de const fun = (arg) => { statement; statement; }; Etc.) serait de faire une petite abstraction sur la façon dont Express fonctionne habituellement.

Par exemple, vous pouvez créer des fonctions qui prennent le paramètre req comme paramètre et renvoient un objet qui contient l'état de la réponse, les en-têtes et un flux à transmettre en tant que corps. Ces fonctions peuvent être des fonctions pures, dans la mesure où leur valeur de retour dépend uniquement de leur argument (l'objet de requête), mais vous auriez encore besoin d'un wrapper pour envoyer la réponse en utilisant l'API de Express, intrinsèquement impérative. Ce n'est peut-être pas trivial, mais cela peut être fait.

À titre d'exemple, considérez cette fonction qui prend le corps comme objet à envoyer en tant que json:

 const wrap = f => (req, res) => { const { status = 200, headers = {}, body = {} } = f(req); res.status(status).set(headers).json(body); }; 

Il pourrait être utilisé pour créer des gestionnaires d'itinéraire comme ceci:

 app.get('/sum/:x/:y', wrap(req => ({ headers: { 'Foo': 'Bar' }, body: { result: +req.params.x + +req.params.y }, }))); 

En utilisant une fonction qui renvoie une seule expression sans effets secondaires.

Exemple complet:

 const app = require('express')(); const wrap = f => (req, res) => { const { status = 200, headers = {}, body = {} } = f(req); res.status(status).set(headers).json(body); }; app.get('/sum/:x/:y', wrap(req => ({ headers: { 'Foo': 'Bar' }, body: { result: +req.params.x + +req.params.y }, }))); app.listen(4444); 

Test de la réponse:

 $ curl localhost:4444/sum/2/4 -v * Hostname was NOT found in DNS cache * Trying 127.0.0.1... * Connected to localhost (127.0.0.1) port 4444 (#0) > GET /sum/2/4 HTTP/1.1 > User-Agent: curl/7.35.0 > Host: localhost:4444 > Accept: */* > < HTTP/1.1 200 OK < X-Powered-By: Express < Foo: Bar < Content-Type: application/json; charset=utf-8 < Content-Length: 12 < ETag: W/"c-Up02vIPchuYz06aaEYNjufz5tpQ" < Date: Wed, 19 Jul 2017 15:14:37 GMT < Connection: keep-alive < * Connection #0 to host localhost left intact {"result":6} 

Bien sûr, ceci n'est qu'une idée de base. Vous pourriez faire en sorte que la fonction wrap() accepte des promesses pour la valeur de retour des fonctions pour les opératures asynchrones, mais cela ne sera pas sans effet contraire aux effets secondaires:

 const wrap = f => async (req, res) => { const { status = 200, headers = {}, body = {} } = await f(req); res.status(status).set(headers).json(body); }; 

Et un gestionnaire:

 const delay = (t, v) => new Promise(resolve => setTimeout(() => resolve(v), t)); app.get('/sum/:x/:y', wrap(req => delay(1000, +req.params.x + +req.params.y).then(result => ({ headers: { 'Foo': 'Bar' }, body: { result }, })))); 

J'ai utilisé .then() au lieu d' async / await dans le gestionnaire lui-même pour le rendre plus fonctionnel, mais il peut être écrit comme .then() :

 app.get('/sum/:x/:y', wrap(async req => ({ headers: { 'Foo': 'Bar' }, body: { result: await delay(1000, +req.params.x + +req.params.y) }, }))); 

Il pourrait être rendu encore plus universel si la fonction qui est un argument à wrap serait un générateur qui, au lieu de donner seulement des promesses à résoudre (comme les corutines basées sur le générateur en général), il produirait soit des promesses de résolution, soit des mandrins à transmettre, Avec un emballage pour distinguer les deux. C'est juste une idée de base, mais cela peut être étendu beaucoup plus loin.