PHP 8 News: Constructor Property Promotion

Constructor Property Promotion is a feature introduced in PHP 8 that simplifies property declaration and initialization within a class. Before PHP 8, you had to explicitly declare class properties and then initialize them inside the constructor. With this feature, you can declare and initialize properties directly in the constructor's parameter list, reducing boilerplate code.

Traditional Syntax (Before PHP 8)

class Product {
    private string $name;
    private float $price;

    public function __construct(string $name, float $price) {
        $this->name = $name;
        $this->price = $price;
    }
}

Constructor Property Promotion Syntax (PHP 8)

class Product {
    public function __construct(
        private string $name,
        private float $price
    ) {}
}

Benefits

1. Reduces Boilerplate Code:

   • Eliminates the need to declare properties outside the constructor and manually initialize them.

2. Improves Readability:

   • Makes the code more concise and easier to understand, especially in classes with many properties.

3. Supports Immutability:

   • Properties can be marked as readonly (introduced in PHP 8.1) to prevent changes after initialization.

Notes

1. Visibility Modifiers:

   • Promoted properties must include a visibility modifier (private, protected, or public).

2. Default Values:

   • You can't set default values directly for promoted properties, but you can use default argument values in the constructor.

   class Product {
      public function __construct(
          private string $name = 'Unnamed',
          private float $price = 0.0
      ) {}
   }
   

3. Mixing Promoted and Non-Promoted Properties:

   • You can combine traditional properties and promoted properties in the same class.

   class Product {
      private string $category;
   
      public function __construct(
          private string $name,
          private float $price
      ) {
          $this->category = 'General';
      }
   }
   

Use Cases

Constructor Property Promotion is particularly useful for simple classes like DTOs (Data Transfer Objects), where the primary purpose is to store data.

class CustomerDTO {
    public function __construct(
        public string $name,
        public string $email,
        public ?string $phone = null
    ) {}
}

Conclusion

Constructor Property Promotion is a powerful feature in PHP 8 that enhances productivity and reduces code complexity. It is ideal for classes with multiple properties where concise and clear initialization is desired.

Attribute integration

In PHP 8, Attributes (also known as Annotations) can be seamlessly combined with Constructor Property Promotion, resulting in cleaner and more expressive code, especially in scenarios where metadata needs to be associated with properties.

Integration with Constructor Property Promotion

With Constructor Property Promotion, properties are defined directly in the constructor. You can use Attributes to decorate these properties and add contextual information without needing to declare the properties separately.

Practical Example

Suppose you're working on a DTO (Data Transfer Object) and want to map properties to database columns

Without Constructor Property Promotion

use Attribute;

#[Attribute]
class Column {
    public function __construct(public string $name) {}
}

class User {
    #[Column('user_id')]
    private int $id;

    #[Column('username')]
    private string $name;

    public function __construct(int $id, string $name) {
        $this->id = $id;
        $this->name = $name;
    }
}

With Constructor Property Promotion

use Attribute;

#[Attribute]
class Column {
    public function __construct(public string $name) {}
}

class User {
    public function __construct(
        #[Column('user_id')] private int $id,
        #[Column('username')] private string $name
    ) {}
}

Benefits of Integration

1. Reduced Boilerplate Code:

   • Promoted properties eliminate duplicate declarations, and Attributes can be applied directly to the constructor's properties.

2. Cleaner, More Readable Code:

   • The integration combines initialization, metadata, and visibility in one place.

3. Flexibility with Reflection:

   • You can use PHP's Reflection API to access and process Attributes applied to promoted properties.

Accessing Attributes with Reflection

// Reflection allows us to inspect and manipulate the User class at runtime.
$reflectionClass = new ReflectionClass(User::class);

// Get the constructor of the User class.
$constructor = $reflectionClass->getConstructor();

// Iterate through the constructor's parameters.
foreach ($constructor->getParameters() as $parameter) {
    // Retrieve all attributes of type Column applied to the current parameter.
    $attributes = $parameter->getAttributes(Column::class);

    // Process each attribute found.
    foreach ($attributes as $attribute) {
        // Instantiate the attribute to access its values.
        $column = $attribute->newInstance();

        // Output the parameter name and the associated column name from the attribute.
        echo "Parameter: {$parameter->getName()}, Column: {$column->name}" . PHP_EOL;
    }
}

Explanation of the Code

1. Defining the Column Attribute:

   • The #[Attribute] decorator indicates that the Column class is an attribute.
   • The attribute class accepts a single parameter name, which is used to associate a property with a database column.

2. Adding Attributes to the Constructor Parameters:

   • Attributes like #[Column('user_id')] and #[Column('username')] are added to the constructor parameters id and name.

3. Using Reflection:

   • The ReflectionClass object is created for the User class, allowing us to inspect its properties and methods.

4. Accessing the Constructor:

   • getConstructor() retrieves the constructor of the User class.

5. Iterating Over Parameters:

   • getParameters() retrieves all parameters of the constructor.

6. Fetching Attributes:

   • getAttributes(Column::class) retrieves all attributes of type Column applied to a parameter.

7. Instantiating the Attribute:

   • newInstance() creates an instance of the Column attribute, giving access to its name property.

8. Printing Metadata:

   • Outputs the parameter name (e.g., id) and its associated column name (e.g., user_id) to the console.

Output:

Parameter: id, Column: user_id
Parameter: name, Column: username

Common Use Cases

1. Database Mapping:

   • Using attributes like #[Column] to specify database columns.

2. Data Validation:

   • Applying validations directly to properties, such as #[NotNull] or #[MaxLength(255)].

3. Serialization/Deserialization:

   • Mapping properties to JSON fields, e.g., #[JsonField('user_name')].

Conclusion

The integration of Constructor Property Promotion with Attributes provides a powerful and concise way to structure classes in PHP. This is particularly useful in systems that rely on metadata, such as ORM, validation, or serialization, making the code more expressive and organized.