Reflection and Introspection in PHP: How to Look Inside Your Code

Reflection and Introspection in PHP: How to Look Inside Your Code and Make It Smarter

Have you ever looked at someone else's (or your own old) code and thought: "What's going on here? What methods does this class have? What arguments does this method take?" In everyday life, you would open the file and read it. But what if the code could answer these questions itself? In PHP, this is not science fiction, but a reality called reflection and introspection.

Imagine you are a detective, and your code is a suspect. Reflection and introspection are your tools to interrogate it, learn all its secrets, and make it work for you even more efficiently. In this article, we will not just break down the theory, but show with live examples how these mechanisms turn PHP from a simple scripting language into a powerful platform for metaprogramming. Let's go!

What are Reflection and Introspection? There is a Difference!

These terms are often used as synonyms, but there is a fine line between them.

\n
• Introspection is the ability of an object to "look at itself": to find out what properties and methods it has, which class it belongs to. It's like a mirror for code.
\n
• Reflection is a broader concept. It's not just "looking," but also "changing": dynamically creating objects, calling methods, changing properties, even if you don't know their names at the time of writing the code.
\n

Simply put: introspection is reading, and reflection is reading + writing. In PHP, a powerful set of classes from the Reflection API extension handles this.

Why is This Needed? Real-World Scenarios

You might think: "Well, that's cool, but it won't be useful in real work." It will be very useful! Here are a few situations where reflection is an indispensable helper:

\n
• Creating ORM (Object-Relational Mapping): Automatically map class properties to database columns.
\n
• Frameworks (Laravel, Symfony): Dependency Injection Container — the container itself looks at what arguments the constructor needs and provides them.
\n
• Documentation Generation: phpDocumentor uses reflection to analyze your code and create beautiful manuals.
\n
• Debugging and Logging: Universal dumpers that show the structure of any object.
\n
• Unit Tests: Mock objects and testing private methods.
\n

Agree, that sounds powerful? Let's move on to the most interesting part — the code.

Main Tools: ReflectionClass, ReflectionMethod, ReflectionProperty

PHP has a whole family of classes, but the most popular ones are ReflectionClass, ReflectionMethod, and ReflectionProperty. Let's break them down using a simple class as an example.

Example 1: Class Introspection (Who Are You?)

Let's say we have a class like this:

<?php\n\nclass User\n{\n    private int $id;\n    public string $name;\n    protected string $email;\n\n    public function __construct(string $name, string $email)\n    {\n        $this->name = $name;\n        $this->email = $email;\n    }\n\n    public function getName(): string\n    {\n        return $this->name;\n    }\n\n    private function validateEmail(): bool\n    {\n        return filter_var($this->email, FILTER_VALIDATE_EMAIL) !== false;\n    }\n}\n\n// And now — the magic of reflection\n$reflection = new ReflectionClass(User::class);\n\necho "Class name: " . $reflection->getName() . "<br>";\necho "Is the class abstract? " . ($reflection->isAbstract() ? 'Yes' : 'No') . "<br>";\necho "Is the class final? " . ($reflection->isFinal() ? 'Yes' : 'No') . "<br>";\necho "Parent class: " . ($reflection->getParentClass() ? $reflection->getParentClass