Corak bersyarat lanjutan untuk membina aplikasi PHP yang fleksibel

Gunakan mod dasar untuk menggantikan logik bersyarat dengan tingkah laku yang boleh ditukar ganti; 2. Gunakan mod objek kosong untuk menghapuskan pemeriksaan nilai null; 3. Gunakan mod keadaan untuk membuat objek mengubah tingkah laku mengikut keadaan dalaman; 4. Menggabungkan peraturan perniagaan yang kompleks melalui mod spesifikasi; 5. Menggabungkan mod arahan dengan pengawal untuk mencapai kawalan pelaksanaan tanpa syarat; 6. Gunakan pengedaran berasaskan kelas untuk menggantikan pernyataan suis; Mod ini meningkatkan kebolehkerjaan, kesesuaian dan skalabilitas kod dengan menukar logik bersyarat ke dalam polimorfisme dan kombinasi, dengan itu membina lebih banyak aplikasi PHP yang fleksibel.

Apabila membina aplikasi PHP yang fleksibel dan boleh dipelihara, bergantung semata-mata pada pernyataan asas if-else dengan cepat boleh membawa kepada kod yang tegar dan keras. Corak bersyarat lanjutan membolehkan pemaju menulis logik yang lebih dinamik, berskala, dan boleh dibaca. Corak -corak ini melampaui cawangan mudah dan merangkumi prinsip -prinsip reka bentuk yang menggalakkan pemisahan kebimbangan, kesesuaian, dan lanjutan.

Berikut adalah beberapa corak bersyarat lanjutan yang boleh anda gunakan untuk menjadikan aplikasi PHP anda lebih mudah disesuaikan.

1. Corak Strategi: Gantikan logik bersyarat dengan tingkah laku yang boleh ditukar ganti

Daripada menggunakan switch panjang atau rantai if-elseif untuk menentukan tingkah laku, merangkum setiap variasi ke dalam kelasnya sendiri menggunakan corak strategi.

Contoh: Pemprosesan pembayaran

 Interface PaymentProcessor
{
    Proses Fungsi Awam (Float $ Amaun): BOOL;
}

Kelas CreditCardProcessor Melaksanakan PEMBAYARAN PEMBAYARAN
{
    Proses Fungsi Awam (Float $ Amaun): Bool
    {
        // Proses kad kredit
        kembali benar;
    }
}

Kelas PayPalProcessor Melaksanakan PEMBAYARAN PEMBAYARAN
{
    Proses Fungsi Awam (Float $ Amaun): Bool
    {
        // Proses melalui PayPal
        kembali benar;
    }
}

PEMBAYARAN KELAS
{
    Pemproses PaymentProcessor $ Private;

    Fungsi Awam SetProcessor (PEMPERSIHIAN PEMBAYARAN $ Pemproses): Kekosongan
    {
        $ this-> pemproses = $ pemproses;
    }

    Fungsi Awam Jalankan (Float $ Amaun): Bool
    {
        kembali $ this-> processor-> process ($ amaun);
    }
}

Mengapa lebih baik:

• Tiada syarat yang diperlukan semasa memilih logik
• Mudah untuk menambah kaedah pembayaran baru
• Menggalakkan suntikan dan ujian ketergantungan

Gunakan ini apabila:

• Anda mempunyai pelbagai algoritma untuk tugas yang sama
• Perubahan tingkah laku berdasarkan konteks atau konfigurasi

2. Null Object Corak: Hilangkan pemeriksaan null

Daripada penyebaran if ($object !== null) cek, gunakan objek null yang melaksanakan antara muka yang sama tetapi tidak melakukan apa -apa.

 Logger antara muka
{
    log fungsi awam (rentetan $ mesej);
}

Kelas FileLogger Melaksanakan Logger
{
    log fungsi awam (rentetan $ mesej)
    {
        file_put_contents ('app.log', $ mesej. php_eol, file_append);
    }
}

Kelas Nulllogger melaksanakan Logger
{
    log fungsi awam (rentetan $ mesej)
    {
        // buat apa -apa
    }
}

Kelas Pengguna Kelas
{
    Logger peribadi $ logger;

    Fungsi awam __Construct (logger $ logger = null)
    {
        $ this-> logger = $ logger ?? baru nulllogger (); // Elakkan pemeriksaan null
    }

    Daftar Fungsi Awam (String $ E -mel)
    {
        // tidak perlu memeriksa sama ada logger adalah batal
        $ this-> logger-> log ("pengguna berdaftar: $ e-mel");
    }
}

Manfaat: Kod bersih, lebih sedikit keadaan mempertahankan.

3. Corak Negeri: Biarkan objek mengubah tingkah laku berdasarkan keadaan dalaman

Apabila tingkah laku objek berubah secara drastik berdasarkan keadaannya, elakkan keadaan seperti if ($status === 'active') dengan mengeksport logik keadaan.

 Antara muka Orderstate
{
    Kapal Fungsi Awam (OrderContext $ Order);
    Batalkan fungsi awam (OrderContext $ order);
}

kelas yang belum selesai melaksanakan Orderstate
{
    Kapal Fungsi Awam (OrderContext $ Order) { / * tidak dibenarkan * /}
    Fungsi awam Batal (OrderContext $ order) {$ order-> setState (new CancelledState ()); }
}

Kelas ShippedState melaksanakan Orderstate
{
    kapal fungsi awam (orderContext $ order) { / * sudah dihantar * /}
    Fungsi awam Batal (orderContext $ order) { / * tidak dapat membatalkan * /}
}

Kelas OrderContext
{
    Orderstate swasta $ state;

    fungsi awam __construct ()
    {
        $ this-> state = new IningState ();
    }

    Fungsi Awam SetState (Orderstate $ State)
    {
        $ this-> state = $ state;
    }

    kapal fungsi awam () {$ this-> state-> ship ($ this); }
    fungsi awam membatalkan () {$ this-> state-> membatalkan ($ ini); }
}

Ini menghilangkan keadaan seperti:

 jika ($ this-> status === 'menunggu') {
    $ this-> status = 'dihantar';
}

Sebaliknya, tingkah laku diwakilkan ke objek keadaan semasa.

4. Corak Spesifikasi: Tuliskan Peraturan Perniagaan Kompleks

Gunakan logik Boolean melalui objek untuk mewakili peraturan perniagaan. Ini amat berguna untuk pengesahan atau penapisan.

 spesifikasi antara muka
{
    fungsi awam issatisfiedby ($ calon): bool;
    Fungsi Awam dan (Spesifikasi $ Lain): Spesifikasi;
    fungsi awam atau (spesifikasi $ lain): spesifikasi;
    fungsi awam tidak (): spesifikasi;
}

Kelas Agespecification Melaksanakan Spesifikasi
{
    persendirian int $ minage;

    Fungsi Awam __Construct (int $ minage)
    {
        $ this-> minage = $ minage;
    }

    Fungsi Awam IssatisFiedBy ($ calon): Bool
    {
        kembali $ calon-> umur> = $ this-> minage;
    }

    Fungsi Awam dan (Spesifikasi $ Lain): Spesifikasi
    {
        Kembalikan dan spesifikasi baru ($ ini, $ yang lain);
    }

    // ... sama untuk atau (), tidak ()
}

Sekarang anda boleh menyusun peraturan:

 $ canvote = (Agespecification baru (18))-> dan (Kewarganegaraan Kewarganegaraan Baru ('US'));
jika ($ canvote-> issatisfiedBy ($ user)) {...}

Ini menggantikan keadaan bersarang kompleks dengan objek peraturan yang boleh dibaca dan boleh diguna semula.

5. Corak Perintah dengan Pengawal: Pelaksanaan bersyarat tanpa IFS

Campurkan corak arahan dengan prasyarat (pengawal) untuk mengawal aliran pelaksanaan.

 Perintah antara muka
{
    fungsi awam canExecute (): bool;
    fungsi awam melaksanakan ();
}

Kelas DeleteacCountCommand melaksanakan arahan
{
    Pengguna Swasta $ Pengguna;

    Fungsi Awam __Construct (pengguna $ pengguna)
    {
        $ this-> user = $ user;
    }

    fungsi awam canExecute (): bool
    {
        kembali $ this-> user-> isVerified () &&! $ this-> user-> hastiveSubscriptions ();
    }

    fungsi awam melaksanakan ()
    {
        jika (! $ this-> canExecute ()) {
            membuang RuntimeException baru ("tidak dapat melaksanakan perintah");
        }
        // melaksanakan penghapusan
    }
}

Kemudian proses arahan secara amnya:

 foreach ($ perintah sebagai $ cmd) {
    jika ($ cmd-> canExecute ()) {
        $ cmd-> Execute ();
    }
}

Ini memusatkan logik bersyarat dan menjadikan saluran perintah mudah dikendalikan.

6. Gunakan penghantaran berasaskan kelas dan bukannya menukar pernyataan

Bukannya:

 suis (type $) {
    kes 'pdf': kembali pdfexporter baru (); 
    kes 'csv': kembali csvexporter baru ();
    // ...
}

Gunakan peta jenis ke kelas:

 Ekspor Kelas
{
    array peribadi $ peta = [
        'pdf' => pdfexporter :: kelas,
        'csv' => csvexporter :: kelas,
    ];

    Buat Fungsi Awam (String $ Type): Pengeksport
    {
        jika (! isset ($ this-> map [$ type])) {
            membuang InvalidArgumentException baru ("Jenis Tidak Diketahui: $ Jenis");
        }

        kembali baru $ this-> map [$ type] ();
    }
}

Lebih baik: Gunakan bekas DI untuk menyelesaikannya secara dinamik.

Pemikiran terakhir

Corak bersyarat lanjutan membantu anda:

• Kurangkan duplikasi kod
• Meningkatkan kebolehlihatan
• Menjadikan sistem lebih mudah untuk dilanjutkan
• Elakkan kerumitan bersarang dan siklomatik yang mendalam

Daripada bertanya "Apa yang perlu saya lakukan seterusnya?" Dalam keadaan, tanya:

• Bolehkah ini menjadi objek?
• Bolehkah ini disuntik?
• Bolehkah ini disusun?

Dengan menggantikan keadaan dengan polimorfisme dan komposisi, anda membina sistem yang lebih mudah untuk membuat alasan dan berkembang dari masa ke masa.

Pada asasnya, jika anda menulis if pernyataan untuk menentukan apa jenis perkara yang perlu dilakukan - mungkin masa untuk menggunakan corak.

Atas ialah kandungan terperinci Corak bersyarat lanjutan untuk membina aplikasi PHP yang fleksibel. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!