TOC

Correspondência de padrões em seqüências de caracteres no Groovy

Correspondência de padrões em seqüências de caracteres no Groovy

1. Visão geral

Neste artigo, veremos os recursos da linguagem Groovy para correspondência de padrões em Strings.

Veremos como a abordagem de baterias incluídas do Groovy nos fornece uma sintaxe poderosa e ergonômica para nossas necessidades básicas de correspondência de padrões.

2. Operador Padrão

A linguagem Groovy introduz o chamado operador de padrão~. Este operador pode ser considerado um atalho sintático para o métodojava.util.regex.Pattern.compile(string) do Java.

Vamos dar uma olhada na prática como parte de um testeSpock: 

def "pattern operator example"() {
    given: "a pattern"
    def p = ~'foo'

    expect:
    p instanceof Pattern

    and: "you can use slashy strings to avoid escaping of blackslash"
    def digitPattern = ~/\d*/
    digitPattern.matcher('4711').matches()
}

Isso também é muito conveniente, mas veremos que esse operador é apenas a linha de base para alguns outros operadores ainda mais úteis.

3. Operador de correspondência

Na maioria das vezes, e especialmente ao escrever testes, não estamos realmente interessados ​​em criar objetosPattern, mas em vez disso, queremos verificar se aString corresponde a uma determinada expressão regular (ouPattern). Groovy, portanto, também contém o operador de correspondência==~.

Ele retornabooleane executa uma correspondência estrita com a expressão regular especificada. Basicamente, é um atalho sintático ao invés de chamarPattern.matches(regex, string).

Mais uma vez, examinaremos isso na prática como parte de um testeSpock: 

def "match operator example"() {
    expect:
    'foobar' ==~ /.*oba.*/

    and: "matching is strict"
    !('foobar' ==~ /foo/)
}

4. Localizar Operador

O último operador Groovy no contexto de correspondência de padrões é o operador find~=. Nesse caso, o operador criará e retornará diretamente uma instânciajava.util.regex.Matcher.

Podemos agir sobre essa instânciaMatcher, é claro, acessando seus métodos Java API conhecidos. Além disso, também podemos acessar grupos correspondentes usando uma matriz multidimensional.

E isso não é tudo - a instânciaMatcher forçará automaticamente para um tipoboolean chamando seu métodofind() se usado como um predicado. Citando os documentos oficiais do Groovy, isso significa que "o operador = ~ é consistente com o uso simples do operador = ~ do Perl".

Aqui, vemos o operador em ação: 

def "find operator example"() {
    when: "using the find operator"
    def matcher = 'foo and bar, baz and buz' =~ /(\w+) and (\w+)/

    then: "will find groups"
    matcher.size() == 2

    and: "can access groups using array"
    matcher[0][0] == 'foo and bar'
    matcher[1][2] == 'buz'

    and: "you can use it as a predicate"
    'foobarbaz' =~ /bar/
}

5. Conclusão

Vimos como a linguagem Groovy nos dá acesso aos recursos Java integrados em relação às expressões regulares de uma maneira muito conveniente.

Oofficial Groovy documentation também contém alguns exemplos concisos sobre este tópico. É especialmente legal se você considerar que os exemplos de código nos documentos são executados como parte da construção da documentação.

Como sempre, exemplos de código podem ser encontrados emGitHub.

Related