Chapitre 10 – Les Classes

Clean Code — Chapitre 10 : Les Classes

Le chapitre 10 marque un tournant dans Clean Code. Après avoir parlé de fonctions, de tests, et de frontières, Martin s'attaque à la structure de plus haut niveau : les classes. Son message est clair : une classe propre est petite, a une seule responsabilité, et ses méthodes/propriétés sont fortement cohésives. En TypeScript/React, ce chapitre prend une dimension particulière avec les classes de services, les custom hooks, et les composants.

💡 L'idée clé du chapitre en une phrase :

« Les classes doivent être petites. Encore plus petites que ça. La première règle des classes : elles doivent être petites. La seconde : encore plus petites. »

  • SRP (Single Responsibility Principle) — Une classe = une seule raison de changer
  • Cohésion maximale — Chaque méthode utilise la plupart des propriétés de la classe
  • OCP (Open/Closed Principle) — Ouverte à l'extension, fermée à la modification
  • Petites classes, nombreuses — Mieux vaut 10 classes de 50 lignes qu'une classe de 500 lignes
Anatomie d'une classe propre ✅ Classe propre 1. Constantes publiques static readonly MAX_SIZE = 100 2. Propriétés privées private items: Item[] 3. Constructeur constructor(dependencies) 4. Méthodes publiques public add(), remove(), find() 5. Méthodes privées (helpers) 📐 Principes à respecter S Une seule responsabilité C Cohésion maximale P Petite (< 200 lignes) T Facilement testable O Ouverte/Fermée (OCP)

1. Organisation d'une classe — convention standard

Martin propose une convention simple et universelle pour l'organisation interne d'une classe. En TypeScript, cela se traduit directement :

  1. Constantes statiques publiques en premier
  2. Propriétés privées ensuite
  3. Constructeur (ou propriétés promues en TypeScript)
  4. Méthodes publiques — l'API de la classe
  5. Méthodes privées — les helpers, juste après les méthodes publiques qui les appellent

📐 Classe bien organisée en TypeScript

// ✅ Organisation Clean Code appliquée
export class ShoppingCart {
  // ──────────────────────────────────────────
  // 1. Constantes publiques
  // ──────────────────────────────────────────
  static readonly MAX_ITEMS = 100;
  static readonly DEFAULT_CURRENCY = "EUR";

  // ──────────────────────────────────────────
  // 2. Propriétés privées
  // ──────────────────────────────────────────
  private items: CartItem[] = [];
  private discount: Discount | null = null;

  // ──────────────────────────────────────────
  // 3. Constructeur (avec promoted properties)
  // ──────────────────────────────────────────
  constructor(
    private readonly userId: string,
    private readonly currency: string = ShoppingCart.DEFAULT_CURRENCY
  ) {}

  // ──────────────────────────────────────────
  // 4. Méthodes publiques (API)
  // ──────────────────────────────────────────
  public addItem(product: Product, quantity: number): void {
    this.validateQuantity(quantity);
    
    const existingItem = this.findItemByProductId(product.id);
    if (existingItem) {
      existingItem.quantity += quantity;
    } else {
      this.items.push({ product, quantity });
    }
  }

  public removeItem(productId: string): void {
    this.items = this.items.filter(item => item.product.id !== productId);
  }

  public calculateTotal(): number {
    const subtotal = this.calculateSubtotal();
    return this.applyDiscount(subtotal);
  }

  public applyDiscountCode(code: string): void {
    this.discount = this.validateDiscountCode(code);
  }

  // ──────────────────────────────────────────
  // 5. Méthodes privées (helpers)
  // ──────────────────────────────────────────
  private validateQuantity(quantity: number): void {
    if (quantity <= 0) throw new Error("Quantité invalide");
    if (this.items.length >= ShoppingCart.MAX_ITEMS) {
      throw new Error("Panier plein");
    }
  }

  private findItemByProductId(id: string): CartItem | undefined {
    return this.items.find(item => item.product.id === id);
  }

  private calculateSubtotal(): number {
    return this.items.reduce(
      (sum, item) => sum + item.product.price * item.quantity,
      0
    );
  }

  private applyDiscount(amount: number): number {
    if (!this.discount) return amount;
    return amount * (1 - this.discount.percentage / 100);
  }

  private validateDiscountCode(code: string): Discount {
    // Logique de validation...
    return { code, percentage: 10 };
  }
}

🔵 Convention de lisibilité : Lisez la classe de haut en bas comme un journal. Les méthodes publiques en premier (ce qui intéresse le lecteur), les détails d'implémentation (privées) après. Cette organisation est aussi celle de ESLint avec @typescript-eslint/member-ordering.

2. Le principe SRP — Single Responsibility Principle

C'est le principe le plus important du chapitre. SRP : Une classe ne devrait avoir qu'une seule raison de changer. Si vous modifiez la logique de persistance en base, et que ça casse votre validation métier, c'est que votre classe viole SRP.

❌ Viole SRP — tout dans une classe

class User {
  constructor(
    public name: string,
    public email: string
  ) {}

  // Responsabilité 1 : Validation
  validate(): boolean {
    return this.email.includes("@");
  }

  // Responsabilité 2 : Persistance
  save(): void {
    fetch("/api/users", {
      method: "POST",
      body: JSON.stringify(this),
    });
  }

  // Responsabilité 3 : Rendu
  toHTML(): string {
    return `<div>${this.name}</div>`;
  }
}
// ❌ 3 raisons de changer cette classe :
// - validation change
// - API change
// - UI change

✅ Respecte SRP — une responsabilité par classe

// Une seule responsabilité : représenter un User
class User {
  constructor(
    public readonly name: string,
    public readonly email: string
  ) {}
}

// Responsabilité : valider un User
class UserValidator {
  validate(user: User): boolean {
    return user.email.includes("@");
  }
}

// Responsabilité : persister un User
class UserRepository {
  async save(user: User): Promise<void> {
    await fetch("/api/users", {
      method: "POST",
      body: JSON.stringify(user),
    });
  }
}

// Responsabilité : afficher un User
function UserCard({ user }: { user: User }) {
  return <div>{user.name}</div>;
}
// ✅ Chaque classe change pour UNE raison

S Single Responsibility Principle

Définition : Une classe = une seule raison de changer. Si vous hésitez à nommer une classe, c'est qu'elle fait probablement trop de choses.

Test simple : Décrivez la classe en une phrase sans « et » ni « ou ». Si vous ne pouvez pas, elle viole SRP.

🎯 Comment détecter une violation de SRP ?

Posez-vous la question : « Si je change X, est-ce que cette classe doit changer ? » Si oui pour plusieurs X différents (validation, persistance, affichage, calcul...), vous violez SRP. Séparez en plusieurs classes.

3. Cohésion — les méthodes doivent utiliser les propriétés

Une classe est cohésive quand chaque méthode utilise la plupart (idéalement toutes) les propriétés de la classe. Si une méthode n'utilise qu'une ou deux propriétés sur dix, c'est un signal qu'elle devrait probablement être dans une autre classe.

📊 Cohésion — Visualisation

Haute cohésion (90%)
Faible (0%) Moyenne (50%) Haute (100%)

Objectif : Chaque méthode utilise ≥80% des propriétés

❌ Faible cohésion — signaux d'alarme

class ReportGenerator {
  private data: Data[];
  private config: Config;
  private logger: Logger;
  private emailClient: EmailClient;
  private pdfGenerator: PDFGenerator;

  // Utilise : data, config
  generateReport(): Report {
    return this.config.format(this.data);
  }

  // Utilise : logger uniquement
  logActivity(msg: string): void {
    this.logger.log(msg);
  }

  // Utilise : emailClient uniquement
  sendEmail(to: string): void {
    this.emailClient.send(to, "Report");
  }

  // Utilise : pdfGenerator uniquement
  exportPDF(): Buffer {
    return this.pdfGenerator.create();
  }
}
// ❌ Faible cohésion : chaque méthode
// utilise 1-2 propriétés sur 5

✅ Haute cohésion — classes séparées

// Classe 1 : génération du rapport
class ReportGenerator {
  constructor(
    private data: Data[],
    private config: Config
  ) {}

  generate(): Report {
    return this.config.format(this.data);
  }
}

// Classe 2 : export PDF
class PDFExporter {
  constructor(
    private pdfGenerator: PDFGenerator
  ) {}

  export(report: Report): Buffer {
    return this.pdfGenerator.create(report);
  }
}

// Classe 3 : notification
class ReportNotifier {
  constructor(
    private emailClient: EmailClient,
    private logger: Logger
  ) {}

  notify(report: Report, to: string): void {
    this.logger.log(`Sending to ${to}`);
    this.emailClient.send(to, report);
  }
}
// ✅ Chaque classe : haute cohésion

⚠️ Le refactoring vers plus de cohésion produit souvent plus de petites classes. C'est normal et souhaitable. Mieux vaut 5 classes de 30 lignes très cohésives qu'une classe de 150 lignes peu cohésive.

4. Le principe OCP — Open/Closed Principle

OCP : Une classe doit être ouverte à l'extension, fermée à la modification. En clair : vous devez pouvoir ajouter de nouvelles fonctionnalités sans modifier le code existant. Cela passe par l'utilisation d'interfaces et de composition.

O Open/Closed Principle

Définition : Ouverte à l'extension (on peut ajouter du comportement), fermée à la modification (sans toucher au code existant).

Mécanisme : Utiliser des interfaces/abstractions pour injecter de nouveaux comportements.

❌ Viole OCP — modification directe

class PaymentProcessor {
  process(method: string, amount: number) {
    if (method === "card") {
      // Traiter carte
      console.log(`Carte: ${amount}€`);
    } else if (method === "paypal") {
      // Traiter PayPal
      console.log(`PayPal: ${amount}€`);
    }
    // ⚠️ Ajouter Stripe = modifier cette classe
  }
}

// Pour ajouter Stripe, il faut modifier
// le code existant → risque de casser
// les paiements carte et PayPal

✅ Respecte OCP — extension sans modification

// Interface stable
interface PaymentMethod {
  process(amount: number): void;
}

// Implémentations fermées
class CardPayment implements PaymentMethod {
  process(amount: number): void {
    console.log(`Carte: ${amount}€`);
  }
}

class PayPalPayment implements PaymentMethod {
  process(amount: number): void {
    console.log(`PayPal: ${amount}€`);
  }
}

// Nouvelle méthode = nouvelle classe
// SANS toucher au code existant
class StripePayment implements PaymentMethod {
  process(amount: number): void {
    console.log(`Stripe: ${amount}€`);
  }
}

// Processeur générique
class PaymentProcessor {
  process(method: PaymentMethod, amount: number) {
    method.process(amount);
  }
}
// ✅ Extension par ajout, pas par modification

🔵 En React : OCP se traduit par des composants qui acceptent des children ou des props de type fonction (render props, slots). Vous étendez le comportement sans modifier le composant source.

5. Application concrète en React — Classes vs Hooks

React moderne privilégie les hooks et les fonctions aux class components. Mais les principes du chapitre 10 s'appliquent toujours — surtout pour les services, les stores, et la logique métier complexe.

Quand utiliser des classes en TypeScript/React ?

Contexte Classes Hooks/Fonctions Recommandation
Composants UI ❌ Déprécié ✅ Fonction + hooks Toujours fonctionnel
Services métier ✅ Classes ⚠️ Fonctions pures Classes avec DI
State management ✅ Classes (MobX, stores) ✅ Hooks (Zustand, Jotai) Selon complexité
Utilitaires ❌ Overkill ✅ Fonctions pures Fonctions simples
Repositories ✅ Classes ❌ Moins testable Classes avec interface

Appliquer SRP dans un composant React

🧩 Refactoring d'un composant qui viole SRP

// ❌ AVANT — Composant qui fait tout (viole SRP)
function UserDashboard() {
  const [users, setUsers] = useState<User[]>([]);
  const [filter, setFilter] = useState("");
  const [sortBy, setSortBy] = useState<"name" | "email">("name");

  // Responsabilité 1 : Fetching
  useEffect(() => {
    fetch("/api/users")
      .then(res => res.json())
      .then(setUsers);
  }, []);

  // Responsabilité 2 : Filtrage
  const filtered = users.filter(u =>
    u.name.toLowerCase().includes(filter.toLowerCase())
  );

  // Responsabilité 3 : Tri
  const sorted = [...filtered].sort((a, b) =>
    sortBy === "name"
      ? a.name.localeCompare(b.name)
      : a.email.localeCompare(b.email)
  );

  // Responsabilité 4 : Rendu
  return (
    <div>
      <input onChange={e => setFilter(e.target.value)} />
      <select onChange={e => setSortBy(e.target.value as any)}>
        <option value="name">Nom</option>
        <option value="email">Email</option>
      </select>
      {sorted.map(user => (
        <div key={user.id}>{user.name}</div>
      ))}
    </div>
  );
}

// ──────────────────────────────────────────────────────────────
// ✅ APRÈS — SRP appliqué : une responsabilité par hook/composant
// ──────────────────────────────────────────────────────────────

// Hook : Fetching uniquement
function useUsers() {
  const [users, setUsers] = useState<User[]>([]);
  
  useEffect(() => {
    fetch("/api/users")
      .then(res => res.json())
      .then(setUsers);
  }, []);
  
  return users;
}

// Hook : Filtrage/Tri
function useFilteredUsers(
  users: User[],
  filter: string,
  sortBy: "name" | "email"
) {
  return useMemo(() => {
    const filtered = users.filter(u =>
      u.name.toLowerCase().includes(filter.toLowerCase())
    );
    return [...filtered].sort((a, b) =>
      sortBy === "name"
        ? a.name.localeCompare(b.name)
        : a.email.localeCompare(b.email)
    );
  }, [users, filter, sortBy]);
}

// Composant : Contrôles uniquement
function UserFilters({
  filter,
  sortBy,
  onFilterChange,
  onSortChange,
}: {
  filter: string;
  sortBy: "name" | "email";
  onFilterChange: (value: string) => void;
  onSortChange: (value: "name" | "email") => void;
}) {
  return (
    <div>
      <input value={filter} onChange={e => onFilterChange(e.target.value)} />
      <select value={sortBy} onChange={e => onSortChange(e.target.value as any)}>
        <option value="name">Nom</option>
        <option value="email">Email</option>
      </select>
    </div>
  );
}

// Composant : Affichage uniquement
function UserList({ users }: { users: User[] }) {
  return (
    <div>
      {users.map(user => (
        <div key={user.id}>{user.name}</div>
      ))}
    </div>
  );
}

// Composant orchestrateur (coordination uniquement)
function UserDashboard() {
  const [filter, setFilter] = useState("");
  const [sortBy, setSortBy] = useState<"name" | "email">("name");
  
  const users = useUsers();
  const filteredUsers = useFilteredUsers(users, filter, sortBy);

  return (
    <div>
      <UserFilters
        filter={filter}
        sortBy={sortBy}
        onFilterChange={setFilter}
        onSortChange={setSortBy}
      />
      <UserList users={filteredUsers} />
    </div>
  );
}
// ✅ Chaque composant/hook a UNE responsabilité claire

Classes de services en React — avec injection

🏗️ Service class propre avec SRP + OCP

// domain/services/UserService.ts
export class UserService {
  // ✅ SRP : ce service gère UNIQUEMENT la logique métier User
  // ✅ OCP : utilise des interfaces pour être extensible
  
  constructor(
    private repository: IUserRepository,
    private validator: IUserValidator,
    private logger: ILogger
  ) {}

  async createUser(data: CreateUserDTO): Promise<User> {
    // Validation
    const validationResult = this.validator.validate(data);
    if (!validationResult.isValid) {
      throw new ValidationError(validationResult.errors);
    }

    // Persistance
    const user = await this.repository.create(data);

    // Logging
    this.logger.info("User created", { userId: user.id });

    return user;
  }

  async findUser(id: string): Promise<User> {
    const user = await this.repository.findById(id);
    if (!user) throw new NotFoundError("User", id);
    return user;
  }

  async updateUser(id: string, updates: Partial<User>): Promise<User> {
    const user = await this.findUser(id);
    
    // Validation partielle
    if (updates.email) {
      const isValid = this.validator.validateEmail(updates.email);
      if (!isValid) throw new ValidationError(["email"]);
    }

    const updated = await this.repository.update(id, updates);
    this.logger.info("User updated", { userId: id });
    
    return updated;
  }
}

// hooks/useUserService.ts — Injection via Context
import { useContext } from "react";
import { ServicesContext } from "@/contexts/ServicesContext";

export function useUserService() {
  const { userService } = useContext(ServicesContext);
  if (!userService) throw new Error("ServicesContext missing");
  return userService;
}

// components/CreateUserForm.tsx — Usage propre
function CreateUserForm() {
  const userService = useUserService();
  const [error, setError] = useState<string | null>(null);

  const handleSubmit = async (data: CreateUserDTO) => {
    try {
      const user = await userService.createUser(data);
      console.log("User created:", user);
    } catch (e) {
      if (e instanceof ValidationError) {
        setError("Données invalides");
      } else {
        setError("Erreur serveur");
      }
    }
  };

  return (
    <form onSubmit={handleSubmit}>
      {/* formulaire */}
      {error && <div className="error">{error}</div>}
    </form>
  );
}

Checklist de refactoring — Appliquer le chapitre 10

1 Identifier les responsabilités multiples — Listez tout ce que fait une classe/composant. Si >1 : violer SRP.
2 Extraire en classes/hooks séparés — Une responsabilité = une classe/hook. Nommez-les clairement.
3 Vérifier la cohésion — Chaque méthode utilise-t-elle ≥80% des propriétés ? Sinon, séparer.
4 Introduire des interfaces — Pour respecter OCP, dépendre d'abstractions, pas d'implémentations concrètes.
5 Tests : une classe = un fichier de test — Si votre test est complexe, c'est que la classe fait trop.

À Retenir

  • Les classes doivent être petites — Encore plus petites que ce que vous pensez. <200 lignes est un bon objectif, <100 est excellent.
  • SRP (Single Responsibility Principle) — Une classe = une seule raison de changer. Si vous hésitez sur le nom, elle fait probablement trop de choses.
  • Cohésion maximale — Chaque méthode doit utiliser la majorité des propriétés. Si ce n'est pas le cas, créez une nouvelle classe.
  • OCP (Open/Closed Principle) — Ouverte à l'extension (nouveaux comportements), fermée à la modification (code existant intact). Utiliser interfaces et injection de dépendances.
  • Organisation standard — 1) Constantes publiques, 2) Propriétés privées, 3) Constructeur, 4) Méthodes publiques, 5) Méthodes privées.
  • En React moderne — Privilégier hooks et fonctions pour les composants. Utiliser classes pour services, repositories, state management complexe (avec DI).
  • Refactoring progressif — Extraire les responsabilités une par une. Mieux vaut 10 petites classes cohésives qu'une grosse classe tentaculaire.
  • Test de SRP — Décrire la classe en une phrase sans « et » ni « ou ». Si impossible, elle viole SRP.

⏱️ Temps pour refactorer une classe violant SRP : ~1-2h pour identifier et extraire les responsabilités. Sur un nouveau projet : appliquer SRP dès le début = architecture propre native.