__invoke for callable objects in PHP - Step-by-Step Execution

Concept Flow - __invoke for callable objects

Create object of class with __invoke

↓

Call object as function

↓

PHP calls __invoke method

↓

Execute __invoke code

↓

Return or print result

↓

End

When you call an object like a function, PHP runs its __invoke method automatically.

Execution Sample

PHP

<?php
class Greeter {
  public function __invoke($name) {
    return "Hello, $name!";
  }
}
$greet = new Greeter();
echo $greet("Alice");

This code creates a Greeter object and calls it like a function to greet Alice.

Execution Table

Step	Action	Evaluation	Result
1	Create Greeter object	new Greeter()	Object $greet created
2	Call $greet("Alice")	Calls __invoke with 'Alice'	Executes __invoke method
3	__invoke method runs	return "Hello, Alice!"	Returns string 'Hello, Alice!'
4	echo output	Prints returned string	Output: Hello, Alice!

💡 Execution ends after printing the greeting.

Variable Tracker

Variable	Start	After Step 1	After Step 2	After Step 3	Final
$greet	undefined	Greeter object	Greeter object	Greeter object	Greeter object
Input to __invoke	none	none	"Alice"	"Alice"	"Alice"
Return value	none	none	none	"Hello, Alice!"	"Hello, Alice!"

Key Moments - 3 Insights

Why can we call an object like a function?

Because the class has a __invoke method, PHP lets you use the object as if it were a function. See step 2 in execution_table.

What happens if __invoke is not defined but we call the object?

PHP will give an error because it doesn't know what to do when the object is called like a function. This is why __invoke must exist to allow this.

Does __invoke have to return a value?

No, but if you want to get a result from calling the object, __invoke should return something. In the example, it returns a greeting string (step 3).

Visual Quiz - 3 Questions

Look at the execution_table, what is the result returned by __invoke at step 3?

A Greeter object

B "Alice"

C "Hello, Alice!"

D No return value

💡 Hint

Check the 'Result' column at step 3 in execution_table.

At which step does PHP automatically call the __invoke method?

A Step 2

B Step 3

C Step 1

D Step 4

💡 Hint

Look at the 'Action' column describing the call to $greet("Alice") in execution_table.

If the __invoke method did not return anything, what would echo print at step 4?

A An error message

B Nothing (empty output)

C "Hello, Alice!"

D The object address

💡 Hint

Refer to the 'Return value' in variable_tracker and what echo prints in execution_table step 4.

Concept Snapshot

__invoke method lets you call an object like a function.
Define __invoke inside a class to handle calls.
When you do $obj(), PHP runs $obj->__invoke().
You can pass arguments and return values.
Useful for callable objects and cleaner code.

Full Transcript

This example shows how PHP's __invoke method works. First, an object of class Greeter is created. Then, when we call the object like a function with $greet("Alice"), PHP automatically calls the __invoke method inside Greeter with the argument "Alice". The __invoke method returns the string "Hello, Alice!" which is then printed by echo. Variables like $greet hold the object, and the input and return values flow through the __invoke method. If __invoke was missing, calling the object like a function would cause an error. This feature lets objects behave like functions for flexible and readable code.

Practice

1. What does the __invoke method allow an object to do in PHP?

easy

A. Be called like a function using parentheses

B. Automatically convert to a string

C. Serialize itself to JSON

D. Override the constructor behavior

Solution

1. Step 1: Understand the purpose of __invoke

   The __invoke method is a special method in PHP that allows an object to be called as if it were a function.

2. Step 2: Identify what calling an object like a function means

   Calling an object like a function means using parentheses after the object variable, e.g., $obj(). This triggers the __invoke method.

3. Final Answer:

   Be called like a function using parentheses -> Option A

4. Quick Check:

   __invoke enables function-like calls on objects [OK]

Hint: Remember: __invoke makes objects callable like functions [OK]

Common Mistakes:

• Confusing __invoke with __toString
• Thinking __invoke changes constructor behavior
• Assuming __invoke serializes objects

2. Which of the following is the correct syntax to define the __invoke method inside a PHP class?

easy

A. public function __construct() {}

B. public function invoke() {}

C. public function __call() {}

D. public function __invoke() {}

Solution

1. Step 1: Recall the exact method name for callable objects

   The magic method to make an object callable is named __invoke with two underscores at the start.

2. Step 2: Check the syntax for defining magic methods

   Magic methods are defined as public functions with the exact name, so public function __invoke() {} is correct.

3. Final Answer:

   public function __invoke() {} -> Option D

4. Quick Check:

   Correct magic method syntax = public function __invoke() {} [OK]

Hint: Magic methods always start with double underscores __ [OK]

Common Mistakes:

• Using __call instead of __invoke
• Missing double underscores
• Confusing __invoke with __construct

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

$obj = new class { public function __invoke() { return "Hello!"; } };
echo $obj();

medium

A. Hello!

B. Fatal error: Call to undefined method

C. Object cannot be called like a function

D. NULL

Solution

1. Step 1: Understand the anonymous class with __invoke

   The anonymous class defines a __invoke method that returns the string "Hello!".

2. Step 2: Calling the object as a function triggers __invoke

   When $obj() is called, PHP runs the __invoke method and returns "Hello!" which is then echoed.

3. Final Answer:

   Hello! -> Option A

4. Quick Check:

   Calling object with __invoke returns its method output [OK]

Hint: Calling $obj() runs __invoke() if defined [OK]

Common Mistakes:

• Expecting a fatal error for calling object
• Thinking __invoke must be explicitly called
• Assuming output is NULL or empty

4. Identify the error in this PHP code snippet:

class CallableClass {
  public function invoke() {
    return "Called!";
  }
}
$obj = new CallableClass();
echo $obj();

medium

A. Missing parentheses when creating object

B. Method name should be __invoke, not invoke

C. Cannot create object of CallableClass

D. Cannot echo object directly

Solution

1. Step 1: Check method name for callable objects

   The method intended to make the object callable must be named __invoke with double underscores, not just invoke.

2. Step 2: Understand what happens when calling $obj()

   Calling $obj() looks for __invoke. Since it is missing, PHP throws a fatal error.

3. Final Answer:

   Method name should be __invoke, not invoke -> Option B

4. Quick Check:

   __invoke method name is required for callable objects [OK]

Hint: Use double underscores: __invoke, not invoke [OK]

Common Mistakes:

• Using invoke instead of __invoke
• Forgetting to define __invoke method
• Assuming object is callable without __invoke

5. You want to create a PHP class that stores a multiplier value and allows the object to be called with a number to return the product. Which implementation correctly uses __invoke to achieve this?

class Multiplier {
  private int $factor;
  public function __construct(int $factor) {
    $this->factor = $factor;
  }
  // Which __invoke method is correct?
  // A) public function __invoke(int $num): int { return $num / $this->factor; }
  // B) public function __invoke() { return $this->factor; }
  // C) public function __invoke(int $num) { return $num + $this->factor; }
  // D) public function __invoke(int $num): int { return $num * $this->factor; }
}
$obj = new Multiplier(5);
echo $obj(3);

hard

A. public function __invoke(int $num): int { return $num / $this->factor; }

B. public function __invoke() { return $this->factor; }

C. public function __invoke(int $num): int { return $num * $this->factor; }

D. public function __invoke(int $num) { return $num + $this->factor; }

Solution

1. Step 1: Understand the problem requirements

   The class should multiply the input number by the stored factor when the object is called.

2. Step 2: Analyze each __invoke implementation

   public function __invoke(int $num): int { return $num * $this->factor; } multiplies the input by the factor, matching the requirement. public function __invoke() { return $this->factor; } ignores input. public function __invoke(int $num) { return $num + $this->factor; } adds instead of multiplies. public function __invoke(int $num): int { return $num / $this->factor; } divides instead of multiplies.

3. Final Answer:

   public function __invoke(int $num): int { return $num * $this->factor; } -> Option C

4. Quick Check:

   __invoke multiplies input by factor as required [OK]

Hint: Match __invoke logic to problem description exactly [OK]

Common Mistakes:

• Using addition or division instead of multiplication
• Ignoring input parameter in __invoke
• Wrong return type or missing type hints