Il existe beaucoup d’outils, de fonctions et de techniques pour évaluer si une variable existe, si elle est bien définie et si elle n’est pas nulle. En travaillant sur un projet suivant le paradigme de la programmation fonctionnelle, j’en ai pratiqué un qui mérite une attention toute particulière.

Il s’agit en fait de deux méthodes qui sont issues d’une librairie qui offre plusieurs fonctions dédiées à la programmation fonctionnelle en javascript : Folktale.

Et pour illustrer le principe, je propose de décrire 2 exemples simples :

Cas 1 : Le champ facultatif

Je souhaite tester dans mon Backend le contenu d’un champ de formulaire non obligatoire provenant du front.

La première question est : l’utilisateur a-t-il saisi une information ?

Si la réponse est « peut-être » alors on utilise Maybe().

Maybe() peut avoir 2 états :

• Nothing() : pas de valeur
• Just() : une valeur
  

La méthode consiste à initialiser la valeur du champ du formulaire avec Maybe.Nothing() et lors de la saisie d’une valeur par l’utilisateur de la remplacer par un Maybe.Just(« laValeurSaisie »).

Ainsi lorsque le formulaire est envoyé, on peut récupérer la valeur dans l’objet de ce Maybe avec une fonction, et appliquer le traitement souhaité.

En code cela se passe de la manière suivante :

// maVariable est une variable provenant du formulaire

maVariable.matchWith({
	Nothing : () => queFaireSiAucuneValeur(),
	Just : valeur => traitementAAppliquer(valeur.value)
});

Il existe d’autres fonctions qui permettent de tester la variable maVariable pour connaitre son état, comme par exemple :

// maVariable contient un Maybe.Nothing()

maVariable.isJust //false
maVariable.isNothing //true

Cas 2 : Le résultat d’une requête à la BDD

Je souhaite évaluer le résultat d’une requête à la base de données et je peux avoir : soit un résultat, soit une erreur.

Dans ce cas on utilise Result().

Result() peut avoir 2 états :

• Error() : pour contenir les erreurs
• Ok() : pour contenir le résultat
  

La méthode consiste à renvoyer le résultat de la requête avec un Ok(), et de renvoyer un Error() dans la gestion des erreurs.

Ainsi lors de la réception de la réponse, on ne se préoccupe plus de tester le résultat. On décompose simplement le Result() avec la fonction matchwith() :

maVariable.matchwith({
	Error: err => fonctionDeGestionErreur(err.value),
	Ok: resultat => traitementAAppliquer(resultat.value)
});

Exemples pratiques

Pour mettre en oeuvre ces exemples, il faut créer un projet node.js à l’aide de NPM :

1. Créer un répertoire
2. Dans ce répertoire lancer la commande npm init
3. Suivre l’assistant
4. Installer Folktale : npm install --save folktale
5. Ouvrir index.js dans un éditeur
   

Exemple avec Maybe()

const Maybe = require('folktale/Maybe');

// const variable = Maybe.Nothing();
const variable = Maybe.Just('super valeur');

variable.matchWith({
  Nothing: () => console.log('Aucune valeur'),
  Just: (valeur) => console.log('La valeur est : ' + valeur.value),
});

Exemple avec Result()

const Result = require('folktale/Result');

// const variable = Result.Error("ceci est une erreur");
const variable = Result.Ok("Le résultat attendu");

variable.matchWith({
  Error: err => console.log(err.value),
  Ok: valeur => console.log('La valeur est : ' + valeur.value),
});

Si on alterne entre les 2 valeurs possibles de la variable en déplaçant les commentaires, le résultat change lors de l’exécution avec node index.js.

Conclusion

Avec ces méthodes je n’ai pas eu à faire à des valeurs undefined ou null. Cela nécessite un travail préparatoire lors de la définition des valeurs ou des fonctions de récupération de données, mais au final quel confort d’usage !

Cela peut amener à un peu de gymnastique si on ajoute un passage par Redux pour les projets en React, mais finalement ça se met très vite en place et cela permet de prévoir les différentes situations en amont.

Le typage fonctionne très bien avec Flow, mais je regrette que cette librairie ne soit pas compatible avec TypeScript (à l’heure où j’écris ces lignes). Il existe d’autres librairies dans ce cas si vous souhaitez les mettre en oeuvre.

C’est une technique que je continue à utiliser, même en dehors des projets en programmation fonctionnelle !

Et vous, ces techniques vous parlent, avez-vous d’autres méthodes ? N’hésitez pas à en faire part en commentaire.

article également disponible sur Medium :

• english version
• en français