Pourquoi Ken de Street Fighter peut t'aider à mieux coder 🤔

Introduction

Si tu es un développeur, tu connais sûrement cette sensation : tu tombes sur une fonction qui s'étend sur plusieurs lignes, pleine de conditions et de boucles imbriquées, et tu te demandes comment tu vas en sortir vivant. 😵
Eh bien, imagine un instant que Ken de Street Fighter fait un "hurricane kick" à travers ta fonction. Tu visualises l'effet chaotique ? C’est exactement ce qui se passe quand une fonction est trop profondément imbriquée.

Dans son livre incontournable Clean Code, Robert Martin (aka Uncle Bob) propose une règle simple mais efficace pour prévenir ce genre de situations : limiter le nombre d'indentations dans une fonction. Cette approche permet d'éviter une cascade de conditions et de boucles qui rendent le code difficile à lire, à maintenir et à comprendre.

Voyons ensemble pourquoi c’est si important, et surtout comment appliquer cette règle dans tes projets.

Pourquoi limiter les indentations ?

L’indentation, c’est ce que tu fais automatiquement lorsque tu ajoutes une nouvelle condition ou une boucle dans ton code. Bien que ça puisse sembler anodin au début, chaque niveau supplémentaire d’indentation complique un peu plus la lecture et la compréhension du code. Voici pourquoi :

1. Un code imbriqué devient difficile à lire 📉
   Chaque niveau supplémentaire d’indentation alourdit la structure de la fonction. Si tu dois parcourir plusieurs niveaux de conditions pour comprendre ce qui se passe, cela augmente le temps nécessaire pour déchiffrer le comportement du code.

2. La complexité cognitive augmente 💻
   Plus il y a d'indentations, plus la charge mentale nécessaire pour suivre le flux logique de la fonction est élevée. Cela alourdit la compréhension et introduit des risques d’erreurs. Tu te retrouves à jongler avec plusieurs scénarios en parallèle, ce qui est loin d’être idéal.

3. Un code trop imbriqué révèle souvent une fonction qui fait trop de choses ⚙️
   Une fonction qui accumule des niveaux d'indentation indique souvent qu'elle a plusieurs responsabilités. Or, une fonction devrait avoir une seule mission claire, comme le préconise le principe S de SOLID (Single Responsibility Principle).

Comment réduire les indentations dans ton code ✨

Maintenant que tu sais pourquoi les indentations excessives sont problématiques, voyons comment les réduire. Voici trois astuces pour rendre ton code plus propre et plus lisible :

1. Inverser les conditions pour éviter les blocs de code imbriqués

Souvent, tu te retrouves avec une grande condition if qui imbrique du code. Une bonne pratique est d'inverser la logique de cette condition et d'utiliser un return ou un continue plus tôt pour sortir rapidement de la fonction. Cela permet de réduire les niveaux d’imbrication et de maintenir la fonction plus plate.

// Code imbriqué
function processOrder(order) {
  if (order.isValid()) {
    if (order.hasStock()) {
      // code de traitement
    }
  }
}

// Code avec condition inversée
function processOrder(order) {
  if (!order.isValid()) return
  if (!order.hasStock()) return

  // code de traitement
}

2. Extraire des sous-fonctions pour clarifier la logique

Si tu vois que ta fonction commence à accumuler les indentations, il est peut-être temps d’extraire certaines parties de la logique dans des sous-fonctions. Cela permet de segmenter le comportement en plusieurs fonctions plus petites, chacune ayant une mission bien définie.

// Fonction trop imbriquée
function processPayment(order) {
  if (order.isValid()) {
    if (order.hasStock()) {
      if (order.isPaid()) {
        // traitement du paiement
      }
    }
  }
}

// Fonction simplifiée avec sous-fonctions
function processPayment(order) {
  if (!isOrderProcessable(order)) return
  handlePayment(order)
}

function isOrderProcessable(order) {
  return order.isValid() && order.hasStock() && order.isPaid()
}

function handlePayment(order) {
  // traitement du paiement
}

3. Une fonction doit faire une seule chose

C’est un principe fondamental de Clean Code : chaque fonction ne doit avoir qu’une seule responsabilité. Si tu vois que ta fonction fait plusieurs choses (par exemple, vérifier la validité d’une commande, traiter le paiement, envoyer un email, etc.), divise-la en plusieurs fonctions. Une fonction qui fait une seule chose est plus facile à comprendre, à tester et à maintenir.

// Mauvais exemple : trop de responsabilités
function completeOrder(order) {
  if (order.isValid()) {
    processPayment(order)
    sendConfirmationEmail(order)
  }
}

// Bon exemple : une seule responsabilité par fonction
function completeOrder(order) {
  if (!order.isValid()) return

  processOrderPayment(order)
}

function processOrderPayment(order) {
  processPayment(order)
  sendConfirmationEmail(order)
}

En résumé 📝

Comme le montre notre analogie avec Ken de Street Fighter, une fonction avec trop d’indentations est aussi destructrice pour la lisibilité de ton code qu’un coup de pied tournoyant l’est pour un adversaire. 🌀
C'est pourquoi il est crucial de limiter la profondeur des indentations pour rendre ton code plus lisible et plus simple à comprendre.

Alors, souviens-toi : les cascades d'eau, c'est bien 💧, mais les cascades de if, de for ou de while... c'est à éviter à tout prix. ❌

Cet article t'a donné envie de nettoyer ton code ? 🧼 Alors, prends tes fonctions à bras-le-corps, réduis les indentations, et deviens maître du "code propre" ! 👊