Expressions match

  • Article

L’expression match fournit le contrôle de branchement basé sur la comparaison d’une expression à un jeu de modèles.

Syntaxe

// Match expression.
match test-expression with
| pattern1 [ when condition ] -> result-expression1
| pattern2 [ when condition ] -> result-expression2
| ...

// Pattern matching function.
function
| pattern1 [ when condition ] -> result-expression1
| pattern2 [ when condition ] -> result-expression2
| ...

Notes

Les expressions de critères spéciaux permettent de créer des branches complexes basées sur la comparaison d’une expression de test avec un ensemble de modèles. Dans l’expression match, la test-expression est comparée à chaque modèle tour à tour, et lorsqu’une correspondance est trouvée, la result-expression correspondante est évaluée et la valeur résultante est retournée en tant que valeur de l’expression match.

La fonction de critères spéciaux indiquée dans la syntaxe précédente est une expression lambda dans laquelle les critères spéciaux sont immédiatement effectués sur l’argument. La fonction de critères spéciaux indiquée dans la syntaxe précédente est équivalente à la suivante.

fun arg ->
    match arg with
    | pattern1 [ when condition ] -> result-expression1
    | pattern2 [ when condition ] -> result-expression2
    | ...

Pour plus d’informations sur les expressions lambda, voir Expressions lambda : le mot clé fun.

L’ensemble des modèles doit couvrir toutes les correspondances possibles de la variable d’entrée. Généralement, vous utilisez le modèle de caractère générique (_) comme dernier modèle pour faire correspondre toutes les valeurs d’entrée précédemment incompatibles.

Le code suivant illustre certaines des façons dont l’expression match est utilisée. Pour obtenir des références et des exemples de tous les modèles possibles qui peuvent être utilisés, consultez Critères spéciaux.

let list1 = [ 1; 5; 100; 450; 788 ]

// Pattern matching by using the cons pattern and a list
// pattern that tests for an empty list.
let rec printList listx =
    match listx with
    | head :: tail -> printf "%d " head; printList tail
    | [] -> printfn ""

printList list1

// Pattern matching with multiple alternatives on the same line.
let filter123 x =
    match x with
    | 1 | 2 | 3 -> printfn "Found 1, 2, or 3!"
    | a -> printfn "%d" a

// The same function written with the pattern matching
// function syntax.
let filterNumbers =
    function | 1 | 2 | 3 -> printfn "Found 1, 2, or 3!"
             | a -> printfn "%d" a

Protections sur les modèles

Vous pouvez utiliser une clause when pour spécifier une condition supplémentaire que la variable doit satisfaire pour correspondre à un modèle. Une telle clause est appelée protection. L’expression qui suit le mot clé when n’est pas évaluée, sauf si une correspondance est établie avec le modèle associé à cette protection.

L’exemple suivant illustre l’utilisation d’une protection pour spécifier une plage numérique pour un modèle de variable. Notez que plusieurs conditions sont combinées à l’aide d’opérateurs booléens.

let rangeTest testValue mid size =
    match testValue with
    | var1 when var1 >= mid - size/2 && var1 <= mid + size/2 -> printfn "The test value is in range."
    | _ -> printfn "The test value is out of range."

rangeTest 10 20 5
rangeTest 10 20 10
rangeTest 10 20 40

Notez que puisque les valeurs autres que les littéraux ne peuvent pas être utilisées dans le modèle, vous devez utiliser une clause when si vous devez comparer une partie de l’entrée à une valeur. Ceci est illustré dans le code suivant :

// This example uses patterns that have when guards.
let detectValue point target =
    match point with
    | (a, b) when a = target && b = target -> printfn "Both values match target %d." target
    | (a, b) when a = target -> printfn "First value matched target in (%d, %d)" target b
    | (a, b) when b = target -> printfn "Second value matched target in (%d, %d)" a target
    | _ -> printfn "Neither value matches target."
detectValue (0, 0) 0
detectValue (1, 0) 0
detectValue (0, 10) 0
detectValue (10, 15) 0

Notez que lorsqu’un modèle d’union est couvert par une protection, celle-ci s’applique à tous les modèles, pas seulement au dernier. Par exemple, avec le code suivant, la protection when a > 41 s’applique à A a et à B a :

type Union =
    | A of int
    | B of int

let foo() =
    let test = A 42
    match test with
    | A a
    | B a when a > 41 -> a // the guard applies to both patterns
    | _ -> 1

foo() // returns 42

Voir aussi