php-modern-features

name	PHP Modern Features
user-invocable	false
description	Use when modern PHP features including typed properties, union types, match expressions, named arguments, attributes, enums, and patterns for writing type-safe, expressive PHP code with latest language improvements.
allowed-tools	[]

PHP Modern Features

Introduction

Modern PHP (7.4+, 8.0+, 8.1+, 8.2+) has evolved dramatically with features that improve type safety, expressiveness, and developer experience. These additions transform PHP from a loosely-typed scripting language into a powerful, type-safe platform for building robust applications.

Key improvements include strict typing, property and parameter types, union and intersection types, match expressions, named arguments, attributes (annotations), enumerations, and readonly properties. These features enable clearer intent, better IDE support, and fewer runtime errors.

This skill covers typed properties, union/intersection types, match expressions, enums, attributes, named arguments, and patterns for leveraging modern PHP effectively.

Typed Properties and Parameters

Type declarations improve code reliability by enforcing types at runtime and enabling better static analysis.

<?php
// PHP 7.4+ typed properties
class User {
    public string $name;
    public int $age;
    public ?string $email = null; // Nullable
    private array $roles = [];
    protected bool $active = true;
}

$user = new User();
$user->name = "Alice"; // OK
$user->age = 30; // OK
// $user->age = "thirty"; // TypeError

// Constructor property promotion (PHP 8.0+)
class Product {
    public function __construct(
        public string $name,
        public float $price,
        public int $stock,
        private ?string $sku = null
    ) {}
}

$product = new Product("Laptop", 999.99, 10);
echo $product->name; // "Laptop"
// echo $product->sku; // Error: private property

// Return type declarations
function calculateTotal(float $price, int $quantity): float {
    return $price * $quantity;
}

function findUser(int $id): ?User {
    // Return User or null
    return $id > 0 ? new User() : null;
}

function getUsers(): array {
    return [new User(), new User()];
}

// Void return type
function logMessage(string $message): void {
    echo $message . "\n";
}

// Never return type (PHP 8.1+)
function fail(string $message): never {
    throw new Exception($message);
}

// Mixed type (PHP 8.0+)
function process(mixed $value): mixed {
    return $value;
}

// Static return type
class Builder {
    public function setName(string $name): static {
        return $this;
    }

    public function build(): static {
        return new static();
    }
}

// Parameter types
function greet(
    string $name,
    int $age,
    bool $formal = false
): string {
    $greeting = $formal ? "Good day" : "Hello";
    return "$greeting, $name ($age)";
}

// Variadic typed parameters
function sum(int ...$numbers): int {
    return array_sum($numbers);
}

$total = sum(1, 2, 3, 4, 5); // 15

Typed properties and parameters catch type errors early and provide clear contracts for function interfaces.

Union and Intersection Types

Union types allow multiple type possibilities, while intersection types require all specified types simultaneously.

<?php
// Union types (PHP 8.0+)
function processId(int|string $id): void {
    if (is_int($id)) {
        echo "Processing integer ID: $id\n";
    } else {
        echo "Processing string ID: $id\n";
    }
}

processId(123);
processId("ABC-456");

// Union type properties
class Response {
    public function __construct(
        public int|string $code,
        public array|string $data
    ) {}
}

// Nullable as union type
function findProduct(int $id): Product|null {
    return $id > 0 ? new Product("Item", , ) : ;
}


{
      () {
        () => ,
        () => ,
        () => ,
    };
}


{
     = (, FILTER_VALIDATE_INT);
      !==  ?  : ;
}


{
     [ => ];
}


{
     ;
}

{
     ;
}


{
    ->();
    ->();
}

{
     {
         ;
    }

     {
         ;
    }
}


{
    ?->();
}


{
    ->();
}

Union types enable flexible parameter acceptance while intersection types enforce multiple capabilities simultaneously.

Match Expressions

Match expressions provide pattern matching with strict comparisons and exhaustive checking, improving upon switch statements.

<?php
// Basic match expression (PHP 8.0+)
$status = 200;

$message = match ($status) {
    200 => "OK",
    404 => "Not Found",
    500 => "Server Error",
    default => "Unknown",
};

echo $message; // "OK"

// Multiple conditions
$result = match ($status) {
    200, 201, 202 => "Success",
    400, 401, 403 => "Client Error",
    500, 502, 503 => "Server Error",
    default => "Unknown",
};

// Match with expressions
$age = 25;

$category = match (true) {
    $age < 13 => "Child",
    $age < 18 => "Teen",
    $age < 65 => "Adult",
    default => "Senior",
};

// Match without default (throws on no match)
{
      () {
         => ,
         => ,
         => ,
        
    };
}


{
     Draft;
     Published;
     Archived;
}

{
      () {
        :: => ,
        :: => ,
        :: => ,
    };
}


{
      (()) {
         =>  * ,
         => (),
         => (),
         => ,
    };
}


 = ;


 () {
     :
         ; 
        ;
}


 =  () {
     => ,
     => , 
     => ,
};

 ; 

Match expressions are safer than switch due to strict comparison and exhaustive checking requirements.

Enumerations

Enums provide type-safe sets of possible values, replacing magic strings and constants with explicit types.

<?php
// Basic enum (PHP 8.1+)
enum Status {
    case Pending;
    case Approved;
    case Rejected;
}

function updateOrder(Status $status): void {
    echo "Order status: " . $status->name . "\n";
}

updateOrder(Status::Approved);

// Backed enum with values
enum Priority: int {
    case Low = 1;
    case Medium = 2;
    case High = 3;
    case Critical = 4;
}

$priority = Priority::High;
echo $priority->value; // 3
echo $priority->name; // "High"

// String-backed enum
enum Role: string {
    case Admin = 'admin';
    case User = 'user';
    case Guest = 'guest';
}


{
     OK = ;
     Created = ;
     BadRequest = ;
     Unauthorized = ;
     NotFound = ;
     ServerError = ;

     {
         ->value >=  && ->value < ;
    }

     {
         ->value >= ;
    }

     {
          () {
            :: => ,
            :: => ,
            :: => ,
            :: => ,
            :: => ,
            :: => ,
        };
    }
}

 = ::;
 ->() ?  : ;
 ->();


{
     Red = ;
     Green = ;
     Blue = ;

      {
         (, , , );
    }

      {
         = ::();
         [()];
    }
}


 (::()  ) {
     ->name .  . ->value . ;
}


 = ::(); 
 = ::(); 


{
      () {
        :: => ,
        :: => ,
        :: => ,
        :: => ,
    };
}

Enums replace magic strings and constants with type-safe alternatives that support IDE autocompletion and refactoring.

Attributes (Annotations)

Attributes attach metadata to declarations, enabling declarative configuration and reflection-based frameworks.

<?php
// Built-in attributes
#[Attribute]
class Route {
    public function __construct(
        public string $path,
        public array $methods = ['GET']
    ) {}
}

#[Attribute]
class Validate {
    public function __construct(
        public array $rules
    ) {}
}

// Using attributes
class UserController {
    #[Route('/users', methods: ['GET'])]
    public function index(): array {
        return ['users' => []];
    }

    #[Route('/users/{id}', methods: ['GET'])]
    #[Validate(rules: ['id' => 'required|integer'])
     {
         [ => [ => ]];
    }

    (, : [])
    (: [ => ,  => ])
     {
         [ => ];
    }
}


{
     =  ();
     = [];

     (->()  ) {
         = ->(::);

         (  ) {
             = ->();
            [] = [
                 => ->path,
                 => ->methods,
                 => [, ->()],
            ];
        }
    }

     ;
}

 = (::);


(::)
{
     {}
}

(::)
{
     {}
}

{
    ()
    (: )
    (: , : )
     {
         [ => []];
    }
}


(::)
{
     {}
}

(: )
{
      ;
      ;
}


(::)
{
     {}
}

{
    (: , : )
      ;

    (: )
      ;

    (: , : )
     DateTime ;
}

Attributes enable declarative metadata for dependency injection, routing, validation, ORM mapping, and other framework features.

Named Arguments and Other Modern Features

Named arguments improve readability and make optional parameters more usable.

<?php
// Named arguments (PHP 8.0+)
function createUser(
    string $name,
    int $age,
    string $email = '',
    bool $active = true
): User {
    $user = new User();
    $user->name = $name;
    $user->age = $age;
    $user->email = $email;
    $user->active = $active;
    return $user;
}

// Traditional call
$user1 = createUser("Alice", 30, "[e-mail]", true);

// Named arguments (any order, skip defaults)
$user2 = createUser(name: "Bob", age: 25);
$user3 = createUser(age: 28, name: "Charlie", active: false);

// Mixed positional and named
$user4 = (, , : );


{
     {}
}

 =  (, );



 {
     {}
}


 = [, , , , ];


 = (fn() =>  * , );


{
      * ;
}

 = ((...), );


{
     {}
}


 = ?->()?->()?->();


 =  ??   ();


 = ;
 ((, )) {
     ;
}

 ((, )) {
     ;
}

 ((, )) {
     ;
}

Named arguments make function calls self-documenting and enable skipping optional parameters in the middle of parameter lists.

Best Practices

1. Use strict types declaration at file start to enable strict type checking and catch type errors early

2. Leverage typed properties for all class properties to document expected types and enable validation

3. Prefer match over switch for value-based dispatch to benefit from strict comparison and exhaustiveness

4. Replace magic constants with enums to create type-safe, self-documenting sets of allowed values

5. Use named arguments for optional parameters to improve readability and skip unnecessary defaults

6. Apply readonly for immutable data to prevent accidental mutations and express immutability intent

7. Use union types for flexible parameters when functions accept multiple types instead of accepting mixed

8. Leverage attributes for metadata instead of docblocks for reflection-based frameworks and tools

9. Use constructor property promotion to reduce boilerplate in classes with many simple properties

10. Apply nullsafe operator for safe property access on potentially null objects without explicit null checks

Common Pitfalls

1. Forgetting declare(strict_types=1) allows type coercion that defeats purpose of type declarations

2. Overusing union types with too many alternatives reduces type safety benefits and complicates logic

3. Not handling all enum cases in match without default causes runtime errors when new cases added

4. Using enums for non-exhaustive sets like user IDs where values aren't known at compile time

5. Mixing positional and named arguments incorrectly can cause errors; positional must come before named

6. Not marking readonly when appropriate allows mutations that break immutability assumptions

7. Using attributes without understanding reflection leads to unused metadata that has no effect

8. Overusing mixed type instead of specific unions or generics reduces type safety benefits

9. Not checking enum::tryFrom() return value causes crashes when invalid values provided

10. Using void when never is appropriate for functions that always throw affects control flow analysis

When to Use This Skill

Use modern PHP features when building applications on PHP 7.4+ or preferably PHP 8.0+ to leverage improved type safety and developer experience.

Apply typed properties and parameters when designing classes and functions to catch type errors early and improve IDE support.

Employ enums when modeling fixed sets of values like statuses, priorities, or roles instead of using string or integer constants.

Leverage match expressions for cleaner conditional logic based on values, especially with enums or typed values.

Use attributes for framework-level metadata like routing, validation, ORM mapping, or dependency injection configuration.

Resources

• PHP 8.0 Release Notes
• PHP 8.1 Release Notes
• PHP 8.2 Release Notes
• PHP: The Right Way
• PHP Type System Documentation