Reguläre Ausdrücke

in Arbeit …

1. Überblick

Reguläre Ausdrücke sind im IT-Bereich eine Basistechnologie im Umgang mit Textueller Information.

Der englische Begriff: Regular Expression wird im Weiteren (wie allgemein üblich) abgekürzt als RegEx verwendet.

Sie basieren auf einer einer Textmuster-Definitionssprache, die sehr komplexe Such-, Extraktions- und Ersetzungsoperationen ermöglicht.

Einsatzgebiete sind Such- und Ersetzungsfünktionen in Text-Editoren, Suchmaschinen, typischen Unix-Shell-Werkzeugen wie grep, sed und awk, Datenbanken und Lexikalische Analyse – beispielsweise in Compilern.

In nahezu allen aktuellen Programmiersprachen und besseren Text-Editoren sind sie verfügbar. Die Grundidee ist überall gleich, jedoch gibt es unterschiedliche Dialekte je nach Anwendungsgebiet und Herkunft.

Wir werden uns hier auf Java konzentrieren. Hier wird der RegEx als String definiert und oft auch in dieser Form an die entsprechende Methode übergeben. Es kann jedoch auch eine "kompilierte" Repräsentation erzeugt werden (Klasse java.util.regex.Pattern), wenn mehrfache Nutzung des selben RegEx-Ausdrucks vorgesehen ist oder komplexere Aufgaben zu erfüllen sind.

2. Einfache, allgemein bekannte Anwendungen

Im JDK existieren viele Methoden, die RegEx als String-Parameter erwarten. Zu den bekanntesten gehören:

String[] pieces = "ein; kurzer;Text".split("; ?");
teilt den Text an den ';' oder '; ' (' ?': 0 oder 1 Leerzeichen nach dem ';') und liefert ein String-Array mit den Teilstücken (ohne die Trennzeichenfolgen) zurück
boolean foundTheNumber = "Hier steht Ganzzahl -273°C drin".matches(".*-?[0-9]+°C.*"); liefert true ('.' steht für 1 beliebiges Zeichen, das '*' danach ist die Mengenangabe 0 bis beliebig viele, d.h. zu Beginn und am Ende können beliebig viele beliebige Zeichen stehen, dazwischen muss mindestens eine Ziffer mit optional davorstehendem Minuszeichen auftreten)
String changedTxt = "Streunende Katzen kommen ins Katzenheim".replaceAll("(Katzen", "Hunde"); ist weitgehend selbsterklärend, der einfachste RegEx ist wie hier normaler Text. Die Ersetzung ist kein RegEx, könnte aber Referenzen ($1, $2, …) auf Treffer von (als Gruppen definierten) Teilen des RegEx enthalten (hier normaler Text).

3. Komplexere Anwendung

Sobald komplexere Aufgaben anstehen, muss der RegEx-Ausdruck kompiliert werden:

Pattern pt = Pattern.compile(".*(-?[0-9]+)°C.\*"); Matcher mt = pt.matcher("Hier steht Temperatur -273°C drin"); // if (mt.matches()) { System.out.println("Temperaturwert gefunden: " + mt.group(1)); }

Zu Beginn wird eine kompilierte Repräsentation des RegEx-Ausdruck als Pattern-Objekt erzeugt.
Anschließend wird am Pattern-Objekt Methode matcher(..) aufgerufen, die den zu untersuchenden Text als Parameter erwartet und ein Matcher-Objekt zurückliefert (die Datenstrukturen werden vorbereitet, die eigentliche Arbeit aber noch nicht durchgeführt).
bei Aufruf von matches() wird der RegEx-Ausdruck tatsächlich auf den Text angewendet und das Ergebnis intern bereitgestellt.
group(1) liefert den gefundenen "Treffer" des ersten (und einzigen) Teils des RegEx-Ausdrucks zurück, der in Klammern () eingeschlossen ist.
Eine zweite Anwendungsart ist statt matches() (Prüfung des gesamten Texts) die Methode find() (Prüfung ab aktueller Startposition bis RegEx "getroffen hat"):
Pattern pt = Pattern.compile("(-?[0-9a-f]+);?"); Matcher mt = pt.matcher("-26ae;1f2e;3d4c;5b6a"); while (mt.find()) { System.out.println("Hex-Zahl gefunden: " + mt.group(1)); }
Hier wird bei jedem Aufruf von find() der Suchstart auf das erste Zeichen nach dem vorherigen "Treffer" gesetzt (Beim ersten Aufruf auf den Textbeginn). Dann wird das nächste zum RegEx passende Textstück gesucht. Bei einem Treffer wird true zurückgeliefert, der gefundene Textteil kann mit group(1) abgefragt werden. Wird nichts gefunden, wird false zurückgeliefert und die Schleife beendet.

letzte anstelle von mt.matches() sucht das nächste zum RegEx passende Textstück, kann durch den gesamten Text durchiterieren. würde auch Teile des Textes zurückliefern, die den RegEx-Ausdruck enthalten, aber nicht vollständig mit ihm übereinstimmen.

4. Etwas Hintergrund

Reguläre Ausdrücke sind eine Art von formalen Sprachen und gehören zur Theoretischen Informatik. Sie sind ein Teilgebiet der formalen Grammatiken und Automaten und können Reguläre Sprachen beschreiben. Details siehe u.a. Regulärer Ausdruck – Wikipedia bzw. ausführlicher in Englisch: Regular expression - Wikipedia.

Reguläre Ausdrücke sind für eine festgelegte (endliche) Zeichenmenge definiert (Sogenanntes Alphabet). Sie basieren auf genau drei Operationen: Alternative, Verkettung und Wiederholung.

in Arbeit ...

5. Syntax

Greedy (gierig … NORMAL) Reluctant (unwillig) Possessive (besitzergreifend) Bedeutung

Greedy (gierig … NORMAL)	Reluctant (unwillig)	Possessive (besitzergreifend)	Bedeutung
`X?`	`X??`	`X?+`	`X`, einmal oder keinmal
`X*`	`X*?`	`X*+`	`X`, beliebig viele (auch 0) Vorkommen
`X+`	`X+?`	`X++`	`X`, 1 oder mehr Vorkommen
`X{n}`	`X{n}?`	`X{n}+`	`X`, genau `n` Vorkommen
`X{n,}`	`X{n,}?`	`X{n,}+`	`X`, zumindest n Vormommen
`X{n,m}`	`X{n,m}?`	`X{n,m}+`	`X`, zwischen `n` und `m` Vorkommen

X?

X??

X?+

X, einmal oder keinmal

X*

X*?

X*+

X, beliebig viele (auch 0) Vorkommen

X+

X+?

X++

X, 1 oder mehr Vorkommen

X{n}

X{n}?

X{n}+

X, genau n Vorkommen

X{n,}

X{n,}?

X{n,}+

X, zumindest n Vormommen

X{n,m}

X{n,m}?

X{n,m}+

X, zwischen n und m Vorkommen

5.1. Flags

Oft benötigt:
Pattern.CASE_INSENSITIVE (?i)
Pattern.COMMENTS (?x)
Pattern.MULTILINE (?m)
Pattern.DOTALL (?s)

Selten:
Pattern.LITERAL None
Pattern.CANON_EQ None
Pattern.UNICODE_CASE (?u)
Pattern.UNIX_LINES (?d)

5.2. Look ahead/behind (negativ/positiv)

Positiver Lookahead: (?=Ausdruck)
Negativer Lookahead: (?!Ausdruck)
Positive Lookbehind: (?<=Ausdruck)
Negativer Lookbehind: (?<!Ausdruck)

6. Einfache Beispiele

7. Komplexere Beispiele

Regular Expression Examples … 2024-04-16

8. Alternativen für komplexere Aufgaben

jsoup: Java HTML parser, built for HTML editing, cleaning, scraping, and XSS safety

ANTLR
(ANother Tool for Language Recognition) is a powerful parser generator for reading, processing, executing, or translating structured text or binary files. It’s widely used to build languages, tools, and frameworks. From a grammar, ANTLR generates a parser that can build and walk parse trees.

9. Links

https://de.wikipedia.org/wiki/Regulärer_Ausdruck [Regulärer Ausdruck – Wikipedia] … 2024-03-18

https://www.grund-wissen.de/linux/shell/shell-scripting/sed-und-awk.html [Sed und Awk — Linux und Open Source] … 2024-03-18

https://armann-systems.com/wiki/textverarbeitungswerkzeuge-unter-linux-ein-tiefgehender-einblick-in-sed-und-awk/ [Textverarbeitungswerkzeuge unter Linux: Ein tiefgehender Einblick in Sed und Awk] … 2024-03-18

chrome-extension://mhjfbmdgcfjbbpaeojofohoefgiehjai/index.html [awk_sed_7.pdf] … 2024-03-18 #

Lookahead and Lookbehind in Java Regex | Baeldung … 2024-04-09

Java Regular Expressions | w3schools … 2024-04-09

https://regexone.com/problem/matching_html [RegexOne - Learn Regular Expressions - Problem 4: Matching HTML] … 2024-04-16