Use is_a() to determine the pitfalls when judging anonymous classes

M66 2025-06-04

In PHP, the is_a() function is often used to determine whether an object belongs to a certain class or its subclass. This is very useful in type checking and object-oriented programming. However, when anonymous class is involved, the behavior of is_a() may have some unexpected "pits", resulting in code judgment errors and affecting program logic.

This article will combine specific cases to deeply analyze the problems that may be encountered when judging anonymous classes using is_a() and provide a reasonable solution.

1. Basic usage of is_a()

The syntax of is_a() function is as follows:

 is_a(object|string $object_or_class, string $class_name, bool $allow_string = false): bool

It is used to determine whether $object_or_class is an instance or subclass of $class_name .

To give a simple example:

 class Foo {}
$obj = new Foo();

var_dump(is_a($obj, 'Foo')); // true

This is very intuitive.

2. The special nature of anonymous

Anonymous classes are classes that are dynamically defined at runtime, without explicit class names. For example:

 $anon = new class {
    public function sayHello() {
        return "Hello";
    }
};

The anonymous class will be assigned an internal name like class@anonymous/path/to/file.php:line by PHP, but this name is unpredictable and cannot be used directly as type judgment.

3. The pitfalls when using is_a() to determine anonymous classes

Case demonstration

Suppose we have the following code:

 class Base {}

$anon = new class extends Base {};

var_dump(is_a($anon, 'Base'));           // Output true
var_dump(is_a($anon, 'class@anonymous')); // Output false，The internal name of the anonymous class cannot be recognized

If you directly use the internal name of an anonymous class to make judgments, it is difficult to match correctly because the name is dynamic and includes paths and line numbers.

Pit 1: Anonymous class names are uncontrollable

The name of anonymous class contains the file path and line number, such as:

 class@anonymous /path/to/file.php:10

This makes it impossible for us to hardcode anonymous class names to make judgments.

Pit 2: Unable to match anonymous class names with strings

The second parameter of is_a() must be the class name of the string type, but the anonymous class name is not fixed and difficult to reference.

Pit 3: Inheritance chain judgment is invalid (some scenarios)

Although anonymous classes can inherit other classes, is_a()' s inheritance judgment on the instance is valid, if the code logic hardcodes the anonymous class name with string class name, the judgment will inevitably fail.

4. Practical solutions

Solution 1: Judge the parent class

Since anonymous classes inherit a specific class, we usually judge whether the object is an instance of the parent class:

 var_dump(is_a($anon, Base::class)); // true

This is also the easiest and recommended way to do it.

Solution 2: Define anonymous classes with interfaces

Define the interface and enable the anonymous class to implement it, so that the judgment is clearer by using the interface type:

 interface SayHelloInterface {
    public function sayHello();
}

$anon = new class implements SayHelloInterface {
    public function sayHello() {
        return "Hello";
    }
};

var_dump(is_a($anon, SayHelloInterface::class)); // true

Solution 3: Avoid making judgments directly using the internal name of anonymous class

If it is not a special need, the code should avoid judging the "real class name" of anonymous classes, but instead make type judgments through the parent class or interface.

5. Complete sample code

 <?php

class Base {
    public function who() {
        return "I am Base";
    }
}

interface GreetInterface {
    public function greet(): string;
}

// Anonymous inheritance Base
$anon1 = new class extends Base {
    public function who() {
        return "I am Anonymous extending Base";
    }
};

// Anonymous class implements interface
$anon2 = new class implements GreetInterface {
    public function greet(): string {
        return "Hello from anonymous";
    }
};

echo is_a($anon1, Base::class) ? "anon1 is Base\n" : "anon1 is NOT Base\n";
echo is_a($anon2, GreetInterface::class) ? "anon2 implements GreetInterface\n" : "anon2 does NOT implement GreetInterface\n";

// Error demonstration：Directly judge the internal name of anonymous class（Not available）
$className = get_class($anon1);
echo "Class name of anon1: $className\n";
var_dump(is_a($anon1, $className));  // true, but $className Not suitable for hard-coded judgment

6. Summary

The class name of an anonymous class is dynamically generated with a path and line number, and cannot be used directly as a basis for judgment.
When is_a() determines whether an anonymous class instance is an instance of a certain parent class or interface, the inheritance relationship judgment is normal and valid.
It is recommended to judge the object type through the parent class or interface to avoid directly relying on the anonymous class "real class name".
The code written in this way is more robust and conforms to the principle of object-oriented design.

If you involve type judgment of anonymous classes in your code, keeping in mind the above "pits" and solutions can avoid many unnecessary debugging and errors. Hope this article will be helpful for you to understand PHP anonymous classes and is_a() !

is_a