Anonymous Function

An anonymous function, also known as a closure, is a function without a specified name. In PHP, anonymous functions are first-class citizens implemented internally as instances of the built-in Closure class. They can be assigned to variables, passed as arguments to higher-order functions, or returned from other functions.

$anonymousFunction = function(string $param): string {
    return "Processed: " . $param;
};

$anonymousFunction("Data");

Lexical Scoping and State Capture

Unlike functions in languages with block-level scope inheritance, standard PHP anonymous functions do not automatically inherit variables from their parent scope. To access variables from the enclosing execution context, they must be explicitly imported using the use construct.

Variables imported via use are captured by value at the exact moment the closure is defined, not when it is invoked.

$message = "Initial state";

$closure = function() use ($message) {
    echo $message;
};

$message = "Mutated state";
$closure(); // Outputs: "Initial state"

To allow the closure to mutate the original variable or to capture its state at the time of invocation, the variable must be captured by reference using the & operator.

$counter = 0;

$increment = function() use (&$counter) {
    $counter++;
};

$increment();
// $counter is now 1

Object Context and $this Binding

When an anonymous function is declared within a class method, PHP automatically binds the current object instance to the closure, making $this accessible within the function body.

class Contextual {
    private int $value = 42;

    public function getClosure(): Closure {
        return function() {
            return $this->value; // $this is automatically bound
        };
    }
}

If object binding is unnecessary or undesirable, the closure can be declared with the static keyword. A static anonymous function prevents the automatic binding of $this, which can optimize memory usage and prevent unintended state mutation.

class Contextual {
    public function getStaticClosure(): Closure {
        return static function() {
            // $this is not available here
            // Fatal error: Uncaught Error: Using $this when not in object context
        };
    }
}

Arrow Functions

Introduced in PHP 7.4, arrow functions provide a more concise syntax for anonymous functions. They are defined using the fn keyword and differ from standard closures in two technical aspects:

1. They are limited to a single expression, which is implicitly returned.
2. They automatically capture variables from the parent scope by value. Explicit use declarations are not required or permitted.

$multiplier = 10;

// Standard anonymous function
$standard = function($value) use ($multiplier) {
    return $value * $multiplier;
};

// Arrow function equivalent
$arrow = fn($value) => $value * $multiplier;

Internal Representation

Because anonymous functions are objects of the Closure class, they expose methods that allow dynamic manipulation of their context and scope after definition. Methods such as Closure::bind() and Closure::bindTo() permit developers to duplicate a closure with a new bound object and class scope, effectively altering the execution context at runtime.

$closure = function() {
    return $this->secret;
};

class Target {
    private string $secret = "Classified";
}

// Bind the closure to an instance of Target, granting access to private scope
$boundClosure = $closure->bindTo(new Target(), Target::class);

Master PHP with Deep Grasping Methodology!

Learn More