__invoke for callable objects in PHP - Cheat Sheet & Quick Revision

Recall & Review

beginner

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

The __invoke method allows an object to be called as if it were a function. When you use parentheses after an object, PHP looks for this method to execute.

beginner

How do you make an object callable in PHP?

You make an object callable by defining the __invoke method inside its class. This method runs when you use parentheses on the object.

beginner

Example: What will this code output?<br><pre>class Greeter {
  public function __invoke($name) {
    return "Hello, $name!";
  }
}
$greet = new Greeter();
echo $greet("Alice");</pre>

The output will be: Hello, Alice!
This happens because $greet("Alice") calls the __invoke method with "Alice" as argument.

intermediate

Can __invoke accept multiple arguments?

Yes, __invoke can accept any number of arguments just like a normal function. You define parameters in the method signature to receive them.

intermediate

Why use __invoke instead of a regular method?

Using __invoke makes the object behave like a function, which can make code cleaner and more flexible, especially when passing objects as callbacks.

What happens when you call an object with parentheses in PHP and it has a __invoke method?

A The object is converted to a string.

B PHP throws an error.

C The <code>__invoke</code> method is executed.

D Nothing happens.

Calling an object with parentheses triggers the __invoke method if it exists.

Which of these is true about the __invoke method?

A It can only accept one argument.

B It makes the object callable like a function.

C It automatically runs when the object is created.

D It converts the object to an array.

__invoke allows the object to be called like a function with parentheses.

How do you define the __invoke method in a class?

A public function __invoke() {}

B public function invoke() {}

C public function __call() {}

D public function __construct() {}

The magic method is named exactly __invoke with two underscores.

What will happen if you call an object without a __invoke method using parentheses?

A It will call the <code>__call</code> method.

B It will call the constructor.

C It will return null.

D PHP will throw a fatal error.

Calling an object like a function without __invoke causes a fatal error.

Which scenario is a good use case for __invoke?

A When you want to make an object behave like a callback function.

B When you want to overload operators.

C When you want to convert an object to a string.

D When you want to serialize an object.

__invoke is useful to make objects callable, like callbacks.

Explain how the __invoke method works in PHP and give a simple example.

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

Describe a practical situation where using __invoke would be helpful in your PHP code.

Consider callbacks or functional programming style.

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