🚫
methodologie

DRY

Principe "Don't Repeat Yourself" : chaque concept doit avoir une seule représentation dans le code.

Qu'est-ce que le principe DRY ?

DRY (Don't Repeat Yourself) est un principe de développement logiciel formule par Andy Hunt et Dave Thomas dans leur livre "The Pragmatic Programmer" (1999). Il stipule que "chaque élément de connaissance doit avoir une représentation unique, non ambigue et faisant autorité au sein d'un système". En pratique, cela signifie éviter la duplication de logique, de données et de configuration.

Application du principe DRY

La duplication de code est la forme la plus visible : deux blocs de code identiques ou presque identiques. La solution est l'extraction dans une fonction, une classe ou un module réutilisable. La duplication de logique est plus subtile : deux blocs de code différents en surface mais implémentant le même concept métier. La duplication de données concerne les mêmes informations stockées à plusieurs endroits (schéma de base de données et code de validation dupliques). La duplication de configuration survient quand les mêmes paramètres sont repetes dans plusieurs fichiers.

Techniques pour appliquer DRY

Extraction de fonctions : identifier les blocs de code repetes et les isoler dans des fonctions nommées. Abstraction : créer des classes ou interfaces pour les concepts partages. Centralisation de la configuration : fichiers de constantes, variables d'environnement, fichiers de config centralises. Génération de code : schémas qui génèrent la validation, les types et la documentation (OpenAPI, Prisma, GraphQL codegen). Templates et génériques : code parametrable qui s'adapte a différents types de données.

Limites et pièges du DRY

Le DRY excessif est un piège courant. Deux morceaux de code qui se ressemblent ne representent pas forcement le même concept. Forcer une abstraction prematuree pour éviter la duplication cree un couplage inapproprie : quand un des cas evolue differemment, l'abstraction devient un frein. La règle pratique : la duplication est acceptable tant qu'il n'y a pas trois occurrences (rule of three). Un code duplique mais simple est souvent préférable à une abstraction complexe et fragile.

DRY vs WET vs AHA

WET (Write Everything Twice / We Enjoy Typing) est l'anti-pattern de la duplication excessive. AHA (Avoid Hasty Abstractions), propose par Kent C. Dodds, recommande de préférer la duplication à une mauvaise abstraction. "Optimisez pour le changement d'abord, puis pour la duplication." L'objectif n'est pas zéro duplication mais le bon équilibre entre réutilisation et simplicité. Le contexte determine le bon choix : dans une bibliothèque, DRY est crucial ; dans un script jetable, la duplication est acceptable.

Besoin d'aide technique ?

Decrivez votre projet pour des conseils personnalises par nos experts.

Recevoir des conseils

Questions fréquentes

Quand est-il acceptable de dupliquer du code ?
Quand les deux occurrences representent des concepts metier differents qui evoluent independamment, quand une abstraction serait plus complexe que la duplication, quand il n'y a que deux occurrences (attendez la troisieme), et dans les tests (la lisibilite et l'independance des tests priment sur le DRY).
Le DRY s'applique-t-il aux tests unitaires ?
Avec moderation. Les tests doivent etre independants et lisibles. Trop de factorisation dans les tests (fixtures partagees, helpers abstraits) les rend fragiles et difficiles a comprendre. Privilegiez des tests explicites meme si cela implique une certaine repetition. Les fixtures de setup et les factories de donnees sont un bon compromis.

Pages liées

Chaque semaine, le meilleur de la tech française

Tendances, salaires, outils et opportunités — directement dans votre boîte mail.

Gratuit. Desabonnement en un clic. Pas de spam.