Huraikan prinsip -prinsip yang kukuh dan bagaimana ia memohon kepada pembangunan PHP.

Penggunaan prinsip pepejal dalam pembangunan PHP termasuk: 1. Prinsip Tanggungjawab Tunggal (SRP): Setiap kelas bertanggungjawab untuk hanya satu fungsi. 2. Prinsip Terbuka dan Tutup (OCP): Perubahan dicapai melalui lanjutan dan bukannya pengubahsuaian. 3. Prinsip Penggantian Richter (LSP): Subkelas boleh menggantikan kelas asas tanpa menjejaskan ketepatan program. 4. Prinsip Pengasingan Antara Muka (ISP): Gunakan antara muka halus untuk mengelakkan kebergantungan dan kaedah yang tidak digunakan. 5. Prinsip Inversi Ketergantungan (DIP): Modul peringkat tinggi dan rendah bergantung kepada abstraksi dan dilaksanakan melalui suntikan ketergantungan.

Pengenalan

Dalam dunia pengaturcaraan, prinsip pepejal adalah seperti bintang utara yang membimbing kita ke arah kod elegan. Prinsip-prinsip ini bukan hanya asas reka bentuk berorientasikan objek, tetapi juga kompas untuk mengejar kod berkualiti tinggi dan dikekalkan. Hari ini, kami akan meneroka prinsip -prinsip yang kukuh secara mendalam dan meneroka aplikasi khusus mereka dalam pembangunan PHP. Melalui artikel ini, anda bukan sahaja akan memahami definisi dan peranan prinsip -prinsip ini, tetapi juga menguasai cara menerapkannya dalam projek sebenar untuk meningkatkan kualiti kod anda.

Semak pengetahuan asas

Sebelum kita menyelam ke dalam prinsip yang kukuh, mari kita semak konsep asas pengaturcaraan berorientasikan objek (OOP). Inti OOP adalah untuk mengatur kod melalui kelas dan objek, dan menggunakan ciri -ciri seperti enkapsulasi, warisan dan polimorfisme untuk mencapai penggunaan semula kod dan modularization. Dalam PHP, konsep -konsep ini dilaksanakan melalui mekanisme seperti kelas, antara muka, dan sifat.

Konsep teras atau analisis fungsi

Definisi dan fungsi Prinsip Pepejal

Prinsip pepejal adalah akronim untuk lima prinsip reka bentuk berorientasikan objek yang dicadangkan oleh Robert C. Martin. Mereka adalah:

• Prinsip Tanggungjawab Tunggal (SRP) : Kelas harus mempunyai hanya satu sebab untuk perubahannya.
• Prinsip Terbuka/Tertutup (OCP) : Entiti perisian (kelas, modul, fungsi, dan lain -lain) harus dibuka kepada sambungan dan ditutup kepada pengubahsuaian.
• Prinsip Penggantian Liskov (LSP) : Subkelas harus dapat menggantikan kelas asas mereka tanpa melanggar ketepatan program.
• Prinsip Pengasingan Antara Muka (ISP) : Pelanggan tidak boleh dipaksa untuk bergantung pada kaedah yang tidak mereka gunakan.
• Prinsip Inversi Ketergantungan (DIP) : Modul peringkat tinggi tidak boleh bergantung kepada modul peringkat rendah, kedua-duanya harus bergantung pada abstraksi; Abstraksi tidak boleh bergantung pada butiran, butiran harus bergantung pada abstraksi.

Peranan prinsip -prinsip ini adalah untuk membantu kami merancang kod yang lebih fleksibel, lebih mudah untuk mengekalkan dan memperluas.

Bagaimana ia berfungsi

Mari kita bincangkan bagaimana prinsip -prinsip ini berfungsi dalam pembangunan PHP satu demi satu:

Prinsip Tanggungjawab Tunggal (SRP)

Idea utama SRP adalah untuk menjadikan setiap kelas bertanggungjawab untuk hanya satu fungsi atau tanggungjawab. Kelebihan ini ialah apabila keperluan berubah, anda hanya perlu mengubah suai kelas yang berkaitan dengan perubahan tanpa menjejaskan bahagian lain.

// counterexample: kelas bertanggungjawab untuk pelbagai tanggungjawab kelas usermanager {
    Fungsi awam SaveUser (pengguna $ pengguna) {
        // simpan logik pengguna}

    fungsi awam SendeMail (pengguna $ pengguna) {
        // Hantar logik e -mel}
}

// Contoh positif: Setiap kelas bertanggungjawab untuk satu kelas tanggungjawab userrepository {
    Fungsi awam SaveUser (pengguna $ pengguna) {
        // simpan logik pengguna}
}

Kelas E -melService {
    fungsi awam SendeMail (pengguna $ pengguna) {
        // Hantar logik e -mel}
}

Prinsip Pembukaan dan Penutupan (OCP)

OCP menggalakkan kita untuk menangani perubahan dengan memperluaskan daripada mengubahsuai kod sedia ada. Ini boleh dicapai dengan menggunakan kelas abstrak dan antara muka.

// counterexample: secara langsung mengubah suai kelas PaymentProcessor yang sedia ada {
    Proses Proses Fungsi Awam (Pembayaran $ Pembayaran) {
        jika ($ pembayaran-> getType () == 'credit_card') {
            // Proses Pembayaran Kad Kredit} elseif ($ payment-> getType () == 'PayPal') {
            // Proses pembayaran paypal}
    }
}

// Contoh afirmatif: Melaksanakan OCP melalui lanjutan
Antara muka PaymentGateway {
    proses fungsi awam (pembayaran $ pembayaran);
}

Kelas CreditCardGateway melaksanakan PaymentGateway {
    proses fungsi awam (pembayaran $ pembayaran) {
        // proses pembayaran kad kredit}
}

Kelas PayPalgateway melaksanakan PaymentGateway {
    proses fungsi awam (pembayaran $ pembayaran) {
        // Proses pembayaran paypal}
}

Kelas PaymentProcessor {
    Private $ Gateway;

    fungsi awam __construct (paymentgateway $ gateway) {
        $ this-> gateway = $ gateway;
    }

    Proses Proses Fungsi Awam (Pembayaran $ Pembayaran) {
        $ this-> Gateway-> Process ($ payment);
    }
}

Prinsip Penggantian Lisch (LSP)

LSP menekankan bahawa subkelas mesti dapat menggantikan kelas asas mereka tanpa mengubah ketepatan program. Ini bermakna subkelas harus mengikuti kontrak kelas asas.

// counterexample: subclasses melanggar kontrak kelas segi empat tepat kelas asas {
    dilindungi $ lebar;
    dilindungi $ ketinggian;

    Fungsi awam setWidth ($ lebar) {
        $ this-> width = $ width;
    }

    Fungsi awam Setheight ($ ketinggian) {
        $ this-> height = $ ketinggian;
    }

    fungsi awam getArea () {
        kembali $ this-> width * $ this-> height;
    }
}

Kelas persegi memanjangkan segi empat tepat {
    Fungsi awam setWidth ($ lebar) {
        $ this-> width = $ this-> height = $ width;
    }

    Fungsi awam Setheight ($ ketinggian) {
        $ this-> width = $ this-> height = $ height;
    }
}

// ia akan menyebabkan masalah apabila menggunakan $ rectangle = rectangle baru ();
$ rectangle-> setWidth (5);
$ Rectangle-> SetTeight (10);
echo $ rectangle-> getArea (); // output 50

$ square = New Square ();
$ square-> setWidth (5);
$ square-> Setheight (10);
echo $ square-> getArea (); // output 100, melanggar LSP

// Contoh rasmi: Melaksanakan LSP melalui antara muka dan kombinasi
Bentuk antara muka {
    fungsi awam getArea ();
}

Kelas Rectangle mengimplementasikan bentuk {
    Swasta $ lebar;
    ketinggian peribadi $;

    fungsi awam __construct ($ lebar, $ ketinggian) {
        $ this-> width = $ width;
        $ this-> height = $ ketinggian;
    }

    fungsi awam getArea () {
        kembali $ this-> width * $ this-> height;
    }
}

Kelas persegi melaksanakan bentuk {
    $ persendirian;

    fungsi awam __construct ($ side) {
        $ this-> side = $ side;
    }

    fungsi awam getArea () {
        kembali $ this-> side * $ this-> side;
    }
}

Prinsip Pengasingan Antara Muka (ISP)

ISP menekankan bahawa pelanggan tidak boleh bergantung pada kaedah yang tidak mereka gunakan. Ini boleh dicapai dengan menentukan antara muka berbutir yang lebih baik.

// counterexample: Pekerja antara muka yang besar dan lengkap {
    kerja fungsi awam ();
    fungsi awam makan ();
}

kelas robot melaksanakan pekerja {
    kerja fungsi awam () {
        // logik kerja robot}

    fungsi awam makan () {
        // Robot tidak perlu makan, tetapi kaedah ini mesti dilaksanakan}
}

// Contoh positif: ISP dilaksanakan melalui antara muka halus
antara muka yang boleh dilaksanakan {
    kerja fungsi awam ();
}

antara muka yang boleh dimakan {
    fungsi awam makan ();
}

Kelas Manusia Alat Boleh Dilatih, Makan {
    kerja fungsi awam () {
        // logik kerja manusia}

    fungsi awam makan () {
        // logik makan manusia}
}

Kelas robot mengimplementasikan {
    kerja fungsi awam () {
        // logik kerja robot}
}

Prinsip Penyongsangan Ketergantungan (DIP)

Dip menekankan bahawa modul peringkat tinggi tidak boleh bergantung pada modul peringkat rendah, kedua-duanya harus bergantung pada abstraksi. Ini boleh dicapai melalui suntikan ketergantungan.

// counterexample: modul peringkat tinggi bergantung pada modul peringkat rendah pengguna kelas {
    fungsi awam getUserData () {
        $ pangkalan data = mysqldatabase baru ();
        kembali $ pangkalan data-> pertanyaan ('pilih * dari pengguna');
    }
}

// Contoh afirmatif: DIP dilaksanakan melalui suntikan ketergantungan
pangkalan data antara muka {
    pertanyaan fungsi awam ($ SQL);
}

kelas mysqldatabase melaksanakan pangkalan data {
    pertanyaan fungsi awam ($ SQL) {
        // logik pertanyaan mysql}
}

Kelas Userservice {
    Pangkalan data $ $ swasta;

    fungsi awam __construct (pangkalan data pangkalan data) {
        $ this-> pangkalan data = $ pangkalan data;
    }

    fungsi awam getUserData () {
        kembali $ this-> database-> query ('pilih * dari pengguna');
    }
}

Contoh penggunaan

Penggunaan asas

Dalam projek -projek sebenar, menerapkan prinsip pepejal dapat membantu kami merancang kod yang lebih mudah untuk mengekalkan dan memperluas. Sebagai contoh, dalam sistem e-dagang, kita boleh memisahkan pemprosesan pesanan, pemprosesan pembayaran, dan pengurusan inventori ke dalam kelas yang berbeza, setiap kelas bertanggungjawab untuk hanya satu tanggungjawab (SRP).

Kelas OrderProcessor {
    ProcessOrder Fungsi Awam (Order $ Order) {
        // mengendalikan logik pesanan}
}

Kelas PaymentProcessor {
    Proses Proses Fungsi Awam (Pembayaran $ Pembayaran) {
        // logik pembayaran proses}
}

Kelas InventoryManager {
    Fungsi awam UpdateInventory (produk $ produk, $ kuantiti) {
        // Kemas kini logik inventori}
}

Penggunaan lanjutan

Dalam senario yang lebih kompleks, kita boleh menggunakan prinsip -prinsip ini dalam kombinasi. Sebagai contoh, dalam sistem pengurusan kandungan, kita boleh menggunakan prinsip terbuka dan penutupan dan prinsip penyongsangan ketergantungan untuk merancang sistem jenis kandungan berskala.

Kandungan ContentType {
    fungsi awam memberikan ();
}

Kelas TextContent melaksanakan ContentType {
    fungsi awam render () {
        // memberikan kandungan teks}
}

kelas ImageContent melaksanakan ContentType {
    fungsi awam render () {
        // menjadikan kandungan imej}
}

Kelas ContentManager {
    $ contentTypes swasta;

    fungsi awam __construct (array $ contentTypes) {
        $ this-> contentTypes = $ contentTypes;
    }

    RenderContent fungsi awam (kandungan kandungan $) {
        foreach ($ this-> contentTypes as $ contentType) {
            jika ($ contentType instanceof contentType && $ contentType-> supports ($ content)) {
                kembali $ contentType-> render ($ content);
            }
        }
        membuang baru \ pengecualian ('jenis kandungan yang tidak disokong');
    }
}

Kesilapan biasa dan tip debugging

Kesalahan biasa apabila menggunakan prinsip pepejal termasuk:

• Reka bentuk yang lebih tinggi : Mencuba dengan tegas mengikuti SRP di setiap kelas membawa kepada jumlah kelas yang berlebihan, meningkatkan kerumitan sistem.
• Mengabaikan keperluan sebenar : Prinsip menerapkan secara membabi buta tanpa mempertimbangkan keperluan sebenar dan saiz projek membawa kepada kerumitan yang tidak perlu.

Kemahiran menyahpepijat termasuk:

• Kajian Kod : Kajian kod biasa dilakukan untuk memastikan bahawa kod tersebut mengikuti prinsip -prinsip yang kukuh.
• Pembangunan yang didorong oleh ujian (TDD) : Sahkan ketepatan dan skalabiliti kod melalui TDD.

Pengoptimuman prestasi dan amalan terbaik

Apabila menggunakan prinsip yang kukuh, kita juga perlu mempertimbangkan pengoptimuman prestasi dan amalan terbaik:

• Pengoptimuman Prestasi : Walaupun prinsip -prinsip pepejal membantu meningkatkan pemeliharaan kod, overhead tambahan boleh diperkenalkan pada masa -masa. Sebagai contoh, menggunakan suntikan ketergantungan boleh meningkatkan overhead penciptaan objek. Dalam kes ini, kita perlu berdagang prestasi dan mengekalkan, dan caching atau teknik pengoptimuman lain boleh digunakan jika perlu.

// Contoh: Mengoptimumkan prestasi menggunakan suntikan ketergantungan dan pengguna kelas cache {
    Pangkalan data $ $ swasta;
    Cache $ swasta;

    Fungsi awam __Construct (pangkalan data pangkalan data, cache $ cache) {
        $ this-> pangkalan data = $ pangkalan data;
        $ this-> cache = $ cache;
    }

    fungsi awam getUserData ($ userId) {
        jika ($ this-> cache-> mempunyai ($ userId)) {
            kembali $ this-> cache-> get ($ userId);
        }

        $ data = $ this-> database-> query ('Pilih * dari pengguna di mana id =?', [$ userId]);
        $ this-> cache-> set ($ userId, $ data);

        mengembalikan $ data;
    }
}

• Amalan Terbaik : Semasa mengikuti prinsip pepejal, anda juga harus memberi perhatian kepada kebolehbacaan dan pemeliharaan kod. Sebagai contoh, gunakan penamaan yang bermakna, tulis dokumentasi yang jelas, ikuti gaya pengekodan yang konsisten, dll.

Melalui artikel ini, kita bukan sahaja memahami definisi dan peranan prinsip pepejal, tetapi juga meneroka aplikasi mereka dalam pembangunan sebenar melalui contoh kod PHP tertentu. Mudah -mudahan pengetahuan dan pengalaman ini dapat membantu anda merancang lebih elegan, lebih mudah untuk mengekalkan dan mengembangkan sistem ketika menulis kod PHP.

Atas ialah kandungan terperinci Huraikan prinsip -prinsip yang kukuh dan bagaimana ia memohon kepada pembangunan PHP.. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!