Combining property_exists and get_class to determine the type of object properties

In PHP, we often need to type check the properties of an object to ensure that there is no type error when accessing or manipulating properties at runtime. Although PHP is a dynamic language, accurately judging whether the attributes exist and their types when interacting with complex objects or interfaces is still an important means to ensure the robustness of the code.

This article will introduce how to use property_exists() and get_class() functions to accurately judge the existence and specific types of object properties.

1. Background scene

Suppose you are developing a business system that relies on polymorphic object structures, and different types of objects may have the same name but different types of properties. For example:

 class User {
    public Profile $profile;
}

class Admin {
    public AdminProfile $profile;
}

class Guest {
    // No profile property
}

You want to pass in any object and determine whether it has a profile attribute and the specific class name of the attribute without breaking type safety.

2. Use property_exists() to check the existence of attributes

property_exists() is a PHP built-in function that allows us to detect whether a property exists in an object or class. The syntax is as follows:

 bool property_exists(object|string $object_or_class, string $property)

Example:

 if (property_exists($object, 'profile')) {
    // Defined in the description object profile property
}

But note that it does not judge whether the property has been initialized, only whether it is declared.

3. Use get_class() to determine the specific type of attribute

Once we confirm that the object has this property, we can try to get its value and use get_class() to determine the specific type of the value.

 if (property_exists($object, 'profile')) {
    $profileValue = $object->profile;
    if (is_object($profileValue)) {
        $profileClass = get_class($profileValue);
        echo "property profile The type of: $profileClass";
    } else {
        echo "property profile exist，But not the object。";
    }
}

4. Complete encapsulation: a practical detection function

Here is a practical function that accepts arbitrary objects and tries to determine whether they have specified attributes and output the attribute's class name:

 function getObjectPropertyClass(object $object, string $property): ?string {
    if (property_exists($object, $property)) {
        $value = $object->$property ?? null;
        if (is_object($value)) {
            return get_class($value);
        }
    }
    return null;
}

Example of usage:

 $user = new User();
$user->profile = new Profile();

$className = getObjectPropertyClass($user, 'profile');

if ($className) {
    echo "profile The class name is：$className";
} else {
    echo "该property不exist或不是对象。";
}

5. Processing for uninitialized attributes

In PHP 7.4+, if the property is typed and not assigned, accessing it directly throws an error. You can use ReflectionProperty to gracefully determine whether the property has been initialized.

 function isPropertyInitialized(object $object, string $property): bool {
    try {
        $ref = new ReflectionProperty($object, $property);
        return $ref->isInitialized($object);
    } catch (ReflectionException $e) {
        return false;
    }
}

Use in combination:

 if (property_exists($object, 'profile') && isPropertyInitialized($object, 'profile')) {
    $profile = $object->profile;
    if (is_object($profile)) {
        echo "Type is：" . get_class($profile);
    }
}

6. Examples of practical application scenarios

For example, when you are processing a data object returned from a remote API (for example, https://api.gitbox.net/users/123 ), you can use the above method to dynamically determine whether it contains properties such as profile and settings , and further process it.

This approach is ideal for deserializing or processing data interfaces that are not standardized object structures.

7. Conclusion

Combining property_exists() and get_class() , combined with the advanced usage of ReflectionProperty , we can more securely and accurately judge the existence of object properties and their specific types in PHP. This approach is especially suitable for programming scenarios related to data-driven design, interface response processing, or reflection. It has very practical value for improving the robustness and maintainability of the code.