Refactoring The Piramid Doom: Strategi untuk PHP Bersih Jika Blok

Gunakan pulangan awal untuk mengendalikan prasyarat dan menghapuskan bersarang yang mendalam dengan keluar dengan cepat pada kes kegagalan. 2. Mengesahkan semua keadaan di hadapan menggunakan kaedah penolong khusus untuk memastikan logik utama bersih dan boleh diuji. 3. Memusatkan pengesahan dengan pengecualian dan cuba/menangkap blok untuk mengekalkan jalan gembira yang rata dan linear. 4. Ekstrak keadaan kompleks ke dalam kaedah atau kelas yang lebih kecil untuk meningkatkan kebolehbacaan dan kebolehgunaan semula. 5. Leverage Php 8 NULLSAFE dan NULL Coperator Coalescing Untuk Menghilangkan Pemeriksaan Null Redundant Dan Memudahkan Panggilan Kaedah Bertauliah. 6. Untuk logik bersyarat kompleks, gunakan corak keadaan atau strategi untuk menggantikan IF bersarang dengan polimorfisme, meningkatkan kebolehkerjaan dan skalabiliti. Strategi ini secara kolektif mengurangkan beban kognitif, meningkatkan kesesuaian, dan menjadikan kod lebih mudah untuk mengubah suai dan alasan.

Bersarang if pernyataan dalam PHP - sering dipanggil "piramid azab" - adalah bau kod biasa yang membuat logik sukar untuk diikuti, menguji, dan mengekalkan. Mereka biasanya timbul apabila anda mengesahkan prasyarat, mengendalikan kesilapan, atau memeriksa beberapa negeri sebelum melaksanakan logik teras. Yang lebih mendalam bersarang, semakin sukar untuk alasan tentang apa yang sebenarnya dilakukan oleh kod itu.

Berita baik? Anda tidak perlu hidup dengannya. Berikut adalah strategi praktikal untuk meratakan piramid dan menulis kod PHP yang lebih bersih dan lebih mudah dibaca.

1. Kembalikan awal (klausa pengawal)

Salah satu cara yang paling berkesan untuk mengelakkan bersarang adalah menggunakan pulangan awal - juga dikenali sebagai klausa pengawal. Daripada membungkus laluan kejayaan anda dalam lapisan if , keluar awal apabila prasyarat tidak dipenuhi.

Sebelum (Piramid azab):

 Fungsi ProcessUser ($ user) {
    jika ($ user! == null) {
        jika ($ user-> isactive ()) {
            jika ($ user-> haspermission ('edit')) {
                // logik utama di sini
                pulangan $ this-> performAction ($ user);
            } else {
                membuang pengecualian baru ('tiada kebenaran');
            }
        } else {
            Buang pengecualian baru ('Pengguna tidak aktif');
        }
    } else {
        membuang pengecualian baru ('pengguna tidak dijumpai');
    }
}

Selepas (pulangan awal):

 Fungsi ProcessUser ($ user) {
    jika ($ user === null) {
        membuang pengecualian baru ('pengguna tidak dijumpai');
    }

    jika (! $ user-> isactive ()) {
        Buang pengecualian baru ('Pengguna tidak aktif');
    }

    jika (! $ user-> haspermission ('edit')) {
        membuang pengecualian baru ('tiada kebenaran');
    }

    pulangan $ this-> performAction ($ user);
}

Versi ini adalah linear, lebih mudah untuk mengimbas, dan mengekalkan jalan gembira yang tidak diinden. Setiap klausa pengawal mengendalikan satu kes kegagalan dan mengeluarkannya.

2. Gunakan pengesahan di hadapan

Sekiranya anda menyemak pelbagai syarat yang perlu dilalui sebelum meneruskan, pertimbangkan untuk mengesahkannya bersama -sama. Anda boleh mengekstrak logik ke dalam kaedah khusus atau menggunakan cek boolean yang mudah.

 Fungsi ProcessUser ($ user) {
    jika (! $ this-> canProcessUser ($ user)) {
        membuang pengecualian baru ('tidak dapat memproses pengguna');
    }

    pulangan $ this-> performAction ($ user);
}

Fungsi peribadi CanProcessUser ($ user): bool {
    kembali $ pengguna! == null 
        && $ user-> isactive () 
        && $ user-> haspermission ('edit');
}

Ini menjadikan kaedah utama bersih dan menggerakkan logik kompleks kepada pembantu yang bernama dengan baik. Bonus: canProcessUser() kini boleh diuji secara bebas.

3. Pengecualian leverage dan cuba/menangkap

Untuk aliran kerja pengesahan-berat, pertimbangkan untuk menggunakan pengecualian dan bukan manual if cek. Ini membolehkan anda menulis jalan gembira secara linear dan mengendalikan kegagalan di pusat.

 Fungsi ProcessUser ($ user) {
    $ this-> validateUser ($ user);
    pulangan $ this-> performAction ($ user);
}

Fungsi Private ValidateUser ($ user): void {
    jika ($ user === null) membuang InvalidArgumentException baru ('pengguna tidak dijumpai');
    jika (! $ user-> isactive ()) membuang invalidargumentException baru ('pengguna tidak aktif');
    jika (! $ user-> haspermission ('edit')) membuang invalidargumentException baru ('tiada kebenaran');
}

Sekarang logik utama benar -benar rata. Semua pengesahan terpusat, dan anda juga boleh menggunakan semula validateUser() di tempat lain.

4. Ekstrak ke kaedah atau kelas yang lebih kecil

Apabila keadaan melibatkan logik perniagaan yang kompleks, itu adalah tanda yang anda harus mengeluarkannya. Memecahkan kaedah besar ke dalam yang lebih kecil, yang bertanggungjawab tunggal.

Bukannya:

 jika ($ user && $ user-> isactive () && $ order-> isValid () && $ inventory-> hasStock ()) {...}

Lakukan:

 jika (! $ this-> canProcessorder ($ user, $ order)) {
    membuang domainException baru ('perintah tidak boleh diproses');
}

Dan menentukan:

 Fungsi peribadi CanProcesser ($ pengguna, $ perintah): bool {
    pulangan $ pengguna?-> isactive ()
        && $ order-> isvalid ()
        && $ this-> Inventory-> HasStockFor ($ order);
}

Ini meningkatkan kebolehbacaan dan menjadikan ujian lebih mudah.

5. Gunakan keselamatan null dan chaining pilihan (Php 8)

Versi PHP moden membantu mengurangkan pemeriksaan null dengan ketara. Gunakan pengendali nullsafe ( ?-> ) dan pengendali coalescing null ( ?? ) untuk mengelakkan tidak perlu if blok.

Sebelum:

 jika ($ user! == null) {
    jika ($ user-> getProfile ()! == null) {
        kembali $ user-> getProfile ()-> getEmail ();
    }
}
kembali 'tidak diketahui@example.com';

Selepas:

 kembali $ pengguna?-> getProfile ()?-> getEMail () ?? 'tidak diketahui@example.com';

Ini menghilangkan keseluruhan lapisan bersarang dalam satu baris.

Bonus: Pertimbangkan corak negeri atau strategi untuk logik kompleks

Jika anda mendapati diri anda dengan keadaan yang sangat bersarang berdasarkan peranan pengguna, status, atau jenis, mungkin masa untuk bergerak melampaui if kenyataan sepenuhnya.

• Corak Negeri : Mengemas Tingkah laku berdasarkan keadaan objek.
• Corak Strategi : Pilih algoritma atau peraturan berdasarkan konteks.

Corak ini menggantikan logik bersyarat dengan polimorfisme, menjadikan kod lebih extensible dan kurang rapuh.

Memperbaiki piramid azab bukan hanya tentang estetika - ia mengurangkan pepijat, meningkatkan kebolehlaksanaan, dan menjadikan kod anda lebih mudah diubah. Mulakan dengan pulangan awal dan pengekstrakan pengesahan. Kemudian, apabila kerumitan tumbuh, mencapai corak reka bentuk dan ciri PHP moden.

Pada asasnya: Tulis untuk jalan gembira, pengawal terhadap jalan yang sedih, dan simpan if blok anda cetek.

Atas ialah kandungan terperinci Refactoring The Piramid Doom: Strategi untuk PHP Bersih Jika Blok. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!