Comprendre le code propre : l'émergence ⚡️

Le chapitre 12 de Clean Code, intitulé « Émergence », explore la façon dont un logiciel propre et bien structuré émerge de l'adhésion aux principes fondamentaux de conception.

L'émergence dans la conception de logiciels fait référence au processus par lequel un comportement ou une fonctionnalité complexe découle de règles simples et bien comprises.

Le respect de ces règles peut aider les développeurs à créer des logiciels faciles à maintenir, à étendre et à comprendre.

Ce chapitre se concentre sur les quatre règles de conception simple, en mettant l'accent sur la simplicité et la testabilité pour un code propre et efficace.

? Les quatre règles d'une conception simple

• Réussit tous les tests
• Révèle l'intention
• Aucune duplication
• Minimise le nombre de classes et de méthodes

Décomposons chacune de ces règles et voyons comment elles s'appliquent en utilisant JavaScript.

1. Réussit tous les tests

La base d'un logiciel propre et émergent est qu'il doit être fonctionnel.

Tout le code doit réussir ses tests, garantissant que le comportement attendu est préservé et que les nouvelles fonctionnalités n'introduisent pas de bogues.

En JavaScript, cela est souvent réalisé en écrivant des tests unitaires avec des bibliothèques comme Jest ou Mocha.

function add(a, b) {
  return a + b;
}

// Test (using Jest)
test('adds 1 + 2 to equal 3', () => {
  expect(add(1, 2)).toBe(3);
});

En vous assurant que le logiciel réussit tous les tests, vous garantissez que le système fonctionne comme prévu.

Un code propre commence par des tests fiables. Sans cela, aucune des autres règles n'a d'importance.

2. Révèle l'intention

Le code doit communiquer ce qu'il fait. Des fonctions, variables et classes bien nommées peuvent rendre votre code facile à lire et à comprendre sans avoir besoin de commentaires.

Le code qui révèle son intention est explicite.

Mauvais nom :

function d(x) {
  return x * 2;
}

Bon nom :

function doubleNumber(number) {
  return number * 2;
}

Dans ce cas, doubleNumber() révèle clairement l'intention de la fonction.

Quiconque lit ce code peut immédiatement comprendre son objectif sans explications supplémentaires.

Cette pratique réduit non seulement la confusion mais améliore également la maintenabilité.

3. Pas de duplication

La duplication de code est l'un des plus grands ennemis des logiciels propres. Une logique répétée peut entraîner des bogues et un effort de maintenance accru.

L'objectif est de réduire la redondance en abstrayant les comportements courants dans des fonctions ou des modules réutilisables.

Duplication de code :

function calculateAreaOfSquare(side) {
  return side * side;
}

function calculateAreaOfRectangle(length, width) {
  return length * width;
}

Les deux fonctions effectuent des calculs similaires. En refactorisant, nous pouvons éliminer la duplication.

Aucune duplication :

function calculateArea(shape) {
  if (shape.type === 'square') {
    return shape.side * shape.side;
  } else if (shape.type === 'rectangle') {
    return shape.length * shape.width;
  }
}

En généralisant la fonction, nous éliminons la logique répétée et rendons le code plus maintenable.

4. Minimise le nombre de classes et de méthodes

La dernière règle de conception simple encourage à minimiser le nombre de classes et de méthodes sans sacrifier la clarté.

Cela signifie éviter toute complexité inutile.

Chaque classe ou fonction doit avoir une responsabilité claire et ciblée, adhérant au principe de responsabilité unique (SRP).

Trop de méthodes :

class User {
  constructor(name) {
    this.name = name;
  }

  getName() {
    return this.name;
  }

  setName(name) {
    this.name = name;
  }

  printWelcomeMessage() {
    console.log(`Welcome, ${this.name}!`);
  }

  // Additional unrelated methods
  getUserProfile() {
    // ... some logic
  }

  logActivity() {
    // ... some logic
  }
}

Cette classe a trop de responsabilités. Il doit se concentrer uniquement sur la gestion du nom de l’utilisateur.

Refactorisé :

class User {
  constructor(name) {
    this.name = name;
  }

  getName() {
    return this.name;
  }

  setName(name) {
    this.name = name;
  }
}

class Logger {
  static logActivity(user) {
    // ... some logic
    console.log(`${user.getName()} performed an activity.`);
  }
}

En séparant les préoccupations, le code devient plus simple et plus facile à maintenir.

Désormais, chaque classe a une seule responsabilité, adhérant aux principes du minimalisme et de la simplicité.

Conclusion

Les quatre règles de conception simple : réussir tous les tests, révéler l'intention, éliminer la duplication et minimiser le nombre de classes et de méthodes - guident la création d'un code propre, maintenable et émergent.

En suivant ces principes, la complexité est maîtrisée et votre code devient plus adaptable au changement.

Bon codage !

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!