Using Pattern Matching in PHP to Write Cleaner and More Maintainable Code

Writing clean, maintainable code is a goal for every developer, and PHP offers several tools to achieve this. Pattern matching, a powerful yet often overlooked technique, can significantly improve code readability and conciseness. This article explores how to leverage pattern matching in PHP to produce cleaner, smarter code.

What Is Pattern Matching?

Pattern matching is a technique for checking whether given data fits a specific "pattern". It is similar to using regular expressions on strings but can be applied to more complex data structures. Pattern matching lets developers express logic declaratively instead of using verbose conditional statements.

Pattern Matching Techniques in PHP

Although PHP does not have built-in full pattern‑matching like Haskell or Rust, similar effects can be achieved in several ways:

1. Using a switch Statement

function handleResponse($response) {
    switch (true) {
        case $response['status'] === 'success' && isset($response['data']):
            // handle success case
            break;
        case $response['status'] === 'error' && isset($response['message']):
            // handle error case
            break;
        default:
            // default handling
    }
}

2. Using the match Expression (PHP 8.0+)

PHP 8.0 introduced a more powerful match expression, which is closer to true pattern matching than the traditional switch :

$result = match (true) {
    $age < 18 => '未成年人',
    $age >= 18 && $age < 65 => '成年人',
    $age >= 65 => '老年人',
    default => '未知年龄组'
};

3. Using Array Destructuring

PHP 7.1 introduced array destructuring, which can be used for simple pattern matching:

[$type, $payload] = $event;

switch ($type) {
    case 'user_created':
        // handle user created event
        break;
    case 'order_placed':
        // handle order placed event
        break;
}

4. Using Object Destructuring (PHP 8.0+)

Object destructuring in PHP 8.0 can be combined with match :

class Response {
    public function __construct(
        public string $status,
        public mixed $data = null,
        public ?string $message = null
    ) {}
}

$response = new Response('error', null, 'Not found');

$result = match ($response->status) {
    'success' => "Data: " . json_encode($response->data),
    'error'   => "Error: " . $response->message,
    default   => 'Unknown status'
};

Advantages of Pattern Matching

Clearer code structure: complex conditional logic becomes easier to read.

Reduced errors: exhaustive case handling minimizes missed scenarios.

Fewer temporary variables: less need for intermediate state storage.

Better maintainability: adding new cases only requires a new pattern.

Practical Application Examples

Handling API Responses

function handleApiResponse(array $response): string {
    return match (true) {
        isset($response['error']) => "Error: {$response['error']}",
        isset($response['data'])  => "Data: " . json_encode($response['data']),
        $response['status'] === 'pending' => "Operation is pending",
        default => throw new InvalidArgumentException('Invalid response format')
    };
}

Routing Dispatch

$route = parse_url($_SERVER['REQUEST_URI'], PHP_URL_PATH);

match ($route) {
    '/login'      => handleLogin(),
    '/dashboard'  => handleDashboard(),
    '/api/users'  => handleUsersApi(),
    default       => handleNotFound()
};

Data Validation

function validateUser(array $user): array {
    $errors = [];

    match (true) {
        !isset($user['email']) => $errors[] = 'Email is required',
        !filter_var($user['email'], FILTER_VALIDATE_EMAIL) => $errors[] = 'Invalid email format',
        strlen($user['password'] ?? '') < 8 => $errors[] = 'Password must be at least 8 characters',
        default => null
    };

    return $errors;
}

Advanced Pattern Matching Techniques

Using a Custom Matcher

class Matcher {
    public static function match($value, array $patterns) {
        foreach ($patterns as $pattern => $callback) {
            if ($pattern($value)) {
                return $callback($value);
            }
        }
        throw new RuntimeException('No pattern matched');
    }
}

$result = Matcher::match($value, [
    fn($x) => $x > 100 => fn($x) => "Large number: $x",
    fn($x) => $x < 0   => fn($x) => "Negative number: $x",
    fn($x) => $x === 0 => fn()   => "Zero",
    fn($x) => true      => fn($x) => "Positive number: $x" // default
]);

Combining PHP 8.0 Union Types

function processValue(int|string|array|null $value): string {
    return match (true) {
        is_int($value)    => "Integer: $value",
        is_string($value) => "String: $value",
        is_array($value)  => "Array with " . count($value) . " items",
        $value === null   => "Null value",
        default           => "Unknown type"
    };
}

Best Practices

Prefer the match expression: it is more concise and safer in PHP 8.0+.

Keep patterns simple: overly complex patterns reduce readability.

Handle all cases: ensure a default branch or exhaustively cover possibilities.

Avoid side effects: pattern matching works best with pure, functional operations.

Add explanatory comments for complex patterns.

Conclusion

Although PHP's pattern‑matching capabilities are not as powerful as those in some functional languages, by wisely using the match expression, destructuring, and other modern PHP features we can still write cleaner, more declarative code. Pattern matching reduces boilerplate, clarifies business logic, and is a valuable tool for every PHP developer.

As PHP continues to evolve, future versions are expected to bring even stronger pattern‑matching features. Until then, creatively applying the concepts with existing language constructs can already bring noticeable improvements to code quality.