PHP Reflection API: Explore and Manipulate PHP Classes and Functions 🎯

Welcome to your journey into the PHP Reflection API! In this lesson, we'll delve into the fascinating world of introspection, where we can explore and manipulate PHP classes and functions. Let's get started! 📝

What is Reflection? 💡

Reflection is a process that allows us to inspect and manipulate the structure of PHP classes, interfaces, functions, and methods at runtime. It's a powerful tool for creating dynamic applications and understanding the inner workings of PHP.

Why Reflection Matters? 📝

Dynamic Code Generation: Reflection allows us to create classes, methods, and properties on the fly.
Code Analysis: Reflection can help us understand the structure of existing codebases, making it easier to work with and extend.
Dependency Injection: Reflection plays a crucial role in dependency injection, a design pattern that makes our code more modular and testable.

Getting Started with PHP Reflection API 💡

Instantiating Reflection Classes

To work with the Reflection API, we'll use classes from the Reflection namespace. Here's how to create a ReflectionClass instance for a given class:

php

$reflectionClass = new ReflectionClass('ClassName');

Exploring a Class with Reflection 📝

Let's see what we can do with a ReflectionClass instance:

Getting Class Name, Methods, and Properties

php

$reflectionClass = new ReflectionClass('ClassName');

// Get class name
$className = $reflectionClass->getName();

// Get class methods
$methods = $reflectionClass->getMethods();

// Get class properties
$properties = $reflectionClass->getProperties();

Accessing Methods and Properties

We can also access method and property details:

php

// Get method details
$method = $reflectionClass->getMethod('methodName');
$methodName = $method->getName();
$methodParameters = $method->getParameters();

// Get property details
$property = $reflectionClass->getProperty('propertyName');
$propertyName = $property->getName();
$propertyType = $property->getType();

Practical Example 💡

Let's create a simple class and explore it with the Reflection API:

php

class User {
    private $name;
    private $email;

    public function __construct($name, $email) {
        $this->name = $name;
        $this->email = $email;
    }

    public function getName() {
        return $this->name;
    }

    public function setName($name) {
        $this->name = $name;
    }

    public function getEmail() {
        return $this->email;
    }

    public function setEmail($email) {
        $this->email = $email;
    }
}

$reflectionClass = new ReflectionClass('User');

// Get class name
echo $reflectionClass->getName() . "\n";

// Get class methods
foreach ($reflectionClass->getMethods() as $method) {
    echo $method->getName() . "\n";
}

// Get class properties
foreach ($reflectionClass->getProperties() as $property) {
    echo $property->getName() . "\n";
}

Output:

User
__construct
getName
setName
getEmail
setEmail
name
email

Reflection for Methods 📝

We can further explore methods with the ReflectionMethod class:

Invoking Methods

php

$reflectionMethod = new ReflectionMethod('User', '__construct');
$reflectionMethod->invoke(new User('John', 'john@example.com'));

Checking if a Method Exists

php

$reflectionMethod = new ReflectionMethod('User', 'doesNotExist');

if ($reflectionMethod->exists()) {
    echo "Method exists\n";
} else {
    echo "Method does not exist\n";
}

Quiz 📝

Continue your PHP journey with us at CodeYourCraft! Stay tuned for more exciting lessons and practical examples. Happy coding! 💡 🎯