Singleton pattern in PHP - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

What is the output of this Singleton pattern example?

Consider this PHP Singleton class. What will be the output when running the code below?

PHP

<?php
class Logger {
    private static ?Logger $instance = null;
    private function __construct() {}
    public static function getInstance(): Logger {
        if (self::$instance === null) {
            self::$instance = new Logger();
        }
        return self::$instance;
    }
    public function log(string $msg): void {
        echo $msg . "\n";
    }
}

$log1 = Logger::getInstance();
$log2 = Logger::getInstance();
if ($log1 === $log2) {
    echo "Same instance";
} else {
    echo "Different instances";
}
?>

A Same instance

B Different instances

C Fatal error: Cannot instantiate private constructor

D Syntax error

💡 Hint

Think about how the Singleton pattern ensures only one instance exists.

The Singleton pattern uses a private static variable to hold the single instance. The constructor is private to prevent direct instantiation. The getInstance() method creates the instance only once and returns the same object every time. So, $log1 and $log2 point to the same object, making the output "Same instance".

❓ Predict Output

intermediate

What error does this Singleton code produce?

What error will this PHP code produce when executed?

PHP

<?php
class Config {
    private static ?Config $instance = null;
    private function __construct() {}
}

$config = new Config();
?>

A Warning: Undefined property

B No error, object created successfully

C Parse error: syntax error

D Fatal error: Cannot instantiate private constructor

💡 Hint

Check the constructor visibility and how the object is created.

The constructor is private, so trying to create an object with new Config() from outside the class causes a fatal error in PHP. This prevents direct instantiation, enforcing the Singleton pattern.

🧠 Conceptual

advanced

Why use a private constructor in Singleton pattern?

Why is the constructor declared private in a Singleton class?

A To prevent creating multiple instances from outside the class

B To make the class abstract

C To enable multiple instances to be created internally

D To allow subclassing of the Singleton class

💡 Hint

Think about how Singleton controls instance creation.

The private constructor stops code outside the class from creating new instances directly. This ensures only one instance exists, controlled by the class itself.

❓ Predict Output

advanced

What is the output of this modified Singleton code?

What will this PHP code output?

PHP

<?php
class Counter {
    private static ?Counter $instance = null;
    private int $count = 0;
    private function __construct() {}
    public static function getInstance(): Counter {
        if (self::$instance === null) {
            self::$instance = new Counter();
        }
        return self::$instance;
    }
    public function increment(): void {
        $this->count++;
    }
    public function getCount(): int {
        return $this->count;
    }
}

$c1 = Counter::getInstance();
$c1->increment();
$c1->increment();
$c2 = Counter::getInstance();
$c2->increment();
echo $c2->getCount();
?>

A 1

B 2

C 3

D 0

💡 Hint

Remember that both variables point to the same instance.

Since $c1 and $c2 are the same Singleton instance, increments accumulate. Two increments via $c1 plus one via $c2 total 3.

🔧 Debug

expert

Why does this Singleton implementation fail to enforce single instance?

Examine this PHP Singleton code. Why does it fail to enforce a single instance?

PHP

<?php
class BrokenSingleton {
    public static ?BrokenSingleton $instance = null;
    public function __construct() {}
    public static function getInstance(): BrokenSingleton {
        if (self::$instance === null) {
            self::$instance = new BrokenSingleton();
        }
        return self::$instance;
    }
}

$a = new BrokenSingleton();
$b = BrokenSingleton::getInstance();
if ($a === $b) {
    echo "Same instance";
} else {
    echo "Different instances";
}
?>

A Static property is not initialized properly

B Constructor is public, so external code can create multiple instances

C getInstance() method is missing return statement

D Class is missing a destructor

💡 Hint

Check the constructor's visibility and how instances are created.

The constructor is public, so code outside the class can create new instances with new. This breaks the Singleton pattern which requires the constructor to be private or protected to prevent multiple instances.