Expresiones de coincidencia
La match expresión proporciona control de bifurcación que se basa 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 bifurcaciones complejas basadas 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 se devuelve el valor resultante como 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 cubrir todas las coincidencias posibles de la variable de entrada. Con frecuencia, se usa el patrón comodín ( ) como último patrón para coincidir con _ cualquier valor de entrada previamente no coincidente.
En el código siguiente se muestran algunas de las formas en que se match usa la expresión. Para obtener una referencia y ejemplos de todos los patrones posibles que se pueden usar, vea 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
Protección de patrones
Puede usar una cláusula when para especificar una condición adicional que la variable debe cumplir para que coincida con un patrón. Esta cláusula se conoce como protección. La expresión que sigue a la palabra clave no se evalúa a menos que se haga una coincidencia when con el patrón asociado a esa protección.
En el ejemplo siguiente se muestra el uso de una protecció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 valores distintos de literales en el patrón, debe usar una cláusula si tiene que comparar alguna parte de la entrada when 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 está cubierto por una protección, la protección se aplica a todos los patrones, no solo al último. Por ejemplo, dado el código siguiente, la protección when a > 12 se aplica a y A a 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