Espressioni di corrispondenza

  • Articolo

L'espressione match fornisce un controllo di diramazione basato sul confronto di un'espressione con un set di modelli.

Sintassi

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

Osservazioni:

Le espressioni di ricerca dei criteri di ricerca consentono la diramazione complessa in base al confronto di un'espressione di test con un set di modelli. Nell'espressione, l'espressione match test viene confrontata con ogni criterio a sua volta e quando viene trovata una corrispondenza, viene valutata l'espressione di risultato corrispondente e il valore risultante viene restituito come valore dell'espressione di corrispondenza.

La funzione di ricerca di criteri mostrata nella sintassi precedente è un'espressione lambda in cui i criteri di ricerca vengono eseguiti immediatamente sull'argomento. La funzione di ricerca di criteri illustrata nella sintassi precedente equivale alla seguente.

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

Per altre informazioni sulle espressioni lambda, vedere Espressioni lambda: parola fun chiave.

L'intero set di modelli deve coprire tutte le possibili corrispondenze della variabile di input. Spesso si usa il criterio con caratteri jolly (_) come ultimo modello per trovare le corrispondenze con i valori di input precedentemente non corrispondenti.

Il codice seguente illustra alcuni dei modi in cui viene usata l'espressione match . Per informazioni di riferimento ed esempi di tutti i possibili modelli che è possibile usare, vedere Criteri di ricerca.

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

Guardie su modelli

È possibile usare una clausola per specificare una when condizione aggiuntiva che la variabile deve soddisfare per corrispondere a un criterio. Tale clausola viene definita guardia. L'espressione che segue la when parola chiave non viene valutata a meno che non venga effettuata una corrispondenza con il criterio associato a tale protezione.

Nell'esempio seguente viene illustrato l'uso di una protezione per specificare un intervallo numerico per un modello di variabile. Si noti che più condizioni vengono combinate usando operatori booleani.

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

Si noti che poiché non è possibile usare valori diversi dai valori letterali nel modello, è necessario usare una when clausola se è necessario confrontare parte dell'input con un valore. Questo comportamento è illustrato nel codice seguente:

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

Si noti che quando un modello di unione è coperto da una protezione, la protezione si applica a tutti i modelli, non solo all'ultimo. Ad esempio, dato il codice seguente, la protezione when a > 41 si applica sia a che B aa A 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

Vedi anche