Généralités

Le Rust a été conçu par Graydon Hoare en 2006 alors que celui-ci travaillait pour Mozilla Research. C’est un langage compilé et multi-paradigmes dans le sens où, entre autres :

Il est adapté à la programmation système du fait de ses bonnes performances et de la sécurité qu’il offre pour la gestion mémoire et la gestion de la durée de vie des variables.
Il présente des similitudes avec la programmation fonctionnelle, son concepteur ayant été influencé par Ocaml.
Il possède des points communs avec les langages orientés objet.
Il peut gérer les exécutions en parallèle et empêcher les problèmes d’accès concurrents (race condition) dès la compilation.

Tous ces points forts font de lui un langage prisé par de nombreux développeurs, et qui peut être utilisé aussi bien pour développer des logiciels embarqués que des applications performantes. C’est un langage relativement jeune qui va probablement encore évoluer, mais qui est déjà supporté par un grand nombre de plates-formes. Ses grandes qualités ont pour conséquence le fait que la population de ses adeptes est en croissance relativement rapide, malgré les difficultés que l’on peut rencontrer...

Les expressions régulières

Les expressions régulières utilisées par Rust lui sont spécifiques, mais elles sont toutefois très proches du standard PCRE. Elles nécessitent l’utilisation du paquet (crate) regex pour pouvoir être utilisées. Comme pour Julia, C# et d’autres langages, il est possible de spécifier les expressions régulières au format chaînes de caractères sous deux formes différentes : une forme classique de chaînes de caractères dans laquelle les caractères \ (antislash, ou backslash) doivent être doublés, et une forme d’expression régulière dans laquelle les séquences de caractères utilisant un backslash sont comprises et reconnues par les fonctions les manipulant.

Exemples

let re= Regex::new("^\\+?\\d{1,2}\\-?\\d{3,4}\\-?\\d{5,6}");

let re = Regex::new(r"^\+?\d{1,2}\-?\d{3,4}\-?\d{5,6}");

Il est également possible de spécifier des flags à l’intérieur de l’expression régulière aux formats suivants :

(?flags)

ou :

(?flags:expression)

Dans ce cas, l’expression entre parenthèses n’est pas capturée.

Les flags utilisables sont :

i : ignore la casse des lettres.

m : mode multiligne : ^ et $ correspondent...

Manipulation des expressions régulières

1. Compilation d’expression régulière

a. Fonction Regex::new()

La fonction Regex::new() compile une expression régulière sous forme de chaîne de caractères et retourne un objet de type expression régulière compilée. Elle permet de compiler très simplement une expression sans paramètres additionnels. Son utilisation nécessite la directive :

use regex::Regex;

Syntaxe

impl Regex {  
   pub fn new(regex: &str) -> Result<Regex, regex::Error>;  
}

avec :

regex : expression régulière sous forme de chaîne de caractères.

Result : objet de type Regex si l’expression peut être compilée, ou interface d’erreur dans le cas contraire.

Exemples

let regex = Regex::new(r"\d{4}-\d{2}-\d{2}");

let regex = Regex::new("\\d{4}-\\d{2}-\\d{2}");

b. Fonction RegexBuilder::new()

La fonction RegexBuilder::new() permet également la compilation d’une expression régulière, mais possède des fonctionnalités dont Regex::new() est dépourvue. Il lui est notamment possible de spécifier des flags destinés à modifier l’interprétation de l’expression. Ces flags peuvent être modifiés avant la compilation d’expression.

L’utilisation de cette fonction nécessite la directive :

use regex::RegexBuilder;