In PHP, if you want to use external variables in anonymous functions, you must explicitly import them through the use keyword; 1. Use is used to introduce external variables into the lexical scope of the closure; 2. Pass variables by default by value, and pass them by reference with &$var syntax; 3. Multiple variables can be imported, separated by commas; 4. The value of the variable is captured when the closure is defined, not when it is executed; 5. Each iteration in the loop creates an independent closure copy to ensure that the variable value is captured correctly; therefore, use is a key mechanism to implement the interaction between the closure and the external environment, making the code more flexible and controllable.

In PHP, anonymous functions (also known as closings) are powerful tools for writing concise and flexible code. But when you're working with variables from the outer scope inside an anonymous function, you need to understand lexical scoping —and that's where the use keyword comes in.

Unlike some other languages, PHP doesn't automatically inherit variables from the parent scope into closings. If you want to access a variable from outside an anonymous function, you must explicitly import it using use .

What Is Lexical Scoping in PHP?

Lexical scoping referers to how a language determines which variables are accessible based on where they're defined in the source code. In PHP, anonymous functions do not have access to the parent scope's variables by default.

For example, this will not work:

 $factor = 2;
$numbers = [1, 2, 3, 4];

// This will cause an error – $factor is not in scope
$doubled = array_map(function($n) {
    return $n * $factor;
}, $numbers);

PHP throws a notice because $factor is undefined inside the closure.

To fix this, you must use the use keyword:

 $factor = 2;
$numbers = [1, 2, 3, 4];

$doubled = array_map(function($n) use ($factor) {
    return $n * $factor;
}, $numbers);

// Results: [2, 4, 6, 8]

Now, $factor is imported into the closure's scope and can be used safely.

Using use with Multiple Variables

You can import more than one variable by separating them with commas:

 $tax = 1.1;
$shipping = 5;

$total = function($price) use ($tax, $shipping) {
    return $price * $tax $shipping;
};

echo $total(100); // 115

This keeps your closure self-contained while still leveraging external configuration or context.

Important Behavior: Variables Are Passed by Value by Default

One of the most misunderstood aspects of use is that variables are copied by value , not by reference—unless you explicitly say otherwise.

 $count = 0;
$increment = function() use ($count) {
    $count ;
};

$increment();
echo $count; // Still 0

The closure gets its own copy of $count , so modifying it inside doesn't affect the original.

To change this, use the & reference operator:

 $count = 0;
$increment = function() use (&$count) {
    $count ;
};

$increment();
echo $count; // Now it's 1

Now the closure works directly with the original variable.

This is useful when building accumulators, counters, or callbacks that need to modify outer state.

Practical Use Cases for use

1. Configurable Callbacks

    function makeMultiplier($factor) {
       return function($n) use ($factor) {
           return $n * $factor;
       };
   }
   
   $triple = makeMultiplier(3);
   echo $triple(5); // 15

2. Event Handlers with Context

    $logger = new Logger();
   $onSave = function($data) use ($logger) {
       $logger->info("Saved: " . json_encode($data));
   };

3. Dynamic Filtering

    $minAge = 18;
   $adults = array_filter($users, function($user) use ($minAge) {
       return $user['age'] >= $minAge;
   });

Common Pitfalls and Tips

• Don't overuse references : While use (&$var) allows mutation, it can make code harder to debug. Prefer returning values when possible.
• Avoid using use with $this in object context : Inside a class method, closings can access $this automatically as of PHP 5.4. No need to use ($this) —and doing so may cause confusion.
• Be cautious with late binding : The value used in use is captured at the time the closure is defined, not when it's executed.

Example of timing matters:

 $closures = [];
for ($i = 0; $i < 3; $i ) {
    $closures[] = function() use ($i) {
        echo $i;
    };
}
// All will print "3" because $i was captured by value after the loop
foreach ($closures as $closure) {
    $closure();
}

To fix this, you'd need to bind $i per iteration:

 for ($i = 0; $i < 3; $i ) {
    $closures[] = function() use ($i) {
        echo $i;
    };
}

But since $i is copied each time, this actually works as expected now—each closure gets its own copy of $i at that iteration.

Wait—actually, in this corrected version, yes, each closure captures the current value of $i because it's re-evaluated in each loop body. So output would be 0, 1, 2.

But if you were modifying a single variable across iterations without proper capture, you could run into issues.

Summary

• Use use to import variables from the parent scope into anonymous functions.
• By default, variables are passed by value—use &$var in use to pass by reference.
• Closures are great for callbacks, filters, and factories when combined with use .
• Be mindful of timing and variable capture, especially in loops.

Mastering lexical scoping with use gives you fine-grained control over how closings interact with their environment—making your PHP code more modular and expressive.

Basically, if you need a variable inside a closure that's defined outside, just use it. Simple, but powerful.

The above is the detailed content of Mastering Lexical Scoping: The `use` Keyword and PHP Anonymous Functions. For more information, please follow other related articles on the PHP Chinese website!