PHP closures with the use keyword enable lexical scoping by capturing variables from the parent scope. 1. Closures are anonymous functions that can access external variables via use. 2. By default, variables in use are passed by value; to modify them externally, use &$variable for reference. 3. Common use cases include callback functions with context, deferred execution like event handlers, and dependency injection without classes. 4. Avoid common pitfalls such as unnecessary variable capture and incorrect loop variable binding—though PHP correctly binds loop variables in use by value per iteration, unlike JavaScript. 5. Best practices include using value semantics unless mutation is needed, choosing clear variable names, and being cautious with references. When used properly, closures enhance code modularity and readability by encapsulating logic with controlled access to external state.

PHP closures — especially when combined with the use keyword — are powerful tools for creating flexible, encapsulated code. While they might seem tricky at first, understanding how they work with lexical scoping unlocks cleaner, more maintainable code patterns.

Let’s break down how closures work in PHP, why the use keyword matters, and how to use them effectively.

What Is a Closure in PHP?

A closure is an anonymous function that can capture variables from the surrounding (enclosing) scope. Unlike regular functions, closures can "remember" variables even after the parent scope has finished executing.

$greeting = "Hello";
$sayHello = function($name) use ($greeting) {
    echo "$greeting, $name!\n";
};

$sayHello("Alice"); // Output: Hello, Alice!

Here, the closure uses the $greeting variable from the outer scope via the use keyword.

How use Enables Lexical Scoping

The use keyword allows a closure to import variables from the parent scope into its own scope. This is called lexical scoping — the closure "closes over" the variables it references.

Key Rules of use:

• Variables are copied by value by default.
• To modify a variable inside the closure and reflect changes outside, you must pass it by reference using &.
• You cannot use $this in a closure unless it's inside a class context (and even then, it's automatically available).

Example: Value vs Reference

$count = 0;

// By value (default)
$incrementByValue = function() use ($count) {
    $count  ;
};

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

// By reference
$incrementByReference = function() use (&$count) {
    $count  ;
};

$incrementByReference();
echo $count; // Now 1

?? If you need the closure to affect external state, always use &$variable.

Practical Use Cases for Closures and use

Closures shine in scenarios where you want to encapsulate logic with configuration or delay execution.

1. Callback Functions with Context

When passing callbacks, you often need to include context that isn’t part of the function arguments.

function filterByThreshold($items, $min) {
    return array_filter($items, function($item) use ($min) {
        return $item >= $min;
    });
}

$numbers = [5, 10, 15, 20];
$filtered = filterByThreshold($numbers, 12);
// Result: [15, 20]

Here, $min is passed into the closure via use, making the filter logic clean and reusable.

2. Event Handlers or Deferred Logic

Closures can capture environment state for later execution.

$logger = function($message) {
    echo "[" . date('Y-m-d') . "] $message\n";
};

$onUserLogin = function($username) use ($logger) {
    $logger("User '$username' logged in.");
};

$onUserLogin("Bob");
// Output: [2025-04-05] User 'Bob' logged in.

Even if the original $logger changes later, the closure keeps its own copy (or reference).

3. Dependency Injection Without Classes

Sometimes, you don’t need a full class — just a self-contained unit of logic with dependencies.

function createMultiplier($factor) {
    return function($number) use ($factor) {
        return $number * $factor;
    };
}

$doubler = createMultiplier(2);
$tripler = createMultiplier(3);

echo $doubler(5); // 10
echo $tripler(5); // 15

This pattern is lightweight and readable — perfect for utility functions.

Common Pitfalls and Best Practices

• ? Don’t use unnecessary variables — it clutters the closure and can cause memory leaks.
• ? Prefer value semantics unless you explicitly need to modify the outer variable.
• ? Use meaningful variable names in closures — they’re not always obvious when debugging.
• ? Be careful with loops — a common mistake is capturing loop variables incorrectly.

Gotcha: Loop Variable Binding

$functions = [];
for ($i = 0; $i < 3; $i  ) {
    $functions[] = function() use ($i) {
        echo $i . "\n";
    };
}

foreach ($functions as $f) {
    $f();
}
// Output: 3, 3, 3 — not 0, 1, 2!

Why? Because $i is used by value after the loop finishes (where $i === 3). To fix it:

for ($i = 0; $i < 3; $i  ) {
    $functions[] = function() use ($i) {
        echo $i . "\n";
    };
}

Wait — same code? Actually, in PHP, this works correctly because each iteration creates a new scope for use. So this does output 0, 1, 2. (Unlike JavaScript, PHP handles this better.)

But if you were modifying $i by reference, or reusing it, issues could still arise.

Summary

• Closures are anonymous functions that can capture variables via use.
• use imports variables by value unless prefixed with & for reference.
• They’re ideal for callbacks, configuration, and encapsulating logic with context.
• Be mindful of scope, mutability, and loop behavior.

Used wisely, PHP closures make code more expressive and modular — no classes required.

Basically, just remember: use gives your closure access to the outside world, but only what you explicitly allow.

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