Observer pattern in PHP - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

What is the output of this Observer pattern example?

Consider this PHP code implementing a simple observer pattern. What will it print?

PHP

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

class Subject {
    private array $observers = [];

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

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

class ConcreteObserver implements Observer {
    private string $name;

    public function __construct(string $name) {
        $this->name = $name;
    }

    public function update(string $message): void {
        echo $this->name . " received: " . $message . "\n";
    }
}

$subject = new Subject();
$observer1 = new ConcreteObserver("Observer1");
$observer2 = new ConcreteObserver("Observer2");
$subject->attach($observer1);
$subject->attach($observer2);
$subject->notify("Hello Observers!");
?>

A No output

B

Observer1 received: Hello Observers!
Observer2 received: Hello Observers!

C

Observer1 received: Hello Observers!

D

Observer2 received: Hello Observers!

💡 Hint

Think about how many observers are attached and what notify() does.

The Subject has two observers attached. When notify() is called, it calls update() on both observers, so both print their messages.

🧠 Conceptual

intermediate

What is the main purpose of the Observer pattern?

Choose the best description of the Observer pattern's main purpose.

A To encapsulate a group of individual algorithms.

B To restrict access to certain parts of an object.

C To allow an object to notify other objects automatically when its state changes.

D To create a single instance of a class throughout the application.

💡 Hint

Think about how objects communicate changes in state.

The Observer pattern lets one object (subject) notify many other objects (observers) automatically when its state changes.

🔧 Debug

advanced

Why does this Observer pattern code cause a fatal error?

Look at this PHP code snippet. It causes a fatal error. What is the cause?

PHP

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

class Subject {
    private array $observers = [];

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

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

class ConcreteObserver {
    private string $name;

    public function __construct(string $name) {
        $this->name = $name;
    }

    public function update(string $message): void {
        echo $this->name . " received: " . $message . "\n";
    }
}

$subject = new Subject();
$observer = new ConcreteObserver("Obs1");
$subject->attach($observer);
$subject->notify("Test");
?>

A Fatal error because ConcreteObserver does not implement Observer interface.

B Fatal error because attach() method is missing.

C Fatal error because update() method has wrong parameter type.

D No fatal error, code runs fine.

💡 Hint

Check if the observer class matches the interface type hint.

The Subject expects objects implementing Observer interface. ConcreteObserver does not declare it implements Observer, so PHP throws a fatal error when attaching.

📝 Syntax

advanced

Which option correctly implements the detach method in Subject?

We want to add a detach method to remove an observer from the Subject's list. Which option correctly implements this?

PHP

<?php
class Subject {
    private array $observers = [];

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

    // Implement detach method here
}
?>

A

public function detach(Observer $observer): void {
    $index = array_search($observer, $this->observers, true);
    if ($index !== false) {
        unset($this->observers[$index]);
    }
}

B

public function detach(Observer $observer): void {
    foreach ($this->observers as $key => $obs) {
        if ($obs == $observer) {
            unset($this->observers[$key]);
        }
    }
}

C

public function detach(Observer $observer): void {
    $this->observers = array_filter($this->observers, fn($obs) => $obs !== $observer);
}

D

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

💡 Hint

Use strict comparison and remove only the matching observer.

Option A uses strict comparison and unsets the exact observer. Option A uses loose comparison which can cause issues. Option A returns a filtered array but does not reindex keys, which can cause problems. Option A clears all observers, which is incorrect.

🚀 Application

expert

How many observers will be notified after this code runs?

Given this PHP code, how many observers will receive the notification?

PHP

<?php
interface Observer {
    public function update(string $msg): void;
}

class Subject {
    private array $observers = [];

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

    public function detach(Observer $observer): void {
        $index = array_search($observer, $this->observers, true);
        if ($index !== false) {
            unset($this->observers[$index]);
        }
    }

    public function notify(string $msg): void {
        foreach ($this->observers as $observer) {
            $observer->update($msg);
        }
    }
}

class ConcreteObserver implements Observer {
    private string $id;
    public function __construct(string $id) {
        $this->id = $id;
    }
    public function update(string $msg): void {
        echo "Observer {$this->id} got: {$msg}\n";
    }
}

$subject = new Subject();
$obs1 = new ConcreteObserver("1");
$obs2 = new ConcreteObserver("2");
$obs3 = new ConcreteObserver("3");

$subject->attach($obs1);
$subject->attach($obs2);
$subject->attach($obs3);
$subject->detach($obs2);
$subject->attach($obs2);
$subject->detach($obs1);
$subject->notify("Update!");
?>

A 1

B 0

C 3

D 2

💡 Hint

Track attach and detach calls carefully.

Initially, obs1, obs2, obs3 attached (3 observers). Then obs2 detached (2 left). Then obs2 attached again (3 observers). Then obs1 detached (2 left). The final observers are obs3 and obs2. Because detach uses unset without reindexing, the array keys are not continuous but the foreach still iterates all attached observers. However, obs1 is removed, so only obs2 and obs3 receive the notification.

Practice

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

easy

A. To allow objects to watch and react to changes in another object

B. To speed up the execution of PHP scripts

C. To store data in a database efficiently

D. To handle user input validation

Solution

1. Step 1: Understand the Observer pattern concept

   The Observer pattern is designed to let one object notify others about changes.

2. Step 2: Match the purpose with the options

   To allow objects to watch and react to changes in another object correctly describes this notification and reaction mechanism.

3. Final Answer:

   To allow objects to watch and react to changes in another object -> Option A

4. Quick Check:

   Observer pattern = objects watch and react [OK]

Hint: Observer pattern = watch and react to changes [OK]

Common Mistakes:

• Confusing Observer with database or input handling
• Thinking it speeds up code execution
• Mixing it with unrelated design patterns

2. Which of the following is the correct way to attach an observer to a subject in PHP using the Observer pattern?

easy

A. $subject->addObserver($observer);

B. $observer->attach($subject);

C. $subject->attach($observer);

D. $observer->addSubject($subject);

Solution

1. Step 1: Recall the standard method to add observers

   In PHP's Observer pattern, the subject calls attach() to add observers.

2. Step 2: Verify method and object roles

   The subject manages observers, so $subject->attach($observer); is correct.

3. Final Answer:

   $subject->attach($observer); -> Option C

4. Quick Check:

   Subject attaches observer = $subject->attach($observer) [OK]

Hint: Subject attaches observer with attach() method [OK]

Common Mistakes:

• Calling attach() on observer instead of subject
• Using non-standard method names like addObserver
• Mixing up subject and observer roles

3. Given the following PHP code using the Observer pattern, what will be the output?

$subject = new Subject();
$observer = new ConcreteObserver();
$subject->attach($observer);
$subject->setState('Hello');

Assuming ConcreteObserver prints the new state when notified.

medium

A. Hello

B. State changed

C. No output

D. Error: method not found

Solution

1. Step 1: Understand the flow of notification

   The subject changes state and notifies the observer, which prints the new state.

2. Step 2: Identify the observer's reaction

   The observer prints the state 'Hello' when notified.

3. Final Answer:

   Hello -> Option A

4. Quick Check:

   Observer prints new state = Hello [OK]

Hint: Observer prints state when notified after attach [OK]

Common Mistakes:

• Assuming no output without calling notify explicitly
• Confusing printed message with generic text
• Expecting errors without method definitions

4. What is wrong with this PHP Observer pattern code snippet?

class Subject {
  private $observers = [];
  public function attach($observer) {
    $this->observers[] = $observer;
  }
  public function notify() {
    foreach ($this->observers as $observer) {
      $observer->update();
    }
  }
}

$subject = new Subject();
$subject->notify();

medium

A. attach() method is missing

B. Observers array is private and inaccessible

C. notify() method should not call update()

D. No observers attached before notify is called

Solution

1. Step 1: Check observer attachment before notify

   The code calls notify() without attaching any observers first.

2. Step 2: Understand effect of no observers

   Since no observers are attached, notify() loops over an empty array and does nothing.

3. Final Answer:

   No observers attached before notify is called -> Option D

4. Quick Check:

   Notify without observers = no action [OK]

Hint: Attach observers before notify() to trigger updates [OK]

Common Mistakes:

• Thinking private array causes error
• Assuming attach() method is missing
• Believing notify() should not call update()

5. You want to implement an Observer pattern in PHP where multiple observers react differently to the same state change. Which approach best supports this requirement?

hard

A. Use a single observer class and change its behavior with if-else inside update()

B. Create different observer classes implementing a common interface and attach them to the subject

C. Attach only one observer and switch its internal state manually

D. Avoid using Observer pattern and use global variables instead

Solution

1. Step 1: Identify how to support multiple reactions

   Different observer classes allow each to react uniquely to the same notification.

2. Step 2: Evaluate options for flexibility and design

   Create different observer classes implementing a common interface and attach them to the subject uses a common interface but different classes, which is clean and scalable.

3. Final Answer:

   Create different observer classes implementing a common interface and attach them to the subject -> Option B

4. Quick Check:

   Multiple observers = different classes with common interface [OK]

Hint: Use multiple observer classes for different reactions [OK]

Common Mistakes:

• Using one observer with complex if-else logic
• Attaching only one observer limits reactions
• Ignoring design principles by using globals