Reguläre Ausdrücke in Rust: Vollständiger Leitfaden mit Beispielen

Einführung: Reguläre Ausdrücke in Rust – ein mächtiges Werkzeug zur Textverarbeitung

Reguläre Ausdrücke (regex) sind ein unverzichtbarer Bestandteil des Werkzeugkastens jedes Entwicklers, der mit Text arbeitet. In Rust, das für seine Leistung und Sicherheit bekannt ist, wird die Arbeit mit regulären Ausdrücken über die beliebte Crate regex realisiert. Diese Bibliothek bietet eine schnelle und zuverlässige Methode zum Suchen, Extrahieren und Ersetzen von Textmustern.

In diesem Artikel werden wir im Detail besprechen, wie man reguläre Ausdrücke in Rust verwendet: von der Installation der Crate bis hin zu fortgeschrittenen Techniken. Sie erfahren, wie Sie Übereinstimmungen prüfen, Daten extrahieren, Text ersetzen und Fehler behandeln. Alle Codebeispiele sind in Rust geschrieben und einsatzbereit.

1. Installation und Einbindung der regex Crate

Um mit regulären Ausdrücken in Rust zu arbeiten, muss die Crate regex zur Datei Cargo.toml hinzugefügt werden:

[dependencies]regex = "1"

Danach können die notwendigen Module in den Code importiert werden:

use regex::Regex;

Die Crate regex kompiliert reguläre Ausdrücke automatisch in ein effizientes internes Format, was eine hohe Arbeitsgeschwindigkeit gewährleistet.

2. Grundlegende Operationen mit regex in Rust

2.1 Prüfung auf Übereinstimmung (is_match)

Die Methode is_match gibt true zurück, wenn die Zeichenkette mindestens eine Übereinstimmung mit dem Muster enthält:

use regex::Regex;

fn main() {    let re = Regex::new(r"\\d+").unwrap();    let text = "Heute ist der 25. Dezember";

    if re.is_match(text) {        println!("Die Zeichenkette enthält Zahlen");    } else {        println!("Keine Zahlen gefunden");    }}

Diese Methode ist nützlich für eine schnelle Validierung: Prüfung, ob eine Zeichenkette eine E-Mail, Telefonnummer oder andere Muster enthält.

2.2 Suche nach der ersten Übereinstimmung (find)

Die Methode find gibt die erste Übereinstimmung als eine Match-Struktur zurück, die den Anfang und das Ende der Übereinstimmung enthält:

use regex::Regex;

fn main() {    let re = Regex::new(r"\\b\\w+@\\w+\\.\\w+\\b").unwrap();    let text = "Meine E-Mail: user@example.com, sowie admin@test.org";

    if let Some(mat) = re.find(text) {        println!("E-Mail gefunden: {}", mat.as_str());        println!("Position: {}..{}", mat.start(), mat.end());    }}

Ergebnis der Ausführung:

E-Mail gefunden: user@example.comPosition: 13..29

2.3 Suche nach allen Übereinstimmungen (find_iter)

Um alle Übereinstimmungen zu erhalten, wird der Iterator find_iter verwendet:

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: {}", mat.as_str());    }}

Ausgabe:

Zahl: 100Zahl: 250Zahl: 500

3. Extrahieren von Gruppen mit erfassenden Klammern

Eine der mächtigsten Funktionen von regex sind erfassende Gruppen. Sie ermöglichen das Extrahieren von Teilen einer Übereinstimmung:

use regex::Regex;

fn main() {    let re = Regex::new(r"(\\w+)@(\\w+)\\.(\\w+)").unwrap();    let text = "user@example.com";

    if let Some(caps) = re.captures(text) {        println!("Vollständige E-Mail: {}", &caps[0]);        println!("Benutzername: {}", &caps[1]);        println!("Domain: {}", &caps[2]);        println!("Zone: {}", &caps[3]);    }}

Gruppen werden ab 1 nummeriert. Gruppe 0 ist die gesamte Übereinstimmung.

Es können auch benannte Gruppen für einen lesbareren Code verwendet werden:

use regex::Regex;

fn main() {    let re = Regex::new(r"(?P<name>\\w+)@(?P<domain>\\w+\\.\\w+)").unwrap();    let text = "admin@test.org";

    if let Some(caps) = re.captures(text) {        println!("Name: {}", caps.name("name").unwrap().as_str
```