Pendekatan yang betul untuk pengaturcaraan PHP: petua dan contoh praktikal

Kod yang boleh dipercayai dan boleh diselenggara adalah tulang belakang mana-mana projek PHP yang berjaya. Untuk mencapai matlamat ini, kita boleh menulis kod mengikut prinsip SOLID. Prinsip ini termasuk Prinsip Tanggungjawab Tunggal (SRP), Prinsip Tertutup Terbuka (OCP), Prinsip Penggantian Liskov (LSP), Prinsip Pengasingan Antara Muka (ISP) dan Prinsip Inversi Ketergantungan (DIP).

Prinsip Tanggungjawab Tunggal (SRP)

Prinsip Tanggungjawab Tunggal menyatakan bahawa kelas sepatutnya hanya mempunyai satu sebab untuk berubah. Dalam PHP, ini bermakna bahawa kelas harus mempunyai satu tanggungjawab. Reka bentuk sedemikian boleh meningkatkan kebolehselenggaraan dan kebolehbacaan kod.

Contoh Buruk - Tanggungjawab Bercampur

class  User
 { 
    public  function  verify ( $username , $password ) { /* ... */ } 
    public  function  sendEmail ( $message ) { /* ... */ } 
}

Contoh Baik - Tanggungjawab Tunggal

class  UserAuthenticator
 { 
    public  function  verify ( $username , $password ) { /* ... */ } 
} 
class EmailSender
 {
     public  function  sendEmail ( $message ) { /* ... */ }
}

Prinsip Terbuka-Tutup (OCP)

Ditutup tetapi perlu dilanjutkan ke kelas itu tidak terbuka kepada sambungan Pengubahsuaian ditutup. Dalam PHP, kita boleh melaksanakan prinsip ini menggunakan antara muka dan kelas abstrak. Dengan mentakrifkan antara muka dan kelas abstrak, kami boleh melanjutkan fungsi tanpa mengubah suai kod sedia ada.

Contoh yang tidak baik - pengubahsuaian langsung

class Square
{
    public $side;
    public function __construct($side)
    {
        $this->side = $side;
    }
}
class AreaCalculator
{
    public function calculate($shapes)
    {
        $area = 0;
        foreach ($shapes as $shape) {
            if ($shape instanceof Square) {
                $area += $shape->side * $shape->side;
            } elseif ($shape instanceof Circle) {
                $area += pi() * $shape->radius * $shape->radius;
            }
        }
        return $area;
    }
}

Contoh yang baik - terbuka kepada sambungan

interface Shape
{
    public function area();
}
class Square implements Shape
{
    private $side;
    public function __construct($side)
    {
        $this->side = $side;
    }
    public function area()
    {
        return $this->side * $this->side;
    }
}
class Circle implements Shape
{
    private $radius;
    public function __construct($radius)
    {
        $this->radius = $radius;
    }
    public function area()
    {
        return pi() * $this->radius * $this->radius;
    }
}

Prinsip Penggantian Liskov (LSP)

Kelas Penggantian Liskov yang boleh digunakan Penggantian Objek yang boleh digunakan Kelas Gantian Liskov tanpa menjejaskan ketepatan program. Dalam PHP, mematuhi prinsip ini memastikan bahawa kelas terbitan mengekalkan kontrak kelas asasnya. Ini memastikan ketekalan dan kebolehpercayaan kod.

Contoh yang tidak baik - Melanggar LSP

class Bird
{
    public function fly() { /* ... */ }
}
class Ostrich extends Bird
{
    public function fly() { throw new Exception("鸵鸟不能飞"); }
}

Contoh yang baik - Mengikuti LSP

interface Bird
{
    public function fly();
}
class Sparrow implements Bird
{
    public function fly() { /* ... */ }
}
class Ostrich implements Bird
{
    public function fly() { /* ... */ }
}

Prinsip Pengasingan Antara Muka (ISP)

Prinsip tersebut tidak boleh memaksa pelanggan untuk menyatakan semula perkara tersebut pada asasnya. menggunakan antara muka. Dalam PHP, ini bermakna mencipta antara muka yang lebih kecil dan lebih fokus berbanding antara muka monolitik yang besar. Reka bentuk ini meningkatkan fleksibiliti dan kebolehselenggaraan kod.

Contoh Buruk - Abses Antara Muka

interface Worker
{
    public function work();
    public function eat();
    public function sleep();
}

Contoh Baik - Pengasingan Antara Muka

interface Workable
{
    public function work();
}
interface Eatable
{
    public function eat();
}
interface Sleepable
{
    public function sleep();
}

Prinsip Penyongsangan Ketergantungan (DIP)

Modul Ketergantungan peringkat tinggi tidak sepatutnya menyatakan modul Ketergantungan tahap tinggi , tetapi kedua-duanya Kedua-duanya harus bergantung pada abstraksi. Dalam PHP, kita boleh menggunakan suntikan pergantungan dan abstraksi untuk memisahkan kelas. Ini meningkatkan kebolehujian dan kebolehselenggaraan kod anda.

Contoh buruk - modul peringkat tinggi bergantung pada modul peringkat rendah

class LightBulb
{
    public function turnOn() { /* ... */ }
    public function turnOff() { /* ... */ }
}
class Switch
{
    private $bulb;
    public function __construct()
    {
        $this->bulb = new LightBulb();
    }
    public function operate()
    {
        // Operate the bulb
    }
}

Contoh yang baik - abstraksi dan suntikan kebergantungan

interface Switchable
{
    public function turnOn();
    public function turnOff();
}
class LightBulb implements Switchable
{
    public function turnOn() { /* ... */ }
    public function turnOff() { /* ... */ }
}
class Switch
{
    private $device;
    public function __construct(Switchable $device)
    {
        $this->device = $device;
    }
    public function operate()
    {
        // Operate the device
    }
}

Kesimpulannya, menulis kod PHP yang mematuhi prinsip SOLID dan penting untuk mencipta yang boleh diselenggara aplikasi Penting. Dengan mematuhi prinsip ini dan melaksanakan contoh yang disediakan, anda boleh memastikan kod PHP anda lebih mantap, fleksibel dan lebih mudah untuk diselenggara dari semasa ke semasa. Perlu diingat bahawa penggunaan prinsip ini mungkin memerlukan perubahan dalam pemikiran dan reka bentuk, tetapi faedah dalam kualiti dan kebolehselenggaraan kod berbaloi dengan usaha. Semoga berjaya menulis kod PHP yang hebat! 🎜

Atas ialah kandungan terperinci Pendekatan yang betul untuk pengaturcaraan PHP: petua dan contoh praktikal. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!