Dans toutes les applications, il y a potentiellement des bugs lors de sa création :

  • Des cas qui ne sont pas anticipés
  • Des états qui sont changés de la mauvaise manière
  • Des données qui mal traités
  • Des comportements qui ne sont pas déclenchés dans une suite d'événements
  • etc...

Tous ces bugs ont de sérieuses conséquences sur l'application et son bon fonctionnement.

Généralement, dans le meilleur des cas, votre code va déclencher une exception et vous pourrez donc débugger à partir du log d'erreur.

En partant de la stack d'erreur que contient une exception, on peut déterminer d'où vient le problème, pourquoi et le corriger !

Dans le pire des cas, l'application continue de tourner sans prendre en compte l'erreur et cela peut engendrer des comportements non souhaités comme une interface qui ne répond plus.

L'utilisateur peut donc resté bloqué et des données peuvent êtres perdues ou totalement corrompus.

On va partir d'un exemple simple pour expliquer un principe que tu devrais appliquer à ta façon de coder .

Echouer rapidement

Le code JavaScript devrait suivre le principe de l'échec rapide pour rendre visible une erreur.

Avoir une exception avec la stack du log très tôt dans l'exécution d'un processus pour le montrer à l'utilisateur est mieux que d'échouer dans le silence le plus total.

Malheureusement, JavaScript n'est pas conçu pour ce principe .

Il est pauvrement typé par nature, ce qui peut être puissant, mais lui permet d'échouer en silence sans erreur.

Conversion de type implicite

L'une des choses importantes à prendre en compte avec JavaScript c'est qu'il effectue une conversion de type implicite .

Par exemple :

// La bonne vieille function somme !
function somme(nombre1, nombre2) {
		return nombre1 + nombre2;
}

Je pense que tu as compris à quoi sert cette fonction, le souci c'est qu'il y a un principe où on assume implicitement le type des arguments.

Si l'un des deux ou les deux ne sont pas des nombres, alors on va avoir un résultat qui est bien loin de la volonté première de cette fonction : additionner des nombres.

En JavaScript, on a la fâcheuse tendance d'écrire encore et encore des fonctions sans trop vérifier les types .

L'opération + est un dangereux, si on ne prend pas garde, on va concaténer des strings au lieu de faire une opération arithmétique.

Principe :

On veut éviter à tout prix l'ambiguïté de la conversion de type implicite.

Voici comment on devrait écrire cette fonction :

function somme(nombre1, nombre2) {
	if (
		// Si nombre 1 et 2 ne sont pas des types nombres et des variables pas définie
		!(
			// nombre 1 est un type nombre ET une variable définie
			typeof nombre1 === 'number' && !isNaN(nombre1)
			&&
			// nombre 2 est un type nombre ET une variable définie
			typeof nombre2 === 'number' && !isNaN(nombre2)
		)
	{
		throw new TypeError(
			'somme(): Les deux arguments doivent être des nombres. Arguments: "' + nombre1 + '" et "' + nombre2 + '"'
		);
	}
	return nombre1 + nombre2;
}

De cette manière, appliqué à l'ensemble de votre codebase, vous aurez toujours de quoi anticiper les erreurs.

Si la tâche d'un utilisateur est affectée par la fonction que vous avez codée, vous pourrez donc lui présenter une erreur utile et compréhensible. Si vous travaillez à plusieurs, vous vous assurez d'avoir une base de code très solide sur le long terme.

function userInteraction(article) {

	const { user, david } = article.humans;

	if (user.likeArticle) {
		if (!user.isFanFacebookPage) {
			user.likeFacebookPage();
		}
		user.shareFacebook();
		user.shareTwitter();
		user.shareLinkedin();
		david.notifyThankYou();
	} else {
		david.noOffence();
		david.notifyStillLoveYou();
	}

}

userInteraction(this);
Partages ! 😉