Why design patterns matter in PHP - Challenge Your Understanding

Challenge - 5 Problems

❓ Predict Output

intermediate

What is the output of this Singleton pattern example?

Consider this PHP code implementing a Singleton pattern. What will it output?

PHP

<?php
class Singleton {
    private static ?Singleton $instance = null;
    public int $value;

    private function __construct() {
        $this->value = rand(1, 100);
    }

    public static function getInstance(): Singleton {
        if (self::$instance === null) {
            self::$instance = new Singleton();
        }
        return self::$instance;
    }
}

$a = Singleton::getInstance();
$b = Singleton::getInstance();
echo $a->value . ',' . $b->value;
?>

A Same random number printed twice separated by a comma

B Two different random numbers separated by a comma

C Syntax error due to nullable type declaration

D Fatal error: Cannot access private constructor

💡 Hint

Singleton ensures only one instance exists.

The Singleton pattern creates only one instance. Both variables point to the same object, so their values are identical.

🧠 Conceptual

intermediate

Why use design patterns in software development?

Which of the following best explains why design patterns matter?

A They offer proven solutions to common problems, improving code quality and communication

B They guarantee software will have no bugs

C They provide ready-made code that can be copied without understanding

D They force developers to write more complex code to impress others

💡 Hint

Think about how patterns help teams work together and avoid reinventing the wheel.

Design patterns are reusable solutions that help developers solve common problems efficiently and communicate ideas clearly.

🔧 Debug

advanced

What error does this Factory pattern code produce?

Examine this PHP code snippet using a Factory pattern. What error will it raise when run?

PHP

<?php
interface Product {
    public function getName(): string;
}

class ProductA implements Product {
    public function getName(): string {
        return 'Product A';
    }
}

class ProductFactory {
    public static function create(string $type): Product {
        if ($type === 'A') {
            return new ProductA();
        } elseif ($type === 'B') {
            return new ProductB();
        }
        throw new Exception('Unknown product type');
    }
}

$product = ProductFactory::create('B');
echo $product->getName();
?>

A Exception: Unknown product type

B Fatal error: Class 'ProductB' not found

C Syntax error: missing semicolon

D Output: Product B

💡 Hint

Check if all classes used are defined.

The code tries to create an instance of ProductB, but this class is not defined, causing a fatal error.

📝 Syntax

advanced

Which option correctly implements the Observer pattern in PHP?

Which of the following PHP code snippets correctly implements the Observer pattern?

A

<?php
interface Observer {
    public function update();
}

class Subject {
    private array $observers = [];

    public function attach(Observer $observer) {
        $this->observers[] = $observer;
    }

    public function notify() {
        foreach ($this->observers as $observer) {
            $observer->update('Hello');
        }
    }
}
?>

B

<?php
class Subject {
    private array $observers;

    public function attach(Observer $observer) {
        $this->observers->add($observer);
    }

    public function notify(string $message) {
        foreach ($this->observers as $observer) {
            $observer->update($message);
        }
    }
}
?>

C

<?php
interface Observer {
    public function update(string $message);
}

class Subject {
    private array $observers = [];

    public function attach(Observer $observer) {
        $this->observers[] = $observer;
    }

    public function notify() {
        foreach ($this->observers as $observer) {
            $observer->update();
        }
    }
}
?>

D

<?php
interface Observer {
    public function update(string $message);
}

class Subject {
    private array $observers = [];

    public function attach(Observer $observer) {
        $this->observers[] = $observer;
    }

    public function notify(string $message) {
        foreach ($this->observers as $observer) {
            $observer->update($message);
        }
    }
}
?>

💡 Hint

Check method signatures and how observers are stored and notified.

Option D correctly defines the Observer interface with update(string $message), stores observers in an array, and calls update with the message.

🚀 Application

expert

How many objects are created in this Decorator pattern example?

Given this PHP code using the Decorator pattern, how many objects are created in total?

PHP

<?php
interface Coffee {
    public function cost(): float;
}

class SimpleCoffee implements Coffee {
    public function cost(): float {
        return 5.0;
    }
}

class MilkDecorator implements Coffee {
    private Coffee $coffee;

    public function __construct(Coffee $coffee) {
        $this->coffee = $coffee;
    }

    public function cost(): float {
        return $this->coffee->cost() + 1.5;
    }
}

class SugarDecorator implements Coffee {
    private Coffee $coffee;

    public function __construct(Coffee $coffee) {
        $this->coffee = $coffee;
    }

    public function cost(): float {
        return $this->coffee->cost() + 0.5;
    }
}

$coffee = new SugarDecorator(new MilkDecorator(new SimpleCoffee()));
echo $coffee->cost();
?>

A 2 objects

B 1 object

C 3 objects

D 4 objects

💡 Hint

Count each new keyword creating an object.

There are three objects: SimpleCoffee, MilkDecorator wrapping SimpleCoffee, and SugarDecorator wrapping MilkDecorator.