Expresiones match

  • Artículo

La expresión match proporciona control de rama 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
| ...

Comentarios

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 expresión match, test-expression se compara con cada patrón, y cuando se encuentra una coincidencia, se evalúa el valor result-expression correspondiente y el valor resultante se devuelve como el valor de la expresión match.

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 que aparece a continuación.

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

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

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

En el código siguiente se muestran algunas de las formas en que se usa la expresión match. 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 cláusula when para especificar una condición adicional que la variable debe satisfacer para que coincida con un patrón. Esta cláusula se conoce como cláusula de restricción. La expresión que sigue a la palabra clave when no se evaluará a menos que se establezca una coincidencia con el patrón asociado a esa cláusula de restricción.

En el ejemplo siguiente se muestra el uso de una cláusula de restricción para especificar un intervalo numérico para un patrón de 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 unos valores distintos de los literales en el patrón, deberá usar una cláusula when 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 cláusula de restricción when a > 41 se aplica a A a y 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

Vea también