Die Anwendung des soliden Prinzips in der PHP -Entwicklung umfasst: 1. Prinzip der Einzelverantwortung (SRP): Jede Klasse ist nur für eine Funktion verantwortlich. 2. Open and Close Principle (OCP): ?nderungen werden eher durch Erweiterung als durch Modifikation erreicht. 3.. Richter Substitution Prinzip (LSP): Unterklassen k?nnen Basisklassen ersetzen, ohne die Programmgenauigkeit zu beeintr?chtigen. 4. Schnittstellen-Isolationsprinzip (ISP): Verwenden Sie feink?rnige Schnittstellen, um Abh?ngigkeiten und nicht verwendete Methoden zu vermeiden. 5. Abh?ngigkeitsinversionsprinzip (DIP): Hoch- und niedrige Module beruhen auf der Abstraktion und werden durch Abh?ngigkeitsinjektion implementiert.

Einführung

In der Welt der Programmierung ist das solide Prinzip wie der Nordstern, der uns zum eleganten Code führt. Diese Prinzipien sind nicht nur der Eckpfeiler des objektorientierten Designs, sondern auch der Kompass für unser Streben nach qualitativ hochwertigem und wartbarem Code. Heute werden wir solide Prinzipien ausführlich untersuchen und ihre spezifischen Anwendungen in der PHP -Entwicklung untersuchen. In diesem Artikel werden Sie nicht nur die Definition und Rolle dieser Prinzipien verstehen, sondern auch beherrschen, wie Sie sie in realen Projekten anwenden k?nnen, um die Qualit?t Ihres Code zu verbessern.

überprüfung des Grundwissens

Bevor wir uns mit dem soliden Prinzip eintauchen, überprüfen wir die grundlegenden Konzepte der objektorientierten Programmierung (OOP). Der Kern von OOP besteht darin, Code durch Klassen und Objekte zu organisieren und Funktionen wie Kapselung, Vererbung und Polymorphismus zu verwenden, um eine Wiederverwendung und Modularisierung von Code zu erreichen. In PHP werden diese Konzepte durch Mechanismen wie Klassen, Schnittstellen und Merkmale implementiert.

Kernkonzept oder Funktionsanalyse

Definition und Funktion des soliden Prinzips

Das solide Prinzip ist das Akronym für fünf von Robert C. Martin vorgeschlagene objektorientierte Designprinzipien. Sie sind:

• Prinzip der Einzelverantwortung (SRP) : Eine Klasse sollte nur einen Grund für ihre Ver?nderung haben.
• Offenes/geschlossenes Prinzip (OCP) : Softwareentit?ten (Klassen, Module, Funktionen usw.) sollten für Erweiterungen offen sein und für Modifikationen geschlossen werden.
• Liskov Substitution Prinzip (LSP) : Unterklassen sollten in der Lage sein, ihre Basisklassen zu ersetzen, ohne die Richtigkeit des Programms zu brechen.
• Interface -Segregationsprinzip (ISP) : Clients sollten nicht gezwungen sein, sich auf Methoden zu verlassen, die sie nicht anwenden.
• Abh?ngigkeitsinversionsprinzip (DIP) : Auf hohen Modulen sollten nicht von Modulen auf niedriger Ebene abh?ngen, beide sollten auf Abstraktion beruhen. Die Abstraktion sollte sich nicht auf Details beruhen, detaillierten sollten auf Abstraktion beruhen.

Die Rolle dieser Prinzipien besteht darin, uns dabei zu helfen, Code zu entwerfen, der flexibler ist, leichter zu warten und zu erweitern.

Wie es funktioniert

Lassen Sie uns diskutieren, wie diese Prinzipien nacheinander in der PHP -Entwicklung funktionieren:

Prinzip der Einzelverantwortung (SRP)

Die Kernidee von SRP besteht darin, jede Klasse nur für eine Funktion oder Verantwortung verantwortlich zu machen. Der Vorteil davon ist, dass Sie, wenn sich die Anforderung ?ndert, nur die mit der ?nderung verbundene Klasse ?ndern müssen, ohne die anderen Teile zu beeinflussen.

 // Gegenbeispiel: Eine Klasse ist für mehrere Verantwortlichkeiten verantwortlich. Klasse userManager {
    ?ffentliche Funktion SaveUser (Benutzer $ user) {
        // Benutzerlogik speichern}

    ?ffentliche Funktionssendemail (Benutzer $ user) {
        // E -Mail -Logik senden}
}

// Positives Beispiel: Jede Klasse ist für eine Verantwortungsklasse userRepository {verantwortlich {verantwortlich
    ?ffentliche Funktion SaveUser (Benutzer $ user) {
        // Benutzerlogik speichern}
}

Klasse Emailservice {
    ?ffentliche Funktionssendemail (Benutzer $ user) {
        // E -Mail -Logik senden}
}

Er?ffnungs- und Schlussprinzip (OCP)

OCP ermutigt uns, ?nderungen zu behandeln, indem wir den vorhandenen Code eher erweitert, anstatt den vorhandenen Code zu ?ndern. Dies kann durch Verwendung abstrakter Klassen und Schnittstellen erreicht werden.

 // Gegenbeispiel: ?ndern Sie direkt den vorhandenen Klassenzahlungsprozessor {
    Public Function ProcessPayment (Zahlung $ Zahlung) {
        if ($ payment-> gettType () == 'credit_card') {
            // Kreditkartenzahlung verarbeiten} elseif ($ payment-> gettType () == 'paypal') {
            // PayPal -Zahlung verarbeiten}
    }
}

// Best?tigendes Beispiel: OCP durch Erweiterung implementieren
Schnittstelle Paymentgateway {
    ?ffentlicher Funktionsprozess (Zahlung $ Zahlung);
}

Class CreditCardgateway implementiert PaymentGateway {
    ?ffentlicher Funktionsprozess (Zahlung $ Zahlung) {
        // Kreditkartenzahlung verarbeiten}
}

Klasse paypalgateway implementiert PaymentGateway {
    ?ffentlicher Funktionsprozess (Zahlung $ Zahlung) {
        // PayPal -Zahlung verarbeiten}
}

Klasse PaymentProcessor {
    Privat $ Gateway;

    ?ffentliche Funktion __construct (Paymentgateway $ Gateway) {
        $ this-> gateway = $ gateway;
    }

    Public Function ProcessPayment (Zahlung $ Zahlung) {
        $ this-> Gateway-> Prozess ($ Zahlung);
    }
}

Lischersatzprinzip (LSP)

LSP betont, dass Unterklassen ihre Basisklassen ersetzen müssen, ohne die Richtigkeit des Programms zu ?ndern. Dies bedeutet, dass Unterklassen dem Vertrag der Basisklasse folgen sollten.

 // Gegenbeispiel: Unterklassen versto?en gegen den Vertrag der Basisklasse -Rechteck {
    geschützte $ width;
    geschützte $ H?he;

    ?ffentliche Funktion Setwidth ($ width) {
        $ this-> width = $ width;
    }

    ?ffentliche Funktion Seteight ($ HEIGHEIT) {
        $ this-> H?he = $ H?he;
    }

    ?ffentliche Funktion getArea () {
        Return $ this-> width * $ this-> H?he;
    }
}

Das Klassenquadrat erweitert Rechteck {
    ?ffentliche Funktion Setwidth ($ width) {
        $ this-> width = $ this-> H?he = $ width;
    }

    ?ffentliche Funktion Seteight ($ HEIGHEIT) {
        $ this-> width = $ this-> H?he = $ H?he;
    }
}

// Es wird Probleme verursachen, wenn $ rechteck = neu rechteck () verwendet wird;
$ rechteck-> setwidth (5);
$ rechteck-> Seteight (10);
echo $ rechteck-> getArea (); // Ausgabe 50

$ Square = neuer Square ();
$ Square-> Setwidth (5);
$ Square-> Seteight (10);
echo $ Square-> getArea (); // Ausgabe 100, verletzt LSP

// formales Beispiel: Implementieren Sie LSP über Schnittstellen und Kombinationen
Schnittstellenform {
    ?ffentliche Funktion getarea ();
}

Klasse Rechteck implementiert Form {
    private $ width;
    private $ H?he;

    ?ffentliche Funktion __construct ($ width, $ height) {
        $ this-> width = $ width;
        $ this-> H?he = $ H?he;
    }

    ?ffentliche Funktion getArea () {
        Return $ this-> width * $ this-> H?he;
    }
}

Klasse Square implementiert Form {
    private $ Seite;

    ?ffentliche Funktion __construct ($ Seite) {
        $ this-> Seite = $ Seite;
    }

    ?ffentliche Funktion getArea () {
        Return $ this-> Seite * $ this-> Seite;
    }
}

Schnittstellen -Isolationsprinzip (ISP)

ISP betont, dass Kunden sich nicht auf Methoden verlassen sollten, die sie nicht anwenden. Dies kann durch Definieren einer feineren Granularschnittstelle erreicht werden.

 // Gegenbeispiel: Ein gro?er und vollst?ndiger Schnittstellenarbeiter {
    ?ffentliche Funktionsarbeit ();
    ?ffentliche Funktion Eat ();
}

Klassenroboter implementiert Arbeiter {
    ?ffentliche Funktionsarbeit () {
        // Roboter Arbeitslogik}

    ?ffentliche Funktion Eat () {
        // Der Roboter muss nicht essen, aber diese Methode muss implementiert werden}
}

// Positives Beispiel: ISP wird durch feink?rnige Schnittstelle implementiert
Schnittstelle funktionsf?hig {
    ?ffentliche Funktionsarbeit ();
}

Schnittstelle Essbar {
    ?ffentliche Funktion Eat ();
}

Klasse menschliche implementiert praktikable, essbare {
    ?ffentliche Funktionsarbeit () {
        // menschliche Arbeitslogik}

    ?ffentliche Funktion Eat () {
        // Logik für menschliches Essen}
}

Klassenroboter implementiert praktikable {
    ?ffentliche Funktionsarbeit () {
        // Roboter Arbeitslogik}
}

Abh?ngigkeitsinversionsprinzip (DIP)

Dip betont, dass hochrangige Module nicht auf Modulen auf niedrigem Niveau beruhen sollten, beide sollten auf Abstraktion beruhen. Dies kann durch Abh?ngigkeitsinjektion erreicht werden.

 // Counterexample: High-Level-Module basieren auf Modulenklassen-Benutzerservice {modules {
    ?ffentliche Funktion getUserData () {
        $ database = new mySqldatabase ();
        $ database-> query zurückgeben ('aus den Benutzern ausw?hlen');
    }
}

// Best?tigendes Beispiel: DIP wird durch Abh?ngigkeitsinjektion implementiert
Schnittstellendatenbank {
    ?ffentliche Funktionsabfrage ($ SQL);
}

Klasse MySQldatabase implementiert die Datenbank {
    ?ffentliche Funktionsabfrage ($ SQL) {
        // Mysql Query Logic}
}

Klasse UserService {
    private $ Datenbank;

    ?ffentliche Funktion __construct (Datenbank $ Datenbank) {
        $ this-> database = $ Datenbank;
    }

    ?ffentliche Funktion getUserData () {
        $ this-> database-> abfrage zurückgeben ('aus den Benutzern ausw?hlen');
    }
}

Beispiel für die Nutzung

Grundnutzung

In den tats?chlichen Projekten kann die Anwendung des soliden Prinzips uns dabei helfen, Code zu entwerfen, die leichter aufrechterhalten und erweitert werden k?nnen. In einem E-Commerce-System k?nnen wir beispielsweise Bestellverarbeitung, Zahlungsabwicklung und Bestandsverwaltung in verschiedene Klassen trennen. Jede Klasse ist nur für eine Verantwortung (SRP) verantwortlich.

 Klassenorderprozessor {
    public function processOrder (order order order) {
        // Auftragslogik}
}

Klasse PaymentProcessor {
    Public Function ProcessPayment (Zahlung $ Zahlung) {
        // Zahlungslogik verarbeiten}
}

KlasseninventoryManager {
    ?ffentliche Funktion updateInventory (Produkt $ produkt, $ quantity) {
        // Inventarlogik aktualisieren}
}

Erweiterte Verwendung

In komplexeren Szenarien k?nnen wir diese Prinzipien in Kombination verwenden. In einem Content -Management -System k?nnen wir beispielsweise das Open- und Stilldown -Prinzip und das Abh?ngigkeitsinversionsprinzip verwenden, um ein skalierbares Inhaltstypsystem zu entwerfen.

 Schnittstelle ContentType {
    ?ffentliche Funktion render ();
}

Klasse textContent implementiert contentType {
    ?ffentliche Funktion render () {
        // Textinhalt rendern}
}

Klasse imaginiert implementiert ContentType {
    ?ffentliche Funktion render () {
        // den Bildinhalt rendern}
}

Klasse contentManager {
    private $ contentTypes;

    ?ffentliche Funktion __construct (Array $ contentTypes) {
        $ this-> contentTypes = $ contentTypes;
    }

    ?ffentliche Funktion RenderContent (Inhalt $ Inhalt) {
        foreach ($ this-> contentTypes als $ contentType) {
            if ($ contentType instanceof contentType && $ contentTyp-> Unterstützt ($ content)) {
                $ contentType-> render ($ content) zurückgeben;
            }
        }
        Neue \ Ausnahme ('nicht unterstützter Inhaltstyp');
    }
}

H?ufige Fehler und Debugging -Tipps

H?ufige Fehler bei der Anwendung solider Prinzipien umfassen:

• über-Design : Der Versuch, SRP in jeder Klasse strikt zu folgen, führt zu einer überm??igen Anzahl von Klassen, wodurch die Komplexit?t des Systems erh?ht wird.
• Ignorieren tats?chliche Bedürfnisse : Die blinden Anwendung von Prinzipien ohne Berücksichtigung der tats?chlichen Bedürfnisse und der Projektgr??e führt zu unn?tiger Komplexit?t.

Zu den Debugging -F?higkeiten geh?ren:

• CODE -überprüfung : Es werden regelm??ige Codeüberprüfungen durchgeführt, um sicherzustellen, dass der Code solide Prinzipien folgt.
• Testgetriebene Entwicklung (TDD) : überprüfen Sie die Richtigkeit und Skalierbarkeit des Codes über TDD.

Leistungsoptimierung und Best Practices

Bei der Anwendung solider Prinzipien müssen wir auch die Leistungsoptimierung und Best Practices berücksichtigen:

• Leistungsoptimierung : W?hrend solide Prinzipien dazu beitragen, die Code -Wartbarkeit zu verbessern, kann zuweilen ein zus?tzlicher Overhead eingeführt werden. Beispielsweise kann die Verwendung der Abh?ngigkeitsinjektion den Overhead der Objekterstellung erh?hen. In diesem Fall müssen wir die Leistung und Wartbarkeit einteilen, und bei Bedarf k?nnen zwischengespeichert werden oder andere Optimierungstechniken verwendet werden.

 // Beispiel: Die Leistung mithilfe von Abh?ngigkeitsinjektion und Cache -Klasse Userservice {optimieren {
    private $ Datenbank;
    privat $ cache;

    ?ffentliche Funktion __construct (Datenbank $ Datenbank, Cache $ cache) {
        $ this-> database = $ Datenbank;
        $ this-> cache = $ cache;
    }

    ?ffentliche Funktion getUserData ($ userId) {
        if ($ this-> cache-> hat ($ userId)) {
            $ this-> cache-> get ($ userId) zurückgeben;
        }

        $ data = $ this-> Datenbank-> Abfrage ('SELECT * von Benutzern wobei ID =?', [$ userId]);
        $ this-> cache-> set ($ userId, $ data);

        $ Data zurückgeben;
    }
}

• Best Practice : W?hrend Sie dem soliden Prinzip folgen, sollten Sie auch auf die Lesbarkeit und Wartbarkeit des Codes achten. Verwenden Sie beispielsweise eine aussagekr?ftige Benennung, schreiben Sie klare Dokumentation, befolgen Sie einen konsistenten Codierungsstil usw.

In diesem Artikel verstehen wir nicht nur die Definition und Rolle solider Prinzipien, sondern untersuchen auch ihre Anwendung in der tats?chlichen Entwicklung anhand spezifischer Beispiele für PHP -Code. Hoffentlich hilft Ihnen dieses Wissen und diese Erfahrung dabei, ein eleganteres, leichter zu pflegen und erweitertes System beim Schreiben von PHP -Code zu entwickeln.

Das obige ist der detaillierte Inhalt vonBeschreiben Sie die soliden Prinzipien und wie sie sich für die PHP -Entwicklung anwenden.. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!