Partager via

Expressions de correspondance

L’expression match fournit un contrôle de branchement basé sur la comparaison d’une expression avec un ensemble 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
| ...

Remarques

Les expressions de correspondance de modèle permettent une branche complexe basée sur la comparaison d’une expression de test avec un ensemble de modèles. Dans l’expression match , l’expression de test est comparée à chaque modèle à son tour, et lorsqu’une correspondance est trouvée, l’expression de résultat correspondante est évaluée et la valeur résultante est retournée comme valeur de l’expression de correspondance.

La fonction de correspondance de modèle indiquée dans la syntaxe précédente est une expression lambda dans laquelle la correspondance de modèle est effectuée immédiatement sur l’argument. La fonction de correspondance de modèle indiquée dans la syntaxe précédente équivaut à ce qui suit.

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

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

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

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

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 des modèles

Vous pouvez utiliser une when clause pour spécifier une condition supplémentaire que la variable doit satisfaire pour correspondre à un modèle. Une telle clause est appelée une protection L’expression qui suit le when mot clé n’est pas évaluée, sauf si une correspondance est faite au 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, étant donné que les valeurs autres que les littéraux ne peuvent pas être utilisées dans le modèle, vous devez utiliser une when clause 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, étant donné le code suivant, le guard when a > 41 s’applique à la fois A a et B a:

type Union =
    | A of int
    | B of int

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

foo() // returns 1

Voir aussi

  • Last updated on