PHP 8.0 features

What it is and why it exists

PHP 8.0 features aren’t a style guide that you must adopt wholesale. They’re a set of more precise language capabilities. This topic focuses on six PHP 8.0 additions that still shape everyday application code: union types, named arguments, attributes, match, constructor property promotion, and the nullsafe operator. PHP 8.1 enums and Fibers have their own related topics.

A union type writes several permitted runtime types as int|string. It lets the engine enforce existing type rules at calls, returns, and property assignments, and it exposes alternatives to static analysis. It doesn’t describe an array’s internal shape or automatically parse request strings.

A named argument uses parameter: value to send a value to a specific parameter. It’s useful for skipping optional parameters in the middle of a signature and for clarifying otherwise opaque values such as booleans. The cost is that callers depend on parameter names, not just their order.

An attribute is structured metadata attached to a program entity such as a class, method, property, or parameter. A framework or application reads it through the Reflection API, then decides how routing, validation, or serialization should behave. Merely placing an attribute on a method doesn’t execute any logic.

match, property promotion, and the nullsafe operator address three common kinds of boilerplate: strict branches from one input to one result, repeated constructor parameters and property declarations, and step-by-step checks along nullable object chains. They compress expression, not decisions. Every removed line still has semantics that need tests.

These capabilities often meet in DTOs, controllers, configuration objects, domain conversions, and framework integration. When migrating an older project, first use tests to pin down existing behavior, then adopt one feature at a time. A broad mechanical rewrite changes type failures, argument binding, comparisons, and null propagation together, making regressions hard to locate.

How it works

The six capabilities act at different times. Type declarations participate in calls and assignments, named arguments bind parameters during a call, attributes remain in compiled metadata until a consumer reads them, match and the nullsafe operator work during expression evaluation, and property promotion creates and assigns properties during construction.

Types and call boundaries

Union members are separated with |. A value needs to satisfy only one member; meaningless declarations, such as duplicates or combining void with another member, are rejected. A single nullable type is commonly written ?Customer, while a more complex declaration can include null explicitly. Pick one team style where the forms are equivalent and use it consistently.

declare(strict_types=1); affects how calls to user-defined functions originating in the current file handle scalar arguments. It doesn’t turn int|string into a domain enum or inspect the keys and values inside an array. Values from JSON, forms, and databases still need validation and conversion at the boundary before entering typed internal interfaces.

A named argument finds its parameter by name, so calls can use a different order and skip parameters with defaults. Positional arguments must precede named ones. An unknown name or assigning the same parameter twice produces an Error. This is real function-call binding, not associative-array configuration syntax.

Once outside callers can use named arguments, a function or method’s parameter names may become public contract. Renaming $includeTax to $withTax leaves positional calls unchanged but immediately breaks includeTax: true. Library authors should include parameter names in compatibility review, and applications should avoid changing them repeatedly for wording alone.

Metadata and object construction

Attributes use #[Name(arguments)], and their arguments must be valid constant expressions. An attribute class is itself marked with the built-in #[Attribute] attribute and may declare permitted targets and repeatability. getAttributes() on ReflectionClass, ReflectionMethod, and related objects returns ReflectionAttribute descriptors.

Obtaining a descriptor doesn’t construct the attribute object. Only newInstance() runs its constructor and can surface bad arguments, an invalid target, or a class that isn’t marked as an attribute. Metadata consumers should choose when to instantiate, and they should test misconfiguration so startup failures are clear.

Constructor property promotion places a visibility modifier before a constructor parameter, as in public string $id. That parameter also declares a property. During construction, the argument is assigned before the constructor body runs, so the body can validate combined invariants through $this->id. A parameter without visibility remains an ordinary parameter.

A promoted property isn’t a different kind of property. Reflection, inheritance, and type rules still treat it as an ordinary property, and an attribute can be attached directly to the promoted parameter. Don’t also declare a property with the same name; the duplicate is an error, not an override or extension of the promotion.

Strict branches and null propagation

A match expression compares one subject with arm conditions using ===. The result expression of the first matching arm becomes the value of the whole match; there’s no fall-through and no break. Comma-separated conditions can share one result.

If no arm matches and there’s no default, PHP throws UnhandledMatchError when that path executes. That prevents an omission from silently becoming null, but it isn’t compile-time exhaustiveness checking. Explicitly listing a closed input set and testing every member usually exposes requirement changes better than a broad default.

match (true) can express ordered conditions and ranges because each arm condition is strictly compared with true. Order becomes business logic, so narrower or higher-priority conditions must come first. Directly matching the subject is usually clearer when mapping discrete values.

The nullsafe operator is written ?->. If its left side is an object, evaluation continues like ->; if the left side is null, the remaining chain short-circuits and the expression becomes null. Even argument expressions for the skipped method call aren’t evaluated.

Every step that can return null needs ?->. If an ordinary -> follows and its own left side is later null, the access still fails. The nullsafe operator is read-only: it can’t appear on the left of an assignment or yield a reference. Updates need an explicit existence check.

Examples

These four examples share an order-processing setting. They begin with types and branches, then add object modeling, attribute metadata, and nullsafe short-circuiting. Every output shown below comes from running its file with the local PHP 8.3.33 CLI.

Union types, named arguments, and match

The status conversion accepts an internal integer code or an external string reference. Strict comparison in match keeps integer 1 separate from string '1', while the named argument explains that the second boolean controls priority.

The union says that both technical representations are valid, but the function still rejects unknown statuses. Using switch or first converting every input to a string could accidentally merge the integer code and external reference. Tests should cover every type member plus boundary values that look equal but have different types.

priority: true is clearer than a bare boolean. The call now depends on the name $priority, though. Renaming that parameter requires updating every named call or treating the change as a breaking change to a public API.

Building objects with property promotion

The order and customer objects use promoted properties to remove duplicate declarations. The constructor body still owns the domain invariant that total must be positive; promotion itself only declares and assigns.

<?php
declare(strict_types=1);

final class Address
{
    public function __construct(public string $city) {}
}

final class Customer
{
    public function __construct(
        public string $name,
        public ?Address $address = null,
    ) {}
}

final class Order
{
    public function __construct(
        public string $id,
        public Customer $customer,
        public int|float $total,
    ) {
        if ($this->total <= 0) {
            throw new InvalidArgumentException('total must be positive');
        }
    }

    public function summary(): string
    {
        $city = $this->customer->address?->city ?? 'pickup';
        return sprintf('%s|%s|%.2f', $this->id, $city, $this->total);
    }
}

$delivery = new Order(
    id: 'A-17',
    customer: new Customer('Mina', new Address('Paris')),
    total: 42.5,
);
$pickup = new Order(id: 'A-18', customer: new Customer('Noah'), total: 19);

echo $delivery->summary(), PHP_EOL;
echo $pickup->summary(), PHP_EOL;

A-17|Paris|42.50
A-18|pickup|19.00

Named arguments keep the second construction readable on one line. The total union preserves integer and float input, while sprintf() normalizes both to one amount format at the output boundary. Real monetary values also need an explicit precision and currency policy that a union type can’t replace.

address is nullable, so the step that accesses city uses ?->. The ?? 'pickup' is a business default separate from the nullsafe operator’s propagation semantics. If a missing address should block checkout, reject it in a constructor or service boundary instead of displaying a default.

Defining and reading repeatable attributes

RequiresRole is restricted to methods and may be repeated. The reader first filters the target attributes, then calls newInstance() to obtain typed configuration objects.

<?php
declare(strict_types=1);

#[Attribute(Attribute::TARGET_METHOD | Attribute::IS_REPEATABLE)]
final class RequiresRole
{
    public function __construct(public string $role) {}
}

final class OrderController
{
    #[RequiresRole('support')]
    #[RequiresRole('admin')]
    public function refund(): void {}
}

$method = new ReflectionMethod(OrderController::class, 'refund');
$attributes = $method->getAttributes(RequiresRole::class);

foreach ($attributes as $attribute) {
    $rule = $attribute->newInstance();
    echo $method->getName(), ':', $rule->role, PHP_EOL;
}

refund:support
refund:admin

The program prints roles because consumer code explicitly reads, instantiates, and interprets the attributes. Without that Reflection logic, #[RequiresRole] performs no authorization. Production authorization must also get roles from a trusted identity and define whether repeated attributes mean “any role” or “all roles.”

IS_REPEATABLE and TARGET_METHOD describe structural constraints, not that composition policy. When adding an attribute consumer, test no attribute, one attribute, repeated attributes, bad arguments, and a bad target rather than only the successful path.

Observing nullsafe short-circuiting

The last example gives a method argument a visible side effect. When the profile data is absent, auditLabel() isn’t evaluated. It runs before format() only when the object chain exists.

<?php
declare(strict_types=1);

final class Profile
{
    public function __construct(public ?DeliveryAddress $address = null) {}
}

final class DeliveryAddress
{
    public function __construct(public string $city) {}

    public function format(string $audit): string
    {
        return "{$audit}:{$this->city}";
    }
}

function auditLabel(): string
{
    echo "audit evaluated\n";
    return 'ship';
}

function destination(?Profile $profile): string
{
    return $profile?->address?->format(auditLabel()) ?? 'pickup';
}

echo destination(new Profile()), PHP_EOL;
echo destination(new Profile(new DeliveryAddress('Paris'))), PHP_EOL;

pickup
audit evaluated
ship:Paris

Short-circuiting can avoid wasted work, but placing required auditing, counting, or validation in a method argument makes that work conditional. If a side effect must happen whether or not the object exists, run it before the nullsafe chain and use explicit control flow for the missing object.

Both nullable steps use ?->: $profile may be null, and so may address. Protecting only the first position and then writing ->address->format() doesn’t protect the second null.

Pitfalls

Treating a union type as input validation

Fix: validate raw shape and values at an HTTP, CLI, database, or message boundary, then convert to a narrow internal representation. Test every union member, boundary values, and rejected types. If alternatives have distinct business behavior, consider a value object or enum instead of adding more members.

Forgetting that named arguments bind parameter names

Fix: document stable parameter names on public methods and retain at least one named call in integration tests. Use named arguments when skipping optional parameters or when they materially improve readability. Migrate callers as part of a compatibility change when renaming a public parameter.

Assuming attributes execute policy

Fix: identify which startup or request component reads attributes, when it calls newInstance(), and how it combines repeats. Use a reflection integration test to walk registered handlers so bad configuration fails during deployment or startup. For security policy, also test the default behavior when metadata is absent.

Hiding new branches behind default

Fix: list every arm for a closed set and have a data provider visit every valid value. Use default only when every future value can safely share one fallback. Validate and reject unknown external input before it enters the match.

Letting nullsafe access erase domain meaning

Fix: define the domain meaning of each null, then choose propagation, a default, or an exception. Test every nullable position in the chain, not only the first. Don’t hide required logging, authorization, or validation inside a method argument that may be short-circuited.

Changing behavior during migration

Fix: change one semantic dimension at a time, with characterization tests that record old inputs and outputs first. Resolve PHP 8.0 incompatibilities and dependency support before adopting syntax. For every switch, inspect subject types, break, fall-through paths, and the default arm.

Further reading

• PHP 8.0 new features
• PHP type declarations
• PHP attributes overview
• PHP named arguments
• PHP match
• PHP nullsafe operator