PHP Match Expression Mastery: Complete Tutorial

Welcome to our comprehensive tutorial on mastering the “php match” expression. 

Whether you’re a beginner or an experienced PHP developer, this tutorial will equip you with the knowledge and skills to confidently incorporate php match expressions into your projects.

Get ready to level up your coding abilities and unlock new possibilities with the php match expression. Let’s dive in!

What is the php match expression?

PHP 8 introduced the powerful addition of the “php match” expression. It provides an alternative syntax for conditional statements, offering a concise and expressive way to handle complex matching patterns.

The advantages of using the “php match” expression are manifold. Firstly, it simplifies and streamlines code by reducing the need for multiple if-else statements or lengthy switch cases. This leads to more readable and maintainable code. Additionally, the “php match” expression also improves code robustness by ensuring exhaustive pattern matching. It requires developers to handle all cases explicitly, eliminating the possibility of unintended fall-throughs or overlooked conditions.

The “php match” expression also offers a more expressive and flexible approach to conditional logic. It supports both simple value comparisons and more complex patterns, including the use of regular expressions. This allows for sophisticated matching scenarios and makes code more concise.

In summary, the “php match” expression brings your code simplicity, readability, and robustness. Its expressive syntax and pattern matching capabilities make it a valuable feature for developers, enabling them to handle conditional logic more efficiently and effectively.

Example syntax and usage of the php match expression

$result = match ($value) {
    pattern1 => expression1,
    pattern2 => expression2,
    // Additional patterns and expressions
    default => expression_default,
};

Here’s a breakdown of each component:

• $value: The patterns will match against this variable.
• pattern1, pattern2, etc…: These patterns will match the $value. Patterns can be literals, variables, or expressions.
• expression1, expression2, etc.: These expressions will execute correspondingly when a specific pattern is matched.
• default : This is an optional keyword that specifies a default case when none of the patterns match the $value.
• expression_default: The expression to be executed when none of the patterns matches.

Here’s an example to illustrate the usage of the php match expression:

$dayOfWeek = 'Monday';
$result = match ($dayOfWeek) {
    'Monday' => 'Start of the week!',
    'Tuesday', 'Wednesday', 'Thursday' => 'Midweek days',
    'Friday' => 'TGIF!',
    'Saturday', 'Sunday' => 'Weekend vibes',
    default => 'Invalid day',
};
echo $result; // Output: Start of the week!

In this example, we use the “php match” expression to determine the type of day based on the $dayOfWeek value. The expression matches the value against different patterns and executes the corresponding expression.

In this case, since $dayOfWeek is ‘Monday’, it matches the first pattern and assigns the result ‘Start of the week!‘ to the $result variable.
The optional default keyword allows you to specify a fallback expression when none of the patterns match.
By leveraging the syntax and power of the “php match” expression, you can create more concise and readable code that efficiently handles complex matching scenarios in your PHP applications.

Example 1: Basic value matching

$value = 3;

$result = match ($value) {
    1 => "One",
    2 => "Two",
    3 => "Three",
    default => "Not found",
};

echo $result; // Output: Three

In this example, we match the value of the variable $value against different cases. If $value is 1, the result will be “One”. If it’s 2, the result will be “Two”. Since $value is 3 in this case, the match expression returns “Three”.

Example 2: Complex value matching

$userRole = "admin";
$loggedIn = true;

$result = match (true) {
    $loggedIn && $userRole === "admin" => "Welcome, Admin!",
    $loggedIn => "Welcome, User!",
    default => "Please log in.",
};

echo $result; // Output: Welcome, Admin!

In this example, we combine multiple conditions to perform complex value matching.

The match expression checks if the user is logged in and has an “admin” role.

If both conditions are met, it returns “Welcome, Admin!”. If the user is logged in but does not have an “admin” role, it returns “Welcome, User!”. Otherwise, if the user is not logged in, it prompts them to log in.

Example 3: Pattern matching with regular expressions

$email = "john@example.com";

$result = match (true) {
    preg_match('/^[a-zA-Z0-9]+@[a-zA-Z0-9]+\.[a-zA-Z]{2,}$/', $email) => "Valid email address",
    default => "Invalid email address",
};

echo $result; // Output: Valid email address

In this example, we utilize regular expressions for pattern matching within the match expression. The regular expression checks if the email address stored in the variable $email is valid. If it matches the pattern, the match expression returns “Valid email address”. Otherwise, it returns “Invalid email address”.

These examples provide a glimpse into the diverse applications of PHP match expressions. You can explore further and combine different conditions and patterns to suit your specific needs.

Here is the another example,

$input = "ABC123";

$result = match ($input) {
    preg_match('/^[a-zA-Z]+$/', $input) => "Alphabetic characters only",
    preg_match('/^[0-9]+$/', $input) => "Numeric characters only",
    default => "Mixed characters",
};

echo $result;  // Output: Alphabetic characters only

In this example, the match expression uses regular expressions to match patterns in the input string $input. By leveraging the power of regular expressions, you can easily handle different types of input and perform specific actions based on the detected pattern.

Comparison PHP match with Switch statements:

Let’s compare the match expression with traditional switch statements to highlight the advantages and differences between the two approaches.

Example:

Consider a scenario where you have a variable $dayOfWeek representing the current day of the week (e.g., Monday, Tuesday, etc.). You want to perform different actions based on the day of the week using either the match expression or a switch statement.

Using PHP Match Expression:

$dayOfWeek = "Monday";

$result = match ($dayOfWeek) {
    "Monday", "Tuesday", "Wednesday", "Thursday", "Friday" => "Weekday",
    "Saturday", "Sunday" => "Weekend",
    default => "Invalid day",
};

echo $result; // Output: Weekday

Using PHP Switch Statement:

$dayOfWeek = "Monday";

switch ($dayOfWeek) {
    case "Monday":
    case "Tuesday":
    case "Wednesday":
    case "Thursday":
    case "Friday":
        $result = "Weekday";
        break;
    case "Saturday":
    case "Sunday":
        $result = "Weekend";
        break;
    default:
        $result = "Invalid day";
        break;
}

echo $result; // Output: Weekday

The match expression offers a more concise syntax compared to switch statements. In the match expression, you can group multiple cases together, reducing the repetition of code. This results in cleaner and more readable code, especially when dealing with a large number of cases.

1. Conciseness: The match expression offers a more concise syntax compared to switch statements. In the match expression, you can group multiple cases together, reducing the repetition of code. This results in cleaner and more readable code, especially when dealing with a large number of cases.
2. No Fall-Through: In the match expression, there is no fall-through behavior like in switch statements. The match expression handles each case independently, eliminating the need for explicit break statements. This helps prevent unintended execution of multiple cases and eliminates the need for extra attention to ensure correct behavior.
3. Flexibility: The match expression provides greater flexibility for matching complex expressions and combining conditions using logical operators. It allows for dynamic case conditions and supports pattern matching with regular expressions. Switch statements, on the other hand, only allow for exact value matching.
4. Default Case Handling: Both the match expression and switch statements have a default case to handle unmatched conditions. In the match expression, we represent the default case using the default keyword, which offers a more intuitive and descriptive approach to handle unmatched cases.

Overall, the match expression offers a more concise syntax, eliminates fall-through issues, provides greater flexibility for complex matching conditions, and offers improved default case handling. These advantages make it a powerful and preferred choice over switch statements when working with conditional logic in PHP.