Les expressions régulières, souvent abrégées en regex, sont des séquences de caractères définissant des motifs de recherche. Elles permettent de valider, rechercher ou remplacer du texte de manière flexible. Par exemple, dans un système de fichiers, des caractères génériques comme ? et * simplifient la recherche : un modèle tel que 'data?.dat' correspond à des fichiers comme data1.dat ou data2.dat, tandis que 'data*.dat' élargit la sélection. Cependant, les regex offrent une puissance bien supérieure à ces métacaractères limités.

L'origine des expressions régulières remonte aux travaux en neurophysiologie de Warren McCulloch et Walter Pitts, qui ont modélisé mathématiquement les réseaux neuronaux. En 1956, Stephen Kleene a formalisé le concept dans son article sur les "algèbres d'événements neuronaux", d'où le terme "régulier". Cette théorie a été appliquée aux algorithmes de recherche de Ken Thompson, intégrée dans l'éditeur qed d'Unix, devenant un outil essentiel dans les éditeurs de texte et les utilitaires de recherche.

Les expressions régulières s'avèrent utiles dans diverses tâches : valider des données (comme vérifier un numéro de téléphone), effectuer des remplacements ciblés dans des documents, ou extraire des sous-chaînes à partir de motifs. Par exemple, pour mettre à jour un site web, on peut utiliser des regex pour identifier et modifier des balises HTML ou du contenu obsolète. Dans des langages comme VBScript ou JScript, les regex améliorent considérablement les capacités de manipluation de chaînes, permettant des opérations complexes en une seule expression.

Une expression régulière est composée de caractères ordinaires (lettres, chiffres) et de métacaractères spéciaux. Elle agit comme un modèle pour correspondre à des chaînes spécifiques. Voici des exemples courants : une regex comme /\[\t\s\]*$/ en JScript ou "[\t\s]*" en VBScript détecte une ligne vide, tandis que /\d{2}-\d{5}/ ou "\d{2}-\d{5}" valide un identifiant composé de deux chiffres, un tiret et cinq chiffres. Un modèle tel que /<(.*)>.*<\/\1>/ ou "<(.*)>.*<\/\1>" correspond à une balise HTML.

Les métacaractères définissent des comportmeents spécifiques. Par exemple, \ échappe le caractère suivant, ^ et $ ancrent respectivement le début et la fin d'une chaîne, tandis que *, + et ? contrôlent les répétitions (zéro ou plusieurs fois, une ou plusieurs fois, zéro ou une fois). Les accolades {n}, {n,} et {n,m} précisent les occurrences exactes, minimales ou dans une plage. Le point . correspond à n'importe quel caractère sauf le saut de ligne, et les parenthèses () capturent des groupes pour référence ultérieure. D'autres métacaractères comme \b délimitent les mots, et \d, \s, \w correspondent respectivement aux chiffres, espaces et caractères alphanumériques.

La construction d'une regex suit une logique similaire aux expressions mathématiques, avec des opérateurs et une hiérarchie de priorité. Les opérateurs d'échappement \ ont la priorité la plus élevée, suivis des parenthèses et crochets, puis des quantificateurs *, +, ?, des ancres ^ et $, et enfin de l'opérateur d'alternance |. En JScript, les regex sont délimitées par des slashes /expression/, tandis qu'en VBScript, elles sont entre guillemets "expression".

Les caractères ordinaires correspondent à eux-mêmes dans une chaîne. Par exemple, la regex /a/ ou "a" trouve la lettre 'a'. Pour inclure des caractères spéciaux comme $, (, *, +, ., [, ?, \, ^, {, |, il faut les échapper avec \. Par exemple, /\$/ correspond au dollar, et /\./ à un point littéral.

Les caractères non imprimables, utiles pour des opérations de formatage, s'échappent via des séquences comme \n pour un saut de ligne, \t pour une tabulation, ou \s pour tout espace blanc. \c*x représente un caractère de contrôle, comme \cM pour un retour chariot.

La correspondance de caractères peut être affinée avec des plages et ensembles dans des crochets []. Par exemple, /[a-z]/ correspond à toute lettre minuscule, et /[^0-9]/ à tout caractère non numérique. Pour inclure un tiret, on peut utiliser [-a-z] ou [a-z-]. Un exemple pratique est /[A-Za-z0-9]/ pour correspondre aux caractères alphanumériques.

Les quantificateurs adaptent la correspondance aux occurrences variables. *, +, ? et les accolades spécifient le nombre de répétitions. Par exemple, la regex /Chapter [1-9][0-9]*/ en JScript ou "Chapter [1-9][0-9]*" en VBScript correspond à des numéros de chapitre à plusieurs chiffres. Pour limiter à deux chiffres, on utilise /[0-9]{1,2}/. Les quantificateurs sont gourmands par défaut (matching maximal), mais un ? après *, + ou ? les rend non gorumands (matching minimal), comme /<.*?>/ pour une balise HTML concise.

Voici des exemples de code adaptés. En Python, pour valider un email :

import re
email_pattern = r'^[\w.-]+@[\w.-]+\.\w+$'
test_string = "utilisateur@exemple.com"
if re.match(email_pattern, test_string):
    print("Email valide")

En JavaScript, pour extraire des URLs :

const urlPattern = /https?:\/\/[\w.-]+\.\w+/;
const text = "Visitez https://example.com ou http://test.org";
const urls = text.match(urlPattern);
console.log(urls); // ["https://example.com", "http://test.org"]

En Perl, pour remplacer des espaces multiples :

$texte = "Exemple   avec   espaces";
$texte =~ s/\s+/ /g;
print $texte; # "Exemple avec espaces"