├── .gitignore
├── Adapter
    └── Adapter.php
├── Decorator
    └── Decorator.php
├── DependencyInjection
    └── DependencyInjection.php
├── Facade
    └── Facade.php
├── Factory
    ├── AbstractFactory.php
    ├── FactoryMethod.php
    └── SimpleFactory.php
├── Iterator
    └── Iterator.php
├── Observer
    └── Observer.php
├── Proxy
    └── Proxy.php
├── README.md
├── Singleton
    └── Singleton.php
└── Strategy
    └── Strategy.php


/.gitignore:
--------------------------------------------------------------------------------
1 | .DS_Store
2 | 


--------------------------------------------------------------------------------
/Adapter/Adapter.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | 
  3 | interface AdapterInterface
  4 | {
  5 |     public function query($sql);
  6 | 
  7 |     public function result();
  8 | }
  9 | 
 10 | class MySQLAdapter implements AdapterInterface
 11 | {
 12 |     protected $connection;
 13 | 
 14 |     protected $result;
 15 | 
 16 |     public function __construct($host, $username, $password, $dbname)
 17 |     {
 18 |         $this->connection = new mysqli($host, $username, $password, $dbname);
 19 |     }
 20 | 
 21 |     public function query($sql)
 22 |     {
 23 |         $this->result = $this->connection->query($sql);
 24 | 
 25 |         return $this;
 26 |     }
 27 | 
 28 |     public function result()
 29 |     {
 30 |         if (gettype($this->result) === 'boolean') {
 31 |             return $this->result;
 32 |         } elseif ($this->result->num_rows > 0) {
 33 |             $result = [];
 34 | 
 35 |             while ($row = $this->result->fetch_assoc()) {
 36 |                 $result[] = $row;
 37 |             }
 38 | 
 39 |             return $result;
 40 |         } else {
 41 |             return [];
 42 |         }
 43 |     }
 44 | }
 45 | 
 46 | class PDOAdapter implements AdapterInterface
 47 | {
 48 |     protected $connection;
 49 | 
 50 |     protected $result;
 51 | 
 52 |     public function __construct($host, $username, $password, $dbname)
 53 |     {
 54 |         $this->connection = new PDO("mysql:host=$host;dbname=$dbname", $username, $password);
 55 |     }
 56 | 
 57 |     public function query($sql)
 58 |     {
 59 |         $query = $this->connection->prepare($sql);
 60 |         $exec = $query->execute();
 61 | 
 62 |         if ($query->columnCount() == 0) {
 63 |             $this->result = $exec;
 64 |         } else {
 65 |             $this->result = $query;
 66 |         }
 67 | 
 68 |         return $this;
 69 |     }
 70 | 
 71 |     public function result()
 72 |     {
 73 |         if (gettype($this->result) === 'boolean') {
 74 |             return $this->result;
 75 |         } else {
 76 |             $data = [];
 77 | 
 78 |             while ($row = $this->result->fetch(PDO::FETCH_ASSOC)) {
 79 |                 $data[] = $row;
 80 |             }
 81 | 
 82 |             return $data;
 83 |         }
 84 |     }
 85 | }
 86 | 
 87 | class Database
 88 | {
 89 |     protected $adapter;
 90 | 
 91 |     public function __construct(AdapterInterface $adapter)
 92 |     {
 93 |         $this->adapter = $adapter;
 94 |     }
 95 | 
 96 |     public function query($sql)
 97 |     {
 98 |         return $this->adapter->query($sql);
 99 |     }
100 | 
101 |     public function result()
102 |     {
103 |         return $this->adapter->result();
104 |     }
105 | }
106 | 
107 | $mysql = new MySQLAdapter('localhost', 'root', '1234', 'demo');
108 | $db = new Database($mysql);
109 | 
110 | $query = $db->query("SELECT * FROM users");
111 | $result = $query->result();
112 | var_dump($result);
113 | 


--------------------------------------------------------------------------------
/Decorator/Decorator.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | interface EmailInterface
 4 | {
 5 |     public function body();
 6 | }
 7 | 
 8 | class Email implements EmailInterface
 9 | {
10 |     public function body()
11 |     {
12 |         return 'Simple email body.';
13 |     }
14 | }
15 | 
16 | abstract class EmailDecorator implements EmailInterface
17 | {
18 |     public $email;
19 | 
20 |     public function __construct(EmailInterface $email)
21 |     {
22 |         $this->email = $email;
23 |     }
24 | 
25 |     abstract public function body();
26 | }
27 | 
28 | class NewYearEmailDecorator extends EmailDecorator
29 | {
30 |     public function body()
31 |     {
32 |         return $this->email->body() . ' Additional text from deocorator.';
33 |     }
34 | }
35 | 
36 | // Simple Email
37 | $email = new Email();
38 | var_dump($email->body());
39 | 
40 | // Decorated Email
41 | $emailNewYearDecorator = new NewYearEmailDecorator($email);
42 | var_dump($emailNewYearDecorator->body());
43 | 


--------------------------------------------------------------------------------
/DependencyInjection/DependencyInjection.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | class Database
 4 | {
 5 |     protected $adapter;
 6 | 
 7 |     public function __construct(MySqlAdapter $adapter)
 8 |     {
 9 |         $this->adapter = $adapter;
10 |     }
11 | }
12 | 
13 | class MysqlAdapter
14 | {
15 | 
16 | }
17 | 
18 | class Database2
19 | {
20 |     protected $adapter;
21 | 
22 |     public function setterMethod(MySqlAdapter $adapter)
23 |     {
24 |         $this->adapter = $adapter;
25 |     }
26 | }
27 | 
28 | class Database3
29 | {
30 |     protected $adapter;
31 | 
32 |     public function __construct(AdapterInterface $adapter)
33 |     {
34 |         $this->adapter = $adapter;
35 |     }
36 | }
37 | 
38 | interface AdapterInterface
39 | {
40 | 
41 | }
42 | 
43 | class MysqlAdapter2 implements AdapterInterface
44 | {
45 | 
46 | }
47 | 
48 | /** Usage **/
49 | // Contructor Injection
50 | $mysqlAdapter = new MysqlAdapter;
51 | $database = new Database($mysqlAdapter);
52 | 
53 | // Setter Method Injection
54 | $mysqlAdapter = new MysqlAdapter;
55 | $database = new Database();
56 | $database->setterMethod($mysqlAdapter);
57 | 
58 | // Interface Injection
59 | $mysqlAdapter = new MysqlAdapter2;
60 | $database = new Database($mysqlAdapter);
61 | 


--------------------------------------------------------------------------------
/Facade/Facade.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | 
  3 | class Cart
  4 | {
  5 |     public function addProducts($products)
  6 |     {
  7 |         // Product adding codes goes here
  8 |     }
  9 | 
 10 |     public function getProducts()
 11 |     {
 12 |         // Product retrieval codes goes here
 13 |     }
 14 | }
 15 | 
 16 | class Order
 17 | {
 18 |     public function process($products)
 19 |     {
 20 |         // Order processing codes goes here
 21 |     }
 22 | }
 23 | 
 24 | class Payment
 25 | {
 26 |     public function charge($charge)
 27 |     {
 28 |         // Additional charge codes goes here
 29 |     }
 30 | 
 31 |     public function makePayment()
 32 |     {
 33 |         // Payment method verify & payment codes goes here
 34 |     }
 35 | }
 36 | 
 37 | class Shipping
 38 | {
 39 |     public function calculateCharge()
 40 |     {
 41 |         // Calculation codes goes here
 42 |     }
 43 | 
 44 |     public function shipProducts()
 45 |     {
 46 |         // Ship process codes goes here
 47 |     }
 48 | }
 49 | 
 50 | class CustomerFacade
 51 | {
 52 |     public function __construct()
 53 |     {
 54 |         $this->cart = new Cart;
 55 |         $this->order = new Order;
 56 |         $this->payment = new Payment;
 57 |         $this->shipping = new Shipping;
 58 |     }
 59 | 
 60 |     public function addToCart($products)
 61 |     {
 62 |         $this->cart->addProducts($products);
 63 |     }
 64 | 
 65 |     public function checkout()
 66 |     {
 67 |         $products = $this->cart->getProducts();
 68 | 
 69 |         $this->totalAmount = $this->order->process($products);
 70 |     }
 71 | 
 72 |     public function makePayment()
 73 |     {
 74 |         $charge = $this->shipping->calculateCharge();
 75 |         $this->payment->charge($charge);
 76 | 
 77 |         $isCompleted = $this->payment->makePayment();
 78 | 
 79 |         if ($isCompleted) {
 80 |             $this->shipping->shipProducts();
 81 |         }
 82 |     }
 83 | }
 84 | 
 85 | $customer = new CustomerFacade;
 86 | 
 87 | $products = [
 88 |     [
 89 |         'name' => 'Polo T-Shirt',
 90 |         'price' => 40,
 91 |     ],
 92 |     [
 93 |         'name' => 'Smart Watch',
 94 |         'price' => 400,
 95 |     ],
 96 | ];
 97 | 
 98 | $customer->addToCart($products);
 99 | $customer->checkout();
100 | $customer->makePayment();
101 | 


--------------------------------------------------------------------------------
/Factory/AbstractFactory.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | /**
  3 |  * Abstract Factory Pattern.
  4 |  *
  5 |  * Unlike the simple factory and factory method pattern, an abstract factory is an interface to create of related objects without specifying/exposing their classes. We can also say that it provides an object of another factory that is responsible for creating required objects.
  6 |  */
  7 | 
  8 | abstract class AbstractVehicleFactory
  9 | {
 10 |     abstract public function makeCar();
 11 |     abstract public function makeBike();
 12 | }
 13 | 
 14 | class BangladeshiFactory extends AbstractVehicleFactory
 15 | {
 16 |     public function makeCar()
 17 |     {
 18 |         return new ToyotaCar();
 19 |     }
 20 | 
 21 |     public function makeBike()
 22 |     {
 23 |         return new YamahaBike();
 24 |     }
 25 | }
 26 | 
 27 | class USAFactory extends AbstractVehicleFactory
 28 | {
 29 |     public function makeCar()
 30 |     {
 31 |         return new MercedesCar();
 32 |     }
 33 | 
 34 |     public function makeBike()
 35 |     {
 36 |         return new DucatiBike();
 37 |     }
 38 | }
 39 | 
 40 | abstract class AbstractVehicle
 41 | {
 42 |     abstract public function design();
 43 |     abstract public function assemble();
 44 |     abstract public function paint();
 45 | }
 46 | 
 47 | abstract class AbstractCarVehicle extends AbstractVehicle
 48 | {
 49 | 
 50 | }
 51 | 
 52 | abstract class AbstractBikeVehicle extends AbstractVehicle
 53 | {
 54 | 
 55 | }
 56 | 
 57 | class MercedesCar extends AbstractCarVehicle
 58 | {
 59 |     public function design()
 60 |     {
 61 |         return 'Designing Mercedes Car';
 62 |     }
 63 | 
 64 |     public function assemble()
 65 |     {
 66 |         return 'Assembling Mercedes Car';
 67 |     }
 68 | 
 69 |     public function paint()
 70 |     {
 71 |         return 'Painting Mercedes Car';
 72 |     }
 73 | }
 74 | 
 75 | class ToyotaCar extends AbstractCarVehicle
 76 | {
 77 |     public function design()
 78 |     {
 79 |         return 'Designing Toyota Car';
 80 |     }
 81 | 
 82 |     public function assemble()
 83 |     {
 84 |         return 'Assembling Toyota Car';
 85 |     }
 86 | 
 87 |     public function paint()
 88 |     {
 89 |         return 'Painting Toyota Car';
 90 |     }
 91 | }
 92 | 
 93 | class YamahaBike extends AbstractBikeVehicle
 94 | {
 95 |     public function design()
 96 |     {
 97 |         return 'Designing Yamaha Bike';
 98 |     }
 99 | 
100 |     public function assemble()
101 |     {
102 |         return 'Assembling Yamaha Bike';
103 |     }
104 | 
105 |     public function paint()
106 |     {
107 |         return 'Painting Yamaha Bike';
108 |     }
109 | }
110 | 
111 | class DucatiBike extends AbstractBikeVehicle
112 | {
113 |     public function design()
114 |     {
115 |         return 'Designing Ducati Bike';
116 |     }
117 | 
118 |     public function assemble()
119 |     {
120 |         return 'Assembling Ducati Bike';
121 |     }
122 | 
123 |     public function paint()
124 |     {
125 |         return 'Painting Ducati Bike';
126 |     }
127 | }
128 | 
129 | $bangladeshiFactoryInstance = new BangladeshiFactory;
130 | $car = $bangladeshiFactoryInstance->makeCar();
131 | echo $car->design() . '<br/>';
132 | echo $car->assemble() . '<br/>';
133 | echo $car->paint() . '<br/>';
134 | 
135 | echo '<br/>';
136 | 
137 | $bike = $bangladeshiFactoryInstance->makeBike();
138 | echo $bike->design() . '<br/>';
139 | echo $bike->assemble() . '<br/>';
140 | echo $bike->paint() . '<br/>';
141 | 
142 | echo '<br/>';
143 | 
144 | $usaFactoryInstance = new USAFactory;
145 | $car = $usaFactoryInstance->makeCar();
146 | echo $car->design() . '<br/>';
147 | echo $car->assemble() . '<br/>';
148 | echo $car->paint() . '<br/>';
149 | 
150 | echo '<br/>';
151 | 
152 | $bike = $usaFactoryInstance->makeBike();
153 | echo $bike->design() . '<br/>';
154 | echo $bike->assemble() . '<br/>';
155 | echo $bike->paint() . '<br/>';
156 | 


--------------------------------------------------------------------------------
/Factory/FactoryMethod.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | /**
  3 |  * Factory Method Pattern.
  4 |  *
  5 |  * This allows interfaces for creating objects, but allow subclasses to determine which class to instantiate.
  6 |  */
  7 | abstract class VehicleFactoryMethod
  8 | {
  9 |     abstract public function make($brand);
 10 | }
 11 | 
 12 | class CarFactory extends VehicleFactoryMethod
 13 | {
 14 |     public function make($brand)
 15 |     {
 16 |         $car = null;
 17 | 
 18 |         switch ($brand) {
 19 |             case "mercedes":
 20 |                 $car = new MercedesCar;
 21 |                 break;
 22 |             case "toyota":
 23 |                 $car = new ToyotaCar;
 24 |                 break;
 25 |         }
 26 | 
 27 |         return $car;
 28 |     }
 29 | }
 30 | 
 31 | class BikeFactory extends VehicleFactoryMethod
 32 | {
 33 |     public function make($brand)
 34 |     {
 35 |         $bike = null;
 36 | 
 37 |         switch ($brand) {
 38 |             case "yamaha":
 39 |                 $bike = new YamahaBike;
 40 |                 break;
 41 |             case "ducati":
 42 |                 $bike = new DucatiBike;
 43 |                 break;
 44 |         }
 45 | 
 46 |         return $bike;
 47 |     }
 48 | }
 49 | 
 50 | interface CarInterface
 51 | {
 52 |     public function design();
 53 | 
 54 |     public function assemble();
 55 | 
 56 |     public function paint();
 57 | }
 58 | 
 59 | interface BikeInterface
 60 | {
 61 |     public function design();
 62 | 
 63 |     public function assemble();
 64 | 
 65 |     public function paint();
 66 | }
 67 | 
 68 | class MercedesCar implements CarInterface
 69 | {
 70 |     public function design()
 71 |     {
 72 |         return 'Designing Mercedes Car';
 73 |     }
 74 | 
 75 |     public function assemble()
 76 |     {
 77 |         return 'Assembling Mercedes Car';
 78 |     }
 79 | 
 80 |     public function paint()
 81 |     {
 82 |         return 'Painting Mercedes Car';
 83 |     }
 84 | }
 85 | 
 86 | class ToyotaCar implements CarInterface
 87 | {
 88 |     public function design()
 89 |     {
 90 |         return 'Designing Toyota Car';
 91 |     }
 92 | 
 93 |     public function assemble()
 94 |     {
 95 |         return 'Assembling Toyota Car';
 96 |     }
 97 | 
 98 |     public function paint()
 99 |     {
100 |         return 'Painting Toyota Car';
101 |     }
102 | }
103 | 
104 | class YamahaBike implements BikeInterface
105 | {
106 |     public function design()
107 |     {
108 |         return 'Designing Yamaha Bike';
109 |     }
110 | 
111 |     public function assemble()
112 |     {
113 |         return 'Assembling Yamaha Bike';
114 |     }
115 | 
116 |     public function paint()
117 |     {
118 |         return 'Painting Yamaha Bike';
119 |     }
120 | }
121 | 
122 | class DucatiBike implements BikeInterface
123 | {
124 |     public function design()
125 |     {
126 |         return 'Designing Ducati Bike';
127 |     }
128 | 
129 |     public function assemble()
130 |     {
131 |         return 'Assembling Ducati Bike';
132 |     }
133 | 
134 |     public function paint()
135 |     {
136 |         return 'Painting Ducati Bike';
137 |     }
138 | }
139 | 
140 | $carFactoryInstance = new CarFactory;
141 | 
142 | $mercedes = $carFactoryInstance->make('mercedes');
143 | echo $mercedes->design() . '<br/>';
144 | echo $mercedes->assemble() . '<br/>';
145 | echo $mercedes->paint() . '<br/>';
146 | 
147 | echo '<br/>';
148 | 
149 | $toyota = $carFactoryInstance->make('toyota');
150 | echo $toyota->design() . '<br/>';
151 | echo $toyota->assemble() . '<br/>';
152 | echo $toyota->paint() . '<br/>';
153 | 
154 | echo '<br/>';
155 | 
156 | $bikeFactoryInstance = new BikeFactory;
157 | 
158 | $yamaha = $bikeFactoryInstance->make('yamaha');
159 | echo $yamaha->design() . '<br/>';
160 | echo $yamaha->assemble() . '<br/>';
161 | echo $yamaha->paint() . '<br/>';
162 | 
163 | echo '<br/>';
164 | 
165 | $ducati = $bikeFactoryInstance->make('ducati');
166 | echo $ducati->design() . '<br/>';
167 | echo $ducati->assemble() . '<br/>';
168 | echo $ducati->paint() . '<br/>';
169 | 


--------------------------------------------------------------------------------
/Factory/SimpleFactory.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | /**
 3 |  * Simple Factory Pattern.
 4 |  *
 5 |  * This allows interfaces for creating objects without exposing the object creation logic to the client.
 6 |  */
 7 | class CarFactory
 8 | {
 9 |     protected $brands = [];
10 | 
11 |     public function __construct()
12 |     {
13 |         $this->brands = [
14 |             'mercedes' => 'MercedesCar',
15 |             'toyota' => 'ToyotaCar',
16 |         ];
17 |     }
18 | 
19 |     public function make($brand)
20 |     {
21 |         if (!array_key_exists($brand, $this->brands)) {
22 |             return new Exception('Not available this car');
23 |         }
24 | 
25 |         $className = $this->brands[$brand];
26 | 
27 |         return new $className();
28 |     }
29 | }
30 | 
31 | interface CarInterface
32 | {
33 |     public function design();
34 |     public function assemble();
35 |     public function paint();
36 | }
37 | 
38 | class MercedesCar implements CarInterface
39 | {
40 |     public function design()
41 |     {
42 |         return 'Designing Mercedes Car';
43 |     }
44 | 
45 |     public function assemble()
46 |     {
47 |         return 'Assembling Mercedes Car';
48 |     }
49 | 
50 |     public function paint()
51 |     {
52 |         return 'Painting Mercedes Car';
53 |     }
54 | }
55 | 
56 | class ToyotaCar implements CarInterface
57 | {
58 |     public function design()
59 |     {
60 |         return 'Designing Toyota Car';
61 |     }
62 | 
63 |     public function assemble()
64 |     {
65 |         return 'Assembling Toyota Car';
66 |     }
67 | 
68 |     public function paint()
69 |     {
70 |         return 'Painting Toyota Car';
71 |     }
72 | }
73 | 
74 | $carFactory = new CarFactory;
75 | 
76 | $mercedes = $carFactory->make('mercedes');
77 | echo $mercedes->design() . '<br/>';
78 | echo $mercedes->assemble() . '<br/>';
79 | echo $mercedes->paint() . '<br/>';
80 | 
81 | echo '<br/>';
82 | 
83 | $toyota = $carFactory->make('toyota');
84 | echo $toyota->design() . '<br/>';
85 | echo $toyota->assemble() . '<br/>';
86 | echo $toyota->paint() . '<br/>';
87 | 


--------------------------------------------------------------------------------
/Iterator/Iterator.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | class Book
 4 | {
 5 |     private $title;
 6 | 
 7 |     public function __construct($title)
 8 |     {
 9 |         $this->title = $title;
10 |     }
11 | 
12 |     public function getTitle()
13 |     {
14 |         return $this->title;
15 |     }
16 | }
17 | 
18 | class BookList implements Iterator, Countable
19 | {
20 |     private $books = [];
21 | 
22 |     private $currentIndex = 0;
23 | 
24 |     public function current()
25 |     {
26 |         return $this->books[$this->currentIndex];
27 |     }
28 | 
29 |     public function key()
30 |     {
31 |         return $this->currentIndex;
32 |     }
33 | 
34 |     public function next()
35 |     {
36 |         $this->currentIndex++;
37 |     }
38 | 
39 |     public function rewind()
40 |     {
41 |         $this->currentIndex = 0;
42 |     }
43 | 
44 |     public function valid()
45 |     {
46 |         return isset($this->books[$this->currentIndex]);
47 |     }
48 | 
49 |     public function count()
50 |     {
51 |         return count($this->books);
52 |     }
53 | 
54 |     public function addBook(Book $book)
55 |     {
56 |         $this->books[] = $book;
57 |     }
58 | 
59 |     public function removeBook(Book $bookToRemove)
60 |     {
61 |         foreach ($this->books as $key => $book) {
62 |             if ($book->getTitle() === $bookToRemove->getTitle()) {
63 |                 unset($this->books[$key]);
64 |             }
65 |         }
66 | 
67 |         $this->books = array_values($this->books);
68 |     }
69 | }
70 | 
71 | $bookList = new BookList();
72 | $bookList->addBook(new Book('Design Pattern'));
73 | $bookList->addBook(new Book('Head First Design Pattern'));
74 | $bookList->addBook(new Book('Clean Code'));
75 | $bookList->addBook(new Book('The Pragmatic Programmer'));
76 | 
77 | $bookList->removeBook(new Book('Design Pattern'));
78 | 
79 | foreach ($bookList as $book) {
80 |     echo $book->getTitle() . PHP_EOL;
81 | }
82 | 


--------------------------------------------------------------------------------
/Observer/Observer.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | class Model implements \SplSubject
 4 | {
 5 |     protected $observers;
 6 | 
 7 |     public function __construct()
 8 |     {
 9 |         $this->observers = new \SplObjectStorage();
10 | 
11 |         foreach ($this->setObservers() as $observer) {
12 |             $this->attach($observer);
13 |         }
14 |     }
15 | 
16 |     public function attach(\SplObserver $observer)
17 |     {
18 |         $this->observers->attach($observer);
19 |     }
20 | 
21 |     public function detach(\SplObserver $observer)
22 |     {
23 |         $this->observers->detach($observer);
24 |     }
25 | 
26 |     public function notify()
27 |     {
28 |         foreach ($this->observers as $observer) {
29 |             $observer->update($this);
30 |         }
31 |     }
32 | 
33 |     protected function setObservers()
34 |     {
35 |         return [];
36 |     }
37 | 
38 |     public function __set($name, $value)
39 |     {
40 |         $this->data[$name] = $value;
41 |         // notify the observers, that model has been updated
42 |         $this->notify();
43 |     }
44 | }
45 | 
46 | class Post extends Model
47 | {
48 |     protected function setObservers()
49 |     {
50 |         return [
51 |             new PostModelObserver,
52 |             new Observer2,
53 |         ];
54 |     }
55 | }
56 | 
57 | class PostModelObserver implements \SplObserver
58 | {
59 |     public function update(\SplSubject $subject)
60 |     {
61 |         echo get_class($subject) . ' has been updated' . '<br>';
62 |     }
63 | }
64 | 
65 | class Observer2 implements \SplObserver
66 | {
67 |     public function update(\SplSubject $subject)
68 |     {
69 |         echo get_class($subject) . ' has been updated' . '<br>';
70 |     }
71 | }
72 | 
73 | $post1 = new Post();
74 | $post2 = new Post();
75 | $post3 = new Post();
76 | 
77 | $post1->title = 'Hello World';
78 | $post2->title = 'Another Post Title';
79 | $post3->body = 'Lorem ipsum............';
80 | 


--------------------------------------------------------------------------------
/Proxy/Proxy.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | interface FileInterface
 4 | {
 5 |     public function content();
 6 | }
 7 | 
 8 | class RealFile implements FileInterface
 9 | {
10 |     private $fileName;
11 | 
12 |     private $fileContent;
13 | 
14 |     public function __construct($fileName)
15 |     {
16 |         $this->fileName = $fileName;
17 | 
18 |         $this->readFile();
19 |     }
20 | 
21 |     private function readFile()
22 |     {
23 |         $this->fileContent = file_get_contents($this->fileName);
24 |     }
25 | 
26 |     public function content()
27 |     {
28 |         return $this->fileContent;
29 |     }
30 | }
31 | 
32 | class ProxyFile implements FileInterface
33 | {
34 |     private $fileName;
35 | 
36 |     private $realFileObject;
37 | 
38 |     public function __construct($fileName)
39 |     {
40 |         $this->fileName = $fileName;
41 |     }
42 | 
43 |     public function content()
44 |     {
45 |         // Lazy load the file using the RealFile class
46 |         if (!$this->realFileObject) {
47 |             $this->realFileObject = new RealFile($this->fileName);
48 |         }
49 | 
50 |         return $this->realFileObject->content();
51 |     }
52 | }
53 | 
54 | $realFile = new RealFile('/path/to/file.jpg');
55 | var_dump(memory_get_usage()); // ~5Mb
56 | $realFile->content();
57 | var_dump(memory_get_usage()); // ~5Mb
58 | 
59 | $realFile->content();
60 | var_dump(memory_get_usage()); // ~5Mb
61 | 
62 | $proxyFile = new ProxyFile('/path/to/file.jpg');
63 | var_dump(memory_get_usage()); // ~350Kb
64 | $proxyFile->content();
65 | var_dump(memory_get_usage()); // ~5Mb
66 | 
67 | $proxyFile->content();
68 | var_dump(memory_get_usage()); // ~5Mb
69 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | # PHP Design Patterns
 2 | 
 3 | ## Patterns
 4 | - [x] Adapter
 5 | - [x] DependencyInjection
 6 | - [x] Facade
 7 | - [x] Factory
 8 | - [x] Observer
 9 | - [x] Singleton
10 | - [x] Strategy
11 | - [x] Iterator
12 | - [x] Proxy
13 | - [x] Decorator
14 | - [ ] S.O.L.I.D Principle
15 | - [ ] CLEAN Architecture
16 | 


--------------------------------------------------------------------------------
/Singleton/Singleton.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | class Singleton
 4 | {
 5 |     private static $instance;
 6 | 
 7 |     public static function getInstance()
 8 |     {
 9 |         if (null === self::$instance) {
10 |             self::$instance = new self();
11 |         }
12 | 
13 |         return self::$instance;
14 |     }
15 | 
16 |     private function __construct()
17 |     {
18 | 
19 |     }
20 | 
21 |     public function sayHi()
22 |     {
23 |         echo 'Hi';
24 |     }
25 | }
26 | 
27 | $singleton = Singleton::getInstance();
28 | 
29 | $singleton->sayHi();
30 | 


--------------------------------------------------------------------------------
/Strategy/Strategy.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | interface TravelStrategy
 4 | {
 5 |     public function travel();
 6 | }
 7 | 
 8 | class BusTravelStrategy implements TravelStrategy
 9 | {
10 |     public function travel()
11 |     {
12 |         // Bus travel strategy will goes here
13 |     }
14 | }
15 | 
16 | class TrainTravelStrategy implements TravelStrategy
17 | {
18 |     public function travel()
19 |     {
20 |         // Train travel strategy will goes here
21 |     }
22 | }
23 | 
24 | class PlaneTravelStrategy implements TravelStrategy
25 | {
26 |     public function travel()
27 |     {
28 |         // Plane travel strategy will goes here
29 |     }
30 | }
31 | 
32 | class Traveler
33 | {
34 |     protected $traveler;
35 | 
36 |     public function __construct(TravelStrategy $traveler)
37 |     {
38 |         $this->traveler = $traveler;
39 |     }
40 | 
41 |     public function travel()
42 |     {
43 |         $this->traveler->travel();
44 |     }
45 | }
46 | 
47 | $traveler = new Traveler(new BusTravelStrategy());
48 | $traveler->travel();
49 | 
50 | $traveler1 = new Traveler(new PlaneTravelStrategy());
51 | $traveler1->travel();
52 | 


--------------------------------------------------------------------------------