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

Expressions régulières en Rust : un outil puissant pour travailler avec les chaînes de caractères

Les expressions régulières (regex) sont un outil indispensable pour rechercher, extraire et remplacer du texte selon un motif donné. En Rust, le travail avec les expressions régulières est implémenté via la crate populaire regex, qui offre des performances élevées et la sécurité caractéristiques du langage. Dans cet article, nous allons explorer les bases du travail avec les expressions régulières en Rust à travers des exemples concrets.

Installation et importation de la crate regex

Pour commencer, ajoutez la dépendance dans le fichier Cargo.toml de votre projet :

[dependencies]regex = "1"

Ensuite, importez les modules nécessaires dans votre code :

use regex::Regex;

Création et utilisation de base des expressions régulières

Le type principal pour travailler avec les expressions régulières est Regex. Il est créé à l'aide de la méthode Regex::new(), qui prend une chaîne de caractères avec le motif et retourne un Result. Examinons un exemple simple de recherche d'un mot dans une chaîne :

use regex::Regex;

fn main() {    let re = Regex::new(r"hello").unwrap();    let text = "hello world, hello Rust!";        // Vérification de la présence d'une correspondance    if re.is_match(text) {        println!("Correspondance trouvée !");    }        // Recherche de la première correspondance    match re.find(text) {        Some(mat) => println!("Trouvé : '{}'", mat.as_str()),        None => println!("Aucune correspondance"),    }        // Recherche de toutes les correspondances    for mat in re.find_iter(text) {        println!("Trouvé : '{}' à la position {}", mat.as_str(), mat.start());    }}

Notez l'utilisation de la chaîne brute (r"..."). Cela permet d'éviter l'échappement des barres obliques inverses, ce qui est particulièrement pratique lors du travail avec les expressions régulières.

Groupes de capture et extraction de données

Les groupes de capture permettent d'extraire des parties de la chaîne correspondant à certaines parties du motif. En Rust, les groupes sont indiqués par des parenthèses () :

use regex::Regex;

fn main() {    // Extraction d'une date au format AAAA-MM-JJ    let re = Regex::new(r"(\\d{4})-(\\d{2})-(\\d{2})").unwrap();    let text = "Aujourd'hui : 2024-01-15, hier : 2024-01-14";        for cap in re.captures_iter(text) {        println!("Année : {}, Mois : {}, Jour : {}",                  &cap[1], &cap[2], &cap[3]);    }        // Extraction d'adresses email    let email_re = Regex::new(r"([\\w.]+)@([\\w.]+)").unwrap();    let email_text = "Contacts : user@example.com, admin@test.org";        if let Some(caps) = email_re.captures(email_text) {        println!("Nom d'utilisateur : {}", &caps[1]);        println!("Domaine : {}", &caps[2]);    }}

Les groupes peuvent être nommés pour améliorer la lisibilité du code :

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 = "2024-01-15";        if let Some(caps) = re.captures(text) {        println!("Année : {}", caps.name("year").unwrap().as_str());        println!("Mois : {}", caps.name("month").unwrap().as_str());        println!("Jour : {}", caps.name("day").unwrap().as_str());    }}

Remplacement de texte à l'aide d'expressions régulières

La crate regex fournit des méthodes puissantes pour le remplacement de texte. Examinons plusieurs variantes :

use regex::Regex;

fn main() {    let re = Regex::new(r"\\d+").unwrap();    let text = "J'ai 2 chats et 3 chiens";        // Remplacement simple de tous les chiffres par un mot    let result = re.replace_all(text, "plusieurs");    println!("{}", result); // "J'ai plusieurs chats et plusieurs chiens"        // Remplacement avec utilisation de groupes de capture    let re2 = Regex::new(r"(\\w+)@(\\w+)").unwrap();    let email = "user@example.com";    let replaced = re2.rep