PHP Closures and the use Keyword Explained

A PHP closure is an anonymous function that can be stored in a variable, passed to another function, and executed later. The use clause explicitly gives the closure access to variables from the surrounding scope. In this example, $tax is copied into the closure and $total is imported by reference so the callback can update it.

A closure is an anonymous function together with the variables it captures from the scope where it was created.

Anonymous functions are useful as callbacks: small pieces of behavior passed to functions such as array_walk, array_filter, and usort.

PHP functions have their own local scope. Therefore, a variable created outside an anonymous function is not automatically available inside it:

$tax = 0.20;

$calculate = function ($price) {
    // $tax is not available here.
    return $price * (1 + $tax);
};

The use clause solves this by importing selected variables from the surrounding scope:

$calculate = function ($price) use ($tax) {
    return $price * (1 + $tax);
};

In the original code:

Think of an anonymous function as a worker sent to process each item in a list.

The worker has its own workspace, so it cannot automatically see everything on your desk outside the workspace. The use clause is the set of items you put into the worker's bag before sending it out.

• use ($tax) puts a photocopy of the tax rate in the bag.
• use (&$total) gives the worker access to the same shared tally sheet. Each time it processes an item, it can update the original total.

The & means “share this variable,” rather than “make a copy of its current value.”

The general closure syntax is:

$function = function (parameters) use (outerVariables) {
    // function body
};

A closure can then be called like a normal function:

$greeting = 'Hello';

$welcome = function ($name) use ($greeting) {
    return $greeting . ', ' . $name . '!';
};

echo $welcome('Ava'); // Hello, Ava!

$greeting is defined outside the closure, so it must be listed in use.

Capture by value

Without &, PHP captures the variable's value at the time the closure is created:

$discount = ;

 = {
      * ( - );
};

 = ;

 (); 

Consider this smaller example:

$tax = 0.20;
$total = 0.00;

$items = [
    'book' => 2,
    'pen' => 3,
];

$prices = [
    'book' => 10.00,
    'pen' => 2.00,
];

array_walk($items, function ($quantity, $product) use ($tax, &$total, $prices) {
    $total += $prices[$product] * $quantity * (1 + $tax);
});

echo $total; // 31.2

Execution proceeds as follows:

1. $tax is 0.20, and $total starts at 0.00.
2. PHP creates the closure. It captures $tax and $prices by value, and by reference.

Closures with use are common when a callback needs context from its surrounding code.

• Filtering search results: Capture a minimum price or selected category.
• Sorting: Capture a configuration setting that controls sort behavior.
• Validation: Capture allowed values, a current user, or a validation rule.
• Data transformation: Capture exchange rates, tax rates, or formatting options while mapping records.
• Event handlers: Capture an ID or service needed when an event occurs later.
• Retries and error handling: Capture an operation's context for a callback that runs after a failure.

For example, filter products using a user-selected maximum price:

$maxPrice = 50;

$affordableProducts = array_filter(
    $products,
    function (array $product) use ($maxPrice) {
        return $product['price'] <= $maxPrice;
    }
);

In production PHP code, closures are often short, focused callbacks. Capturing configuration by value is especially common:

$allowedRoles = ['admin', 'editor'];

$canAccess = function (string $role) use ($allowedRoles): bool {
    return in_array($role, $allowedRoles, true);
};

A common pattern is a guard clause inside a callback, which skips invalid records early:

$activeEmails = array_filter($users, function (array $user): bool {
    if (!isset($user['email'])) {
        return false;
    }

    return $user['active'] === true;
});

When transforming data, prefer returning a value from array_map() rather than mutating an outside variable by reference:

Forgetting use

Outer local variables are not automatically in a closure's scope.

$rate = 0.20;

$withTax = function ($price) {
    return $price * (1 + $rate); // Undefined variable $rate
};

Fix it by importing the variable:

$withTax = function ($price) use ($rate) {
    return $price * (1 + $rate);
};

Expecting a by-value capture to change later

$rate = 0.10;
$calculate = function ($price) use ($rate) {
    return  * ( + );
};

 = ;
 (); 

// Create an anonymous function
$callback = function ($value) {
    return $value * 2;
};

// Capture an outer variable by value
$callback = function ($value) use ($multiplier) {
    return $value * $multiplier;
};

// Capture an outer variable by reference
$callback = function ($value) use (&$total) {
    $total += $value;
};

• A closure is an anonymous function that captures surrounding variables.
• use imports local variables from the enclosing scope.
• use ($name) captures the value when the closure is created.
• use (&$name) shares the original variable and permits outer-state changes.
• Variables must be defined before creating the closure.
• Closure parameters, such as function ($value), are separate from captured variables in .

What is a closure in PHP?

A closure is an anonymous function that can capture variables from the scope where it is created. It can be stored in a variable, passed as a callback, and called later.

Why does PHP use the use keyword with closures?

PHP closures have their own scope. use explicitly imports selected variables from the surrounding local scope into the closure.

What is the difference between use ($variable) and use (&$variable)?

Without &, the closure receives a captured value. With &, it shares the original variable by reference, so changes made inside the closure affect the outside variable.

Is use the same as importing a namespace in PHP?

No. Namespace imports use use at file or namespace scope, such as use App\Service\Mailer;. Closure use appears after a function's parameter list and captures local variables. They are different language features that use the same keyword.

Can a closure access global variables without use?

Not automatically. A closure can use the global keyword, but explicitly capturing required variables with is generally clearer and easier to test.

• Anonymous functions — Closures are anonymous functions that may capture surrounding variables.
• Variable scope — Explains why a variable outside a function is not automatically available inside it.
• References in PHP — Needed to understand &$total and shared mutable variables.
• Callback functions — Closures are frequently passed as callbacks to built-in functions.
• array_walk — The function used in the example to run a callback for every array entry.
• array_map — Transforms each array item by returning a new value.
• array_filter — Keeps array items that satisfy a callback condition.
• array_reduce — Combines items into one value, such as a total, without requiring a referenced accumulator.
• foreach loops — A clear alternative for many iteration and accumulation tasks.