Groovy de la syntaxe d'expression régulière correspondant

Quel est le Groovy équivalent de la suite du code Perl?

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

Je sais qu'il ya plus d'une façon de le faire (y compris la régulière Java cours) - mais qu'est-ce que le "Groovy façon" de faire cela?

C'est une façon de le faire, mais il se sent un peu mal à l'aise - en particulier la notation de tableau (m[0][1]) qui se sent un peu étrange. Est-il une meilleure façon de le faire? Si ce n' - veuillez décrire la logique derrière m[0][1].

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

InformationsquelleAutor knorv | 2009-04-18

groovy regex

78

m[0] est le premier match de l'objet.

m[0][0] est tout ce qui correspond dans ce match.

m[0][1] est la première capture dans ce match.

m[0][2] est la deuxième capture dans ce match.

Après ce que j'ai lu (je ne programme en Groovy, ou d'en avoir une copie à portée de main), étant donné
```
def m = "barbaz" =~ /(ba)([rz])/;
```
m[0][0] sera "bar"

m[0][1] sera "ba"

m[0][2] sera "r"

m[1][0] sera "baz"

m[1][1] sera "ba"

m[1][2] sera "z"

Je ne pouvais pas supporter de ne pas savoir si j'avais raison ou pas, j'ai donc téléchargé groovy et a écrit un exemple:
```
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]
```
- Merci pour votre réponse. Pourriez-vous donner un exemple quand il pourrait y avoir plusieurs correspondre à des objets (m[1])?
- Donc, il y a un implicite /g pour le multi-match? Hein
InformationsquelleAutor Chas. Owens
19

C'était la correspondance la plus proche du code Perl que j'ai pu réaliser:
```
def txt = "abc : groovy : def"
if ((m = txt =~ / : (.+?) : /)) {
  def match = m.group(1)
  println "MATCH=$match"
}
```
- Que sera cette impression? Paraît compliquée à l'œil nu.
- Comment cela fonctionne? À quoi ça sert? Paraît compliquée à l'œil nu.
- pourquoi avez-vous envelopper l' m = txt =~ / : (.+?) : / partie dans un if?
- parce que =~ est un opérateur regex et si rien ne sera trouvée m serait nulle.
- Si vous utilisez @TypeChecked ou @CompileStatic, il suffit d'ajouter Matcher m avant la if.
InformationsquelleAutor knorv
0

C'est mon meilleure compréhension de la façon de le faire à l'aide de Groovy syntaxe (mais voir lfaraone réponse de trop):
```
import java.util.regex.Matcher

def txt = 'abc : groovy : def'
if (txt =~ ~/: (.+?) : /) {
    def match = Matcher.lastMatcher[0][1]
    println "MATCH=$match"
}
```
- Merci pour votre réponse! Je pense que votre code échoue avec un IndexOutOfBoundsException si il n'y a pas de match. J'ai édité mon post avant que j'ai vu votre réponse - de sorte que vous pouvez revoir votre post. Veuillez voir les choses sur le m[0][1] la notation.
- Merci, j'ai mis à jour ma réponse. Aussi, un Comparateur en Java peut avoir plusieurs matchs. (Pensez à l' /g drapeau pour Perl correspondances). Le premier index vous permet de spécifier le match se soucient de vous.
InformationsquelleAutor Chris Jester-Young

Vous devez vous connecter pour publier un commentaire.