The use keyword in PHP allows a closure to access variables from its parent scope. By default, closures cannot access external variables, but use imports them as read-only copies at the time the closure is defined, for example: $sayHi = function() use ($greeting) { echo $greeting; };. Multiple variables can be imported by separating them with commas, such as use ($var1, $var2). To allow modifications to the original variable, it must be passed by reference using &, like use (&$count). However, overusing use can lead to complex code or memory issues, so it’s best used sparingly and with clear intent.

When you're working with closures in PHP, you might have come across the use keyword and wondered what it's for. The short answer is: it allows a closure to access variables from its parent scope. That’s important because by default, functions (and closures) don’t automatically inherit variables from where they’re defined.

How Variable Scope Works in Closures

In PHP, closures have their own scope. This means that even if you define a closure inside another function or block of code, it doesn't automatically "see" the variables declared outside of it.

For example:

$greeting = 'Hello';

$sayHi = function() {
    echo $greeting; // This will cause an error
};

Trying to run this would throw an error like “Undefined variable: greeting” — because $greeting isn’t accessible inside the closure unless explicitly passed in via the use keyword.

This behavior helps prevent side effects and keeps things more predictable, but sometimes you do want to bring certain values into the closure. That’s where use comes in handy.

Using use to Import Variables

The use keyword lets you import variables from the parent scope into your closure. Here's how you use it:

$greeting = 'Hello';

$sayHi = function() use ($greeting) {
    echo $greeting;
};

$sayHi(); // Outputs: Hello

A few key points about using use:

• It makes variables available read-only inside the closure by default.
• You can pass multiple variables by separating them with commas:

  use ($var1, $var2, $var3)

• These variables are bound at the time the closure is defined, not when it’s called. So if the original variable changes later, the closure still sees the original value.

This is especially useful when writing callbacks or event handlers where you need to capture some context without relying on global variables.

Modifying Variables by Reference

If you want the closure to be able to modify the original variable, you need to pass it by reference using the & symbol:

$count = 0;

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

$increment();
echo $count; // Outputs: 1

Without the ampersand, $count would remain unchanged outside the closure. This behavior is helpful when you're building logic that needs to update state within a closure, such as counters, accumulators, or data transformers.

Just be careful — changing variables by reference inside closures can make code harder to follow if overused, so keep it limited to cases where it makes sense.

When Not to Use use

While use is powerful, it’s not always the best choice:

• If your closure starts needing too many external variables, it may be a sign that it’s doing too much or should be part of a class instead.
• Avoid using use for large data structures unless necessary — since values are captured at definition time, you might end up with stale or memory-heavy data.

In those cases, consider refactoring or passing values directly as arguments to the closure when calling it.

So that’s the main idea behind use in PHP closures: it gives you control over what outer variables a closure can access, and whether it works with copies or references. It’s a small feature that makes closures way more flexible and practical.

The above is the detailed content of What is the purpose of the use keyword with PHP closures?. For more information, please follow other related articles on the PHP Chinese website!