Sintassi di Groovy per la corrispondenza delle espressioni regolari

Question

Qual è l'equivalente di Groovy del seguente codice Perl?

my $txt = "abc : groovy : def"; 
if ($txt =~/: (.+?) : /) { 
    my $match = $1; 
    print "MATCH=$match\n"; 
    # should print "MATCH=groovy\n" 
} 

So che c'è più di un modo per farlo (compresa la strada normale Java) - ma che cosa è la "via Groovy" di farlo?

Questo è un modo per farlo, ma ci si sente un po 'goffi, specialmente la notazione degli array (m[0][1]) che sembra un po' strana. C'è un modo migliore di farlo? In caso contrario, descrivere la logica alla base dello m[0][1].

def txt = "java : groovy : grails" 
if ((m = txt =~/: (.+?) :/)) { 
    def match = m[0][1] 
    println "MATCH=$match" 
} 

Answer 1

Questa è stata la partita più vicina al codice Perl che ho potuto realizzare:

def txt = "abc : groovy : def" 
if ((m = txt =~/: (.+?) : /)) { 
    def match = m.group(1) 
    println "MATCH=$match" 
} 

Answer 2

Questa è la mia migliore comprensione di come fare questa sintassi Groovy usando (ma si veda la risposta di lfaraone troppo):

import java.util.regex.Matcher 

def txt = 'abc : groovy : def' 
if (txt =~ ~/ : (.+?) : /) { 
    def match = Matcher.lastMatcher[0][1] 
    println "MATCH=$match" 
} 

Answer 3

m[0] è il primo oggetto di corrispondenza.
m[0][0] è tutto ciò che corrisponde a questa partita.
m[0][1] è la prima cattura in questa partita.
m[0][2] è la seconda cattura in questa partita.

In base a quello che ho letto (non fare il programma in Groovy o avere una copia a portata di mano), dato

def m = "barbaz" =~ /(ba)([rz])/; 

m[0][0] sarà "bar"
m[0][1] sarà "ba"
m[0][2] sarà "r"
m[1][0] sarà "baz"
m[1][1] sarà "ba"
m[1][2] sarà "z"

non potevo stare senza sapere se avevo ragione o no, così ho scaricato Groovy e ha scritto un esempio:

def m = "barbaz" =~ /(ba)([rz])/; 

println "m[0][0] " + m[0][0] 
println "m[0][1] " + m[0][1] 
println "m[0][2] " + m[0][2] 
println "m[1][0] " + m[1][0] 
println "m[1][1] " + m[1][1] 
println "m[1][2] " + m[1][2]