Um das durch verschachtelte "Todespyramiden" -Problem zu l?sen, sollten die folgenden fünf Rekonstruktionsmethoden angewendet werden: 1. Flach der Zustandsprüfung unter Verwendung der frühen Rückkehr (Wachklauseln), um eine tiefe Verschachtelung zu vermeiden; 2. extrahieren komplexe Bedingungen in eine private Methode mit klaren Namen, um die Lesbarkeit und Wiederverwendbarkeit zu verbessern. 3. Verwenden Sie Verifizierungsobjekte oder Middleware -Muster für komplexe Prozesse, um eine komponierbare und erweiterbare überprüfungslogik zu implementieren. V. 5. Ersetzen Sie die Fehlerzeichenfolge zurück durch Ausnahmen, verarbeiten Sie Fehler zentral und halten Sie die Kernlogik rein. Das ultimative Ziel ist es, den Code sicherer, leichter zu testen und durch ein schnelles Versagen, logische Trennung und geeignete Entwurfsmuster einfacher zu halten.

Verschachtelte if Aussagen in PHP - insbesondere wenn sie tief gestapelt sind - k?nnen sich schnell in das verwandeln, was Entwickler die "Pyramide des Schicksals" nennen. Code wird schwer zu lesen, schwerer zu testen und ein Albtraum zu pflegen. Je tiefer die Verachtung, desto kognitiver laden sie jedem, der versucht, die Logik zu verstehen oder zu ?ndern.

Schauen wir uns an, wie diese verschachtelten Bedingungen zu einem saubereren, gepflegten Code reflektiert werden.

1. Kehren Sie früh zurück, um die Struktur zu verflachten

Eine der effektivsten Techniken sind frühe Rückkehr (oder Schutzklauseln ). Anstatt Logikbl?cke in if Anweisungen einzuwickeln, beenden Sie frühzeitig, wenn Voraussetzungen nicht erfüllt sind.

Vor (Pyramide des Schicksals):

 Funktionsprozessuser ($ user) {
    if ($ user) {
        if ($ user-> isActive ()) {
            if ($ user-> HaSpermission ('bearbeiten') {
                // Tats?chliche Logik hier
                $ this-> sendNotification ($ user) zurückgeben;
            } anders {
                Rückgabe "Erlaubnis abgelehnt";
            }
        } anders {
            Rückgabe "Benutzer ist nicht aktiv";
        }
    } anders {
        zurück "Benutzer nicht gefunden";
    }
}

Nach (frühzeitige Rückkehr):

 Funktionsprozessuser ($ user) {
    if (! $ user) {
        zurück "Benutzer nicht gefunden";
    }

    if (! $ user-> isActive ()) {
        Rückgabe "Benutzer ist nicht aktiv";
    }

    if (! $ user-> HaSermission ('bearbeiten') {
        Rückgabe "Erlaubnis abgelehnt";
    }

    $ this-> sendNotification ($ user) zurückgeben;
}

Diese Version ist linear, leichter zu scannen und vermeidet eine tiefe Verschachtung. Jede Bedingung wird auf der oberen Ebene überprüft und behandelt.

2.. Bedingungen in beschreibende Methoden extrahieren

Wenn Ihre Bedingungen komplex oder wiederholt sind, extrahieren Sie sie mit sinnvollen Namen in private Methoden. Dies verbessert die Lesbarkeit und Wiederverwendbarkeit.

 Funktionsprozessuser ($ user) {
    if (! $ this-> userexists ($ user)) {
        zurück "Benutzer nicht gefunden";
    }

    if (! $ this-> userisactive ($ user)) {
        Rückgabe "Benutzer ist nicht aktiv";
    }

    if (! $ this-> userCanedit ($ user)) {
        Rückgabe "Erlaubnis abgelehnt";
    }

    $ this-> sendNotification ($ user) zurückgeben;
}

private function userexists ($ user): bool {
    Rückgabe! leer ($ user);
}

private function userisactive ($ user): bool {
    $ user-> isActive () zurückgeben;
}

private function usercanedit ($ user): bool {
    $ user-> HaSpermission zurückgeben ('bearbeiten');
}

Jetzt liest die Hauptmethode wie eine Checkliste, und jede Bedingung ist selbstdokumentiert.

3. Verwenden Sie Validierungsobjekte oder Middleware

Für komplexe Workflows (z. B. Formularverarbeitung, API -Anforderungen) sollten Sie eine Validierungspipeline oder ein Middleware -Muster verwenden.

 Klasse UserProcessor
{
    private Array $ validators = [];

    ?ffentliche Funktion Addvalidator (Callable $ Validator): self {
        $ this-> validators [] = $ validator;
        kehren Sie dies zurück;
    }

    ?ffentlicher Funktionsprozess ($ user) {
        foreach ($ this-> validatoren als $ validator) {
            $ result = $ validator ($ user);
            if ($ result! == true) {
                Return $ Ergebnis; // Fehlermeldung zurückgeben
            }
        }

        $ this-> sendNotification ($ user) zurückgeben;
    }
}

Verwendung:

 $ processor = new userProcessor ();
$ processor-> addvalidator (fn ($ user) => $ user? true: 'user nicht gefunden');
$ processor-> addvalidator (fn ($ user) => $ user-> isActive ()? TRUE: 'Benutzer ist nicht aktiv');
$ processor-> addvalidator (fn ($ user) => $ user-> HaSpermission ('bearbeiten')? TRUE: 'Erlaubnis verweigert');

$ result = $ processor-> prozess ($ user);

Dieser Ansatz macht die Validierungslogik komponierbar und erweiterbar , ohne die Kernlogik zu ?ndern.

4. Tern?r oder Nullkoalecing für einfache F?lle

Verwenden Sie für sehr einfache bedingte Renditen die kurze Syntax - aber nur, wenn sie die Klarheit verbessert.

 $ user zurückgeben? ($ user-> isActive ()? 'Active': 'inaktiv'): 'Unbekannt';

Aber vermeiden Sie Nistnistern - es schafft nur eine andere Art von Pyramide. Halten Sie sich an eine Ebene oder noch besser, verwenden Sie frühzeitige Renditen.

5. Ausnahmen werfen, anstatt Fehler zurückzugeben

Manchmal ist es nicht ideal, zurückkehrende Saiten wie 'Permission denied' zu sein. Verwenden Sie Ausnahmen für au?ergew?hnliche F?lle.

 Funktionsprozessuser ($ user) {
    if (! $ user) {
        Neue InvalidArgumentException ('Benutzer nicht gefunden');
    }

    if (! $ user-> isActive ()) {
        Neue RunTimeException werfen ('Benutzer ist nicht aktiv');
    }

    if (! $ user-> HaSermission ('bearbeiten') {
        Neue Erlaubnis werfen, ();
    }

    $ this-> sendNotification ($ user) zurückgeben;
}

Gehen Sie diese dann auf zentralisierte Weise (z. B. in einem Controller oder in einer Middleware) um und halten Sie die Kernlogik sauber.

Letzte Gedanken

Der Schlüssel zur Z?hlung der Pyramide des Schicksals ist:

• Scheitern Sie schnell mit frühen Renditen
• Logik in gut benannte Methoden extrahieren
• Separate Bedenken - Mischen Sie keine Validierung mit der Gesch?ftslogik
• Verwenden Sie das richtige Muster für die Komplexit?t (z. B. Pipelines, Strategie)

Refactoring verschachtelt, if s nicht nur die ?sthetik ist, macht es Ihren Code sicherer, prüfbar und leichter zu erweitern.

Wenn Sie mehr als zwei Ebenen tief in Einklang bringen, ist es an der Zeit, den Fluss zu überdenken.

Das obige ist der detaillierte Inhalt vonZ?hmung der Pyramide des Untergang. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!