首页 > web前端 > js教程 > 代码异味:代码库中您无法忽视的警告标志

代码异味:代码库中您无法忽视的警告标志

Patricia Arquette
发布: 2024-10-07 14:20:29
原创
719 人浏览过

Code Smells: Warning Signs in Your Codebase You Can

Si vous êtes un codeur, vous avez probablement rencontré du code qui vous semble « faux » : il est plus difficile à maintenir, à comprendre ou à faire évoluer. Ces signes d'avertissement courants dans votre base de code, connus sous le nom de odeurs de code, indiquent que quelque chose ne va pas. Tout comme une mauvaise odeur indique quelque chose de pourri, une odeur de code fait allusion à des problèmes potentiels liés à la conception ou à la mise en œuvre de votre code.

Avant de plonger dans le vif du sujet, clarifions :

Le terme "odeur" est une métaphore, comparant un code problématique à une odeur nauséabonde. Ce qui constitue une odeur de code peut être subjectif, selon :

  • Le langage de programmation que vous utilisez
  • La méthodologie de développement suivie par votre équipe
  • Les préférences personnelles des développeurs

Pourquoi devriez-vous vous soucier des odeurs de code ?

Ignorer les odeurs de code, c'est comme retarder l'entretien d'une voiture : cela ne pose peut-être pas de problèmes aujourd'hui, mais avec le temps, cela peut entraîner des pannes majeures. Voici pourquoi vous devriez vous en soucier :

  1. Maintenabilité

    Un code gonflé ou peu clair est un cauchemar à maintenir. Cela ralentit le débogage et augmente la probabilité d'introduire des bugs.

  2. Évolutivité

    Un code malodorant rend difficile la mise à l’échelle de votre application. À mesure que votre base de code se développe, les problèmes sous-jacents peuvent provoquer des problèmes exponentiels.

  3. Dette technique

    Ignorer les odeurs de code, c'est comme accumuler des dettes : vous devrez éventuellement les rembourser, souvent avec des intérêts, sous la forme de réécritures ou de débogages fastidieux.


Odeurs de code courantes (et comment les corriger)

Explorons certaines des odeurs de code les plus courantes et les stratégies pour les nettoyer.

1. Code gonflé

? Méthodes ou cours longs

Lorsque les méthodes ou les cours durent trop longtemps, ils deviennent difficiles à comprendre, à tester et à maintenir.

Exemple:

function processOrder(order) {
    validateOrder(order);
    calculateDiscount(order);
    applyTaxes(order);
    updateInventory(order);
    sendConfirmation(order);
}


登录后复制

Bien que cette méthode semble bonne, elle effectue trop de tâches, ce qui la rend difficile à suivre.

Solution : Divisez les méthodes longues en fonctions plus petites et à usage unique.


function processOrder(order) {
    validateOrder(order);
    applyDiscountsAndTaxes(order);
    finalizeOrder(order);
}

function applyDiscountsAndTaxes(order) {
    calculateDiscount(order);
    applyTaxes(order);
}


登录后复制

? Commentaires excessifs

Des commentaires excessifs peuvent indiquer que le code n'est pas explicite.

Exemple:

// Calculate the total price after applying the discount
let totalPrice = price - (price * discount);


登录后复制

Solution : Refactorisez le code pour qu'il soit auto-documenté.


let totalPrice = applyDiscount(price, discount);


登录后复制

2. Abus orientés objet

? Déclarations de changement

Les instructions Switch qui traitent du comportement spécifique à un type peuvent souvent être remplacées par du polymorphisme dans la programmation orientée objet.

Exemple:

function getArea(shape) {
    switch(shape.type) {
        case 'circle':
            return Math.PI * shape.radius ** 2;
        case 'square':
            return shape.side * shape.side;
    }
}


登录后复制

Solution : Utilisez le polymorphisme pour gérer le comportement spécifique à la forme.


class Shape {
    getArea() {
        throw "Must be implemented by subclass";
    }
}

class Circle extends Shape {
    constructor(radius) {
        super();
        this.radius = radius;
    }

    getArea() {
        return Math.PI * this.radius ** 2;
    }
}

class Square extends Shape {
    constructor(side) {
        super();
        this.side = side;
    }

    getArea() {
        return this.side * this.side;
    }
}


登录后复制

? Champs temporaires

Les champs qui ne sont utilisés que dans certains scénarios peuvent encombrer votre classe et entraîner une complexité inutile.

Solution : Déplacez ces champs vers des variables ou des paramètres locaux lorsque cela est possible, ou divisez les responsabilités en plusieurs classes.


3. Rigidité

? Changement divergent

Quand une seule classe doit être modifiée pour des raisons indépendantes, c'est le signe que la classe essaie d'en faire trop.

Solution : Appliquez le Principe de responsabilité unique en divisant la classe en unités plus petites et plus ciblées.

? Chirurgie au fusil de chasse

Quand un changement nécessite de modifier plusieurs classes, cela signale une mauvaise modularité. Cela peut rendre la refactorisation ou l'ajout de fonctionnalités pénible.

Solution : Identifiez la raison des changements épars et refactorisez en regroupant la logique associée.


4. Complexité inutile

? Code en double

Avoir le même morceau de code à plusieurs endroits peut entraîner des bugs et des problèmes de maintenance.

Exemple:

function calculateTotalPrice(price, tax) {
    return price + (price * tax);
}

function calculateDiscountedPrice(price, discount, tax) {
    let discountedPrice = price - (price * discount);
    return discountedPrice + (discountedPrice * tax);
}


登录后复制

Solution : Extraire la logique commune dans des méthodes réutilisables.


function calculatePrice(price, tax, discount = 0) {
    let discountedPrice = price - (price * discount);
    return discountedPrice + (discountedPrice * tax);
}


登录后复制

? Code mort

Le code mort est une fonctionnalité qui n'est plus utilisée. Cela peut encombrer votre base de code et dérouter les développeurs.

Solution : Supprimez régulièrement le code inutilisé pour garder votre base de code propre et concise.


5. Couplage serré

? Envie de fonctionnalités

Lorsqu'une méthode s'appuie fortement sur les données d'un autre objet au lieu des siennes, c'est le signe d'un couplage étroit.

Example:

function getDiscount(customer) {
    return customer.purchaseHistory.totalAmount > 1000 ? 0.1 : 0;
}


登录后复制

Solution: Consider moving the behavior to the object itself.


class Customer {
    getDiscount() {
        return this.purchaseHistory.totalAmount > 1000 ? 0.1 : 0;
    }
}


登录后复制

? Inappropriate Intimacy

Classes that rely too heavily on each other’s internal details create unnecessary dependencies.

Solution: Enforce stricter encapsulation and reduce reliance on internal data.


Additional Code Smells to Watch Out For

  • Magic Numbers Replace unexplained numbers with named constants to improve readability and maintainability.

Example:


  const SALES_TAX = 0.07;
  let total = price + (price * SALES_TAX);


登录后复制
  • Deep Nesting

    Simplify deeply nested loops or conditionals for better readability. Consider early returns or extracting methods.

  • Long Parameter Lists

    Refactor methods that take many parameters by using parameter objects or reducing the method’s responsibility.


How to Deal with Code Smells

Code smells don’t mean your code is broken, but they are early indicators that your design may need improvement. Here's how you can deal with them:

  1. Refactoring

    The most effective way to deal with code smells is through refactoring—improving the internal structure of your code without changing its external behavior.

  2. Incremental Changes

    You don’t have to fix everything at once. Start with small, focused refactorings, targeting the smelliest areas of your code.

  3. Testing

    Before you refactor, ensure that your code has adequate tests in place. This helps you catch regressions and verify that the refactored code behaves as expected.


Final Thoughts

Recognizing and addressing code smells is crucial for maintaining healthy, scalable, and maintainable code. Think of it as preventative care—cleaning up these smells early will save you time, effort, and headaches down the line. Keep an eye out for these common warning signs, and make refactoring a regular part of your coding process!

以上是代码异味:代码库中您无法忽视的警告标志的详细内容。更多信息请关注PHP中文网其他相关文章!

来源:dev.to
本站声明
本文内容由网友自发贡献,版权归原作者所有,本站不承担相应法律责任。如您发现有涉嫌抄袭侵权的内容,请联系admin@php.cn
作者最新文章
热门教程
更多>
最新下载
更多>
网站特效
网站源码
网站素材
前端模板