在PHP中，若要在匿名函數(shù)內(nèi)使用外部變量，必須通過use關鍵字顯式導入；1. use用於將外部變量引入閉包的詞法作用域；2. 默認按值傳遞變量，需用&$var語法按引用傳遞；3. 可導入多個變量，用逗號分隔；4. 變量的值在閉包定義時捕獲，而非執(zhí)行時；5. 循環(huán)中每次迭代會創(chuàng)建獨立的閉包副本，確保正確捕獲變量值；因此，use是實現(xiàn)閉包與外部環(huán)境交互的關鍵機制，使代碼更靈活且可控。

In PHP, anonymous functions (also known as closures) 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 closures. 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 refers 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);

// Result: [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, closures 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 closures 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.

以上是掌握詞彙範圍：'使用”關鍵字和PHP匿名函數(shù)的詳細內(nèi)容。更多資訊請關注PHP中文網(wǎng)其他相關文章！