# RegEx-Frage, Groß-/Kleinschreibung



## Daniel_L (4. Mrz 2009)

Hallo,

ich habe folgenden regulären Ausdruck:

```
dummy = dummy.replaceAll("(?i)"+st+"(?![^<>]*>)", "<span class=\"hs\">$0</span>");
```

In der Variable _st_ ist der Suchbegriff. Ich habe eine HTML-Seite, und der Suchebegriff _st_ soll nicht innerhalb von HTML-Tags ersetzt werden, das soll durch "(?![^<>]*>)" erreicht werden.

Wenn ich nun bspw. "in" als Suchbegriff (st) habe, werden die ersten beiden Buchstaben des Wortes "Interessant" mit dem span-Tag umschlossen. Habe ich jedoch "int" als Suchbegriff, passiert nichts. Wenn ich wiederum "Int" (mit großen i) eingebe, werden die ersten drei Buchstaben von "Interessant" mit span-Tag umschlossen.

Meine Frage: Wieso nicht bei klein geschriebenem i? Und wieso ja, wenn ich "in" als Suchbegriff habe, dann aber nicht mehr, wenn ich "int" habe?

Leider kenn ich mich nicht ganz so gut mit RegEx aus, als dass ich hier den Fehler finde...

Gruß
Daniel


----------



## SlaterB (4. Mrz 2009)

hast du Beispielcode dafür? 
bei mir:

```
public class Test
{
 
    public static void main(String[] args)
        throws Exception
    {
        String dummy = "Interessant";
        String st = "int";
        dummy = dummy.replaceAll("(?i)" + st + "(?![^<>]*>)", "<span class=\"hs\">$0</span>");
        System.out.println(dummy);
    }
}
 
->
<span class="hs">Int</span>eressant
```
vielleicht ist dein st doch nciht genau 'int'?

bei i klappts auch,
warum hier Groß-/ Kleinschreibung ignoriert wird, kann ich aber nicht sagen

edit:
ohne dass (?i) am Anfang klappts weniger mit groß/ klein, das hat wohl Auswirkung


----------



## Daniel_L (4. Mrz 2009)

Ah, ok. Ich habe den Fehler gefunden.


```
String[] findterms = null;
            try {
                // create a pattern from the first search term. if it fails, go on
                // to the catch-block, else contiue here.
                Pattern p = Pattern.compile(st);
                // now we know we have a valid regular expression. we now want to
                // retrieve all matching groups
                Matcher m = p.matcher(dummy);
                // add each found string to a linked array-list
                List<String> founds = new ArrayList<String>();
                // iterate all matching groups and check whether these "search terms" have already
                // been added to the linked list. if not, add it,
                while (m.find()) if (!founds.contains(m.group())) founds.add(m.group());
                // finally, copy contenr of the array list to the findterms.
                findterms = founds.toArray(new String[founds.size()]);
            }
            catch (PatternSyntaxException e) {
                findterms = st;
            }
```

Hier frage ich ab, ob der Suchbegriff _st_ ein Regulärer Ausdruck ist. "int" wird als regulärer Ausdruck angesehen. Ich dachte immer, die müssen mindestens mit Klammern oder so anfangen, und bin davon ausgegangen, dass eine "normale" Eingabe wie eben "int" beim Pattern.compile eine Exception auslöst, sodass dann als Suchbegriff der "reine" String genommen wird, und nicht der reguläre Ausdruck...

Ziel der ganzen Geschichte war, anhand des Suchbegriffs automatisch zu erkennen, ob es sich um einen "normalen" Begriff oder um einen regulären Ausdruck handelt, und dann entsprechend entweder den Suchbegriff beizubehalten, oder ein Array mit Suchbegriffen, die aufgrund des regulären Ausdrucks gefunden wurden, zu füllen...

Also muss ich irgendwie meine "automatische Erkennung" regulärer Ausdrücke überarbeiten.

Warum ich da nicht vorher drauf gekommen bin, mir mit System.out oder dem Debugger die Variablen-Werte anzugucken... Habe immer an der falschen Stelle debugged. ^^


----------

