Expresiones de coincidenciaMatch expressions

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.The match expression provides branching control that is based on the comparison of an expression with a set of patterns.

SintaxisSyntax

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

ComentariosRemarks

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.The pattern matching expressions allow for complex branching based on the comparison of a test expression with a set of patterns. 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.In the match expression, the test-expression is compared with each pattern in turn, and when a match is found, the corresponding result-expression is evaluated and the resulting value is returned as the value of the match expression.

La función de coincidencia de patrones mostrada en la sintaxis anterior es una expresión lambda en la que la coincidencia de patrones se realiza inmediatamente en el argumento.The pattern matching function shown in the previous syntax is a lambda expression in which pattern matching is performed immediately on the argument. La función de coincidencia de patrones que se muestra en la sintaxis anterior es equivalente a la siguiente.The pattern matching function shown in the previous syntax is equivalent to the following.

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: fun Palabra clave.For more information about lambda expressions, see Lambda Expressions: The fun Keyword.

Todo el conjunto de patrones debe cubrir todas las posibles coincidencias de la variable de entrada.The whole set of patterns should cover all the possible matches of the input variable. Con frecuencia, se usa el patrón de_carácter comodín () como último patrón para buscar coincidencias con los valores de entrada no coincidentes previamente.Frequently, you use the wildcard pattern (_) as the last pattern to match any previously unmatched input values.

En el código siguiente se muestran algunas de las formas en que match se usa la expresión.The following code illustrates some of the ways in which the match expression is used. Para obtener una referencia y ejemplos de todos los patrones posibles que se pueden usar, vea coincidencia de patrones.For a reference and examples of all the possible patterns that can be used, see Pattern Matching.

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

Protecciones en patronesGuards on patterns

Puede usar una when cláusula para especificar una condición adicional que la variable debe cumplir para que coincida con un patrón.You can use a when clause to specify an additional condition that the variable must satisfy to match a pattern. Este tipo de cláusula se conoce como protección.Such a clause is referred to as a guard. La expresión que sigue when a la palabra clave no se evalúa a menos que se haga una coincidencia con el patrón asociado a dicha protección.The expression following the when keyword is not evaluated unless a match is made to the pattern associated with that guard.

En el ejemplo siguiente se muestra el uso de una protección para especificar un intervalo numérico para un patrón de variable.The following example illustrates the use of a guard to specify a numeric range for a variable pattern. Tenga en cuenta que se combinan varias condiciones mediante el uso de operadores booleanos.Note that multiple conditions are combined by using Boolean operators.

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 los valores distintos de los literales no se pueden usar en when el modelo, debe utilizar una cláusula si tiene que comparar alguna parte de la entrada con un valor.Note that because values other than literals cannot be used in the pattern, you must use a when clause if you have to compare some part of the input against a value. Esto se muestra en el código siguiente:This is shown in the following code:

// 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 modelo de Unión está incluido en una protección, la protección se aplica a todos los patrones, no solo al último.Note that when a union pattern is covered by a guard, the guard applies to all of the patterns, not just the last one. Por ejemplo, según el código siguiente, la protección when a > 12 se aplica tanto A a a B acomo a:For example, given the following code, the guard when a > 12 applies to both A a and 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énSee also