Compartir a través de

Expresiones de coincidencia

La match expresión proporciona un control de bifurcación basado en la comparación de una expresión con un conjunto de patrones.

Sintaxis

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

Observaciones

Las expresiones de coincidencia de patrones permiten la bifurcación compleja basada en la comparación de una expresión de prueba con un conjunto de patrones. En la match expresión, test-expression se compara con cada patrón a su vez y, cuando se encuentra una coincidencia, se evalúa la expresión de resultado correspondiente y el valor resultante se devuelve como el valor de la expresión de coincidencia.

La función de coincidencia de patrones que se muestra en la sintaxis anterior es una expresión lambda en la que la coincidencia de patrones se realiza inmediatamente en el argumento . La función de coincidencia de patrones que se muestra en la sintaxis anterior es equivalente a la siguiente.

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

Para obtener más información sobre las expresiones lambda, vea Expresiones lambda: La fun palabra clave .

Todo el conjunto de patrones debe abarcar todas las posibles coincidencias de la variable de entrada. Con frecuencia, se usa el patrón comodín (_) como último patrón para que coincida con los valores de entrada no coincidentes anteriormente.

En el código siguiente se muestran algunas de las formas en que se usa la match expresión. Para obtener una referencia y ejemplos de todos los patrones posibles que se pueden usar, consulte Coincidencia de patrones.

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

Cláusulas de restricción en patrones

Puede usar una when cláusula para especificar una condición adicional que la variable debe satisfacer para que coincida con un patrón. Esta cláusula se conoce como protección. La expresión que sigue a la when palabra clave no se evalúa a menos que se realice una coincidencia con el patrón asociado a esa protección.

En el ejemplo siguiente se muestra el uso de una guarda para especificar un intervalo numérico para el patrón de una variable. Tenga en cuenta que se combinan varias condiciones mediante operadores booleanos.

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

Tenga en cuenta que, dado que no se pueden usar valores distintos de literales en el patrón, debe usar una when cláusula si tiene que comparar parte de la entrada con un valor. Esto se muestra en el código siguiente:

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

Tenga en cuenta que cuando un patrón de unión se incluye en una cláusula de restricción, esta se aplica a todos los patrones, no solo al último. Por ejemplo, dado el código siguiente, la guard when a > 41 se aplica tanto a A a como a 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

Consulte también