Closures and variable binding with use in PHP - Time & Space Complexity

Time Complexity: Closures and variable binding with use

O(n)

Understanding Time Complexity

We want to understand how the time needed to run a closure with variable binding changes as the input grows.

How does the number of operations grow when using closures with variables passed by use?

Scenario Under Consideration

Analyze the time complexity of the following code snippet.

$numbers = [1, 2, 3, 4, 5];
$sum = 0;

$addToSum = function($num) use (&$sum) {
    $sum += $num;
};

foreach ($numbers as $number) {
    $addToSum($number);
}

echo $sum;
    

This code sums all numbers in an array using a closure that accesses a variable by reference.

Identify Repeating Operations

Identify the loops, recursion, array traversals that repeat.

• Primary operation: The foreach loop that calls the closure for each number.
• How many times: Once for each element in the $numbers array.

How Execution Grows With Input

Each number in the array causes one call to the closure, which adds it to the sum.

Input Size (n)	Approx. Operations
10	10 additions
100	100 additions
1000	1000 additions

Pattern observation: The number of operations grows directly with the number of elements.

Final Time Complexity

Time Complexity: O(n)

This means the time to run grows in a straight line with the number of items in the array.

Common Mistake

[X] Wrong: "Using use inside closures makes the code slower or adds hidden loops."

[OK] Correct: The use keyword just binds variables; it does not add extra loops or slow down the code beyond the existing operations.

Interview Connect

Understanding how closures work with variable binding helps you write clear and efficient code, a skill valued in many coding challenges and real projects.

Self-Check

"What if the closure was called inside a nested loop over the array? How would the time complexity change?"

Practice

1. What does the use keyword do in a PHP closure?

easy

A. It defines a new variable inside the closure.

B. It creates a global variable accessible everywhere.

C. It imports variables from the parent scope into the closure.

D. It calls the closure immediately.

Solution

1. Step 1: Understand closure scope

   A closure is a function inside another function that can access variables from the outside only if explicitly told.

2. Step 2: Role of use

   The use keyword brings variables from the parent scope into the closure's scope so the closure can use them.

3. Final Answer:

   It imports variables from the parent scope into the closure. -> Option C

4. Quick Check:

   use = import variables [OK]

Hint: Remember: use imports outside variables into closure [OK]

Common Mistakes:

• Thinking use creates new variables inside closure
• Confusing use with global keyword
• Assuming use calls the closure

2. Which of the following is the correct syntax to pass a variable $x by reference into a closure using use?

easy

A. function() use ($x) { }

B. function() use (&x) { }

C. function() use ($&x) { }

D. function() use (&$x) { }

Solution

1. Step 1: Understand passing by reference

   To allow a closure to modify an outside variable, it must be passed by reference using &.

2. Step 2: Correct syntax with use

   The correct syntax is use (&$x) where & is before the variable name with the dollar sign.

3. Final Answer:

   function() use (&$x) { } -> Option D

4. Quick Check:

   Reference = & before $variable [OK]

Hint: Use & before $var inside use to pass by reference [OK]

Common Mistakes:

• Placing & after $ or before variable name without $
• Omitting & when intending to modify variable
• Using invalid syntax like $&x

3. What will be the output of this PHP code?

$count = 0;
$func = function() use (&$count) { $count++; echo $count; };
$func();
$func();
echo $count;

medium

A. 111

B. 122

C. 120

D. Error

Solution

1. Step 1: Analyze closure calls and reference

   The closure uses &$count by reference, so changes inside affect the outside variable.

2. Step 2: Trace each call and output

   First call: increments count to 1 and echoes '1'. Second call: increments count to 2 and echoes '2'. Finally, outside echo prints 2.

3. Final Answer:

   122 -> Option B

4. Quick Check:

   Reference increments count = 122 [OK]

Hint: Reference in use means closure changes outside variable [OK]

Common Mistakes:

• Assuming closure copies variable, so count stays 0
• Expecting output '111' by mistake
• Thinking code causes error

4. Identify the error in this PHP code snippet:

$x = 5;
$func = function() use ($x) { $x++; echo $x; };
$func();
echo $x;

medium

A. Output will be '65' because $x inside closure is a copy.

B. Runtime error because $x is undefined inside closure.

C. Syntax error because $x is not passed by reference.

D. Output will be '55' because closure does not run.

Solution

1. Step 1: Understand variable binding without reference

   Using use ($x) passes $x by value, so closure gets a copy.

2. Step 2: Trace output of closure and outside variable

   Closure increments its copy to 6 and echoes it. Outside $x remains 5, so echo prints 5.

3. Final Answer:

   Output will be '65' because $x inside closure is a copy. -> Option A

4. Quick Check:

   Value copy in use means outside unchanged [OK]

Hint: Without &, closure changes copy, not original variable [OK]

Common Mistakes:

• Expecting outside $x to change without &
• Thinking code causes syntax or runtime error
• Confusing output order

5. Given this code, what will be the output?

$values = [1, 2, 3];
$sum = 0;
$funcs = [];
foreach ($values as $v) {
    $funcs[] = function() use (&$sum, $v) { $sum += $v; };
}
foreach ($funcs as $f) { $f(); }
echo $sum;

Why does this output occur?

hard

A. 6, because each closure adds its own $v to $sum by value and $sum is by reference.

B. 3, because $v is shared and only last value is added multiple times.

C. 0, because closures do not run correctly.

D. Error, because $v cannot be used without reference.

Solution

1. Step 1: Understand variable binding in loop closures

   Each closure captures $v by value (copy) and $sum by reference.

2. Step 2: Trace closure execution

   Each closure adds its own $v (1, 2, 3) to the shared $sum. After all run, $sum = 6.

3. Final Answer:

   6, because each closure adds its own $v to $sum by value and $sum is by reference. -> Option A

4. Quick Check:

   Value copy for $v + reference $sum = 6 [OK]

Hint: Use value for loop var, reference for accumulator [OK]

Common Mistakes:

• Assuming $v is shared reference causing wrong sum
• Expecting error due to $v usage
• Thinking closures do not run