1. Información general
En este artículo, veremos las características del lenguaje Groovy para la coincidencia de patrones en Strings.
Veremos cómo el enfoque de Groovy con baterías incluidas nos proporciona una sintaxis potente y ergonómica para nuestras necesidades básicas de coincidencia de patrones.
2. Operador de patrón
El lenguaje Groovy introduce el llamado operador de patrón ~ . Este operador puede considerarse un atajo sintáctico de azúcar para el método java.util.regex.Pattern.compile (string) de Java .
Veámoslo en la práctica como parte de una prueba de Spock :
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() }Esto también es bastante conveniente, pero veremos que este operador es simplemente la línea de base para algunos otros operadores aún más útiles.
3. Operador de partidos
La mayoría de las veces, y especialmente cuando escribimos pruebas, no estamos realmente interesados en crear objetos de patrón , sino que queremos verificar si una cadena coincide con una determinada expresión regular (o patrón ). Groovy, por lo tanto, también contiene el operador de coincidencia == ~ .
Devuelve un valor booleano y realiza una coincidencia estricta con la expresión regular especificada. Básicamente, es un atajo sintáctico sobre llamar a Pattern.matches (regex, string) .
Nuevamente, lo veremos en la práctica como parte de una prueba de Spock :
def "match operator example"() { expect: 'foobar' ==~ /.*oba.*/ and: "matching is strict" !('foobar' ==~ /foo/) }4. Buscar operador
El último operador Groovy en el contexto de la coincidencia de patrones es el operador de búsqueda ~ = . En este caso, el operador creará y devolverá directamente una instancia de java.util.regex.Matcher .
Podemos actuar sobre esta instancia de Matcher , por supuesto, accediendo a sus conocidos métodos API de Java. Pero además, también podemos acceder a grupos coincidentes mediante una matriz multidimensional.
Y eso no es todo: la instancia de Matcher coaccionará automáticamente a un tipo booleano llamando a su método find () si se usa como predicado. Citando los documentos oficiales de Groovy, esto significa que “el operador = ~ es consistente con el uso simple del operador = ~ de Perl”.
Aquí vemos al operador en acción:
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. Conclusión
Hemos visto cómo el lenguaje Groovy nos da acceso a las funciones integradas de Java con respecto a las expresiones regulares de una manera muy conveniente.
La documentación oficial de Groovy también contiene algunos ejemplos concisos sobre este tema. Es especialmente bueno si considera que los ejemplos de código en los documentos se ejecutan como parte de la compilación de la documentación.
Como siempre, los ejemplos de código se pueden encontrar en GitHub.