PHP 7.1 introduced multi-exception catch blocks to handle multiple exception types in a single catch block using the pipe (|) symbol. 1. This feature allows specifying multiple exception classes separated by | inside one catch block, such as catch (ExceptionType1 | ExceptionType2 $e). 2. It prevents code duplication and avoids catching overly broad exceptions like \Exception which could unintentionally capture unrelated errors. 3. Multi-catch is useful when working with multiple libraries, handling exceptions from APIs uniformly, or implementing centralized error handling in frameworks. 4. Best practices include using fully qualified class names, ensuring all types implement Throwable, keeping logic generic across exception types, avoiding mixing unrelated exceptions, not catching \Throwable without cause, and properly logging or rethrowing exceptions.

PHP 7.1 introduced a useful feature for handling exceptions called multi-exception catch blocks. This means you can catch multiple exception types in a single catch block, instead of writing separate ones for each exception class.

Before PHP 7.1, if you wanted to handle different exceptions the same way, you had to either duplicate code or catch a broader parent exception (like \Exception), which could accidentally capture more than you intended.

With multi-catch, you can specify several exception types separated by the pipe (|) symbol inside one catch block.

How to Use Multi-Catch in PHP 7.1

Here’s a basic example:

try {
    // Some code that may throw exceptions
} catch (ExceptionType1 | ExceptionType2 $e) {
    // Handle both ExceptionType1 and ExceptionType2 here
}

This is especially helpful when dealing with custom exceptions or built-in ones like PDOException and Exception, where you want to handle them similarly but still keep type specificity.

For example:

try {
    // Database-related code
} catch (PDOException | InvalidArgumentException $e) {
    echo "Caught an error: " . $e->getMessage();
}

In this case, both PDOException and InvalidArgumentException are handled the same way, without catching every possible exception.

When Should You Use It?

You’ll find this feature most useful in these situations:

• You're working with multiple libraries that throw different exception types.
• You want to handle several exceptions the same way (e.g., logging, user notification).
• You want to avoid overly broad catches like \Exception, which might hide unexpected errors.

Some common use cases:

• Handling API-related exceptions from different services uniformly.
• Centralized error handling in frameworks or larger applications.
• Writing cleaner try-catch logic in complex business logic flows.

Important Notes and Best Practices

• Only fully qualified class names work in multi-catch blocks unless you're using the correct namespace context.
• Each exception type must be a valid class that implements Throwable — so it works with both Exception and Error.
• The variable name ($e in examples) stays the same for all types caught — no need to change it based on exception type.
• Keep your logic inside the catch block generic enough to safely handle any of the caught types.

A few things to remember:

• Don't mix too many unrelated exceptions in one catch unless they truly share behavior.
• Avoid catching \Throwable unless you have a very good reason (it includes Errors like ParseError).
• Always rethrow or log exceptions properly to avoid silent failures.

That's the core idea behind multi exception catch blocks in PHP 7.1 . It’s a small but powerful addition that makes exception handling cleaner and more expressive.

The above is the detailed content of What are multi exception catch blocks in PHP 7.1?. For more information, please follow other related articles on the PHP Chinese website!