# REGEX Erklaerung



## tanzverfuehrung (31. Jul 2012)

Also es gibt ja für Eclipse das plugin Eclipse Regular Expression (RegExp) Tester und damit habe ich mir nun mein Regulären Ausdruck zusammen gebaut, aber eine Sache ergibt für mich einfach kein Sinn!
Und dazu bräuchte ich male eine Erklärung

das ein beispiel code jetzt



```
dsdsad
}

@Test
public void shouldRemoveItem() {
 QueueX queue = new QueueX();
 queue.add(c);
 assertThat(queue.size(), eq(1))
 queue.remove(c);
 if (bla){

}
 assertThat(queue.size(), eq(0))
}


/*asdsad
```


und genau , der abschnitt soll gefunden werden



@Test
public void shouldRemoveItem() {
 QueueX queue = new QueueX();
 queue.add(c);
 assertThat(queue.size(), eq(1))
 queue.remove(c);
 if (bla){

}
 assertThat(queue.size(), eq(0))
}


also eine testmethode, mit und ohne kommentar oben drueber..
und das ganze funktioniert mit dem regex:

*
(\/\*((\r\n).*)*\*\/)*(\r\n)*\@Test.*((\r\n).*)*.*shouldRemoveItem.*((\r\n).*)*\}*


so was ich jetzt aber nicht verstehe, wieso es nicht bei der ersten *}* klammer zu ende ist!!! weil eigentlich der Ausdruck  **shouldRemoveItem.*((\r\n).*)*\}*  , sagt ja eigentlich nur...das nach der methode beliebig viele zeichen kommen und beliebig viele zeilenumspruenge bis diese  *}* Klammer kommt!

Kann mir das jemand bitte erklaeren!:rtfm::bahnhof:


----------



## Skrodde (31. Jul 2012)

tanzverfuehrung hat gesagt.:


> *
> (\/\*((\r\n).*)*\*\/)*(\r\n)*\@Test.*((\r\n).*)*.*shouldRemoveItem.*((\r\n).*)*\}*
> 
> so was ich jetzt aber nicht verstehe, wieso es nicht bei der ersten *}* klammer zu ende ist!



Hm, ich sehe in dem gesamten Ausdruck nur eine schließende geschweifte Klammer ganz am Ende. Was meinst du denn genau mit "der ersten"? ???:L


----------



## bygones (31. Jul 2012)

ist es nicht einfacher diesmal ohne regex das zu machen ? der regex kann nur gross, unverstaendlich und unwartbar werden meiner Ansicht nach.

Parser schreiben der eine Methode inklusive Kommentare erkennt und dann den entsprechenden Eintrag loeschen oder was auch immer - der parser kann dann nach dem einfachen substring/indexOf oder was auch immer arbeiten


----------



## tanzverfuehrung (31. Jul 2012)

Skrodde hat gesagt.:


> Hm, ich sehe in dem gesamten Ausdruck nur eine schließende geschweifte Klammer ganz am Ende. Was meinst du denn genau mit "der ersten"? ???:L




ich meinte in meinem java code gibt es zwei klammern

```
@Test
public void shouldRemoveItem() {
QueueX queue = new QueueX();
queue.add(c);
assertThat(queue.size(), eq(1))
queue.remove(c);
if (bla){

}
assertThat(queue.size(), eq(0))
}
```

und nach dem regex wuerde ich sagen, das eigentlich nur bis hier geht:

@Test
public void shouldRemoveItem() {
QueueX queue = new QueueX();
queue.add(c);
assertThat(queue.size(), eq(1))
queue.remove(c);
if (bla){

}

er geht aber bis zur letzten klammer , also

@Test
public void shouldRemoveItem() {
QueueX queue = new QueueX();
queue.add(c);
assertThat(queue.size(), eq(1))
queue.remove(c);
if (bla){

}
assertThat(queue.size(), eq(0))
}

und da brauchte ich jetzt eine erklaerung zu!?!?!????:L

weil da verstehe ich nicht.wieso?weshalb?warum?:rtfm:

also es ist ja richtig aber ich will es ja auch verstehen!danke


----------



## tanzverfuehrung (31. Jul 2012)

bygones hat gesagt.:


> ist es nicht einfacher diesmal ohne regex das zu machen ? der regex kann nur gross, unverstaendlich und unwartbar werden meiner Ansicht nach.
> 
> Parser schreiben der eine Methode inklusive Kommentare erkennt und dann den entsprechenden Eintrag loeschen oder was auch immer - der parser kann dann nach dem einfachen substring/indexOf oder was auch immer arbeiten



ja ich wollte es ja auch eigentlich ohne regex machen und finde es auch übersichtlicher , ABER mein Ausbilder hier im Ausland, hat sich das angeguckt und meinte er will das mit REGEx haben:bahnhof:;(
kann ich nichts machen. ich führe nur aus...


----------



## Michael... (31. Jul 2012)

tanzverfuehrung hat gesagt.:


> und da brauchte ich jetzt eine erklaerung zu!?!?!????:L
> 
> weil da verstehe ich nicht.wieso?weshalb?warum?:rtfm:
> 
> also es ist ja richtig aber ich will es ja auch verstehen!danke


Erklärung: Das ist RegEx ;-) In dem RegEx ist ja nicht festgelegt, dass er nach der ersten Klammer aufhören soll. Quantoren sind standardmäßig gierig, heißt sie nehmen möglichst viel mit was ins "Muster" passt. Mittels ? nach einem Quantor kann man dieses Verhalten abstellen.


----------



## Michael... (31. Jul 2012)

Muss der RegEx denn so aussehen? Oder konkret was soll der RegEx den finden? Warum diese vielen Linefeeds im Ausdruck?


----------



## tanzverfuehrung (31. Jul 2012)

Michael... hat gesagt.:


> Muss der RegEx denn so aussehen? Oder konkret was soll der RegEx den finden? Warum diese vielen Linefeeds im Ausdruck?



also erst mal danke für deine Erklärung.

Naja der regEx soll eine bestimmte Testmethode finden...da ich aber nicht weiß wie viele Zeilen die Methode hat, brauche ich  so viele Linefeed's, denke ich!Und davor brauche ich Linefeed's, weil es könnte ja sein, das ein Methodenkommentar dabei ist 

```
/*
*kommentar
*/
```
es muss aber kein Kommentar vorhanden sein
und zwischen dem Kommentar und der @Test annotation kann ja auch eine oder mehrere Leerzeile sein, muss aber nicht!!!

hoffe war verständlich!
aber durch deine Erklärung, ist klar geworden,das der regex noch nicht ganz richtig ist!


----------



## Michael... (31. Jul 2012)

Wie nutzt Du den RegEx? Mit Pattern und Matcher? Mit dem Flag Pattern.DOTALL gilt ein *.* im RegEx auch für einen Zeilenumbruch.


----------



## bygones (31. Jul 2012)

schonmal zb hier geschaut: Regex that Will Match a Java Method Declaration - Stack Overflow (sie haben das ohne kommentar, aber vielleicht interessante ansaetze)

oder hier Finding Comments in Source Code Using Regular Expressions


----------



## Mujahiddin (31. Jul 2012)

Michael... hat gesagt.:


> Wie nutzt Du den RegEx? Mit Pattern und Matcher? Mit dem Flag Pattern.DOTALL gilt ein *.* im RegEx auch für einen Zeilenumbruch.



oder einfach ein (?s) vor den gesamten Ausdruck setzen.
Übrigens, ich hab mal deinen Regex getrimmt! Du hast einige Sachen escapet, die man nicht escapen braucht.


```
(?s)(/\*.*\*/)*.*@Test.*shouldRemoveItem.*\}
```

Paar Anmerkungen:
- Der Kommentar wird gecaptured. Um das zu verhindern:

```
(?s)(?:/\*.*\*/)*.*@Test.*shouldRemoveItem.*\}
```

- Falls am Ende der Methode noch irgendwas steht und bei diesem Irgendwas ein "}" auftaucht, wird alles bis zu diesem } gematcht.


----------



## tanzverfuehrung (31. Jul 2012)

```
dsdsad
}
 /*
*kommentar
*/

@Test
public void shouldRemoveItem() {
 QueueX queue = new QueueX();
 queue.add(c);
 assertThat(queue.size(), eq(1))
 queue.remove(c);
 if (bla){
 
}
 assertThat(queue.size(), eq(0))
}
 
/*asdsad
```





also das ding ist, das ich die ganze Testmethode finden will, also bis zur letzten Klammer { , die meine methode schließt...mit @Test Annotaion und mit Kommentar, ALSO GENAU DAS


 /*
*kommentar
*/
@Test
public void shouldRemoveItem() {
QueueX queue = new QueueX();
queue.add(c);
assertThat(queue.size(), eq(1))
queue.remove(c);
if (bla){

}
assertThat(queue.size(), eq(0))
}

das funktioniert auch schon mit meinem regex, das einzige Problem ist, wenn ich im Code noch eine Klammer ganz unten hinzufüge, ist das die letzte
also
WENN der Code ist

```
dsdsad
}
 /*
*kommentar
*/

@Test
public void shouldRemoveItem() {
 QueueX queue = new QueueX();
 queue.add(c);
 assertThat(queue.size(), eq(1))
 queue.remove(c);
 if (bla){
 
}
 assertThat(queue.size(), eq(0))
}
 
/*asdsad
}
```

(siehe letzte Zeile)

DANN kriege ich den ganzen block:

 /*
*kommentar
*/

@Test
public void shouldRemoveItem() {
 QueueX queue = new QueueX();
 queue.add(c);
 assertThat(queue.size(), eq(1))
 queue.remove(c);
 if (bla){

}
 assertThat(queue.size(), eq(0))
}

/*asdsad
}



also das Problem liegt nicht in den Kommentaren...das funktioniert schon alles!
und die stack Overflow seite zeigt nur wie ich eine Methoden Deklaration finde, also nur die erste Zeile, ich brauch aber die ganze Methode, mit INHALT und bis ZUR LETZTEN KLAMMER!!!!


----------



## tanzverfuehrung (31. Jul 2012)

erst mal *DANKE!*:toll:



Mujahiddin hat gesagt.:


> Paar Anmerkungen:
> - Der Kommentar wird gecaptured. Um das zu verhindern:
> 
> ```
> ...



Sorry aber was genau heißt gecaptured???
bzw. was genau macht jetzt *?:*   ??






Mujahiddin hat gesagt.:


> - Falls am Ende der Methode noch irgendwas steht und bei diesem Irgendwas ein "}" auftaucht, wird alles bis zu diesem } gemacht.


genau das ist eigentlich auch , nach der Erklärung, mein Problem gewesen.:bahnhof:

EDIT:
zu   *(?s)*  ...also

wenn ich mir die Erklärung für *s* angucke, heißt es ja das die Steuerzeichen da drin vorhanden sind zozusagen  und deswegen passt das auch für zeilenumbrueche???

und für das Fragezeichen *?*, heißt es ja eigentlich, er kann einmal vorkommen, muss es aber nicht, d. h. der Ausdruck kommt null- oder einmal vor. (Dies entspricht {0,1})

aber es feedlines kommen ja öfter vor, also musste das dann nicht eigentlich * * * sein???
also es funktioniert mit ? aber verstehe schon wieder nicht wieso das funktioniert?!?!


ok habe es grad ausprobiert, es funktioniert sogar nur mit dem fragezeichen aber wieso?????:L

EDIT:
und dein regex....nimmt auch alles mit was vor dem kommentar steht....das darf nicht passieren!


----------



## Mujahiddin (31. Jul 2012)

Hallo
Zum 
	
	
	
	





```
(?s)
```
:
Normalerweise matcht ein Punkt "." jedem Charakter außer Zeilenumbrüchen.
Wenn du vor dein Regex ein (?s) setzt, setzt du diesen "Flag", also du sagst deinem Matcher, dass er bei "." ALLES inklusive Zeilenumbrüche nehmen soll!
Es gibt noch andere Flags, z.B. i für case-insensitive. Auf Groß/Kleinschreibung wird dann keinen Wert gelegt. Und dann noch "m" und "d" (Google!)

Ja, alles vor dem Kommentaren wird auch genommen, dazu würde ich für diese eine Stelle den Flag "s" ausschalten:


```
(?s)(/\*.*\*/)(?s:.)*@Test.*shouldRemoveItem *\{.*\}
```

Und eine Lösung dafür, dass nur die Methode genommen wird, ist ein wenig verzwickt.
Bei verschachtelten { } kommt man da schnell ins Grübeln...
Mir fällt gerade auch nicht wirklich ein, wie man das macht.


----------



## Mujahiddin (31. Jul 2012)

Bei näheren Überlegen denke ich, dass das mit Regex gar nicht funktioniert.
Bei einfach verschachtelten { } ist es einfach mit folgendem Regex:


```
(?s)(/\*.*\*/)(?s:.)*@Test.*shouldRemoveItem *\{(.*\{.*?\})*.*?\}
```

Aber bei doppelt verschachtelten oder n-fach verschachtelten { } ist das schwer (bishin zu unmöglich) mit Regex.
Du kommst wahrscheinlich nicht drumrum, einen Parser zu schreiben.
Du könntest allerdings einen kleinen eigenen Parser schreiben, der einen Counter (zu Beginn 0) hat, in die Methode "reingeht" und bei allen öffnenden Klammern den Counter +1 setzt und bei allen schließenden -1. Sobald der Counter auf -1 fällt, bricht er ab.


----------

