# Remplacer un switch par une expression match pour calculer une méthode d’expédition personnalisée

> PHP 8.0 a introduit l'expression match, plus stricte et plus concise qu'un switch classique. Voici comment refactoriser la logique conditionnelle d'une méthode WC_Shipping_Method sur mesure.

- Auteur : WordPress Développement
- Publié le : 2022-11-16
- Mis à jour le : 2022-11-16
- Catégorie : E-commerce
- URL : https://www.wpmoderne.fr/ecommerce/remplacer-switch-match-expression-calculer-methode-expedition/

## L’essentiel

- match compare les valeurs en typage strict, contrairement à switch
- Aucun break n'est nécessaire, match ne connaît pas la propagation entre branches
- Une branche default absente lève une erreur explicite plutôt qu'un silence

Douze branches `case`, autant d'instructions `break` à ne surtout pas oublier : la logique conditionnelle d'une méthode d'expédition personnalisée qui calcule un tarif selon la zone de destination finit souvent par ressembler à un bloc `switch` difficile à relire d'un coup d'œil. PHP 8.0 introduit l'expression `match`, une alternative plus concise et surtout plus sûre, qui élimine une catégorie entière de bugs liés à l'oubli d'un `break`.

Ce billet montre le refactoring d'une méthode d'expédition personnalisée héritant de `WC_Shipping_Method`, du `switch` classique vers l'expression `match`, sans entrer dans la construction du plugin d'expédition lui-même.

## Le point de départ : un switch qui grossit

Voici la logique typique d'une méthode `calculate_shipping()` qui applique un tarif selon une zone commerciale déterminée en amont :

```
public function calculer_tarif( string $zone ): float {
    switch ( $zone ) {
        case 'metropole':
            $tarif = 4.90;
            break;
        case 'corse':
            $tarif = 9.90;
            break;
        case 'outre-mer':
            $tarif = 14.90;
            break;
        default:
            $tarif = 19.90;
            break;
    }
    return $tarif;
}
```

Chaque branche oubliant son `break` laisse le flux d'exécution continuer vers la branche suivante, un comportement hérité du C historique qui surprend encore régulièrement, y compris des développeurs expérimentés relisant du code écrit rapidement.

## La même logique avec match

> L'essentiel à retenir : match compare les valeurs en typage strict, contrairement à switch ; Aucun break n'est nécessaire, match ne connaît pas la propagation entre branches ; Une branche default absente lève une erreur explicite plutôt qu'un silence

```
public function calculer_tarif( string $zone ): float {
    return match ( $zone ) {
        'metropole' => 4.90,
        'corse'     => 9.90,
        'outre-mer' => 14.90,
        default     => 19.90,
    };
}
```

L'expression `match` évalue chaque branche avec une comparaison stricte, équivalente à l'opérateur `===`, contrairement au `switch` qui utilise une comparaison lâche pouvant produire des correspondances inattendues entre types différents. Aucune instruction `break` n'est nécessaire : une seule branche s'exécute, jamais de propagation possible vers la suivante.

## Regrouper plusieurs valeurs sur une même branche

Pour des départements groupés sous une même tarification, `match` accepte une liste de valeurs séparées par une virgule sur une seule ligne :

```
return match ( $code_departement ) {
    '2A', '2B'          => 9.90,
    '971', '972', '973' => 14.90,
    default             => 4.90,
};
```

## Ce qui change vraiment côté fiabilité

- Une valeur qui ne correspond à aucune branche et pour laquelle `default` est absent déclenche une `UnhandledMatchError` explicite, plutôt qu'un silence renvoyant `null`
- Le typage strict des comparaisons élimine les correspondances involontaires entre une chaîne numérique et un entier
- Le code devient une expression qui retourne directement une valeur, sans variable intermédiaire à initialiser puis retourner en fin de méthode

## Le cas où match ne convient pas

Pour une logique de zone qui dépend de plusieurs conditions combinées, comme un poids ET une destination, `match` reste limité à une comparaison de valeur unique par branche : une structure conditionnelle classique, ou un tableau de règles évaluées séquentiellement, garde alors tout son intérêt plutôt que de forcer `match` dans un usage pour lequel il n'est pas prévu.

> Sur nos méthodes d'expédition personnalisées, la règle appliquée est simple : dès qu'une branche de zone tarifaire se limite à une correspondance de valeur unique, match remplace systématiquement le switch, sans exception.

## Un point de vigilance lors de la migration

La comparaison stricte de `match` peut révéler, au moment du refactoring, des cas jusque-là masqués par la comparaison lâche du `switch` d'origine. Une valeur de zone stockée comme entier quelque part dans le code, comparée à une chaîne dans les branches, provoquait auparavant une correspondance accidentelle qui fonctionnait par hasard ; avec `match`, cette même valeur tombe dans la branche `default`, ce qui oblige à corriger la source du type incohérent plutôt que de la laisser filer plus loin dans le calcul du tarif.

## En résumé

Le passage de `switch` à `match` pour une logique tarifaire de méthode d'expédition n'est pas qu'une question d'esthétique de code : la comparaison stricte et l'absence de propagation entre branches suppriment une catégorie entière d'erreurs silencieuses qui se glissaient facilement dans un `switch` mal relu.