Pourquoi tes fonctions ne doivent pas avoir d'effets secondaires

Introduction

Dans le monde du développement logiciel, écrire du code propre et maintenable est un défi permanent.

Parmi les nombreux concepts que Robert Martin aka Oncle Bob aborde dans son livre Clean Code, l’idée qu’une fonction ne doit pas avoir d’effets secondaires (side effects) est particulièrement cruciale.

Si tu souhaites améliorer la qualité de ton code et éviter des bugs difficiles à débusquer, comprendre ce principe est indispensable.

Qu’est-ce qu’un effet secondaire ?

En termes simples, un effet secondaire est un changement d'état qui survient en dehors du cadre direct d'une fonction.

Cela peut être la modification d’une variable globale, l’altération d’un objet passé en paramètre, ou même l’écriture dans un fichier ou la console.

En bref, un effet secondaire se produit chaque fois qu'une fonction affecte des parties du programme qui ne sont pas strictement liées à sa tâche principale.

Prenons un exemple pour mieux comprendre.

Exemple d’une fonction avec effet secondaire :

let total = 0

function addToTotal(amount: number) {
  total += amount
  console.log(`Total: ${total}`)
}

Pourquoi éviter les effets secondaires ?

1. Prévisibilité et simplicité : Une fonction sans effet secondaire est simple à comprendre.
   Tu sais qu’en passant une entrée donnée, tu obtiendras toujours le même résultat sans te soucier de l’impact sur d’autres parties du programme.
   Cela rend ton code prévisible et réduit les surprises.

2. Débogage plus facile : Imagine un bug où une variable globale a une valeur incorrecte.
   Si cette variable est manipulée par plusieurs fonctions avec des effets secondaires, retrouver l’origine du bug peut s’avérer un véritable casse-tête.
   En évitant ces effets, tu t’épargnes des heures de débogage.

3. Tests unitaires simplifiés : Tester une fonction avec des effets secondaires est compliqué.
   Si la fonction modifie l'état global ou produit des effets externes (comme écrire dans un fichier), les tests doivent prendre en compte ces impacts, ce qui complique la couverture des tests.
   À l'inverse, une fonction sans effet secondaire est beaucoup plus facile à tester en isolation.

Comment éviter les effets secondaires ?

Le principe est simple : tes fonctions doivent être pures.

Une fonction pure est une fonction qui, pour un ensemble d’entrées données, retourne toujours le même résultat sans modifier l'état global du programme.

Voici un exemple d'une telle fonction :

function add(a: number, b: number): number {
  return a + b
}

Bien gérer les objets

L’une des sources fréquentes d’effets secondaires survient lorsque des objets sont passés en paramètres.

Si une fonction modifie un objet passé en argument, elle introduit un effet secondaire subtil. Il est donc important de retourner une nouvelle instance avec une valeur modifiée, au lieu de changer l'objet d'origine.

Voici comment éviter cela :

Mauvaise pratique :

function incrementAge(person: { age: number }) {
  person.age++
}

Bonne pratique :

function incrementAge(person: { age: number }): { age: number } {
  return { age: person.age + 1 }
}

Les exceptions

Bien sûr, il existe des cas où des effets secondaires sont inévitables, comme l’écriture dans une base de données ou l’appel à une API. Mais même dans ces cas, il est crucial de structurer ton code de manière à isoler ces opérations.

Un bon moyen d’y parvenir est d’utiliser des fonctions de plus haut niveau pour gérer les effets secondaires, en maintenant les autres fonctions aussi pures que possible.

Conclusion

Oncle Bob nous enseigne dans Clean Code que l’absence d’effets secondaires dans une fonction rend le code plus propre, plus facile à comprendre, à tester et à maintenir.

En appliquant cette règle, tu réduis les risques d’introduire des bugs subtils et facilites le travail de ceux qui reprendront ton code plus tard — ou même à toi-même dans quelques mois.

En fin de compte, écrire des fonctions sans effet secondaire est un pas important vers un code plus robuste et plus durable.