Reguläre Ausdrücke und Fehlerbehandlung

[l8storm]

Hallo,
mich würde mal interessieren, ob es eine Möglichkeit gibt mittels der java.util.regex.* Klassen eine NICHT erfolgreichen Match zu untersuchen, also einen Rückgabewert über die Position zu erhalten, an dem der Match gescheitert ist.

Beispiel:
Ich habe folgenden regulären Ausdruck:

String valid = "1 2 20 4 18 21 15 " +
                "16 (21 16 )*" +
                "3 12 " +
                "6 ((21 6 )|(3 6 ))*" +
                "7 ((21 7 )|(3 7 ))*" +
                "8 ((21 8 )|(3 8 ))*" + 
                "9 ((21 9 )|(3 9 ))*" + 
                "10 ((21 10 )|(3 10 ))*" + 
                "11 ((21 11 )|(3 11 ))*" + 
                "13 14 ((21 14 )|(3 14 ))*" + 
                "19\\s?";

und möchte nun überprüfen, ob der String hier passt:

String testMe = "1 2 20 4 18 21 15 16 21 16 21 16 3 12 6 3 6 3 6 3 6 7 3 7 3 7 8 3 8 3 8 9 10 11 13 14 3 14 21 14 3 14 3 21 14 21 14 19 ";

Pattern p = Pattern.compile(valid);
Matcher m = p.matches(testMe);

boolean isMatching = m.matches();

Wenn man es sich genauer ansieht scheitert ein Matching an der Position 105 (ziemlich am Ende, wechsel von 3 nach 21 ist nicht erlaubt) und isMatching ergibt false.

Frage also: Komme ich irgendwie an die (hier manuell ermittelte) Position 105? Hab in der API erstmal nix gefunden.

Grüße,
Steffen

 

[SlaterB]

for (int i=0; i<valid.length; i++) {
  Pattern p = Pattern.compile(valid.subString(0,i)); 

  for (int j=0; j<testMe.length; j++) {
    Matcher m = p.matches(testMe.subString(0,j)); 
    boolean isMatching = m.matches(); 
    // ..
  }
}

----------

ansonsten: ich kenne mich da nicht ganz so gut aus, kann mir aber vorstellen, dass es bei manchen Matches vielleicht gar nicht so richtig Sinn macht, nach einer solchen Position zu fragen?,

du hast ja nun einen relativ einfachen Spezialfall,
wäre es da nicht denkbar, diese Suche nach bestimmten Strings selber durchzuführen?
suche String 1, merke Position x,
suche String 2 ab Position x, merke Position x
...

dann ist es ein leichtes die Abbruch-Position zu markieren,
und mit etwas Glück kriegst du das ganze auch performanter hin als die allgemeine Match-Operation, die zig Regeln beachten muss

---------

ach und was ich gerne mal wieder erwähne:

mit

String valid = "1 (2) 20"; 
und möchte nun überprüfen, ob der String hier passt: 

String testMe = "1 2 19"; 
Pattern p = Pattern.compile(valid); 
Matcher m = p.matches(testMe); 
boolean isMatching = m.matches(); 
..

oder ähnlich kurz hättest du das gleiche Problem 'etwas' einfacher beschreiben können

------------


und noch mal edit:
anscheinend ist valid deine Validierung und testMe der Teststring,
naja, dann hab ich wohl nicht so richtig weitergeholfen,

 

[Leroy42]

Ich verstehe die Frage nicht :autsch:

Der Match ist doch überall, an jeder Position gescheitert.

Deine Methode müßte allso alle Indizes von 0 bis string.length()-1 zurückliefern,

 

[l8storm]

du hast ja nun einen relativ einfachen Spezialfall,
wäre es da nicht denkbar, diese Suche nach bestimmten Strings selber durchzuführen?
suche String 1, merke Position x,
suche String 2 ab Position x, merke Position x

Genau darum ging es ja, das es eben nicht nur für Spezialfälle gilt, sondern auch Allgemein. Ich wollte ja wissen, OB es denn möglich ist.

String valid = "1 (2) | 20"; 
und möchte nun überprüfen, ob der String hier passt: 

String testMe = "1 2 19"; 
Pattern p = Pattern.compile(valid); 
Matcher m = p.matches(testMe); 
boolean isMatching = m.matches(); 
..

hättest du das gleiche Problem 'etwas' einfacher beschreiben können

OkOk, hast recht , den Code hatte ich nur grad zur Hand und Spaß am zählen hab ich auch. Werds demnächst beherzigen und mich kurz fassen.

Ich verstehe die Frage nicht

Der Match ist doch überall, an jeder Position gescheitert.

Deine Methode müßte allso alle Indizes von 0 bis string.length()-1 zurückliefern,

War vielleicht was unglücklich ausgedrückt. Was ich meinte war, ja, der Match ist gescheitert, aber die Frage ist eben, ob er mir auch sagen kann warum bzw. an welcher Stelle im String das Problem auftrat. Ich nehme jetzt einfach mal an, dass die Matcher-Klasse irgendwie über den String iterieren muss, und daher ja auch die Position kennt, an der der weitere Matchingvorgang gescheitert ist.

 

[Leroy42]

Das kann nicht funktionieren.

Beispiel:

regulärer Ausdruck: "(a|ab)*c"
Kandidat: "aaadab"

Wo scheitert der Ausdruck deiner Meinung nach denn nun genau? :shock:

Beim 'd' oder nach dem 'b'?

 

[l8storm]

Das kann nicht funktionieren.

Beispiel:

regulärer Ausdruck: "(a|ab)*c"
Kandidat: "aaadab"

Wo scheitert der Ausdruck deiner Meinung nach denn nun genau? :shock:

Beim 'd' oder nach dem 'b'?

Wenn du durch den String "aaadab" iterierst wirst du den fehler bei 'd' haben, also wäre die gesuchte Position: 3

 

[Wildcard]

Er scheitert aber auch beim b. Ich schätze einfach mal du suchst den längsten teilweisen match.
Dafür gibt's IMO nichts. Wird dir nichts anderes übrig bleiben als das selbst zu implementieren

 

[l8storm]

Er scheitert aber auch beim b. Ich schätze einfach mal du suchst den längsten teilweisen match.
Dafür gibt's IMO nichts. Wird dir nichts anderes übrig bleiben als das selbst zu implementieren

Genau das wollte ich wissen

Schade dass ich den Teilmatch nicht herausfinden kann, aber damit hat sich die Sache für mich erledigt. Danke an alle!

 

[Leroy42]

Er scheitert aber auch beim b. Ich schätze einfach mal du suchst den längsten teilweisen match.

Eben! Vielleicht suche ich ja auch den kürzesten. Wer schreibt mir das vor.

IMHO macht die ganze Aufgabenstellung (bei beliebigen regulären Ausdrücken)
gar keinen Sinn!

Edit: Erinnert mich an diese Matherätsel die zu Anfang zur Vereinfachung ein, zwei Definitionen
eingeführt haben, einen Satz aufgestellt haben, deren Nicht-Gültigkeit jeder normale Mensch
sofort sieht und diesen dann nach ein paar elementaren Umformungen,
die nachweislich vollkommen korrekt waren (kein Teilen durch 0 oder ähnlicher Kinderkram),
bewiesen haben. :shock: ???:L :autsch:

Bis sich herausstellte, daß die Definition selbst mindestens einem Axiom widersprach
und somit gar nicht gemacht werden konnte/durfte.

 

[l8storm]

IMHO macht die ganze Aufgabenstellung (bei beliebigen regulären Ausdrücken) gar keinen Sinn!

Naja, ich weiss ja nicht... sinvoll ists schon, sonst hät ich nicht nach gefragt.

Obiger erster Beitrag verifiziert beispielsweise den Ablauf von Webseitenaufrufen, und ich hätte gerne gewusst, an welcher Stelle sich der Benutzer nicht so verhalten hat wie er es eigentlich hätte tun sollen.

Ob ich nun ein "passt" oder "passt nicht" bekomme bei einem Match, d.h. herausfinden möchte, ob ein Wort in die durch den regulären Ausdruck aufgespannte Sprache enthalten ist, oder eben die (maximale) Stelle des Wortes bekomme, an welcher der endliche Automat (definiert durch den regulären Ausdruck, siehe auch Wikipedia) scheitert, ist doch nicht sehr verschieden. Wenn ich also ein gegebenes Wort sukzessive durch den Automaten schleuse, dann habe ich einen definierten Abbruchpunkt in diesem Wort, sollte das Wort nicht zur regulären Sprache gehören. Diesen Punkt hätte ich gerne, aber das geht ja anscheinend nicht mit der Java API.

Desweiteren wollte ich mich nicht in philosophische Auseinandersetzungen über den Sinn der Frage stürzen, sondern wissen, ob die Java API mächtig genug ist mir irgendetwas über das scheitern eines Matches zu verraten, oder ob ich selbst programmieren muss.

 

[Leroy42]

In diesem speziellen Fall macht es natürlich Sinn, da du einen sehr eingeschränkten
regulären Ausdruck hast.

Nur warum sollten die Sun-Entwickler gerade deinen Spezielfall berücksichtigen.

Ich wollte hier auch keine philosophische Debatte lostreten sondern darauf hinweisen,
das soetwas (bei beliebigen regulären Ausdrücken) nicht machbar ist, da allein schon
das Notwendigste -- die Definition wo das Matchen scheitert -- nicht möglich ist.

In deinem Fall wäre das einfachste dir einen, deinen Bedürfnissen angepassten, Parser
zu basteln und auf RegExps ganz zu verzichten.