If tutorials available on this website are helpful for you, please whitelist this website in your ad blocker😭 or Donate to help us ❤️ pay for the web hosting to keep the website running.
PHP Design Patterns
Design patterns का use programming में एक reusable solution provide करने के लिए किया जाता है, जो कि common software problems को solve करते हैं। ये patterns एक standard way में code लिखने में help करते हैं, जिससे maintainability, scalability, और readability improve होती है।
इस blog में हम कुछ popular PHP design patterns को समझेंगे और उनका use करेंगे।
●●●
Singleton pattern एक ऐसा pattern है जो ensure करता है कि एक class का सिर्फ एक ही instance हो और उस instance को globally access किया जा सके।
class DatabaseConnection {
private static $instance = null;
private function __construct() {
// Database connection code here
}
public static function getInstance() {
if (self::$instance === null) {
self::$instance = new DatabaseConnection();
}
return self::$instance;
}
}
// Usage
$dbConnection = DatabaseConnection::getInstance();आप जब भी एक global database connection maintain करना चाहते हैं तो Singleton pattern use कर सकते हैं , इस pattern से less memory use होती है और multiple instances create hone से बचता है जिससे performance boost होती है ।
●●●
Factory pattern object creation का process simplify करता है। इसमें हम directly constructor call करने के वजाय एक factory class का use करते हैं जो object create करती है।
interface Vehicle {
public function drive();
}
class Car implements Vehicle {
public function drive() {
echo "Driving a car!";
}
}
class Bike implements Vehicle {
public function drive() {
echo "Riding a bike!";
}
}
class VehicleFactory {
public static function createVehicle($type) {
if ($type === 'car') {
return new Car();
} elseif ($type === 'bike') {
return new Bike();
}
throw new Exception("Invalid vehicle type");
}
}
// Usage
$vehicle = VehicleFactory::createVehicle('car');
$vehicle->drive(); // Output: Driving a car!जब आपको multiple classes में से किसी एक का object create करना हो, और वो decision runtime पे लेना हो, तब factory pattern का use होता है। जैसे, अगर आपको different types के vehicles का instance create करना हो।
●●●
Observer pattern एक one-to-many relationship establish करता है, जिसमे एक object change होता है तो उसका notification automatically बाकी सब objects को मिलता है जो उसको observe कर रहे होते हैं।
interface Observer {
public function update($message);
}
class User implements Observer {
public function update($message) {
echo "User received notification: $message";
}
}
class NotificationService {
private $observers = [];
public function registerObserver(Observer $observer) {
$this->observers[] = $observer;
}
public function notifyObservers($message) {
foreach ($this->observers as $observer) {
$observer->update($message);
}
}
}
// Usage
$notificationService = new NotificationService();
$user1 = new User();
$user2 = new User();
$notificationService->registerObserver($user1);
$notificationService->registerObserver($user2);
$notificationService->notifyObservers("New notification!");जब आपको एक event के hone पर multiple systems को notify करना हो, तब observer pattern का use होता है , जैसे, जब एक notification service users को notify करती है।
●●●
Strategy pattern में आप एक class के different behaviors को encapsulate करते हैं और उन्हें runtime पे switch कर सकते हैं , इसमें आप different algorithms को interchangeable बना सकते हैं।
interface PaymentStrategy {
public function pay($amount);
}
class CreditCardPayment implements PaymentStrategy {
public function pay($amount) {
echo "Paid $amount using Credit Card.";
}
}
class PaypalPayment implements PaymentStrategy {
public function pay($amount) {
echo "Paid $amount using PayPal.";
}
}
class ShoppingCart {
private $paymentStrategy;
public function setPaymentStrategy(PaymentStrategy $strategy) {
$this->paymentStrategy = $strategy;
}
public function checkout($amount) {
$this->paymentStrategy->pay($amount);
}
}
// Usage
$cart = new ShoppingCart();
$cart->setPaymentStrategy(new PaypalPayment());
$cart->checkout(100); // Output: Paid 100 using PayPal.Strategy pattern का use तब होता है जब आपको dynamically algorithms को switch करना हो, जैसे payment methods के बीच switch करना।
●●●
Decorator pattern का use object के behavior को extend करने के लिए बिना उसके original class को modify किये किया जाता है।
interface Coffee {
public function cost();
}
class SimpleCoffee implements Coffee {
public function cost() {
return 5;
}
}
class MilkDecorator implements Coffee {
protected $coffee;
public function __construct(Coffee $coffee) {
$this->coffee = $coffee;
}
public function cost() {
return $this->coffee->cost() + 2;
}
}
class SugarDecorator implements Coffee {
protected $coffee;
public function __construct(Coffee $coffee) {
$this->coffee = $coffee;
}
public function cost() {
return $this->coffee->cost() + 1;
}
}
// Usage
$coffee = new SimpleCoffee();
$coffee = new MilkDecorator($coffee);
$coffee = new SugarDecorator($coffee);
echo $coffee->cost(); // Output: 8Decorator pattern का use आप तब करते हैं जब आपको एक object के behavior को dynamically enhance करना हो बिना उसकी original class को change किये , जैसे coffee के साथ milk या sugar add करना।
●●●
PHP में यह patterns काफी useful हैं जब आप complex applications develop कर रहे हो। Design patterns coding को और ज़्यादा efficient, reusable, और maintainable बनाते हैं।
अगर आप इन patterns का use करते हैं, तो आपका code ज़्यादा structured और readable होगा।
Loading ...