Skip to content

4. Reguläre Ausdrücke

🚀 4: Grundlagen der Regulären Ausdrücke (Regex)

  • Konkatenation: ab → „a“ gefolgt von „b“
  • Alternation (ODER): a|b → „a“ oder „b“
  • Wiederholungen:
    • * → 0 oder mehr Wiederholungen (a* → „“, „a“, „aa“, …)
    • + → 1 oder mehr Wiederholungen (a+ → „a“, „aa“, …)
    • ? → 0 oder 1 Vorkommen (a? → „“ oder „a“)
  • Gruppierung: (ab)+ → „ab“, „abab“, …
  • Zeichenklassen:
    • [a-z] → Alle Kleinbuchstaben
    • [0-9] → Alle Ziffern
    • [^abc] → Alles außer „a“, „b“, „c“
  • Escape-Sequenzen:
    • \d → Ziffer (0-9)
    • \w → Alphanumerische Zeichen (Buchstaben, Ziffern, Unterstrich)
    • \s → Whitespace (Leerzeichen, Tab, etc.)
    • \D, \W, \S → Gegenteil von oben

🔍 2. Vorgehensweise zur Lösung der Aufgaben

✅ Aufgabe 1 & 2: Prüfung von Wörtern

  • Ziel: Prüfen, ob Wörter dem regulären Ausdruck entsprechen.
  • Vorgehen:
    1. Zerlege den regulären Ausdruck in seine Bestandteile.
    2. Vergleiche das Wort Schritt für Schritt.
    3. Finde das erste Zeichen, das nicht passt.

✅ Aufgabe 3: Komplexere Ausdrücke

  • Aufbauanalyse:
    • (abc|def) → Entweder „abc“ oder „def“
    • h? → Optionales „h“
    • [i-l]+ → Mindestens ein Zeichen zwischen „i“ und „l“
    • (no)* → Beliebig viele „no“ (auch 0-mal)
    • [^qrs]{2,} → Mindestens 2 Zeichen, die nicht „q“, „r“ oder „s“ sind
    • (uv)? → Optional „uv“
    • \wxyz → Beliebiges alphanumerisches Zeichen gefolgt von „xyz“

✅ Aufgabe 4: FHIR-Datentypen

  • Ziel: Werte finden, die zu den regulären Ausdrücken passen und welche, die nicht passen.
  • Beispiele:
    • Integer: 123 ✅, 12a ❌
    • DateTime: 2023-03-15T10:00:00Z ✅, 2023/03/15 ❌

✅ Aufgabe 5: Hexadezimal-Strings

  • Anforderung:
    • Muss mit 0x beginnen
    • Danach Ziffern 0-9 und Buchstaben A-F (Groß- oder Kleinschreibung)
    • Keine führenden Nullen (außer bei „0x0“)

0x(?!0{2,})[A-Fa-f0-9]+

✅ Aufgabe 6: Java-Programm

  • Ziel: Ein Programm schreiben, das prüft, ob ein String mit einem Regex übereinstimmt.
  • Kernlogik:
    • Verwende die Java-Klassen Pattern und Matcher aus java.util.regex.
    • Beispiel (Java):
import java.util.regex.*;

public class RegexChecker {
    public static void main(String[] args) {
        String regex = "a*b"; 
        String input = "aaab";

        boolean matches = Pattern.matches(regex, input);
        System.out.println(matches);  // true
    }
}

✅ Aufgabe 7: Eigene Regex erstellen

  • Beispiele:
    • Uhrzeit (xx:yy:zz.sss): \d{2}:\d{2}:\d{2}\.\d{3}
    • Blutgruppen: (A|B|AB|0)(pos|neg)
    • Medikamenten-Intervalle: (0|[1-9])-(0|[1-9])-(0|[1-9])
    • Keine Umlaute: ^[^äöüÄÖÜß]*$

✅ Aufgabe 8: Regex101 & Wikipedia-Analyse

  1. Jahreszahlen (1000-1999): 1[0-9]{3}

  2. Quellenverweise (Zahl in eckigen Klammern): \[\d+\]

  3. ISBN-Nummern: ISBN[- ]?(?:\d{10}|\d{13})

  4. Wörter mit Großbuchstaben, ohne a, e, n, t, r: \b[A-Z][^aenrt\s]*\b

  5. Wörter mit ≥10 Zeichen, endend mit n oder r: \b\w{9,}[nr]\b

📝 Zusammenfassung:

  • Regex-Grundlagen verstehen (Konkatenation, ODER, Wiederholungen, etc.)
  • Komplexe Muster in kleinere Einheiten zerlegen
  • Für Java-Aufgaben Regex mit Pattern und Matcher umsetzen
  • Fehlerquellen identifizieren (z.B. erste Abweichung in Zeichenketten)

📋 Regex Cheat Sheet (Reguläre Ausdrücke)

✅ 1. Grundlegende Syntax

  • Konkatenation: ab → "a" gefolgt von "b"
  • Alternation (ODER): a|b → "a" oder "b"
  • Gruppierung: (abc) → Behandelt "abc" als eine Einheit

✨ 2. Quantifizierer (Wiederholungen)

  • * → 0 oder mehr Wiederholungen (z.B. a* → "", "a", "aa", "aaa")
  • + → 1 oder mehr Wiederholungen (z.B. a+ → "a", "aa", "aaa")
  • ? → 0 oder 1 Vorkommen (z.B. a? → "", "a")
  • {n} → Genau n Wiederholungen (z.B. a{3} → "aaa")
  • {n,} → Mindestens n Wiederholungen (z.B. a{2,} → "aa", "aaa", "aaaa")
  • {n,m} → Zwischen n und m Wiederholungen (z.B. a{2,4} → "aa", "aaa", "aaaa")

🔍 3. Zeichenklassen

  • [abc] → a, b oder c
  • [^abc] → NICHT a, b oder c (Negation)
  • [a-z] → Alle Kleinbuchstaben von a bis z
  • [A-Z] → Alle Großbuchstaben von A bis Z
  • [0-9] → Alle Ziffern von 0 bis 9
  • [a-zA-Z0-9] → Alphanumerische Zeichen

🚀 4. Metazeichen & Escape-Sequenzen

  • . → Beliebiges Zeichen (außer Zeilenumbruch)
  • \ → Escape-Zeichen (z.B. \. für einen echten Punkt)
  • \d → Ziffer (entspricht [0-9])
  • \D → Keine Ziffer (entspricht [^0-9])
  • \w → Wortzeichen (Buchstaben, Ziffern, Unterstrich)
  • \W → Kein Wortzeichen
  • \s → Whitespace (Leerzeichen, Tab, Zeilenumbruch)
  • \S → Kein Whitespace

🎯 5. Anker (Positionsmarker)

  • ^ → Anfang der Zeile (z.B. ^abc → "abc" am Zeilenanfang)
  • $ → Ende der Zeile (z.B. xyz$ → "xyz" am Zeilenende)
  • \b → Wortgrenze (z.B. \bword\b findet genau "word")
  • \B → Keine Wortgrenze

🧩 6. Lookahead & Lookbehind (Advanced)

  • Positive Lookahead: X(?=Y) → Match "X", wenn direkt danach "Y" folgt
  • Negative Lookahead: X(?!Y) → Match "X", wenn NICHT "Y" folgt
  • Positive Lookbehind: (?<=Y)X → Match "X", wenn davor "Y" steht
  • Negative Lookbehind: (?<!Y)X → Match "X", wenn davor NICHT "Y" steht

📊 7. Beispiele

  • E-Mail: [a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}
  • IP-Adresse: \b(?:\d{1,3}\.){3}\d{1,3}\b
  • Datum (YYYY-MM-DD): \d{4}-\d{2}-\d{2}
  • Hexadezimalzahl: 0x[0-9A-Fa-f]+
  • Telefonnummer (DE): \+49\s?\d{3,4}\s?\d{6,8}

🚀 8. Nützliche Regex-Tools