__invoke for callable objects in PHP - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

Output of __invoke method call

What is the output of this PHP code when the object is called as a function?

PHP

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

A Nothing is printed

B Fatal error: Uncaught Error: Call to undefined method Greeter::__invoke()

C Hello, World!

D Hello, Alice!

💡 Hint

Remember that __invoke allows an object to be called like a function.

The __invoke method is called when an object is used as a function. Here, calling $greet('Alice') triggers __invoke with 'Alice' as argument, returning 'Hello, Alice!'.

🧠 Conceptual

intermediate

Purpose of __invoke in PHP

What is the main purpose of the __invoke magic method in PHP?

A To allow an object to be called as if it were a function

B To automatically convert an object to a string

C To initialize object properties when created

D To overload arithmetic operators for objects

💡 Hint

Think about how you can use an object like a function.

The __invoke method lets you call an object like a function, executing the code inside __invoke when you do so.

❓ Predict Output

advanced

Output with multiple __invoke parameters

What will this PHP code output?

PHP

<?php
class Calculator {
    public function __invoke(int $a, int $b): int {
        return $a * $b;
    }
}
$calc = new Calculator();
echo $calc(3, 4);

A 12

B 7

C Fatal error: Too few arguments to function Calculator::__invoke()

D 0

💡 Hint

Check how the __invoke method uses the two parameters.

The __invoke method multiplies the two arguments 3 and 4, returning 12.

🔧 Debug

advanced

Identify the error when calling an object without __invoke

What error will this PHP code produce?

PHP

<?php
class Printer {
    public function printMessage() {
        echo "Printing message";
    }
}
$p = new Printer();
echo $p();

A Nothing is printed

B Fatal error: Uncaught Error: Call to undefined method Printer::__invoke()

C Printing message

D Parse error: syntax error, unexpected '()'

💡 Hint

Check if the class has __invoke defined.

Since Printer does not have __invoke, calling $p() causes a fatal error about undefined method __invoke.

🚀 Application

expert

Using __invoke for a callable class in a callback

Which option correctly uses a class with __invoke as a callback for array_map to double each number?

PHP

<?php
class Doubler {
    public function __invoke(int $n): int {
        return $n * 2;
    }
}
$numbers = [1, 2, 3, 4];
$result = array_map( /* fill here */, $numbers);
print_r($result);

A Doubler::__invoke

B "Doubler"

C new Doubler()

D [Doubler, '__invoke']

💡 Hint

array_map expects a callable. An object with __invoke is callable.

Passing an instance of Doubler works because __invoke makes the object callable. The other options are invalid or cause errors.

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