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.

Practice

1. What is the main purpose of the Singleton pattern in PHP?

easy

A. To ensure only one instance of a class is created

B. To allow multiple instances of a class

C. To inherit properties from multiple classes

D. To create objects without a constructor

Solution

1. Step 1: Understand Singleton pattern goal

   The Singleton pattern is designed to restrict a class to a single instance.

2. Step 2: Compare options with Singleton purpose

   Only To ensure only one instance of a class is created correctly states this purpose; others describe different concepts.

3. Final Answer:

   To ensure only one instance of a class is created -> Option A

4. Quick Check:

   Singleton = single instance only [OK]

Hint: Singleton means one and only one instance [OK]

Common Mistakes:

• Thinking Singleton allows multiple instances
• Confusing Singleton with inheritance
• Believing Singleton removes constructors

2. Which of the following is the correct way to declare the static instance variable in a Singleton class in PHP?

easy

A. public static $instance;

B. private static $instance;

C. protected $instance;

D. static $instance;

Solution

1. Step 1: Identify visibility for Singleton instance

   The instance variable must be private static to restrict access and keep one shared instance.

2. Step 2: Check options for correct syntax and visibility

   private static $instance; uses private static, which is correct. Others either lack visibility or static keyword.

3. Final Answer:

   private static $instance; -> Option B

4. Quick Check:

   Singleton instance is private static [OK]

Hint: Singleton instance must be private and static [OK]

Common Mistakes:

• Using public instead of private
• Omitting static keyword
• Using protected instead of private

3. What will be the output of the following PHP code?

class Singleton {
    private static ?Singleton $instance = null;
    public int $value;
    private function __construct() { $this->value = 10; }
    public static function getInstance(): Singleton {
        if (self::$instance === null) {
            self::$instance = new Singleton();
        }
        return self::$instance;
    }
}

$obj1 = Singleton::getInstance();
$obj2 = Singleton::getInstance();
$obj2->value = 20;
echo $obj1->value;

medium

A. 10

B. null

C. 20

D. Error

Solution

1. Step 1: Understand Singleton instance sharing

   Both $obj1 and $obj2 refer to the same Singleton instance.

2. Step 2: Trace value changes

   Changing $obj2->value to 20 affects $obj1->value because they are the same object.

3. Final Answer:

   20 -> Option C

4. Quick Check:

   Singleton shares one object, so value = 20 [OK]

Hint: Singleton returns same object, changes reflect everywhere [OK]

Common Mistakes:

• Assuming separate objects for each getInstance call
• Expecting original value 10 after change
• Thinking code causes error

4. Identify the error in this Singleton implementation:

class Singleton {
    private static $instance;
    private function __construct() {}
    public static function getInstance() {
        if (!isset(self::$instance)) {
            return new Singleton();
        }
        return self::$instance;
    }
}

medium

A. No error, code is correct

B. Constructor should be public

C. Static variable should be public

D. getInstance() does not assign the new object to static instance

Solution

1. Step 1: Check getInstance method logic

   The method creates a new Singleton but does not save it to self::$instance.

2. Step 2: Identify missing assignment

   Without assigning, every call returns a new object, breaking Singleton pattern.

3. Final Answer:

   getInstance() does not assign the new object to static instance -> Option D

4. Quick Check:

   Missing assignment breaks Singleton [OK]

Hint: Always assign new instance to static variable in getInstance [OK]

Common Mistakes:

• Making constructor public
• Not assigning instance in getInstance
• Changing static variable visibility incorrectly

5. You want to extend a Singleton class in PHP but ensure the child class also follows Singleton rules independently. Which approach is best?

hard

A. Use separate static instance variables in parent and child classes

B. Share the parent's static instance variable in the child class

C. Make constructor public in child class

D. Avoid inheritance and duplicate Singleton code

Solution

1. Step 1: Understand Singleton inheritance challenge

   Parent and child classes must maintain separate single instances to avoid conflicts.

2. Step 2: Use separate static variables

   Each class having its own static instance variable ensures independent Singleton behavior.

3. Final Answer:

   Use separate static instance variables in parent and child classes -> Option A

4. Quick Check:

   Separate static instances keep Singleton independent [OK]

Hint: Each class needs its own static instance variable [OK]

Common Mistakes:

• Sharing static instance causes one instance for both classes
• Making constructor public breaks Singleton
• Avoiding inheritance unnecessarily