Why closures matter in PHP - Challenge Your Understanding

Challenge - 5 Problems

❓ Predict Output

intermediate

Output of a closure capturing a variable

What is the output of this PHP code that uses a closure capturing a variable by reference?

PHP

<?php
$counter = 0;
$increment = function() use (&$counter) {
    $counter++;
    return $counter;
};

echo $increment();
echo $increment();
?>

A 11

B 01

C 00

D 12

💡 Hint

Closures can capture variables by reference, so changes inside affect the original variable.

The closure captures $counter by reference, so each call increments the same variable. The first call returns 1, the second returns 2, so output is '12'.

🧠 Conceptual

intermediate

Why use closures in PHP?

Which of the following best explains why closures matter in PHP?

A They prevent any variable from being modified inside the function.

B They allow functions to access variables from the parent scope even after that scope has ended.

C They automatically convert all variables to global scope.

D They replace the need for classes and objects entirely.

💡 Hint

Think about how closures keep variables alive beyond their normal lifetime.

Closures capture variables from their surrounding scope, allowing the function to use those variables even after the outer function has finished.

🔧 Debug

advanced

Identify the error with closure variable capture

What error will this PHP code produce and why?

PHP

<?php
$funcs = [];
for ($i = 0; $i < 3; $i++) {
    $funcs[] = function() {
        return $i;
    };
}
foreach ($funcs as $f) {
    echo $f();
}
?>

A Outputs '333' because $i is not captured correctly

B Syntax error due to missing use keyword

C Outputs '012' as expected

D Notice: Undefined variable $i

💡 Hint

Variables inside closures must be explicitly captured with use().

The closure does not capture $i, so it uses the variable from the outer scope at the time of execution, which is 3 after the loop ends. So it outputs '333'.

📝 Syntax

advanced

Correct syntax for closure with parameters

Which option shows the correct syntax for a PHP closure that takes one parameter and returns its square?

A $square = function($x) { return $x * $x; };

B $square = function $x { return $x * $x; };

C $square = function($x) => $x * $x;

D $square = function { return $x * $x; }($x);

💡 Hint

Closures use the function keyword followed by parentheses for parameters.

Option A correctly defines a closure with one parameter $x and returns its square. Option A misses parentheses, C uses invalid arrow syntax, D is invalid syntax.

🚀 Application

expert

Using closures to create a counter generator

Which option correctly creates a closure in PHP that returns a function acting as a counter starting from 0 and increasing by 1 each call?

A

<?php
function counter() {
    $count = 0;
    return function() {
        return ++$count;
    };
}
$c = counter();
echo $c();
echo $c();
?>

B

<?php
function counter() {
    static $count = 0;
    return function() {
        return ++$count;
    };
}
$c = counter();
echo $c();
echo $c();
?>

C

<?php
function counter() {
    $count = 0;
    return function() use (&$count) {
        return ++$count;
    };
}
$c = counter();
echo $c();
echo $c();
?>

D

<?php
function counter() {
    $count = 0;
    return function() use ($count) {
        return ++$count;
    };
}
$c = counter();
echo $c();
echo $c();
?>

💡 Hint

To keep the count variable updated across calls, capture it by reference.

Option C captures $count by reference, so each call increments the same variable. Option C fails because static $count is not in closure scope. Option C does not capture $count, so it resets each call. Option C captures by value, so increments do not persist.