Using PHP Closure Functions to Encapsulate Reusable Code Blocks

When writing PHP code we often follow the "don't repeat yourself" (DRY) principle, and encapsulating repeated logic with closures is an effective way to achieve it. This article introduces closure functions and shows how to use them to create reusable code blocks.

What is a closure function? A closure is an inner function that captures variables from its outer scope and can still access them after the outer function has finished. In PHP, anonymous functions serve as closures.

$factor = 10;

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

echo $calculate(5); // outputs 50

In this example, the closure $calculate captures the external variable $factor via the use keyword, allowing the multiplication to be performed later.

How to use closures to encapsulate reusable code? By wrapping frequently needed logic in a closure, you can pass different behaviours to a generic function.

function processUserData($data, $callback)
{
    // perform some data processing
    return $callback($data);
}

$uppercase = function ($data) {
    return strtoupper($data);
};

$lowercase = function ($data) {
    return strtolower($data);
};

$data = "Hello World!";

echo processUserData($data, $uppercase); // outputs HELLO WORLD!
echo processUserData($data, $lowercase); // outputs hello world!

Here processUserData receives a closure that defines the specific processing logic, allowing the same function to be reused for different transformations such as converting text to upper‑case or lower‑case.

Combining closures with object‑oriented programming further increases flexibility. The following example shows a class that accepts a closure to process a property.

class User
{
    private $name;

    public function __construct($name)
    {
        $this->name = $name;
    }

    public function processName($callback)
    {
        return $callback($this->name);
    }
}

$uppercase = function ($data) {
    return strtoupper($data);
};

$user = new User("Alice");
echo $user->processName($uppercase); // outputs ALICE

By passing different closures to processName , the class can perform various operations on the stored name without modifying its internal code.

Conclusion Using closure functions to encapsulate reusable code blocks improves code reuse and maintainability, and when combined with OOP they unlock even more possibilities for flexible and extensible PHP applications.