Vergleichsausdrücke

  • Artikel

Beschreibt den match-Ausdruck, der die Verzweigungssteuerung bereitstellt, die auf dem Vergleich eines Ausdrucks mit einer Reihe von Mustern basiert.

Syntax

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

Bemerkungen

Die Musterabgleichsausdrücke ermöglichen eine komplexe Verzweigung basierend auf dem Vergleich eines Testausdrucks mit einer Reihe von Mustern. Im match-Ausdruck wird der Testausdruck mit den einzelnen Mustern verglichen, und wenn eine Übereinstimmung gefunden wird, wird der entsprechende Ergebnisausdruck ausgewertet, und der resultierende Wert wird als Wert des Übereinstimmungsausdrucks zurückgegeben.

Die in der vorherigen Syntax gezeigte Mustervergleichsfunktion ist ein Lambda-Ausdruck, in dem der Musterabgleich sofort für das Argument ausgeführt wird. Die in der vorherigen Syntax gezeigte Mustervergleichsfunktion entspricht folgendem.

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

Weitere Informationen zu Lambdaausdrücken finden Sie unter Lambdaausdrücke: Dasfun Schlüsselwort.

Der gesamte Satz von Mustern sollte alle möglichen Übereinstimmungen der Eingabevariable abdecken. Häufig verwenden Sie das Wildcardmuster (_) als letztes Muster, um allen zuvor nicht übereinstimmenden Eingabewerten zu entsprechen.

Der folgende Code veranschaulicht einige der Möglichkeiten, wie der match-Ausdruck verwendet wird. Eine Referenz und Beispiele für alle möglichen Muster, die verwendet werden können, finden Sie unter Musterabgleich.

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

Schutz vor Mustern

Sie können eine when-Klausel verwenden, um eine zusätzliche Bedingung anzugeben, die die Variable erfüllen muss, um einem Muster zu entsprechen. Eine solche Klausel wird als Schutz bezeichnet. Der Ausdruck, der auf das when-Schlüsselwort folgt, wird nur ausgewertet, wenn eine Übereinstimmung mit dem diesem Schutz zugeordneten Muster erfolgt.

Im folgenden Beispiel wird die Verwendung eines Schutzes veranschaulicht, um einen numerischen Bereich für ein Variablenmuster anzugeben. Beachten Sie, dass mehrere Bedingungen mit booleschen Operatoren kombiniert werden.

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

Beachten Sie, dass Werte, die keine Literale sind, nicht im Muster verwendet werden können, eine when-Klausel verwenden müssen, wenn Sie einen Teil der Eingabe mit einem Wert vergleichen müssen. Dies wird im folgenden Code veranschaulicht:

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

Beachten Sie, dass der Schutz, wenn ein Union-Muster von einem Wachen abgedeckt wird, auf alle Muster und nicht nur auf die letzte angewendet wird. Bei folgendem Code gilt beispielsweise der Schutzwhen a > 41 sowohl für A a als auch 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

Weitere Informationen