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
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 :
- Constantes statiques publiques en premier
- Propriétés privées ensuite
- Constructeur (ou propriétés promues en TypeScript)
- Méthodes publiques — l'API de la classe
- 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
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
À 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.