Expressions régulières

Les expressions régulières (regexps, REs) sont un outil puissant de création de modèle qui peuvent être utilisées pour rechercher et comparer n'importe quel symbole et chaînes de caractères (même les plus complexes) dans un texte.

Comment un tel modèle est-il composé ? Cela se fait avec l'aide de caractères spéciaux, méta-caractères et classes de caractères (sets). une expression régulière est une simple chaîne, et chaque caractère la composant qui n'est pas un caractère spécial (réservé), est traité comme lui-même.

Les caractères spéciaux sont divisés en trois groupes :

• les caractères du premier groupe correspondent à une certaine classe de caractères (set) : l'expression "\w" correspond à "n'importe quel caractère".
• les caractères du second groupe, contrairement à ceux du premier, n'ont pas de longueur définie (aussi appelés 'caractère de taille nulle'): "^" correspond au début d'une ligne, "\b" correspond au début d'un mot.
• le troisième groupe inclut les opérateurs. Les opérateurs s'appliquent aux méta-caractères, caractères courants et aux autres opérateurs.

On peut grouper plusieurs expressions (en les plaçant entre parenthèses) et appliquer un opérateur au groupe entier.

La syntaxe des expressions régulières dans nnBackup est la même que celle du langage Perl, avec quelques minimes différences pour certains opérateurs étendus.

Syntaxe

Toutes les expressions régulières doivent être entre des slashes (/.../). Des paramètres peuvent être placés après le dernier slash :

/.../i	- ignore les différences de casse.
/.../x	- ignore les espaces et les sauts de ligne (selon les choix).
/.../s	- traite l'expression régulière comme une simple ligne (prend le caractère spécial "." comme un simple caractère, y compris le caractère de début de ligne).

Examples:

\ matches only word 'Valery'
/Valery/
\ matches words  'VALERY', 'valery', 'Valery' etc.
/Valery/i 
\ matches  'foobar', 'foobar barfoo'
/foobar/
\ matches  'foobar', 'FOOBAR', 'foobar and two other foos'
/ FOO bar /ix
\ matches 'Valery%crlf%Kondakoff'
/Valery.*Kondakoff/s

Tous les caractères d'une expression régulière sont consécutivement (de gauche à droite) comparés à la chaîne cible. Tous les caractères qui ne sont pas des caractères spéciaux ou des opérateurs listés ci-dessous sont simplement traités comme eux-même et testés pour une simple correspondance.

Caractères spéciaux

Exemples :

\ matches word  'help' followed by a stop
/help\./
\ matches words 'cats', 'cars' etc.
/ca.s/
\ matches  'testing', 'tester', but not 'the test'
/^test/
\ matches 'see me', but not 'meter' or 'me and you'
/me$/
\ matches one of the vowels
/[aeiou]/
\ matches one letter or digit
/[a-z0-9]/
\ matches 'footer', 'footing', 'a foot', but not 'afoot'
/\bfoot/
\ matches 'afoot', 'foot.' (stop is not considered a part of the word)
\ doesn't  match 'footing'
/foot\B/
\ matches whole word 'foot' only
/\bfoot\B/
\ matches words 'q2w', 'r5t' etc.
/\D\d\D/

Caractères spéciaux étendus

Contrairement aux caractères spéciaux ordinaires, ceux étendus ne sont pas compatibles avec Perl :

Exemple :

\ matches phrases 'man to man', '
\ hand to hand', '100 to 100' etc.
(\b\w+\B) to \1

Opérateurs

Les opérateurs ne peuvent pas être utilisés par eux-mêmes, ils doivent être précédés par un caractères ou méta-caractère qu'ils affecteront. Si un opérateur est précédé par des expressions entre parenthèses, il affectera le contenu entier de la parenthèse.

( ... )	Groupe des caractères dans une seule expression et la garde en mémoire. Marque le début et la fin d'une sous-expression. Les sous-expressions peuvent être capturées pour une utilisation ultérieure.
|	Expression précédente ou suivante (OU logique)
*	Correspond zéro ou plusieurs fois au caractère ou à la sous-expression qui précède.
+	Correspond une ou plusieurs fois au caractère ou à la sous-expression qui précède
?	Correspond zéro ou une fois au caractère ou à la sous-expression qui précède
{n}	A répéter n fois
{n,}	A répéter n ou plusieurs fois
{n,m}	A répéter n à m fois

Exemples :

\ matches words 'cat' или 'mouse'
/(cat)|(mouse)/

\ matches words 'dogs', 'doggie'
/dog(s|gie)/
\ matches 'ma', 'maaa', 'maaaaaaa'
/ma+/
\ matches 'm', 'maaa'
/ma*/
\ matches 'yada yada yada'
/(yada ){2,}/
\ matches 'fooandbar', 'foobar'
/foo(and)?bar/

Si vous ajoutez un caractère "?" après un opérateur, ceci changera un opérateur goumand en opérateur non-gourmand. Par exemple, un opérateur gourmand "*" deviendra un opérateur non-gourmand une fois remplacé par "*?". Les opérateurs gourmands correspond à la plus grande partie possible, un opérateur non-gourmand correspond à la partie la plus petite possible

Opérateurs étendus

?#N	Cherche après l'opérateur . N est le nombre de caractères à rechercher.
?~N	Ne cherche pas après.
?=	Cherche avant.
?!	Ne cherche pas avant.

Notez que les deux derniers opérateurs existents en Perl, ils sont utilisés de cette façon : (?=foobar). Dans nnCron, cet opérateur ressemble à ça : (foobar)?=.

Exemples :

\ matches any word followed by a tab character, 
\ the tab character itself not  included with the mathing characters
/\w+(\t)?=/
\ matches any instance of 'foo' which is not followed by 'bar'
/foo(bar)?!/
\ matches any instance of 'bar' not preceded by 'foo'
/(foo)?#3bar/ 

Plus d'exemples :

\ matches "foobar", "bar"
/(foo)?bar/
\ matches only "foobar"
/^foobar$/
\ matches "foobar", "for", "far"
/f[obar]+r/
\ any number with a decimal point
/([\d\.])+/
\ matches "foofoofoobarfoobar", "bar"
/((foo)|(bar))+/