Utilisez des clauses de garde pour sortir t?t et réduire la nidification; 2. Appliquez le modèle de stratégie pour remplacer les conditions par des classes ou des callables; 3. Remplacez les mappages simples par des tables de recherche ou des tableaux; 4. Utiliser le polymorphisme pour que les objets décident de leur comportement; 5. Utiliser des modèles d'état ou de commande pour les workflows complexes; De plus, utilisez les expressions PHP 8 correspondant à la logique conditionnelle plus propre - ces techniques aplatissent collectivement le code, améliorent la lisibilité et améliorent la maintenabilité en dépla?ant les conditions de la logique principale.

Lorsque le code PHP commence à s'accumuler avec des blocs IF-Else profonds, il devient difficile de lire, de tester et de maintenir. Bien que les conditions de nidification soient courantes, il existe des alternatives plus propres et plus évolutives. Voici comment se libérer de la pyramide If-Else sans sacrifier la clarté logique.

1. Clauses de garde: sortir t?t, réduire la nidification

L'une des techniques les plus simples mais les plus efficaces consiste à utiliser des clauses de garde - les rendements précoces qui gèrent les cas de bord ou les états non valides au début d'une fonction.

Au lieu de:

 fonction processUser ($ user) {
    if ($ utilisateur! == null) {
        if ($ user-> isactive ()) {
            if ($ user-> haspermission ()) {
                // Logique principale ici
                retourner $ this-> SendWelcomeMail ($ utilisateur);
            }
        }
    }
    retourne false;
}

Refactor avec les premières sorties:

 fonction processUser ($ user) {
    if ($ user === null) return false;
    if (! $ user-> isactive ()) return false;
    if (! $ user-> haspermission ()) return false;

    retourner $ this-> SendWelcomeMail ($ utilisateur);
}

Cela maintient la logique principale au niveau supérieur et rend la fonction plus facile à suivre.

2. Modèle de stratégie: remplacer les conditions par des classes

Lorsque vous choisissez entre plusieurs comportements en fonction d'un type ou d'un statut, le modèle de stratégie remplace les cha?nes de si-else longues par une carte des classes ou des callables.

Par exemple, au lieu de:

 Fonction CalculaTetax ($ country, $ montant) {
    if ($ country === 'us') {
        Retour $ Montant * 0,07;
    } elseif ($ country === 'de') {
        Retour $ Montant * 0,19;
    } elseif ($ country === 'jp') {
        Retour $ Montant * 0,10;
    }
    retour 0;
}

Utilisez une carte de stratégie:

 $ TaxStrategies = [
    'Us' => fn ($ montant) => $ montant * 0,07,
    'De' => fn ($ montant) => $ montant * 0,19,
    'Jp' => fn ($ montant) => $ montant * 0,10,
]]

Fonction CalculaTetax ($ Country, $ Montant, $ Stratégies) {
    Retour $ Stratégies [$ country] (Montant $) ?? 0;
}

Ou allez plus loin avec des classes dédiées mettant en ?uvre une interface TaxStrategy pour une meilleure séparation et testabilité.

3. Tables de recherche et tableaux pour des mappages simples

De nombreuses échelles IF-Else ne sont que des mappages clés à valeur. Remplacez-les par des tableaux.

Au lieu de:

 fonction getStaturSColor ($ status) {
    if ($ status === 'actif') {
        retour ?vert?;
    } elseif ($ status === 'en attente') {
        retour ?jaune?;
    } elseif ($ status === 'inactive') {
        retour ?gris?;
    } elseif ($ status === 'bloqué') {
        retour ?rouge?;
    }
    retour ?inconnu?;
}

Utilisez une recherche:

 fonction getStaturSColor ($ status) {
    $ couleurs = [
        'actif' => 'vert',
        'en attente' => 'jaune',
        'inactif' => 'gris',
        'bloqué' => 'rouge'
    ]]

    retourner $ couleurs [$ status] ?? 'inconnu';
}

Il est plus rapide, plus propre et plus facile à étendre ou même à charger à partir de la configuration.

4. Polymorphisme: laissez les objets décider de leur comportement

Si vos conditions dépendent des types d'objets, utilisez le polymorphisme . Définissez une méthode dans une classe de base ou une interface et laissez les sous-classes implémenter leur propre version.

Exemple:

 Notification d'interface {
    Fonction publique Send ($ message);
}

Classe EmailNotification implémente la notification {
    Fonction publique Envoyer ($ message) {/ * Envoyer par e-mail * /}
}

classe SMSNotification implémente la notification {
    Fonction publique Envoyer ($ message) {/ * Envoyer via SMS * /}
}

// Non si-else nécessaire
fonction notify (utilisateur $ user, notification $ canal, $ msg) {
    $ channel-> Send ($ msg);
}

Désormais, la décision de l' envoi est encapsulée - aucune condition nécessaire sur le site d'appel.

5. Modèle d'état ou de commande pour les flux de travail complexes

Pour des règles commerciales complexes qui changent en fonction de l'état, considérez le modèle d'état ou le modèle de commande . Ceux-ci vous permettent d'encapsuler le comportement et les transitions sans conditionnels tentaculaires.

Par exemple, une commande qui se comporte différemment en attente, expédiée ou annulée peut avoir ses propres objets d'état qui définissent des actions valides.

Alternativement, utilisez une carte de commande :

 $ actions = [
    'create' => new CreateOrderHandler (),
    'Annuler' => new annuleorderHandler (),
    'Refund' => new REFUNDHANDLER (),
]]

$ handler = $ actions [$ command] ?? lancer un nouveau invalidComMandexception ();
$ handler-> EXECUTE ($ data);

Cela évite les blocs de commutation longue / IF lors du routage des commandes.

Bonus: utilisez des expressions de match (PHP 8)

match de PHP 8 est une alternative plus propre au switch et peut souvent remplacer les cha?nes IF-Else:

 $ status = 'actif';

$ label = match ($ status) {
    'actif' => 'utilisateur actif',
    ?en attente? => ?Approbation en attente?,
    'inactif' => 'inactif',
    par défaut => 'statut inconnu'
};

Il est basé sur l'expression, de type type et ne nécessite pas de déclarations break .

La clé n'est pas d'éliminer complètement les conditions - elles sont nécessaires - mais de les sortir de votre logique principale . Utilisez les rendements précoces, les structures de données et les modèles orientés objet pour garder votre code plat, lisible et ouvert pour l'extension.

Fondamentalement: lorsque vous voyez une nidification profonde, demandez - peut-il être une carte, une méthode ou un retour? Souvent, la réponse est oui.

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!