PHP 8.1 introduces intersection types, and uses the & operator to specify that values must satisfy multiple type constraints at the same time. 1. When the intersection type is used for function parameters, ensures that the object implements multiple interfaces, such as function example(FooInterface & BarInterface $param). 2. Usage scenarios include designing APIs or libraries that require combination capabilities, and enhancing type safety when combined with mixin and trait. 3. Practical recommendations: Only used for object types and variable naming should clearly express the meaning of the combination type and avoid excessive nesting use. 4. Modern IDEs and static analysis tools such as PHPStan have well supported this feature. 5. Note that the intersection type requires that the object must fully implement all specified interfaces, which are different from the union type and are more stringent.

In PHP 8.1, intersection types allow you to specify that a value must satisfy multiple type constraints at the same time. While union types (using | ) let you accept one of several types, intersection types (using & ) requires a value to be all of the specified types simultaneously.

This can be particularly useful for function parameters when you need an object that implements multiple interfaces or combines traits. Here's how you can use them effectively.

Understanding Intersection Types

Intersection types are written using the & operator. For example:

 function example(FooInterface & BarInterface $param): void {
    // $param must implement both FooInterface and BarInterface
}

Before PHP 8.1, there was no native way to enforce this behavior directly in type declarations — you'd have to check manually inside the function body. Now, it's enforced at the type level.

This is especially helpful when working with complex systems where objects need to conform to multiple contracts.

When to Use Them for Function Parameters

You should consider using intersection types when:

• You want to ensure an object satisfyes multiple interface requirements.
• You're designing APIs or libraries that expect combined capabilities from input objects.
• You're working with mixins or trait-based designs and want stricter typing.

For instance, imagine you have two interfaces: LoggerInterface and SerializableInterface . If a function needs an object that can both log and be serialized, you can now write:

 function process(LoggerInterface & SerializableInterface $handler): void {
    $handler->log('Started processing');
    file_put_contents('data.txt', serialize($handler));
}

This makes your expectations clear and avoids runtime surprises.

Practical Tips for Using Intersection Types

Here are some things to keep in mind:

• Interfaces only – Intersection types currently work only with object types (not scalar types like int or string ).
• Order doesn't matter – A & B is the same as B & A
• Use describe variable names – Since the type already shows what's expected, naming the parameter something like $loggerAndSerializer helps readability.
• Avoid overuse – Intersection types are powerful but can make code harder to read if overused or nested deeply.

Also, remember that the passed object must actually fulfill all the required interfaces — just implementing one won't be enough.

Compatibility and Tooling Support

As of PHP 8.1 , most modern IDEs (like PhpStorm, VS Code with appropriate extensions) understand interaction types and will provide auto-completion and error checking. Static analysis tools such as PHPStan and Psalm also supports them well.

If you're upgrading older code or working in a team, make sure everyone knows that interference types are stricter than union types and serve a different purpose.

So, when writing functions that expect highly specialized objects, interference types help you express those expectations clearly and safely. It's not complicated, but it does require thinking carefully about your object design.

Basically that's it.

The above is the detailed content of How to use intersection types for function parameters in PHP 8.1?. For more information, please follow other related articles on the PHP Chinese website!