> ## Documentation Index
> Fetch the complete documentation index at: https://docs.syntblaze.com/llms.txt
> Use this file to discover all available pages before exploring further.
# PHP 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.
```php theme={"dark"}
$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.
```php theme={"dark"}
$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.
```php theme={"dark"}
$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.
```php theme={"dark"}
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.
```php theme={"dark"}
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.
```php theme={"dark"}
$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.
```php theme={"dark"}
$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);
```
Tired of Poor PHP Skills? Fix That With Deep Grasping!
Learn More
