Observer pattern in PHP - Step-by-Step Execution

Concept Flow - Observer pattern

Subject state changes

↓

Notify all observers

↓

Each observer updates

↓

Observers react to change

↓

End

The subject changes state, then notifies all observers, which then update themselves accordingly.

Execution Sample

PHP

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

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

  public function setState($state) {
    $this->state = $state;
    $this->notify();
  }

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

class Observer {
  public function update($state) {
    echo "Observer notified with state: $state\n";
  }
}

$subject = new Subject();
$observer1 = new Observer();
$observer2 = new Observer();
$subject->attach($observer1);
$subject->attach($observer2);
$subject->setState('ON');
?>

This PHP code shows a subject notifying two observers when its state changes.

Execution Table

Step	Action	Subject State	Observers Notified	Output
1	Create Subject	null	none
2	Create Observer1	null	none
3	Create Observer2	null	none
4	Attach Observer1	null	none
5	Attach Observer2	null	none
6	Set Subject state to 'ON'	ON	Observer1, Observer2	Observer notified with state: ON Observer notified with state: ON
7	Notify observers	ON	Observer1, Observer2
8	Observer1 update called	ON	Observer1	Observer notified with state: ON
9	Observer2 update called	ON	Observer2	Observer notified with state: ON
10	End	ON	all notified	Notifications complete

💡 All observers notified after subject state changed to 'ON'

Variable Tracker

Variable	Start	After Step 5	After Step 6	After Step 10
subject->state	null	null	'ON'	'ON'
subject->observers	[]	[Observer1, Observer2]	[Observer1, Observer2]	[Observer1, Observer2]

Key Moments - 3 Insights

Why do observers get notified only after the subject's state changes?

Because the notify() method is called inside setState(), so observers update only when the state changes (see execution_table step 6).

Does attaching observers change the subject's state?

No, attaching observers just adds them to the list; the state remains unchanged until setState() is called (see steps 4 and 5).

Why does each observer print the notification message separately?

Because notify() calls update() on each observer individually, so each observer reacts and outputs its own message (see steps 8 and 9).

Visual Quiz - 3 Questions

Look at the execution_table, what is the subject's state after step 5?

A 'ON'

B null

C empty string

D undefined

💡 Hint

Check the 'Subject State' column at step 5 in the execution_table.

At which step do observers start getting notified?

A Step 5

B Step 7

C Step 6

D Step 10

💡 Hint

Look at the 'Observers Notified' column and output messages in execution_table.

If we add a third observer before step 6, how would the 'Observers Notified' column change at step 7?

A Observer1, Observer2, Observer3

B Observer1, Observer2

C Observer3 only

D No observers

💡 Hint

The subject notifies all attached observers, so adding one more means all three get notified.

Concept Snapshot

Observer pattern:
- Subject holds list of observers
- Observers attach to subject
- When subject state changes, it calls notify()
- notify() calls update() on each observer
- Observers react to changes independently

Full Transcript

The Observer pattern lets one object (subject) tell many others (observers) when something changes. Here, the subject keeps a list of observers. When its state changes, it calls notify(), which calls update() on each observer. Each observer then reacts, for example by printing a message. This way, observers stay updated automatically without the subject needing to know details about them.

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