__invoke for callable objects in PHP - Interactive Code Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to make the object callable using __invoke.

PHP

<?php
class CallableClass {
    public function [1]() {
        echo "Called!";
    }
}
$obj = new CallableClass();
$obj();
?>

Drag options to blanks, or click blank then click option'

A__invoke

B__toString

C__construct

D__call

Attempts:

3 left

💡 Hint

Common Mistakes

Using __call instead of __invoke

Forgetting to define __invoke method

Trying to call the object without __invoke defined

The __invoke method allows an object to be called like a function.

2fill in blank

medium

Complete the code to return a string when the object is called.

PHP

<?php
class Greeter {
    public function [1]() {
        return "Hello!";
    }
}
$greet = new Greeter();
echo $greet();
?>

Drag options to blanks, or click blank then click option'

A__toString

B__destruct

C__callStatic

D__invoke

Attempts:

3 left

💡 Hint

Common Mistakes

Using __toString which is for string conversion

Trying to call the object without __invoke defined

The __invoke method can return values when the object is called like a function.

3fill in blank

hard

Fix the error in the code to make the object callable.

PHP

<?php
class Counter {
    private $count = 0;
    public function [1]() {
        $this->count++;
        return $this->count;
    }
}
$c = new Counter();
echo $c();
?>

Drag options to blanks, or click blank then click option'

A__get

B__call

C__invoke

D__set

Attempts:

3 left

💡 Hint

Common Mistakes

Using __call which is for undefined method calls

Not defining __invoke method

The __invoke method must be defined to allow the object to be called like a function.

4fill in blank

hard

Fill both blanks to create a callable object that multiplies a number by a factor.

PHP

<?php
class Multiplier {
    private $factor;
    public function __construct($factor) {
        $this->factor = [1];
    }
    public function [2]($number) {
        return $number * $this->factor;
    }
}
$mul = new Multiplier(5);
echo $mul(3);
?>

Drag options to blanks, or click blank then click option'

A$factor

B__call

C__invoke

D$this->factor

Attempts:

3 left

💡 Hint

Common Mistakes

Using __call instead of __invoke

Assigning wrong variable in constructor

Use $factor to assign the constructor argument, and __invoke to make the object callable.

5fill in blank

hard

Fill all three blanks to create a callable object that stores and returns a message.

PHP

<?php
class Messenger {
    private $message;
    public function __construct([1]) {
        $this->message = [2];
    }
    public function [3]() {
        return $this->message;
    }
}
$msg = new Messenger("Hi there!");
echo $msg();
?>

Drag options to blanks, or click blank then click option'

A$msg

B$message

C__invoke

D$this->message

Attempts:

3 left

💡 Hint

Common Mistakes

Using wrong variable names in constructor

Not defining __invoke method

The constructor takes $message as argument and assigns it to $this->message. The __invoke method returns the message when the object is called.

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