What are the differences between match and switch in PHP8?

Question

PHP 8 looks like have already been launched, with a series of changes and new things. Among the changes, they created the expression match.

I saw that she reminds a little of the old and traditional switch, but it seems a little different.

Example of documentation:

$age = 23;

$result = match (true) {
    $age >= 65 => 'senior',
    $age >= 25 => 'adult',
    $age >= 18 => 'young adult',
    default => 'kid',
};

var_dump($result); // string(11) "young adult"

I’d like to know:

• What are the main differences between switch and match?
• This functionality replaces switch or it’s just different?

Answer 1

The statement switch

Basically, the switch is a statement (in English statement) which allows the programmer to control the code flow. The switch decides which "arms" will be executed based on a sequence of comparisons.

The switch receives a principal value, which will be compared by the value placed on each case. In all cases where the equality comparison is true, body of the case will be executed.

An example:

<?php
$a = 5;
$b = 6;
$operator = '*';

switch ($operator) {
    case '+':
        echo 'Soma: ' . $a + $b;
        break;
    case '-':
        echo 'Subtração: ' . $a - $b;
        break;
    case '*':
        echo 'Multiplicação: ' . $a * $b;
        break;
    case '/':
        // Cuidado com a divisão por zero.
        echo 'Divisão: ' . $a / $b;
        break;
    default:
        echo 'Operação inválida.';
}

Note that:

• The switch was used to change the code flow, depending on the variable $operator.
• I used the break at the end of each case (except in the default). This is necessary because, without them, the switch execute all the cases below the one that was truly evaluated. This behavior is called switch fallthrough.

It can be stated, therefore, that the main objective of a switch is to control the flow of a code by comparing the equal value of the switch to each case.

Eventually, to replace a sequence of several if/elses by the declaration switch, some programmers use switch (true) as a ruse to make each case is executed from a true value assessment (since each case will be implicitly compared with true, the expression passed to the switch). However, this practice can be classified as "gambiarra", since it uses the switch to do something that a sequence of if/else makes - the economy of lines is also rarely significant to the point of justifying such use.

---

The expression match

Unlike the switch, the match is a expression and therefore should always return a value. Therefore, the use of match will now be recommended when you have to return a value.

Let’s look at another example of switch, using an external variable to store the computed value:

<?php
$a = 5;
$b = 6;
$operator = '*';

$result = 0; // Armazenaremos o resultado das computações aqui.
switch ($operator) {
    case '+': $result = $a + $b; break;
    case '-': $result = $a - $b; break;
    case '*': $result = $a * $b; break;
    case '/': $result = $a / $b; break;
}

echo "O resultado da operação com o operador `$operator` é $result.";

Note that, as switch was made for control flow, if we want to use it to compute a value, we have to keep a variable external. I did it with $result, to store the result obtained by the implemented "calculator".

In this type of scenario, the switch can be elegantly replaced by an expression match:

<?php
$a = 5;
$b = 6;
$operator = '*';

$result = match ($operator) {
    '+' => $a + $b,
    '-' => $a - $b,
    '*' => $a * $b,
    '/' => $a / $b
};

echo "O resultado da operação com o operador `$operator` é $result.";

The code output is the same, but the difference is striking. Note that as match is an expression, unlike switch, the use of semicolons at the end of the expression is mandatory.

Note also that although the switch allows the use of a default case, it ends up being optional (as I did in the example above). No match, however, although you have the option of using a default case, in case you do not include it, an exception of type UnhandledMatchError will be released if an expression without match is found. This shows that match always return a value. Otherwise, you should handle this exception. More details in the documentation.

Differences

In general, the differences are:

• The switch is a statement and match is an expression. Therefore, switch by itself is not able to produce a value when being evaluated. Already match, yes.
• No coercion of types. When comparing the values of each case, switch uses the operator == (which makes automatic conversion of types). Already the match, when making the evaluations, uses === (which does not coerce types).
• The switch allows several cases are executed next (if you do not use the break). It’s called fallthrough. In reverse, match does not allow this, allowing only one arm to be evaluated at a time.
• The match is exhaustive. That is, if you find a condition that does not fit any of the arms, the exception UnhandledMatchError. The switch does not have something of the kind and allows not all possible cases to be dealt with (usually this occurs by failure of the programmer).

To page of RFC details each of these differences. Refer to for more details.

It’s far more powerful than a switch. It also helps, in a way, more inattentive programmers, since it has "native defense mechanisms". However, I couldn’t find a use case that the switch didn’t realize - it turns out switch (when used to produce value) is a little more verbose, but this is rarely a problem.

Now it can be said that it is more correct to use switch only to control flow. In the possibility of flow control having to generate a value, match probably be the most appropriate.

Basically, functional programming has risen in popularity recently and Pattern matching is a very common feature among functional languages. Thus, PHP, probably not to "lag behind", seems to have decided copy these resources. Some say it is good, because it modernizes the language. Others may think it is not. In a way, both sides are right. Introducing this type of resource may facilitate certain use cases, but is it really worth introducing a new type of syntactic construction in the language?

Answer 2

The differences: The match is a shorter expression that you don’t need to use break in its structure, you do not need to necessarily declare variables for each case, to return something, just tell directly what it will return, it can combine different expressions using comma, it is No type coercion, ie it is as if it used === instead of ==, Example:

$message = match ($statuscode) {
   200, 301 => null,
   404 => 'not found',
   500 => 'ERROR',
   default => 'unknown status code',
};

Unknown values will throw errors:

$statuscode = 1000000
$retorno = match($stauscode){
   500000 => 'Meio Milhão',
};

In that case you will return UnhandledMatchError

You can see more details and specifics about match on: https://www.php.net/manual/en/control-structures.match.php

Already the switch is much more flexible, especially at the level of comparison, it makes a series of comparisons to decide which code snippets, 'Arms', will be executed, in it you have to use break, so that when a condition is met the switch execution stops. Example:

switch (true) {
case ($a === true):
    echo '$a is true';
    break;
case ($a === false):
    echo '$a is false';
    break;
case ($a === 0):
    echo '$a is 0';
    break;
}

You can see more about switch in the PHP documentation: https://www.php.net/manual/en/control-structures.switch.php