Compartilhar via

Expressões match

A match expressão fornece controle de ramificação baseado na comparação de uma expressão com um conjunto de padrões.

Sintaxe

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

Observações

As expressões de correspondência de padrões permitem ramificação complexa com base na comparação de uma expressão de teste com um conjunto de padrões. match Na expressão, a expressão de teste é comparada com cada padrão por sua vez e, quando uma correspondência é encontrada, a expressão de resultado correspondente é avaliada e o valor resultante é retornado como o valor da expressão de correspondência.

A função de correspondência de padrões mostrada na sintaxe anterior é uma expressão lambda na qual a correspondência de padrões é executada imediatamente no argumento. A função de correspondência de padrões mostrada na sintaxe anterior é equivalente à seguinte.

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

Para obter mais informações sobre expressões lambda, consulte Expressões lambda: a fun palavra-chave.

Todo o conjunto de padrões deve abranger todas as correspondências possíveis da variável de entrada. Com frequência, você usa o padrão curinga (_) como o último padrão para corresponder a qualquer valor de entrada sem correspondência anterior.

O código a seguir ilustra algumas das maneiras pelas quais a match expressão é usada. Para obter uma referência e exemplos de todos os padrões possíveis que podem ser usados, consulte Correspondência de Padrões.

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

Guardas em padrões

Você pode usar uma when cláusula para especificar uma condição adicional que a variável deve satisfazer para corresponder a um padrão. Essa cláusula é conhecida como um guarda. A expressão que segue a palavra-chave when não é avaliada, a menos que haja uma correspondência com o padrão associado a esse guarda.

O exemplo a seguir ilustra o uso de um guarda para especificar um intervalo numérico para um padrão de variável. Observe que várias condições são combinadas usando operadores boolianos.

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

Observe que, como valores diferentes de literais não podem ser usados no padrão, você deve usar uma when cláusula se precisar comparar alguma parte da entrada com um valor. Isso é mostrado no seguinte código:

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

Observe que, quando um padrão de união é coberto por um guarda, o guarda se aplica a todos os padrões, não apenas ao último. Por exemplo, considerando o código a seguir, o guarda when a > 41 se aplica a ambos A a e 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 também