Specialiste de la Dette Technique & des Code Smells
Un agent IA specialise dans l'identification des code smells, de la dette technique et des problemes de maintenabilite qui causeront des problemes a mesure que votre code grandit. Trouve les problemes structurels avant qu'ils ne s'accumulent.
Problemes structurels rendant le code difficile a maintenir, etendre ou comprendre
Problemes structurels indiquant des problemes de conception plus profonds dans votre code
Problemes de conception orientee objet rendant le code difficile a modifier et tester
Violations des principes de conception fondamentaux menant a un code rigide et fragile
Chemins de code trop complexes pour etre compris, testes ou maintenus en securite
Limites objectives signalant quand le code necessite un refactoring
Les methodes doivent tenir sur un ecran
Les classes doivent avoir une seule responsabilite
Envisagez un objet d'options
Extraire des fonctions ou utiliser des retours anticipes
Trop de chemins pour tester de maniere fiable
Extraire vers une fonction partagee
Voyez comment le Conseiller en Refactoring identifie les problemes et suggere des patterns specifiques
function processOrder(order) {
// Valider la commande
if (!order.items || order.items.length === 0) {
throw new Error('Commande vide')
}
if (!order.customer) {
throw new Error('Pas de client')
}
// Calculer les totaux
let subtotal = 0
for (const item of order.items) {
subtotal += item.price * item.quantity
}
const tax = subtotal * 0.1
const total = subtotal + tax
// Appliquer les remises
let discount = 0
if (order.customer.isPremium) {
discount = total * 0.15
} else if (subtotal > 100) {
discount = total * 0.05
}
return total - discount
}Methode faisant 4 choses: validation, calcul, taxes, remises
function processOrder(order) {
validateOrder(order)
const subtotal = calculateSubtotal(order.items)
const total = applyTax(subtotal)
return applyDiscount(total, order.customer)
}
function validateOrder(order) {
if (!order.items?.length) throw new Error('Commande vide')
if (!order.customer) throw new Error('Pas de client')
}
function calculateSubtotal(items) {
return items.reduce((sum, item) =>
sum + item.price * item.quantity, 0)
}Extract Method: chaque fonction fait une seule chose bien
function calculateShipping(order) {
switch (order.shippingType) {
case 'express':
return order.weight * 5.0 + 15
case 'standard':
return order.weight * 2.5 + 5
case 'economy':
return order.weight * 1.0
case 'freight':
return order.weight * 0.5 + 50
default:
throw new Error('Type inconnu')
}
}Switch qui grandit avec chaque nouveau type de livraison
interface ShippingStrategy {
calculate(weight: number): number
}
const shippingStrategies: Record<string, ShippingStrategy> = {
express: { calculate: w => w * 5.0 + 15 },
standard: { calculate: w => w * 2.5 + 5 },
economy: { calculate: w => w * 1.0 },
freight: { calculate: w => w * 0.5 + 50 },
}
function calculateShipping(order) {
const strategy = shippingStrategies[order.shippingType]
if (!strategy) throw new Error('Type inconnu')
return strategy.calculate(order.weight)
}Pattern Strategy: ajouter de nouveaux types sans modifier le code existant
class OrderProcessor {
calculateTax(order) {
const subtotal = order.items.reduce((sum, item) =>
sum + item.price * item.quantity, 0)
const taxRate = order.customer.region === 'EU'
? order.customer.country.vatRate
: 0.0
return subtotal * taxRate
}
}OrderProcessor connait trop de details internes de Order et Customer
class Order {
calculateSubtotal() {
return this.items.reduce((sum, item) =>
sum + item.price * item.quantity, 0)
}
calculateTax() {
return this.calculateSubtotal() * this.customer.getTaxRate()
}
}
class Customer {
getTaxRate() {
return this.region === 'EU' ? this.country.vatRate : 0.0
}
}Deplacer le comportement vers la classe qui possede les donnees
Le Conseiller en Refactoring ne mesure pas seulement des metriques — il comprend les patterns de conception et suggere des techniques de refactoring specifiques qui amelioreront la structure de votre code.
Identifie les code smells et anti-patterns dans la structure de votre code
Suggere des patterns specifiques: Extract Method, Replace Conditional, Move Method
Verifie l'adherence a SRP, OCP, LSP, ISP et DIP
Mesurer les Metriques
Calcule la longueur des methodes/classes et les scores de complexite
Identifier les Patterns
Detecte les code smells et anti-patterns de conception
Verifier SOLID
Verifie l'adherence aux principes de conception
Suggerer le Refactoring
Recommande des patterns specifiques comme Extract Method, Replace Conditional with Polymorphism
Se concentre sur les problemes qui CAUSERONT des problemes de maintenance, pas sur les details de style
Code copie-colle devant etre modifie a plusieurs endroits
Classes faisant trop de choses, impossibles a tester
Fonctions avec trop de chemins pour tester de maniere fiable
Ignores au profit des problemes structurels
La dette technique s'accumule exponentiellement.
Le Conseiller en Refactoring la detecte tot.
Laissez le Conseiller en Refactoring detecter les problemes structurels avant qu'ils ne s'accumulent. Gratuit pendant 14 jours, sans carte de credit.