pteuz Wiki

This page is read only. You can view the source, but not change it. Ask your administrator if you think this is wrong.
======Expressions régulières======

Les expressions régulières, ou expressions rationnelles, ou motifs (ou même regexp en anglais), sont une suite de caractères issues de la logique (mathématique), qui permettent de décrire des chaînes de caractères. Il existe différentes notations, bien qu'elles se ressemblent beaucoup : POSIX, PCRE (Perl-Compatible Regular Expressions), Python, etc... [[https://fr.wikipedia.org/wiki/Expression_rationnelle#Standardisation|(plus de détails sur wikipedia)]]

Penser à consulter un testeur d'expression régulière, comme l'excellent [[https://regex101.com/|regex101]], ou le visualiseur [[https://jex.im/regulex/#!flags=&re=%5E(a%7Cb)*%3F%24|jex.im]].

=====Syntaxe=====

<code bash>
[]  définissent une liste de caractères
()  définissent un élément composé de l'expression régulière qu'elle contient (un bloc)
    (?: parenthèses non capturantes
    (?= motif obligatoire
{}  contiennent un ou plusieurs chiffres séparés par des virgules, qui indiquent le nombre d'occurence
    attendu de l'élément précédant les accolades (par exemple p{3,5} correspond à ppp, pppp ou ppppp)
-   défini un intervalle (par exemple [a-d] équivaut à [abcd])
.   représente un caractère unique
*   zéro ou plusieurs
+   un ou plusieurs
?   zéro ou un
|   OU (lard|cochon)
^   Placé en début d'expression il signifie "chaîne commençant par .. "
    Utilisé à l'intérieur d'une liste c'est un "non"
$   Placé en fin d'expression il signifie "chaîne finissant par .. "
</code>

Les parenthèses sont capturantes par défaut, ce qui veut dire que ce qu'elles matchent peut être récupéré ensuite dans des variables. Par exemple:
<code bash>
echo "je suis heureux" | sed 's/.* \([^ .]*\)/\1 je suis/'
 heureux je suis
</code>
les parenthèses ''\(\)'' encadrent le motif qui matche le dernier mot de la phrase, que l'on récupère ensuite avec la variable ''\1'' (parce que c'est la première parenthèse capturante ; ça marche aussi avec  ''\2'', ''\3'', etc...

Si on veut utiliser des parenthèses dans une regexp mais que l'on ne veux pas récupérer leur contenu, on gagne en performance en les déclarant **non capturantes**, en préfixant leur contenu par ''?:'' :
<code bash>
echo "je suis heureux" | sed 's/.* \(?:[^ .]*\)/\1 je suis/'
</code>

''(?=truc)'' indique que le motif "truc" doit être trouvé pour valider l'ensemble de l'expression régulière (voir exemple du mot de passe plus bas).


=====Les classes de caractères prédéfinis=====

Ils se caractérisent pas la notation **[:classe:]** :
<code bash>
[:alnum:]  caractères alphanumériques (équivalent à [A-Za-z0-9])
[:alpha:]  caractères alphabétiques ([A-Za-z])
[:blank:]  caractères blancs (espace, tabulation)
[:ctrl:]   caractères de contrôle (les premiers du code ASCII)
[:digit:]  chiffres ([0-9])
[:graph:]  caractères d'imprimerie (affichage à l'écran en quelque sorte)
[:lower:]  caractères minuscules ([a-z])
[:print:]  caractères imprimables (tout sauf les caractères de contrôle)
[:punct:]  caractères de ponctuation
[:space:]  caractères d'espacement
[:upper:]  caractères majuscules ([A-Z])
[:xdigit:] caractères hexadécimaux
</code>


=====Cheat sheets=====

{{ :informatique:regex.jpg |}}


=====Exemples=====

  * matcher chaque ligne qui ne contient pas le MOTIF (exclure le motif)
<code bash>
^((?!MOTIF).)*$

# alt : ne pas matcher les lignes qui commencent par MOTIF :
^(?!MOTIF).*$
</code>
src stackoverflow : [[https://stackoverflow.com/questions/406230/regular-expression-to-match-a-line-that-doesnt-contain-a-word|Regular expression to match a line that doesn't contain a word]]

  * Valider une URL :
<code bash>
^(https?:\/\/)?([\da-z\.-]+)\.([a-z\.]{2,6})([\/\w \?=.-]*)*\/?$
</code>

  * Valider une adresse IPv4
<code bash>
((^|\.)((25[0-5])|(2[0-4]\d)|(1\d\d)|([1-9]?\d))){4}$
</code>

  * Valider un mot de passe de 8 caractères minimum, contenant au moins un chiffre, une minuscule, une majuscule, et un caractère spécial :
<code bash>
^(?=.*[0-9])(?=.*[a-z])(?=.*[A-Z])(?=.*[@#$%^&+=.\-_*])([a-zA-Z0-9@#$%^&+=*.\-_]){8,}$
</code>

  * valider une adresse email selon le RFC 5322 (source : [[https://regex101.com/r/gJ7pU0/1|regex101]])
<code bash>
/(?(DEFINE)
    (?<addr_spec> (?&local_part) @ (?&domain) )
    (?<local_part> (?&dot_atom) | (?&quoted_string) | (?&obs_local_part) )
    (?<domain> (?&dot_atom) | (?&domain_literal) | (?&obs_domain) )
    (?<domain_literal> (?&CFWS)? \[ (?: (?&FWS)? (?&dtext) )* (?&FWS)? \] (?&CFWS)? )
    (?<dtext> [\x21-\x5a] | [\x5e-\x7e] | (?&obs_dtext) )
    (?<quoted_pair> \\ (?: (?&VCHAR) | (?&WSP) ) | (?&obs_qp) )
    (?<dot_atom> (?&CFWS)? (?&dot_atom_text) (?&CFWS)? )
    (?<dot_atom_text> (?&atext) (?: \. (?&atext) )* )
    (?<atext> [a-zA-Z0-9!#$%&'*+\/=?^_`{|}~-]+ )
    (?<atom> (?&CFWS)? (?&atext) (?&CFWS)? )
    (?<word> (?&atom) | (?&quoted_string) )
    (?<quoted_string> (?&CFWS)? " (?: (?&FWS)? (?&qcontent) )* (?&FWS)? " (?&CFWS)? )
    (?<qcontent> (?&qtext) | (?&quoted_pair) )
    (?<qtext> \x21 | [\x23-\x5b] | [\x5d-\x7e] | (?&obs_qtext) )
    # comments and whitespace
    (?<FWS> (?: (?&WSP)* \r\n )? (?&WSP)+ | (?&obs_FWS) )
    (?<CFWS> (?: (?&FWS)? (?&comment) )+ (?&FWS)? | (?&FWS) )
    (?<comment> \( (?: (?&FWS)? (?&ccontent) )* (?&FWS)? \) )
    (?<ccontent> (?&ctext) | (?&quoted_pair) | (?&comment) )
    (?<ctext> [\x21-\x27] | [\x2a-\x5b] | [\x5d-\x7e] | (?&obs_ctext) )
    # obsolete tokens
    (?<obs_domain> (?&atom) (?: \. (?&atom) )* )
    (?<obs_local_part> (?&word) (?: \. (?&word) )* )
    (?<obs_dtext> (?&obs_NO_WS_CTL) | (?&quoted_pair) )
    (?<obs_qp> \\ (?: \x00 | (?&obs_NO_WS_CTL) | \n | \r ) )
    (?<obs_FWS> (?&WSP)+ (?: \r\n (?&WSP)+ )* )
    (?<obs_ctext> (?&obs_NO_WS_CTL) )
    (?<obs_qtext> (?&obs_NO_WS_CTL) )
    (?<obs_NO_WS_CTL> [\x01-\x08] | \x0b | \x0c | [\x0e-\x1f] | \x7f )
    # character class definitions
    (?<VCHAR> [\x21-\x7E] )
    (?<WSP> [ \t] )
)
^(?&addr_spec)$/xmg
</code>