Clean Code en TypeScript : principes et exemples pour les praticiens

Clean Code en TypeScript : principes et exemples pratiques

Le code propre (Clean Code) n'est pas simplement un terme à la mode, mais une compétence fondamentale pour tout développeur professionnel. Dans le contexte de TypeScript, qui ajoute un typage statique au monde dynamique de JavaScript, les principes du code propre deviennent encore plus importants. TypeScript nous offre des outils puissants pour l'auto-documentation du code, mais sans une approche correcte, ils peuvent se transformer en chaos.

Dans cet article, nous allons analyser les principes clés du Clean Code appliqués à TypeScript et examiner des exemples pratiques qui vous aideront à écrire un code plus lisible, maintenable et fiable.

1. Nommage : parlez le langage métier

Le premier principe, et le plus évident, du Clean Code est un nommage correct. Les noms des variables, fonctions, classes et interfaces doivent refléter leur essence et l'intention du développeur. TypeScript, avec son typage strict, permet de rendre les noms encore plus informatifs.

Mauvais exemple :

// Que fait cette fonction ? Combien de temps faut-il pour le comprendre ?function d(a: number, b: number): number {    return a * b - (a + b);}

// Et cette interface, qu'est-ce que c'est ?interface I {    n: string;    a: number;    e: string;}

Bon exemple :

// Fonction de calcul de remise avec seuilfunction calculateDiscountedPrice(price: number, discountPercent: number): number {    const discountAmount = price * (discountPercent / 100);    return price - discountAmount;}

// Interface utilisateur avec des champs explicitesinterface UserProfile {    name: string;    age: number;    email: string;}

Règles pour TypeScript :

• Interfaces — utilisez des noms sans préfixe I (par exemple, User, pas IUser). TypeScript moderne et ESLint recommandent cette approche.
• Types — pour les unions complexes, utilisez le symbole | et des noms significatifs : StatusType, ApiResponse.
• Variables booléennes — commencez par is, has, should : isActive, hasPermission.
• Fonctions — utilisez des verbes : getUserData, validateEmail, processOrder.

2. SOLID en TypeScript : application pratique

Les principes SOLID (Single Responsibility, Open-Closed, Liskov Substitution, Interface Segregation, Dependency Inversion) s'intègrent parfaitement à TypeScript grâce au support des interfaces, des classes abstraites et des génériques.

Principe de responsabilité unique (SRP) : une classe ne doit avoir qu'une seule raison de changer.

// Violation du SRP : la classe fait trop de chosesclass UserService {    createUser(data: any) { /* ... */ }    sendEmail(email: string) { /* ... */ }    generateReport() { /* ... */ }}

// Approche correcte : séparation des responsabilitésclass UserRepository {    save(user: User): void { /* ... */ }}

class EmailService {    sendWelcomeEmail(email: string): void { /* ... */ }}

class ReportGenerator {    generateUserReport(users: User[]): Report { /* ... */ }}

Principe de substitution de Barbara Liskov (LSP) : les sous-classes doivent être interchangeables avec la classe de base. En TypeScript, cela est particulièrement pertinent lors de l'utilisation de l'héritage.

// Violation du LSP : la sous-classe réduit le contratclass Bird {    fly(): void { console.log('Flying'); }}

class Penguin extends Bird {    fly(): void {        throw new Error('Penguins cannot fly!');    }}

// Correct : extraction d'une interfaceinterface Flyable {    fly(): void;}

class Bird implements Flyable {    fly(): void { console.log('Flying'); }}

class Penguin {    s