Revenez t?t pour réduire la nidification en sortant des fonctions dès que des cas non valides ou de bord sont détectés, entra?nant un code plus plat et plus lisible. 2. Utilisez des clauses de garde au début des fonctions pour gérer les conditions préalables et garder la logique principale débutée. 3. Remplacez les rendements booléens conditionnels par des expressions directes, telles que l'age de retour> = 18 au lieu d'utiliser un bloc IF-Else. 4. Utilisez des expressions ternaires avec parcimonie pour des décisions simples, mais évitez de les nicher pour maintenir la lisibilité. 5. Extraire les conditions complexes en variables descriptives pour clarifier l'intention et améliorer la maintenabilité. 6. Remplacez les cha?nes IF-ELIF longues par des recherches de dictionnaire lors de la cartographie des conditions des actions ou des valeurs, rendant le code plus propre et plus facile à étendre. Le refactorisation des instructions améliore la clarté, réduit les bogues et améliore la maintenabilité en rendant l'intention du code évidente et en éliminant la complexité inutile.

De Verbose à Concise: un guide pratique de la refactorisation de la déclaration if

Les déclarations longues et if sont une vue courante dans les bases de code, en particulier dans le développement précoce ou dans des délais serrés. Pendant qu'ils fonctionnent, ils nuisent à la lisibilité, augmentent le risque de bogues et rendent la maintenance plus difficile. Les refactoriser en logique propre et concise ne concerne pas seulement le style - il s'agit de clarté et de fiabilité.

Voici comment passer de verbeux à maigre, étape par étape.

1. Retour t?t pour réduire la nidification

L'une des techniques les plus simples et les plus efficaces est les rendements précoces . Au lieu d'envelopper de gros blocs dans des conditions if les conditions, sortez t?t lorsqu'une condition rend le reste de la fonction non pertinente.

Avant (imbriqué):

 Def process_user (utilisateur):
    Si l'utilisateur:
        Si user.is_active:
            Si user.has_permission:
                retourner "traitement autorisé"
            autre:
                retourner "aucune autorisation"
        autre:
            retourner "utilisateur inactif"
    autre:
        retourner "utilisateur non valide"

Après (rendements précoces):

 Def process_user (utilisateur):
    Si ce n'est pas un utilisateur:
        retourner "utilisateur non valide"
    Si non user.is_active:
        retourner "utilisateur inactif"
    Si pas user.has_permission:
        retourner "aucune autorisation"
    retourner "traitement autorisé"

? Avantages:

• Structure plus plate
• Plus facile à suivre la logique
• Moins d'indentation = moins de distractions visuelles

2. Utilisez des clauses de garde pour les contr?les de préconditionnement

Les clauses de garde sont une forme de rendement précoce utilisé au début d'une fonction pour gérer le bord ou les cas non valides. Ils gardent le ?chemin heureux? épuré.

Exemple:

 Def Calculate_Discount (Order):
    Si l'ordre n'est pas:
        retour 0
    si Order.Total <= 0:
        retour 0
    Sinon Order.is_eligible:
        retour 0

    Ordre de retour.total * 0.1

Encore mieux: combiner les conditions connexes :

 Def Calculate_Discount (Order):
    Si non Order ou Order.Total <= 0 ou non Ordre.is_elibleble:
        retour 0
    Ordre de retour.total * 0.1

?? ATTENTION: ne sur-combiné pas. Si les conditions sont complexes ou ont des raisons différentes d'échec, gardez-les séparés pour plus de clarté.

3. Remplacer conditionnel par des expressions booléennes

Lorsqu'une instruction if renvoie un booléen, renvoyez directement l'expression.

Avant:

 Def is_adult (age):
    Si l'age> = 18:
        Retour vrai
    autre:
        retourner faux

Après:

 Def is_adult (age):
    age de retour> = 18

Même résultat, la moitié du code. Cela s'applique à toute logique booléenne.

4. Utiliser des expressions ternaires (conditionnelles) avec parcimonie

Pour des décisions simples, un ternaire peut rendre le code plus concis.

Au lieu de:

 Si score> = 60:
    résultat = "pass"
autre:
    résultat = "échec"

Utiliser:

 résultat = "pass" si score> = 60 else "échoue"

Mais évitez les ternaires nicheurs. C'est difficile à lire:

 status = "high" si score> 80 else "milieu" si score> 60 else "Low" # ?

Briser la logique complexe en lignes ou fonctions distinctes.

5. Extraire les conditions en variables descriptives

Les longues conditions sont difficiles à analyser. Les briser en variables bien nommées.

Avant:

 Si user.is_premium et non user.has_outstanding_balance et (user.login_count> 10 ou user.joined_recely):
    send_offer ()

Après:

 is_qualified_user = (
    user.is_premium
    et pas user.has_outstanding_balance
    et (user.login_count> 10 ou user.joined_recely)
)

Si is_qualified_user:
    send_offer ()

Maintenant, l'intention est claire sans la logique de décodage à la volée.

6. Envisagez d'utiliser une table de recherche ou un dictionnaire

Lorsque vous avez plusieurs conditions mappant sur des valeurs ou des fonctions, un dictionnaire peut remplacer de longues cha?nes if-elif .

Avant:

 Si status == "en attente":
    handler = handle_pending
statut elif == "approuvé":
    handler = handle_approved
ELIF Status == "Rejeté":
    handler = handle_rejected
autre:
    handler = handle_unknown

Après:

 Handlers = {
    "en attente": manche_pose,
    "approuvé": handle_approved,
    "Rejeté": manche_reject,
}
Handler = Handlers.get (statut, handle_unknown)

Plus propre, plus facile à étendre et moins sujet aux erreurs.

Réflexions finales

Refactoring if les déclarations ne concernent pas la rédaction du moins de lignes possible - il s'agit de rendre l'intention du code évidente. L'objectif est d'aider le prochain développeur (ou l'avenir à comprendre rapidement la logique.

Les principaux plats à retenir:

• Revenez t?t pour éviter la nidification profonde
• Utilisez des clauses de garde pour les cas non valides
• Remplacez les if-returns simples par des expressions directes
• Briser les conditions complexes en variables nommées
• Remplacez les cha?nes if-elif par des dictionnaires le cas échéant

La plupart de ces changements sont petits, mais ensemble, ils transforment la logique enchevêtrée en quelque chose de lisible et maintenable.

Fondamentalement, si votre bloc if a besoin d'un organigramme - le renfacteur.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!