Expressions régulières en Rust : guide complet avec exemples

Introduction : Les expressions régulières en Rust — un outil puissant pour le traitement de texte

Les expressions régulières (regex) sont une partie essentielle de l'arsenal de tout développeur travaillant avec du texte. En Rust, réputé pour ses performances et sa sécurité, le travail avec les expressions régulières est implémenté via la célèbre crate regex. Cette bibliothèque offre un moyen rapide et fiable de rechercher, d'extraire et de remplacer des motifs textuels.

Dans cet article, nous allons détailler comment utiliser les expressions régulières en Rust : de l'installation de la crate aux techniques avancées. Vous apprendrez à vérifier des correspondances, à extraire des données, à remplacer du texte et à gérer les erreurs. Tous les exemples de code sont écrits en Rust et prêts à être utilisés.

1. Installation et connexion de la crate regex

Pour travailler avec les expressions régulières en Rust, il est nécessaire d'ajouter la crate regex dans le fichier Cargo.toml :

[dependencies]regex = "1"

Ensuite, vous pouvez importer les modules nécessaires dans le code :

use regex::Regex;

La crate regex compile automatiquement les expressions régulières dans un format interne efficace, ce qui garantit une grande vitesse d'exécution.

2. Opérations de base avec regex en Rust

2.1 Vérification de correspondance (is_match)

La méthode is_match retourne true si la chaîne contient au moins une correspondance avec le motif :

use regex::Regex;

fn main() {    let re = Regex::new(r"\\d+").unwrap();    let text = "Aujourd'hui nous sommes le 25 décembre";

    if re.is_match(text) {        println!("La chaîne contient des nombres");    } else {        println!("Aucun nombre trouvé");    }}

Cette méthode est utile pour une validation rapide : vérifier si une chaîne contient un email, un téléphone ou d'autres motifs.

2.2 Recherche de la première correspondance (find)

La méthode find retourne la première correspondance sous la forme d'une structure Match, qui contient le début et la fin de la correspondance :

use regex::Regex;

fn main() {    let re = Regex::new(r"\\b\\w+@\\w+\\.\\w+\\b").unwrap();    let text = "Mon email : user@example.com, ainsi que admin@test.org";

    if let Some(mat) = re.find(text) {        println!("Email trouvé : {}", mat.as_str());        println!("Position : {}..{}", mat.start(), mat.end());    }}

Résultat de l'exécution :

Email trouvé : user@example.comPosition : 11..27

2.3 Recherche de toutes les correspondances (find_iter)

Pour obtenir toutes les correspondances, on utilise l'itérateur find_iter :

use regex::Regex;

fn main() {    let re = Regex::new(r"\\d+").unwrap();    let text = "Prix : 100, 250 et 500 roubles";

    for mat in re.find_iter(text) {        println!("Nombre : {}", mat.as_str());    }}

Affichage :

Nombre : 100Nombre : 250Nombre : 500

3. Extraction de groupes à l'aide de parenthèses capturantes

L'une des fonctionnalités les plus puissantes des regex est les groupes capturants. Ils permettent d'extraire des parties de la correspondance :

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!("Email complet : {}", &caps[0]);        println!("Nom d'utilisateur : {}", &caps[1]);        println!("Domaine : {}", &caps[2]);        println!("Zone : {}", &caps[3]);    }}

Les groupes sont numérotés à partir de 1. Le groupe 0 correspond à l'intégralité de la correspondance.

On peut également utiliser des groupes nommés pour un code plus lisible :

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!("Nom : {}", caps.name("name").unwrap().as_str
```