SOLID tamoyillari (Obyektga yo‘naltirilgan dasturlashda)

SOLID — bu OOP (Object-Oriented Programming) tamoyillarining asosiy 5 prinsipidan tashkil topgan qisqartma bo‘lib, bu tamoyillar kodni o‘qilishi oson, kengaytiriluvchan va testlanadigan qilishga yordam beradi.

---

S — Single Responsibility Principle

Har bir class faqat bitta vazifani bajarishi kerak.

❌ Yomon uslub:

class User {
    public function save() { /* bazaga saqlash */ }
    public function sendEmail() { /* xabar yuborish */ }
}

✅ To‘g‘ri yondashuv:

class User {
    // faqat userga oid ma’lumotlar
}

class UserRepository {
    public function save(User $user) { /* saqlash */ }
}

class Mailer {
    public function sendEmail(User $user) { /* email yuborish */ }
}

---

O — Open/Closed Principle

Kod ochiq bo‘lishi kerak (kengaytirish uchun), lekin yopiq bo‘lishi kerak (o‘zgartirish uchun).

❌ Yomon uslub:

class Payment {
    public function pay($type) {
        if ($type == 'paypal') { /* paypal bilan to‘lash */ }
        elseif ($type == 'card') { /* karta bilan to‘lash */ }
    }
}

✅ To‘g‘ri yondashuv:

interface PaymentMethod {
    public function pay();
}

class Paypal implements PaymentMethod {
    public function pay() { /* Paypal */ }
}

class Card implements PaymentMethod {
    public function pay() { /* Card */ }
}

class PaymentProcessor {
    public function pay(PaymentMethod $method) {
        $method->pay();
    }
}

---

L — Liskov Substitution Principle

Asosiy klassni istalgan subclass (meros oluvchi) bilan almashtirish mumkin bo‘lishi kerak.

❌ Yomon misol:

class Bird {
    public function fly() { /* uchadi */ }
}

class Ostrich extends Bird {
    // tuyaqush ucha olmaydi, ammo fly() bor
}

✅ To‘g‘ri yondashuv:

interface Bird { }

interface FlyingBird extends Bird {
    public function fly();
}

class Sparrow implements FlyingBird {
    public function fly() { /* uchadi */ }
}

class Ostrich implements Bird {
    // ucha olmaydi, shunchaki qush
}

---

I — Interface Segregation Principle

Katta interfeys o‘rniga, kichik, aniq vazifali interfeyslar yaratish kerak.

❌ Yomon uslub:

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

✅ To‘g‘ri yondashuv:

interface Workable {
    public function work();
}

interface Eatable {
    public function eat();
}

class Robot implements Workable {
    public function work() { /* ishlaydi */ }
}

class Human implements Workable, Eatable {
    public function work() { /* ishlaydi */ }
    public function eat() { /* ovqatlanadi */ }
}

---

D — Dependency Inversion Principle

Yuqori darajadagi komponentlar past darajadagi komponentlarga emas, balki abstraksiyalarga (interface) tayanishi kerak.

❌ Yomon yondashuv:

class MySQLDatabase {
    public function connect() { /* MySQLga ulanadi */ }
}

class App {
    public function __construct() {
        $db = new MySQLDatabase();
        $db->connect();
    }
}

✅ To‘g‘ri yondashuv:

interface Database {
    public function connect();
}

class MySQLDatabase implements Database {
    public function connect() { /* MySQL */ }
}

class PostgreSQLDatabase implements Database {
    public function connect() { /* PostgreSQL */ }
}

class App {
    private $db;

    public function __construct(Database $db) {
        $this->db = $db;
        $this->db->connect();
    }
}

---

Xulosa:

SOLID tamoyillari dasturchiga toza, mustahkam va kengaytiriladigan tizimlar yozish imkonini beradi. Bu prinsiplarga amal qilish — yirik loyihalarda muammosiz ishlash, xatolarni kamaytirish va jamoaviy ishlab chiqishni osonlashtiradi.