Reguläre Ausdrücke in Rust mit Beispielen: in der Praxis

Einleitung: Wozu braucht man reguläre Ausdrücke in Rust?

Reguläre Ausdrücke (regex) sind ein leistungsstarkes Werkzeug zum Suchen, Extrahieren und Ersetzen von Text nach einem Muster. In Rust wird die Arbeit mit regulären Ausdrücken über die Crate regex realisiert, die als eine der schnellsten und sichersten im Ökosystem gilt. Im Gegensatz zu vielen anderen Sprachen prüft der Rust-Compiler die Korrektheit des regulären Ausdrucks bereits zur Kompilierzeit (wenn das Makro regex! verwendet wird), was hilft, Fehler zur Laufzeit zu vermeiden.

In diesem Artikel werden wir praktische Beispiele für die Verwendung regulärer Ausdrücke in Rust durchgehen: von der grundlegenden Suche bis zur komplexen Datenextraktion. Sie erfahren, wie Sie ein Projekt einrichten, Muster schreiben und Ergebnisse verarbeiten.

1. Projekteinrichtung und erste Regex

Abhängigkeit hinzufügen

Fügen Sie zunächst die Crate regex in die Datei Cargo.toml ein:

[dependencies]regex = "1"

Aktualisieren Sie anschließend die Abhängigkeiten mit dem Befehl cargo build.

Erstes Beispiel: Wortsuche

Schreiben wir ein einfaches Programm, das das Wort "Rust" in einer Zeichenkette findet:

use regex::Regex;

fn main() {    let re = Regex::new(r"Rust").unwrap();    let text = "Ich lerne Rust und Python.";        if re.is_match(text) {        println!("Wort 'Rust' gefunden!");    } else {        println!("Wort nicht gefunden.");    }}

Die Funktion Regex::new kompiliert das Muster. Wenn das Muster ungültig ist, wird das Programm mit einem Fehler beendet (verwenden Sie unwrap() nur in Prototypen).

2. Datenextraktion mit Erfassungen

Gruppierung und benannte Gruppen

Reguläre Ausdrücke ermöglichen das Extrahieren von Textteilen mit runden Klammern. Betrachten wir ein Beispiel mit einer E-Mail:

use regex::Regex;

fn main() {    let re = Regex::new(r"(?P<name>[a-zA-Z0-9._%+-]+)@(?P<domain>[a-zA-Z0-9.-]+\\.[a-zA-Z]{2,})").unwrap();    let text = "Meine E-Mail: user@example.com, sowie admin@test.org.";        for caps in re.captures_iter(text) {        println!("Name: {}", &caps["name"]);        println!("Domain: {}", &caps["domain"]);    }}

In diesem Beispiel verwenden wir benannte Gruppen (?P<name>...). Dies macht den Code lesbarer und bequemer für die weitere Verarbeitung.

Alle Übereinstimmungen extrahieren

Wenn Sie alle Übereinstimmungen ohne Gruppen erhalten möchten, verwenden Sie find_iter:

use regex::Regex;

fn main() {    let re = Regex::new(r"\\d+").unwrap();    let text = "Preise: 100, 250 und 500 Rubel.";        for mat in re.find_iter(text) {        println!("Zahl gefunden: {}", mat.as_str());    }}

Die Methode find_iter gibt einen Iterator über Match-Objekte zurück, die die Start- und Endpositionen sowie den Text der Übereinstimmung selbst enthalten.

3. Textersetzung und komplexe Muster

Einfache Ersetzung

Ersetzen wir alle Ziffern durch das Wort "NUMBER":

use regex::Regex;

fn main() {    let re = Regex::new(r"\\d+").unwrap();    let text = "Code: 12345, Status: 0.";    let result = re.replace_all(text, "NUMBER");    println!("{}", result); // "Code: NUMBER, Status: NUMBER."}

Ersetzung mit Erfassungen

Man kann in der Ersetzungszeichenkette mit $1, $2 oder benannten Gruppen $name auf Gruppen verweisen:

use regex::Regex;

fn main() {    let re = Regex::new(r"(?P<year>\\d{4})-(?P<month>\\d{2})-(?P<day>\\d{2})").unwrap();    let text = "Datum: 2024-03-15";    let result = re.replace_all(text, "$day.$month.$year");    println!("{}", result); // "Datum: 15.03.2024"}

Komplexes Muster: Log-Parsing

Betrachten wir ein reales Beispiel – das Parsen einer Webserver-Logzeile:

use regex::Regex;

fn main() {    let log_line =