Expressies vergelijken

  • Artikel

De match expressie biedt vertakkingsbesturingselement dat is gebaseerd op de vergelijking van een expressie met een set patronen.

Syntaxis

// 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
| ...

Opmerkingen

Met de patroonkoppelingsexpressies kunnen complexe vertakkingen worden uitgevoerd op basis van de vergelijking van een testexpressie met een set patronen. In de match expressie wordt de testexpressie vergeleken met elk patroon en wanneer er een overeenkomst wordt gevonden, wordt de bijbehorende resultaatexpressie geëvalueerd en wordt de resulterende waarde geretourneerd als de waarde van de overeenkomstexpressie .

De patroonkoppelingsfunctie die in de vorige syntaxis wordt weergegeven, is een lambda-expressie waarin patroonkoppeling direct op het argument wordt uitgevoerd. De patroonkoppelingsfunctie die in de vorige syntaxis wordt weergegeven, komt overeen met het volgende.

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

Zie Lambda-expressies: Het fun trefwoord voor meer informatie over lambda-expressies.

De hele set patronen moet alle mogelijke overeenkomsten van de invoervariabele omvatten. Vaak gebruikt u het jokertekenpatroon (_) als laatste patroon om eventuele eerder niet-overeenkomende invoerwaarden te vinden.

De volgende code illustreert een aantal manieren waarop de match expressie wordt gebruikt. Zie Patroonkoppeling voor een verwijzing en voorbeelden van alle mogelijke patronen die kunnen worden gebruikt.

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

Bewakers op patronen

U kunt een when component gebruiken om een extra voorwaarde op te geven waaraan de variabele moet voldoen om aan een patroon te voldoen. Een dergelijke clausule wordt een bewaker genoemd. De expressie na het when trefwoord wordt niet geëvalueerd, tenzij er een overeenkomst wordt gemaakt met het patroon dat aan die guard is gekoppeld.

In het volgende voorbeeld ziet u het gebruik van een bewaker om een numeriek bereik voor een variabel patroon op te geven. Houd er rekening mee dat meerdere voorwaarden worden gecombineerd met booleaanse operatoren.

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

Houd er rekening mee dat omdat andere waarden dan letterlijke waarden niet in het patroon kunnen worden gebruikt, u een when component moet gebruiken als u een deel van de invoer moet vergelijken met een waarde. Dit wordt weergegeven in de volgende code:

// 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

Houd er rekening mee dat wanneer een samenvoegpatroon wordt gedekt door een bewaker, de bewaker van toepassing is op alle patronen, niet alleen op de laatste. Als u bijvoorbeeld de volgende code hebt, is de beveiliging when a > 41 van toepassing op zowel als A aB 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

Zie ook