PHP frameworks ਵਿੱਚ ਕਿਹੜੇ design patterns ਆਮ ਹਨ?

Question

Accepted Answer

PHP frameworks (Laravel, Symfony) classic **design patterns** ਉੱਤੇ ਬਣੇ ਹੋਏ ਹਨ — common design problems ਦੇ ਦੁਬਾਰਾ ਵਰਤੋ ਜਾਂਦੇ ਹੱਲ। ਇਨ੍ਹਾਂ ਨੂੰ ਪਛਾਣਨ ਨਾਲ ਤੁਸੀਂ ਸਮਝ ਸਕਦੇ ਹੋ ਕਿ frameworks ਕਿਵੇਂ ਕੰਮ ਕਰਦੇ ਹਨ ਅਤੇ ਤੁਸੀਂ ਆਪਣੇ ਆਪ ਵਿੱਚ ਬਿਹਤਰ-ਢਾਂਚਾਬੱਧ ਕੋਡ ਲਿਖ ਸਕਦੇ ਹੋ।

## MVC (Model-View-Controller) — architectural foundation

```text
Model      → data + business logic (e.g. Eloquent models)
View       → presentation (templates: Blade, Twig)
Controller → handles requests, coordinates models & views
→ The structural pattern of nearly every PHP web framework.
```

## Dependency Injection / IoC Container

```php
// frameworks use a container to resolve & inject dependencies (decoupling, testability)
$service = $container->get(UserService::class);   // dependencies auto-wired
```

## Repository pattern — data access ਨੂੰ abstract ਕਰਨਾ

```php
interface UserRepository {
    public function find(int $id): ?User;
}
class EloquentUserRepository implements UserRepository { /* DB-specific impl */ }
// services depend on the INTERFACE → swap data sources, mock in tests
```

**Repository** pattern data access ਨੂੰ interface ਦੇ ਪਿੱਛੇ abstract ਕਰਦਾ ਹੈ — business logic ਨੂੰ database ਤੋਂ decouple ਕਰਦਾ ਹੈ ਅਤੇ testing ਵਿੱਚ ਮਦਦ ਕਰਦਾ ਹੈ।

## Factory — object creation ਨੂੰ encapsulate ਕਰਨਾ

```php
class PaymentFactory {
    public static function create(string $type): PaymentGateway {
        return match($type) {
            'stripe' => new StripeGateway(),
            'paypal' => new PayPalGateway(),
        };
    }
}
```

## PHP frameworks ਵਿੱਚ ਹੋਰ common patterns

```text
Singleton  → one shared instance (often via the DI container, e.g. config, DB connection)
Observer   → event/listener systems (Laravel events, model observers)
Strategy   → interchangeable algorithms (e.g. different cache/auth drivers)
Decorator  → wrap to add behavior (middleware-style request/response wrapping)
Facade     → a simple static interface to complex subsystems (Laravel Facades:
             Cache::get(), DB::table() — proxy to container-resolved services)
Adapter    → uniform interface over different implementations (e.g. filesystem drivers)
Active Record → models that wrap DB rows with query/save methods (Eloquent)
```

Laravel ਖਾਸ ਤੌਰ ਉੱਤੇ ਇਹ ਦਿਖਾਉਂਦਾ ਹੈ: **Facades** (services ਲਈ static proxies), **Active Record** (Eloquent models), **Observer** (events/model observers), **Strategy** (cache, queue, auth ਲਈ swappable drivers)।

## ਇਸ ਦਾ ਮਹੱਤਵ

Design patterns PHP developers ਲਈ ਮਹੱਤਵਪੂਰਨ ਜ਼ਾਨਕਾਰੀ ਹਨ ਕਿਉਂਕਿ major frameworks (Laravel, Symfony) ਇਨ੍ਹਾਂ ਉੱਤੇ ਪੂਰੀ ਤਰ੍ਹਾਂ ਬਣੇ ਹੋਏ ਹਨ — ਇਸ ਲਈ patterns ਨੂੰ ਸਮਝਣਾ ਜ਼ਰੂਰੀ ਹੈ *ਕਿਵੇਂ ਇਹ frameworks ਕੰਮ ਕਰਦੇ ਹਨ* ਸਮਝਣ ਲਈ ਅਤੇ ਆਪਣੇ ਆਪ ਵਿੱਚ ਚੰਗੀ ਤਰ੍ਹਾਂ-ਢਾਂਚਾਬੱਧ ਕੋਡ ਲਿਖਣ ਲਈ।

**MVC** (ਲਗਭਗ ਹਰ PHP web framework ਦੀ architectural foundation), **Dependency Injection / IoC containers** (frameworks ਕਿਵੇਂ decoupling ਅਤੇ testability ਲਈ dependencies ਨੂੰ wire ਕਰਦੇ ਹਨ), **Repository pattern** (data access ਨੂੰ abstract ਕਰਨਾ testable, swappable persistence ਲਈ), ਅਤੇ framework-specific patterns ਜਿਵੇਂ Laravel ਦੇ **Facades** (services ਲਈ static proxies), **Active Record** (Eloquent models), ਅਤੇ **Observer** (events) ਨੂੰ ਪਛਾਣਨ ਨਾਲ ਇਹ frameworks ਦੇ "magic" ਨੂੰ ਖੁਲਾਸਾ ਕਰਦਾ ਹੈ ਅਤੇ ਤੁਹਾਨੂੰ ਉਨ੍ਹਾਂ ਨੂੰ effectively ਵਰਤਣ ਅਤੇ extend ਕਰਨ ਦਿੰਦਾ ਹੈ।

Frameworks ਨੂੰ ਸਮਝਣ ਤੋਂ ਵੱਧ, common patterns ਨੂੰ ਜਾਣਨ ਨਾਲ ਤੁਹਾਨੂੰ design discussions ਲਈ ਸਾਝੀ vocabulary ਮਿਲਦੀ ਹੈ, recurring problems ਦੇ ਸਾਬਤ ਕੀਤੇ ਹੋਏ ਹੱਲ, ਅਤੇ maintainable, flexible ਕੋਡ ਦਾ ਆਰਕੀਟੈਕਚਰ ਬਣਾਉਣ ਦੀ ਸਮਰੱਥਾ।

Chukੀ ਆਮ ਤੌਰ ਉੱਤੇ PHP development pattern-heavy frameworks ਦੇ ਅੰਦਰ ਹੁੰਦੀ ਹੈ, ਅਤੇ ਚੂੰਕਿ ਚੰਗੀ application design appropriate pattern use ਉੱਤੇ ਨਿਰਭਰ ਕਰਦੀ ਹੈ, common design patterns ਨੂੰ ਸਮਝਣਾ — ਕਿ ਉਹ ਕੀ ਹੱਲ ਕਰਦੇ ਹਨ ਅਤੇ ਉਹ PHP ecosystem ਵਿੱਚ ਕਿੱਥੇ ਦਿਖਾਈ ਦਿੰਦੇ ਹਨ — senior-level ਜ਼ਾਨਕਾਰੀ ਹੈ ਜੋ developers ਨੂੰ ਵੱਖ ਕਰਦੀ ਹੈ ਜਿਹੜੇ ਆਪਣੇ ਟੂਲਸ ਨੂੰ deeply ਸਮਝਦੇ ਹਨ ਅਤੇ ਚੰਗੀ ਤਰ੍ਹਾਂ-ਆਰਕੀਟੈਕਟ ਕੀਤੀ ਗਈ applications ਬਣਾ ਸਕਦੇ ਹਨ ਉਹਨਾਂ ਤੋਂ ਜਿਹੜੇ frameworks ਨੂੰ superficially ਵਰਤਦੇ ਹਨ। (ਚੇਤਾਵਨੀ, ਜਿਵੇਂ ਹਮੇਸ਼ਾ: patterns ਅਸਲ ਸਮੱਸਿਆਵਾਂ ਲਈ ਟੂਲਸ ਹਨ, ਨਾ ਕਿ ਅੰਤ — ਉਹਨਾਂ ਨੂੰ ਜਿੱਥੇ ਉਹ ਫਿਟ ਨਹੀਂ ਹੁੰਦੇ ਲਾਗੂ ਕਰਨ ਨਾਲ ਬੇਲੋੜੀ complexity ਜੁੜ ਜਾਂਦੀ ਹੈ।)