The Art of Being Anonymous in PHP

This post is a tour of PHP’s nameless constructs: from closures and arrow functions to anonymous classes and non-binding catch blocks.

Every day, in most PHP code, things have names. Variables are named, classes have identifiers, functions are called by their name. Though, PHP also offers a rich set of anonymous structures: constructs that exist and operate without ever being bound to a permanent name. Knowing when and why to use them will make the code more expressive, more flexible, and sometimes delightfully terse.

Let’s walk through every anonymous structure PHP offers, to understand their mechanics, and see where they may be put into action.

Anonymous Classes

PHP 7.0 brought anonymous classes: classes without a declared name. They are defined with new class { ... } and can implement interfaces, extend base classes, and accept constructor arguments, all inline. Just like named classes.

<?php

interface Logger
{
    public function log(string $message): void;
}

// Create a one-off implementation on the fly
$logger = new class("[APP]") implements Logger
{
    public function __construct(private string $prefix) {}

    public function log(string $message): void
    {
        echo "{$this->prefix} $message\n";
    }
};

$logger->log("Application started");
// [APP] Application started

?>

Anonymous classes shine in two scenarios. First, in tests, when one need a lightweight stub or mock that satisfies an interface without a dedicated test-double file. Second, in application code when a named class would be used in a very localised context and naming it would add noise without adding clarity.

Multiple anonymous objects

That said, “anonymous” refers to the declaration, not the lifetime of the class. Once it has been instantiated, it is possible to re-instantiate the same anonymous class as many times as one like via new $object:

<?php

$proto = new class("[APP]") implements Logger { /* ... */ };

// Re-instantiate the same anonymous class from an existing object
$another = new $proto("[WORKER]");
$another->log("Worker started");
// [WORKER] Worker started

?>

The class has no name to be typed, but its definition is reachable through any instance of it. The anonymous part is the declaration: not the lifetime of the class itself.

PHP internally assigns anonymous classes a generated name for reflection and error-reporting purposes. Don’t rely on that name in production code: it’s an implementation detail that can change.

Anonymous Catch Blocks

PHP 8.0 quietly introduced one of the nicest quality-of-life features in the language: the ability to catch an exception without binding it to a variable. When the code only need to handle the exception type and don’t need to inspect the exception object itself, the variable is just noise. It may be dropped, just like that.

<?php
// Before PHP 8.0, the variable is required even if unused
try {
    riskyOperation();
} catch (RuntimeException $e) {
    // $e is never used here, just dead weight
    fallback();
}

// PHP 8.0+: omit the variable entirely
try {
    riskyOperation();
} catch (RuntimeException) {
    fallback();  // clean and honest
}

// Works with union types too
try {
    connect();
} catch (ConnectionException | TimeoutException) {
    retryLater();
}

?>

The anonymous catch block is a small feature with a meaningful signal: by omitting the variable, you’re explicitly telling readers “I know an exception occurred, I’ve categorised it by type, and I don’t need its message or trace to handle this.” It’s self-documenting code.

Anonymous Functions

PHP offers two distinct flavours of anonymous functions. They share the “no name” characteristics but differ in how they capture their environment and what they can express.

Closures

A closure is the classic anonymous function. It is an expression that evaluates to a Closure object and can be stored in a variable, passed as an argument, or returned from another function.

<?php

$greet = function(string $name): string {
    return "Hello, $name!";
};

// Capture the outer scope explicitly with `use`
$prefix = "Dear";
$formalGreet = function(string $name) use ($prefix): string {
    return "$prefix $name, welcome.";
};

echo $formalGreet("Alice"); // Dear Alice, welcome.

?>

The key feature of a closure is explicit capture: variables from the enclosing scope are not automatically visible inside. They must be listed in the use clause. By default they are captured by value; prepend & to capture by reference.

Closures are objects of the built-in Closure class. This means the object can call methods like bindTo() or call() on them to rebind $this: a powerful trick for meta-programming.

Arrow Functions

Introduced in PHP 7.4, arrow functions are a more concise syntax for closures with one key difference: they automatically capture variables from the outer scope by value, without an explicit use clause. In a sense they are just renamed closures with a shorter body: the same anonymous function concept, trimmed down.

<?php
$multiplier = 3;

// The arrow function captures $multiplier automatically
$triple = fn($n) => $n * $multiplier;

echo $triple(7); // 21

// Ideal as callbacks in array functions
$numbers = [1, 2, 3, 4, 5];
$doubled = array_map(fn($n) => $n * 2, $numbers);

?>

Arrow functions are limited to a single expression: no multi-statement body. This makes them perfect for short transformations and callbacks, but closures remain the right tool to handover a block of logic.

Use an arrow function for one-liners passed to array_map(), array_filter(), or similar. Use a closure for multiple statements, for reference handling, or $this rebinding.

Anonymous Methods via `__invoke()`

Sometimes a full closure feels like too little: an object that behaves like a callable is much better. That’s where PHP’s magic method __invoke() comes in. Any class that defines it can be called like a function: making the invocation itself effectively anonymous from the caller’s perspective.

<?php
class Multiplier
{
    public function __construct(
        private int $factor
    ) {}

    public function __invoke(int $value): int
    {
        return $value * $this->factor;
    }
}

$double = new Multiplier(2);
echo $double(21); // 42, called like a function!

// Works seamlessly as a callable
$result = array_map(new Multiplier(3), [1, 2, 3]);
// [3, 6, 9]

?>

The method itself doesn’t have a name that callers need to know; they simply invoke the object. This pattern is especially useful in frameworks expecting a callable: the full power of a class, with dependency injection, internal state, testability, interface implementations, while presenting a clean, function-like interface.

Anonymous Constants

This one is the most subtle, but worth naming explicitly. A literal value used directly in code is, in essence, an anonymous constant. And note that this applies to global and local constants only, not class constants, which are always tied to a class name. A bare literal has no identifier; it simply is the value.

<?php
// Named constant, has an identifier
const MAX_RETRIES = 3;

// Anonymous constant (literal), used directly
for ($i = 0; $i < 3; $i++) {
    // 3 is an anonymous constant here
}

// Same with strings, booleans, null…
array_fill(0, 5, null);  // 0, 5, null, all anonymous constants

// Class constants are always named, MyClass::TIMEOUT is never anonymous
echo MyClass::TIMEOUT;

?>

The concept matters because it draws the contrast with named constants. Literals are immediate, context-bound values. When a literal appears more than once or carries non-obvious semantics, it’s a signal to give it a name to graduate it from anonymous to named. This is the well-known magic number anti-pattern in reverse: understanding why we name constants helps us appreciate what anonymity means for a value.

What Must Stay Named

Understanding the anonymous side of PHP is sharpened by understanding its limits. Anonymous form does not apply to some structures in PHP: some of them always have a declared name.

Variables: a variable is its name. The variable’s value change overtime, so it cannot replace the variable.
Properties: one access properties by name. It is the same as variables, and no PHP property, such as hooks or magic method, allows to reach them without a name.
Traits: traits are pulled in via use TraitName: static code needs a name as reference.
Interfaces: same as traits, via implementsand extends.
Enums: enumerations represent a fixed, named set of cases: anonymity would defeat the purpose.

The pattern is consistent: any structure that must be referred to by name elsewhere in the codebase has no anonymous version. You can’t implement a nameless interface, use a nameless trait, or read a nameless property. The name is not incidental: it is the mechanism.

Putting It All Together

I couldn’nt resist finishing with a pot-pourri of several anonymous structures can work in concert in a real-world scenario: a simple pipeline that processes a list of items:

<?php

interface Processor
{
    public function process(array $items): array;
}

$threshold = 10;

// Anonymous class implementing the interface
// with an anonymous method
$processor = new class($threshold) implements Processor
{
    public function __construct(private int $min) {}

    public function __invoke(array $items): array
    {
        // Closure to filter, arrow function to transform
        $filtered = array_filter(
            $items,
            function($item) {
                return is_numeric($item) && $item > $this->min;
            }
        );

        return array_map(fn($n) => $n ** 2, $filtered);
    }
};

try {
    $results = $processor([3, 15, "hello", 42, 7]);
    print_r($results);
} catch (TypeError) {
    // Anonymous catch: we just reset and move on
    echo "Invalid input, skipped.\n";
}

?>

In just a few lines, we’ve used an anonymous class, a closure with $this, an arrow function, and a non-capturing catch. Each anonymous structure earns its place: the class won’t be reused elsewhere, the callbacks are short-lived transformations, and the exception’s details don’t matter to the recovery logic.

Anonymous structures in PHP

PHP’s anonymous structures are more than a convenience syntax: they’re a design vocabulary. They let you signal intent: this logic is local, ephemeral, and contextual. Used judiciously, they reduce noise, improve readability, and keep namespaces clean.

The next time you’re about to declare a class that will only ever be instantiated once, or write a catch $ewhere $e is never read, consider reaching for the anonymous version. PHP put it there for exactly that moment.

Want to Keep in touch with us, subscribe to our newsletter !

Code auditing

The Art of Being Anonymous in PHP

The Art of Being Anonymous in PHP

Anonymous Classes

Multiple anonymous objects

Anonymous Catch Blocks

Anonymous Functions

Closures

Arrow Functions

Anonymous Methods via __invoke()

Anonymous Constants

What Must Stay Named

Putting It All Together

Anonymous structures in PHP

Login

Anonymous Methods via `__invoke()`