__invoke for callable objects in PHP - Mini Project: Build & Apply

__invoke for callable objects in PHP

📖 Scenario: Imagine you want to create a simple calculator object that can be called like a function to add two numbers.

🎯 Goal: You will build a PHP class with the __invoke magic method so that an object of this class can be used as a callable to add two numbers.

📋 What You'll Learn

Create a class named Adder

Add a __invoke method to the Adder class that takes two parameters

The __invoke method should return the sum of the two parameters

Create an object of the Adder class named adder

Call the adder object with two numbers and print the result

💡 Why This Matters

🌍 Real World

Using <code>__invoke</code> lets you create objects that act like functions, which can make your code cleaner and more flexible.

💼 Career

Understanding magic methods like <code>__invoke</code> is useful for PHP developers working on frameworks or libraries that use callable objects.

1

Create the Adder class

Create a class called Adder with no methods or properties.

PHP

<?php

// Create the Adder class
// Your code here

Hint

Use the class keyword followed by Adder and curly braces.

2

Add the __invoke method

Inside the Adder class, add a public method named __invoke that takes two parameters named $a and $b.

PHP

<?php

class Adder {
    // Add the __invoke method with parameters $a and $b
    // Your code here
}

Hint

Define a public function named __invoke with parameters $a and $b.

3

Return the sum inside __invoke

Inside the __invoke method, return the sum of $a and $b using the return statement.

PHP

<?php

class Adder {
    public function __invoke($a, $b) {
        // Return the sum of $a and $b
        // Your code here
    }
}

Hint

Use return $a + $b; to send back the sum.

4

Create object and call it like a function

Create an object named adder from the Adder class. Then call adder with the numbers 5 and 7 and print the result using echo.

PHP

<?php

class Adder {
    public function __invoke($a, $b) {
        return $a + $b;
    }
}

// Create the adder object
// Call adder with 5 and 7 and print the result
// Your code here

Hint

Create the object with new Adder(), then call it like a function with (5, 7), and print with echo.

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