Manuel PHP
Précédent |  | Suivant

# syntaxe des masques

syntaxe des masques -- Fonctionnement des expressions rationnelles

## Description

La bibliothèque PCRE est un ensemble de fonctions qui implémentent la recherche par expressions rationnelles, en utilisant la même syntaxe et la même sémantique que le Perl 5, avec quelques nuances (voir ci-dessous). L'implémentation actuelle est celle de Perl 5.005.

## Différences avec Perl

Les différences avec le Perl 5.005 sont présentées ici :

1. Par défaut, un caractère d'espacement correspond à n'importe quel caractère que la fonction C `isspace()` reconnaît, bien qu'il soit possible de recompiler la bibliothèque PCRE avec d'autres tables de caractères. Normalement, `isspace()` retourne `TRUE` pour les espaces, les retours chariot, les nouvelles lignes, les formfeed, les tabulations verticales et horizontales. Le Perl 5 n'accepte plus la tabulation verticale comme caractère d'espacement. La séquence \v qui était dans la documentation Perl depuis longtemps n'a jamais été reconnue. Cependant, la tabulation verticale elle-même était reconnue comme un caractère d'espacement jusqu'à la version 5.002. Avec les versions 5.004 et 5.005, l'option \s l'ignore.

2. PRCE ne tolère pas la répétition de quantificateurs dans les expressions. Perl le permet, mais cela ne signifie pas ce que vous pourriez penser. Par exemple, (?!a){3} ne s'interprète pas : les trois caractères suivants ne sont pas des "a". En fait, cela s'interprète comme : le caractère suivant n'est pas "a" trois fois.

3. Les occurrences de sous-masques qui interviennent dans des assertions négatives sont comptées, mais elles ne sont pas enregistrées dans le vecteur d'occurrences. Perl modifie ses variables numériques pour toutes les occurrences de sous-masque, avant que l'assertion ne vérifie le masque entier, et uniquement si les sous-masques ne trouvent qu'une seule occurrence.

4. Bien que les caractères nul soient tolérés dans la chaîne de recherche, ils ne sont pas acceptés dans le masque, car le masque est utilisé comme une chaîne C standard, terminée par le caractère nul. Il faut donc utiliser la séquence d'échappement "\x00" dans le masque pour rechercher les caractères nul.

5. Les séquence d'échappement suivantes ne sont pas supportées par le Perl: \l, \u, \L, \U. En fait, elles sont implémentées par la gestion intrinsèque de chaînes du Perl, et ne font pas partie de ses caractères spéciaux.

6. L'assertion \G du Perl n'est pas supportée car elle n'est pas pertinente pour faire des recherches avec des masques uniques.

7. De manière assez évidente, PCRE n'accepte pas la construction `(?{code})`.

8. Au moment de l'écriture de PCRE, Perl 5.005_02 avait quelques comportements étranges avec la capture des chaînes lorsqu'une partie du masque est redoublée. Par exemple, "aba" avec le masque /^(a(b)?)+$/ va affecter à $2 la valeur "b", mais la même manipulation avec "aabbaa" et /^(aa(bb)?)+$/ laissera $2 vide. Cependant, si le masque est remplacé par /^(aa(b(b))?)+$/ alors $2 (et d'ailleurs $3) seront correctement affectés. Avec le Perl 5.004, $2 sera correctement affecté dans les deux cas, et c'est aussi vrai avec PCRE. Si Perl évolue vers un autre comportement cohérent, PCRE s'adaptera probablement.

9. Une autre différence encore non résolue est le fait qu'en Perl 5.005_02 le masque /^(a)?(?(1)a|b)+$/ accepte la chaîne "a", tandis que PCRE ne l'accepte pas. Cependant, que ce soit avec Perl ou PCRE /^(a)?a/ et "a" laisseront $1 vide.

10. PCRE propose quelques extensions aux expressions rationnelles du Perl.

    1. (a) Bien que les assertions arrières (`lookbehind`) soient obligées de rechercher une chaîne de longueur fixe, toutes les assertions arrières peuvent avoir une longueur différente. Perl 5.005 leur impose d'avoir toutes la même longueur.

    2. (b) Si PCRE_DOLLAR_ENDONLY est activé, et que PCRE_MULTILINE ne l'est pas, le méta caractère `$` ne s'applique qu'à la fin physique de la chaîne, et non pas avant les caractères de nouvelle ligne.

    3. (c) Si PCRE_EXTRA est activé, un anti-slash suivi d'une lettre sans signification spéciale est considéré comme une erreur.

    4. (d) Si PCRE_UNGREEDY est activé, la "gourmandise" des quantificateurs de répétition est inversée, ce qui est rend non gourmand par défaut, mais s'ils sont suivis de ?, il seront gourmands.

## Détails sur les expressions rationnelles

### Introduction

La syntaxe et la sémantique des expressions rationnelles supportées par PCRE sont décrites ci-dessous. Les expressions rationnelles sont aussi décrites dans la documentation Perl, et dans un grand nombre d'autres livres, avec de nombreux exemples. Le libre de Jeffrey Friedl "Mastering Regular Expressions", édité chez O'Reilly (ISBN 1-56592-257-3), les décrits en profondeur. Cette description est organisée comme une documentation de référence.

Une expression rationnelle est un masque appliqué à une chaîne sujet, de gauche à droite. La plupart des caractères se représentent eux-mêmes. Un exemple trivial : un masque qui serait "`Le rapide renard gris`", pourra correspondre à une partie de la chaîne sujet qui sera identique au masque, par exemple "`Le rapide renard gris court dans la forêt`",

### Méta-caractères

La puissance des expressions rationnelles provient de leur capacité à autoriser des alternatives et des quantificateurs de répétition dans le masque. Ils sont encodés dans le masque par des méta-caractères, qui ne représentent pas ce qu'ils sont, mais sont interprétés d'une certaine manière.

Il y a deux sortes de méta-caractères : ceux qui sont reconnus n'importe où dans un masque, hormis entre crochets, et ceux qui sont reconnus entre crochets.

À l'extérieur des crochets, les méta-caractères sont :

\ anti-slash

  Caractère d'échappement, avec de multiples usages

^ Accent circonflexe

  Le début de la chaîne sujet (ou de ligne, en mode multi-lignes)

$ Dollar

  La fin de la chaîne sujet (ou de ligne, en mode multi-lignes)

. Point

  Remplace n'importe quel caractère, hormis le caractère de nouvelle ligne (par défaut) ;

[ Crochet ouvrant

  Caractère de début de définition de classe

] Crochet fermant

  Caractère de fin de définition de classe

| Barre verticale

  Caractère de début d'alternative

( Parenthèse ouvrante

  Caractère de début de sous-masque

) Parenthèse fermante

  Caractère de fin de sous-masque

? Point d'interrogation

  Etend le sens de (; quantificateur de 0 ou 1; quantificateur de minimisation

* Etoile

  Quantificateur de 0 ou plus

+ Plus

  Quantificateur de 1 ou plus

{ Accolade ouvrante

  Caractère de début de quantificateur minimum/maximum

} Accolade fermante

  Caractère de fin de quantificateur minimum/maximum

La partie du masque qui est entourée de crochets est appelée classe de caractères. Dans les classes de caractères, les seuls méta-caractères autorisés sont :

\ Anti-slash

  Caractère d'échappement, avec de multiples usages

^ Accent circonflexe

  Négation de la classe, mais uniquement si placé tout au début de la classe

- Moins

  Indique un intervalle de caractères

] Crochet fermant

  Termine la classe de caractères

La section suivante décrit l'utilisation de chaque méta-caractère.

### Anti-slash

Le caractère anti-slash a de nombreuses utilisations. En premier lieu, s'il est suivi d'un caractère non alpha-numérique, il ne prendra pas la signification spéciale qui y est rattachée. Cette utilisation de l'anti-slash comme caractère d'échappement s'applique à l'intérieur et à l'extérieur des classes de caractères.

Par exemple, pour rechercher le caractère étoile "`*`", il faut écrire dans le masque : "`\*`". Cela s'applique dans tous les cas, que le caractère qui suive soit un méta-caractère ou non. C'est un moyen sûr pour s'assurer qu'un caractère sera recherché pour sa valeur littérale, plutôt que pour sa valeur spéciale. En particulier, pour rechercher les anti-slashs, il faut écrire : "`\\`".

> Note : La chaîne de caractères PHP simple ou double guillemet a une signification spéciale des anti-slashs. Donc, si \ doit être recherché avec une expression rationnelle \\, alors "\\\\" ou '\\\\' doit être utilisé dans le code PHP.

Si un masque est utilisé avec l'option PCRE_EXTENDED, les espaces blancs du masque, mais qui ne sont pas dans une classe de caractères, et les caractères entre dièses "`#`", ainsi que les nouvelles lignes sont ignorées. L'anti-slash peut être utilisé pour échapper et ainsi rechercher un espace ou un dièse.

La deuxième utilité de l'anti-slash est de pouvoir coder des caractères invisibles dans les masques. Il n'y a pas de restriction sur la place de ces caractères invisibles, hormis pour le caractère nul qui doit terminer le masque. Lors de la préparation du masque, il est souvent plus pratique d'utiliser les séquences d'échappement suivantes, plutôt que le caractère binaire qu'elles représentent :

\a

  alarme, c'est-à-dire le caractère BEL (hex 07)

\cx

  "contrôle-x", avec x qui peut être n'importe quel caractère.

\e

  escape (hex 1B)

\f

  formfeed (hex 0C)

\n

  nouvelle ligne (hex 0A)

\r

  retour chariot (hex 0D)

\t

  tabulation (hex 09)

\xhh

  caractère en hexadécimal, de code hh

\ddd

  caractère en octal, de code ddd, ou référence arrière

Dans la séquence "`\cx`" si "`x`" est en minuscule, il est converti en majuscule. Puis, le bit 6 (hex 40) est inversé. Ainsi "`\cz`" devient `1A`, mais "`\c{`" devient hex 3B, tandis que "`\c;`" devient hex 7B.

Après "`\x`", deux caractères hexadécimaux sont lus (les lettres peuvent être en majuscule ou minuscule). En mode UTF-8, "`\x{...}`" est aurotisé, où le contenu des accolades est une chaîne hexadécimale. Il sera interprété comme un caractère UTF-8 où le numéro de code est le numéro hexadécimal donné. La séquence d'échappement hexadécimale originale, `\xhh`, correspond à un caractère UTF-8 sur 2 octets si la valeur est plus grande que 127.

Après "`\0`", deux caractères octaux sont lus. Dans chacun des cas, le méta-caractère tente de lire autant de caractères que possible. Ainsi, la séquence "`\0\x\07`" sera comprise comme deux caractères nuls, suivis d'un caractère alarme (BEL). Assurez-vous que vous fournissez suffisamment de chiffres après le méta-caractère.

L'anti-slash de fin suivi par un nombre autre que 0 est compliqué. À l'extérieur d'une classe de caractère, PCRE le lit, et tous les nombres qui suivent, en tant que nombres décimaux. Si le nombre est plus petit que 10 ou s'il y a eu au moins précédemment une parenthèse gauche capturante dans l'expression, la séquence entière est prise en tant que référence arrière. Une description sur le fonctionnement est donnée plus tard, suivez la discussion sur les parenthèses des sous masques.

À l'intérieur d'un caractère de classe ou s'il est plus grand que 9, et qu'il n'y a pas eu assez de parenthèses ouvrantes auparavant, PCRE lit jusqu'à 3 chiffres octaux à la suite de l'anti-slash, et génère un octet unique, à partir des 8 bits de poids faible de la séquence. Tous les chiffres qui suivent ne sont pas interprétés, et se représentent eux-mêmes. Par exemple:

\040

  une autre manière d'écrire un espace

\40

  identique, dans la mesure où il n'y a pas 40 parenthèses ouvrantes auparavant

\7

  est toujours une référence arrière

\11

  peut être une référence de retour, ou une tabulation

\011

  toujours une tabulation

\0113

  est une tabulation suivie du caractère "3"

\113

  est le caractère 113 (étant donné qu'il ne peut y avoir plus de 99 références arrières)

\377

  est un octet dont tous les bits sont à 1

\81

  peut être soit une référence arrière, soit un zéro binaire suivi des caractères "8" et "1"

Les valeurs octales supérieures ou égales à 100 ne doivent pas être introduites par un 0, car seuls les trois premiers octets seront lus.

Toutes les séquences qui définissent une valeur d'un seul octet peuvent être utilisées dans les classes de caractères, et à l'extérieur. De plus, dans une classe de caractères, la séquence "`\b`" est interprétée comme un caractère effacer (hex 08). À l'extérieur, elle peut avoir d'autres significations (voir ci-dessous).

On peut encore se servir de l'anti-slash pour préciser des types génériques de valeurs :

\d

  tout caractère décimal

\D

  tout caractère qui n'est pas un caractère décimal

\s

  tout caractère blanc

\S

  tout caractère qui n'est pas un caractère blanc

\w

  tout caractère de "mot"

\W

  tout caractère qui n'est pas un caractère de "mot"

Chaque paire précédente définit une partition de la table des caractères : les deux ensembles sont disjoints. Un caractère satisfera soit un méta-caractère, soit l'autre.

Un caractère de "mot" sera une lettre, un chiffre ou le caractère souligné, c'est-à-dire un caractère qui pourra être une partie d'un mot Perl. La définition des lettres et chiffres est définie par les tables de caractères de PCRE, et peut varier suivant la table locale de caractères. Par exemple, dans la configuration "français" ("fr"), certains caractères ont des codes supérieurs à 128, pour les caractères accentués, et ils seront compris par le méta-caractère `\w`.

Ces séquences de caractères peuvent apparaître à l'intérieur ou à l'extérieur des classes de caractères. Elles remplacent à chaque fois un caractère du type correspondant. Si cette séquence est placée en fin de masque, et qu'il n'y a plus de caractère à comparer dans la chaîne sujet, la recherche échoue.

La quatrième utilisation de l'anti-slash intervient lors d'assertions simples. Une assertion impose une condition à un certain point, sans remplacer de caractère. L'utilisation de sous-masques pour réaliser des assertions plus complexes est décrite plus-bas. Les assertions avec anti-slash sont les suivantes :

\b

  limite de mot

\B

  pas limite de mot

\A

  début de la chaîne sujet (indépendant du mode multi-lignes)

\Z

  fin de la chaîne sujet ou nouvelle ligne à la fin de la chaîne sujet (indépendant du mode multi-lignes)

\G

  position de la première occurence trouvé dans la chaîne sujet

\z

  fin de la chaîne sujet (indépendant du mode multi-lignes)

Ces assertions ne peuvent pas apparaître dans une classe de caractères (mais "\b" a une autre signification à l'intérieur d'une classe de caractères).

Une limite de mot est un emplacement dans la chaîne sujet ou un caractère et son suivant ne sont pas en même temps des caractères de mot, ou le contraire (on peut le voir comme `\w\W` ou `\W\w`), ou encore le premier ou le dernier caractère est un caractère mot.

Les assertions `\A`, `\Z`, et `\z` diffèrent des méta-caractères `^` et `$` dans la mesure où ils ne sont pas dépendants des options, notamment PCRE_MULTILINE ou PCRE_DOLLAR_ENDONLY. La différence entre `\Z` et `\z` tient au fait que `\Z` recherche les positions avant les nouvelles lignes et à la fin de la chaîne sujet, tandis que `\z` ne recherche que la fin de la chaîne.

L'assertion `\G` est réalisée uniquement lorsque la position courante de l'occurence trouvée est au début de l'occurence, comme spécifié par l'argument `offset` de la fonction preg_match(). Elle diffère de `\A` lorsque la valeur du paramètre `offset` est différente de zéro. Elle est disponible depuis PHP 4.3.3.

`\Q` et `\E` peuvent être utilisés pour ignorer les méta-caractères regexp dans le masque depuis PHP 4.3.3. Par exemple : `\w+\Q.$.\E$` recherchera un ou plusieurs caractères suivis par la chaîne litérale `.$.` et ancrés à la fin de la chaîne.

### Propriétés des caractères Unicode

Depuis PHP 4.4.0 et 5.1.0, trois nouvelles séquences d'échappement pour trouver des types de caractères sont disponibles lorsque le mode UTF-8 est sélectionné. Elles sont :

\p{xx}

  un caractère avec les propriétés xx

\P{xx}

  un caractère sans les propriétés xx

\X

  une séquence étendue Unicode

Les noms des propriétés représentés par `xx` ci-dessus sont limités aux catégories de propriétés générales Unicode. Chaque caractère a exactement une seule de ces propriétés, spécifié par une abréviation sur deux caractères. Pour des raisons de compatibilité avec Perl, la négation peut être spécifiée en incluant un accent circonflexe entre l'accolade ouvrante et le nom de la propriété. Par exemple, `\p{^Lu}` équivaut à la même chose que `\P{Lu}`.

Si une seule lettre est spécifiée avec `\p` ou `\P`, il inclut toutes les propriétés qui commencent par cette lettre. Dans ce cas, en l'absence de négation, les accolades dans la séquence d'échappement sont optionnelles ; ceci revient à la même chose :

\p{L}
\pL

Tableau 1. Codes des propriétés supportées

`C` | Autre
`Cc` | Contrôle
`Cf` | Format
`Cn` | Non affecté
`Co` | Utilisation privée
`Cs` | Substitut
`L` | Lettre
`Ll` | Lettre en minuscule
`Lm` | Lettre de modification
`Lo` | Autres lettres
`Lt` | Lettre titrée
`Lu` | Lettre en majuscule
`M` | Marque
`Mc` | Marque d'espacement
`Me` | Marque d'enfermement
`Mn` | Marque non espacée
`N` | Nombre
`Nd` | Nombre décimal
`Nl` | Nombre Lettre
`No` | Autres nombres
`P` | Pnctuation
`Pc` | Ponctuation de connecteur
`Pd` | Tiret de ponctuation
`Pe` | Ponctuation de fermeture
`Pf` | Ponctuation finale
`Pi` | Ponctuation initiale
`Po` | Autres ponctuations
`Ps` | Ponctuation ouvrante
`S` | Symbole
`Sc` | Symbole monétaire
`Sk` | Symbole de modification
`Sm` | Symbole mathématique
`So` | Other symbol
`Z` | Séparateur
`Zl` | Séparateur de ligne
`Zp` | Séparateur de paragraphe
`Zs` | Séparateur d'espace

Les propriétés étendues comme "Greek" ou "InMusicalSymbols" ne sont pas supportées par PCRE.

Spécifié la casse pour la recherche n'affecte pas les séquences d'échappement. Par exemple, `\p{Lu}` cherchera toujours uniquement les lettres en majuscules

L'échappement `\X` cherchera n'importe quel numéro de caractères Unicode qui forme une séquence étendue Unicode. `\X` est l'équivalent de `(?>\PM\pM*)`.

C'est-à-dire qu'il cherchera un caractère sans la propriété "Marque", suivi par zéro ou plus caractères avec la propriété "Marque", et traitera la séquence en tant que groupe atomique (voir ci-dessous). Les caractères avec la propriété "Marque" sont typiquement des accents qui affectent le caractère précédent.

La recherche de caractères par les propriétés Unicode n'est pas la méthode la plus rapide, car PCRE doit chercher une structure qui contient les données dans plus de quinze mille caractères. C'est pour cela que les séquences d'échappement traditionnelles comme `\d` et `\w` n'utilisent pas les propriétés Unicode dans PCRE.

### Accent circonflexe et Dollar

En dehors d'une classe de caractères, avec les options par défaut, `^` est une assertion qui n'est vraie que si elle est placée tout au début de la chaîne. À l'intérieur d'une classe de caractères, `^` a un tout autre sens (voir ci-dessous).

`^` n'a pas besoin d'être le premier caractère du masque, si plusieurs alternatives sont proposées, mais il doit être placé en premier dans chaque alternative. Si toutes les alternatives commencent par `^`, alors le masque est dit ancré (il y a une autre construction qui porte cette appellation).

`$` est une assertion qui n'est vraie que si elle est placée tout en fin de chaîne ou juste avant un caractère de nouvelle ligne qui serait le dernier caractère de la chaîne. À l'intérieur d'une classe de caractères, `$` a un tout autre sens (voir ci-dessous).

`$` n'a pas besoin d'être le dernier caractère du masque, si plusieurs alternatives sont proposées, mais il doit être placé en dernier dans chaque alternative. Si toutes les alternatives finissent par `$`, alors le masque est dit ancré (il y a une autre construction qui porte cette appellation). `$` n'a pas de valeur particulière dans une classe de caractères.

La signification de `$` peut changer, de manière à l'amener à ce qu'il ne puisse se trouver qu'en toute fin de la chaîne sujet. Cela se fait en ajoutant l'option PCRE_DOLLAR_ENDONLY au moment de la compilation, ou de l'exécution. Cette option est inopérante sur `\Z`.

La signification de `^` peut changer, de manière à l'amener à ce qu'il puisse se trouver immédiatement avant et immédiatement après un caractère de nouvelle ligne "`\n`". Cela se fait en ajoutant l'option PCRE_MULTILINE au moment de la compilation ou de l'exécution. Par exemple, le masque `/^abc$/` accepte la chaîne "`def\nabc`" uniquement en mode multi-lignes. Par conséquent, toutes les parties du masque qui commencent par "`^`" ne sont pas ancrées, en mode multi-lignes. L'option PCRE_DOLLAR_ENDONLY est ignorée si l'option PCRE_MULTILINE est choisie.

Notez que les méta-caractères `\A`, `\Z`, et `\z` peuvent servir à repérer le début et la fin du sujet, et toutes les parties du masque qui commenceront par `\A` seront toujours ancrées, avec l'option PCRE_MULTILINE ou non.

### Point

En dehors d'une classe de caractères, un point remplace n'importe quel caractère, même invisible et à l'exception du caractère de nouvelle ligne. Avec l'option PCRE_DOTALL le point remplace n'importe quel caractère, même le caractère de nouvelle ligne. La gestion des points et complètement indépendante de `^` et `$`. Le seul point commun est que les deux ont un comportement particulier vis-à-vis des caractères de nouvelle ligne. Le point n'a pas de comportement particulier dans une classe de caractères.

\C peut être utilisé pour chercher un seul octet. Il prend tout son sens en mode UTF-8 où le point correspond à un caractère entier qui peut être constitué de plusieurs octets.

### Crochets

Un crochet ouvrant `[` introduit une classe de caractères, et le crochet fermant `]`la conclut. Le crochet fermant n'a pas de signification en lui-même. Si le crochet fermant est nécessaire à l'intérieur d'une classe de caractères, il faut qu'il soit le premier caractère (après un `^` éventuel) ou échappé avec un anti-slash.

Une classe de caractères remplace un seul caractère dans la chaîne sujet, à moins que le premier caractère de la classe soit un accent circonflexe `^`, qui représente une négation : le caractère ne doit pas se trouver dans la classe. Si `^` est nécessaire dans la classe, il suffit qu'il ne soit pas le premier caractère, ou bien qu'il soit échappé avec un anti-slash.

Par exemple, le caractère `[aeiou]` remplace n'importe quelle voyelle minuscule, tandis que `[^aeiou]` remplace n'importe quelle caractère qui n'est pas une voyelle minuscule. `^` est une notation pratique pour spécifier des caractères qui sont dans une classe, en ne citant que ceux qui n'y sont pas. Le comportement est inchangé.

Avec l'option d'insensibilité à la casse, toutes les lettres d'une classe de caractères représentent en même temps la majuscule et la minuscule. Par exemple, `[aeiou]` représentera "`A`" ou "`a`", et `[^aeiou]` n'acceptera pas ni "`A`", tandis que sans l'option, elle l'accepterait.

Le caractère de nouvelle ligne n'est pas traité de manière spéciale dans les classes de caractères, quelque soit l'option PCRE_DOTALL ou PCRE_MULTILINE. Une classe telle que `[^a]` acceptera toujours une nouvelle ligne.

Le signe moins (`-`) est utilisé pour spécifier un intervalle de caractères, dans une classe. Par exemple, `[d-m]` remplace toutes les lettres entre d et m inclus. Si le caractère moins est requis dans une classe, il faut l'échapper avec un anti-slash, ou le faire apparaître à une position où il ne pourra pas être interprété comme une indication d'intervalle, c'est-à-dire au début ou à la fin de la classe.

Il n'est pas possible d'avoir le caractère crochet fermant "`]`" comme fin d'intervalle. Un masque tel que `[W-]46]` est compris comme la classe de caractères contenant deux caractères ("W" et "-") suivie de la chaîne littérale "46]", ce qui fait qu'il va accepter "`W46]`" ou "`-46]`". Cependant, si "`]`" est échappé avec un anti-slash, le masque `[W-\]46]` est interprété comme une classe d'un seul caractère, contenant un intervalle de caractères.

La valeur octale ou hexadécimale de "`]`" peut aussi être utilisée pour déterminer les limites de l'intervalle. Les intervalles travaillent sur des séquences ASCII. Ils peuvent aussi être précisés avec des valeurs numériques : par exemple "`[\000-\037]`". Si cet intervalle inclut des lettres utilisées avec une option d'insensibilité de casse, les majuscules ou minuscules correspondantes seront aussi incluses. Par exemple, "`[C-c]`" est équivalent à "`[][\^_`wxyzabc]`", avec l'option d'insensibilité de casse. Si la table locale de caractères est "fr", "`[\xc8-\xcb]`" correspond aux caractères accentués.

Les types de caractères `\d`, `\D`, `\S`, `\s`, `\w`, `\W` peuvent aussi intervenir dans les classes de caractères. Par exemple, "`[][\^_`wxyzabc][\dABCDEF]`" acceptera n'importe quel caractère hexadécimal. Un accent circonflexe peut aussi être utilisé pour spécifier adroitement des ensembles de caractères plus restrictifs : par exemple `[^\W_]` accepte toutes les lettres et les chiffres, mais pas les soulignés. Tous les caractères non alpha- numériques autres que `\, -, ^` (placés en début de chaîne) et `]` n'ont pas de signification particulière, mais ils ne perdront rien à être échappés.

### Barre verticale

La barre verticale `|` sert à séparer des alternatives. Par exemple, dans le masque "`/dupont|martin/`" recherche soit "`dupont`", soit "`martin`". Le nombre d'alternatives n'est pas limité, et il est même possible d'utiliser la chaîne vide. Lors de la recherche, toutes les alternatives sont essayées, de gauche à droite, et la première qui est acceptée est utilisée. Si les alternatives sont dans un sous-masque, elle ne réussiront que si le masque principal réussi aussi.

### Options internes

Les options PCRE_CASELESS, PCRE_MULTILINE, PCRE_DOTALL, PCRE_UNGREEDY, PCRE_EXTRA et PCRE_EXTENDED peuvent être changées à l'intérieur du masque lui-même, avec des séquences mises entre "`(?`" et "`)`". Les options sont :

Tableau 2. Internal option letters

`i` | pour PCRE_CASELESS
`m` | pour PCRE_MULTILINE
`s` | pour PCRE_DOTALL
`x` | pour PCRE_EXTENDED
`U` | pour PCRE_UNGREEDY
`X` | Pour PCRE_EXTRA

Par exemple, `(?im)` rend le masque insensible à la casse, et multi-lignes. Il est possible d'annuler ces options en les faisant précéder par un signe `-` : par exemple `(?im-sx)`, ajoutera les options PCRE_CASELESS et PCRE_MULTILINE mais annulera les options PCRE_DOTALL et PCRE_EXTENDED. Si une option apparaît avant et après le signe moins, l'option sera annulée.

Lorsqu'une modification d'option survient au degrès le plus haut (et donc, pas dans les parenthèses du sous-masque), les modifications sont appliquées dans le reste du masque qui suit. Donc, `/ab(?i)c/` valide uniquement "abc" et "abC". Ce comportement a été modifié en PCRE 4.0 et est inclus depuis PHP 4.3.3. Dans les versions précédentes, `/ab(?i)c/` fonctionne de la même façon que `/abc/i` (e.g. valide "ABC" et "aBc").

Si une option intervient dans un sous-masque, le comportement est différent. C'est un changement de comportement apparu en Perl 5.005. Une option à l'intérieur d'un sous-masque n'affecte que cette partie du masque, ce qui fait que `(a(?i)b)c` acceptera `abc` et `aBc` mais aucune autre chaîne (en supposant que PCRE_CASELESS n'est pas utilisé). Cela signifie que les options permettent d'avoir différentes configurations de recherche pour différentes parties du masque.

Une séquence d'options dans une alternative affecte toute l'alternative. Par exemple : `(a(?i)b|c)` accepte "`ab`", "`aB`", "`c`", et "`C`", même si, comme dans le cas de "`C`", la première alternative qui porte l'option n'est pas prise en compte. Sinon, cela risque d'introduire des comportements très étranges : les options spécifiques à PCRE telles PCRE_UNGREEDY et PCRE_EXTRA peuvent être modifiées de la même manière, en utilisant respectivement les caractères U et X. L'option `(?X)` est particulière, car elle doit toujours intervenir avant toutes les autres options, même au niveau du masque entier. Il vaut mieux l'activer au début du masque.

### Sous-masques

Les sous-masques sont délimités par des parenthèses, et peuvent être imbriqués. Ajouter des sous-masques a deux utilités :

1. Délimiter des alternatives. Par exemple, le masque `char(don|mant|)` acceptera les mots "`char`", "`charmant`", ou "`charmant`". Sans les parenthèses, il n'accepterait que "`chardon`", "`mant`" ou la chaîne vide "".

2. Le sous-masque est considéré comme capturant : lorsqu'une chaîne sujet est acceptée par le masque complet, les sous-masques sont transmis à l'appelant grâce à un vecteur de sous-masques. Les parenthèses ouvrantes sont comptées de gauche à droite, (commençant à 1). Par exemple, soit la chaîne sujet "`le roi soleil`" qui est utilisée avec le masque suivant : `Le ((roi|prince) (soleil|charmant))` les sous-masques capturés sont "`roi soleil`", "`roi`", et "`soleil`", numérotés respectivement 1, 2, et 3.

L'ubiquité des parenthèses n'est pas toujours simple d'emploi. Il y a des moments où regrouper des sous-masques est nécessaire, sans pour autant capturer la valeur trouvée. Si une parenthèse ouvrante est suivie de "`?:`", le sous-masque ne capture pas la chaîne assortie, et ne sera pas compté lors de la numérotation des captures. Par exemple, avec la chaîne "`le prince charmant`", utilisé avec le masque `Le (( ?roi|prince) (soleil|charmant))` les chaînes capturées seront "`prince charmant`" et "`charmant`", numérotés respectivement 1 et 2.

Le nombre maximal de chaînes capturées est de 99, et le nombre total de sous-masques (capturant ou non) ne doit pas dépasser 200.

`(?i:samedi|dimanche)` et `(?:(?i) samedi | dimanche)` : de plus, comme les séquences d'options sont valables sur toute une alternative, les masques ci-dessus accepteront aussi bien "DIMANCHE" que "Dimanche".

Il est possible de nommer le sous-masque avec `(?P<name>pattern)` depuis PHP 4.3.3. Les tableaux avec les masques doivent contenir le masque indexé par la chaîne à côté le masque indexé par le numéro.

### Répétitions

Les répétitions sont spécifiées avec des quantificateurs, qui peuvent être placés à la suite des caractères suivants :

a

  Un caractère unique, même s'il s'agit d'un méta-caractère

.

  Un méta-caractère

[abc]

  Une classe de caractères

\2

  Une référence de retour (voir section suivante)

(a|b|c)

  Un sous-masque avec parenthèses (à moins que ce ne soit une assertion, voir plus loin)

Les quantificateurs généraux précisent un nombre minimum et maximum de répétitions possibles, donnés par deux nombres entre accolades, et séparés par une virgule. Ces nombres doivent être plus petits que 65536, et le premier nombre doit être égal ou inférieur au second. Par exemple `z{2,4}` accepte "`zz`", "`zzz`", ou "`zzzz`". L'accolade fermante n'a pas de signification par elle-même.

Si le second nombre est omis, mais que la virgule est là, cela signifie qu'il n'y a pas de limite supérieure. Si le second nombre et la virgule sont omis, le quantificateur correspond au nombre exact de répétitions attendues. Par exemple : accepte n'importe quelle succession d'au moins 3 voyelles minuscules, tandis que `\d{d}` n'accepte que 8 chiffres exactement.

Une accolade ouvrante qui apparaît à une position où un quantificateur n'est pas accepté, ou si la syntaxe des quantificateurs n'est pas respectée, sera considérée littérale. Par exemple, "`{,6}`" n'est pas un quantificateur, mais une chaîne de 4 caractères.

Le quantificateur {0} est autorisé, mais l'expression est alors ignorée.

Par convenance (et pour une compatibilité historique), les trois quantificateurs les plus communs ont une abréviation sur un seul caractère :

Tableau 3. Quantificateurs sur un seul caractère

`*` | équivalent à `{0,}`
`+` | équivalent à `{1,}`
`?` | équivalent à `{0,1}`

Il est possible de constituer des boucles infinies en créant un sous-masque sans caractères, mais pourvu d'un quantificateur sans limite supérieure. Par exemple "`(a?)*`.

Les versions plus anciennes de Perl et PCRE généraient alors une erreur au moment de la compilation. Cependant, étant donné qu'il existe des situations où ces constructions peuvent être utiles, ces masques sont désormais autorisés. Toutefois, si la répétition du sous-masque ne trouve aucun caractère, la boucle est interrompue.

Par défaut, les quantificateurs sont dits "gourmands", c'est à dire, qu'ils cherchent d'abord à trouver le nombre maximal de répétitions qui autorisent le succès de la recherche. L'exemple classique posé par cette gourmandise est la recherche de commentaires d'un programme en C. Les commentaires apparaissent entre les séquences `/*....*/` et à l'intérieur de ces délimiteurs, les `*` et `/` sont autorisés. Appliquer le masque `/\*.*\*/` à la chaîne `/* premier commentaire */ aucun commentaire /* second commentaire */` ne peut réussir, car le masque travaille sur toute la chaîne, à cause de la gourmandise du caractère `.*`.

Cependant, un quantificateur suivi d'un point d'interrogation cesse d'être gourmand, et au contraire, ne recherche que le nombre minimum de répétition. Dans ces conditions, le masque `/\*.*?\*/` trouvera bien les commentaires du code C. La signification des autres quantificateurs n'est pas changée. Attention à ne pas confondre l'utilisation du point d'interrogation ici avec son utilisation comme quantificateur lui-même. À cause de cette ambiguïté, il peut apparaître des situations où il faut le doubler : `\d??\d`. Ce masque va tenter de lire un seul chiffre, mais, le cas échéant, il acceptera 2 chiffres pour permettre à la recherche d'aboutir.

Si l'option PCRE_UNGREEDY est activée, (une option qui n'est pas disponible avec Perl) alors les quantificateurs sont non gourmands par défaut, mais peuvent être rendu gourmands au cas par cas, en ajoutant un point d'interrogation après. En d'autres termes, cette option inverse le comportement par défaut.

Les quantificateurs suivis par `+` sont "possessifs". Ils mangent autant de caractères que possible et ne retournent pas pour chercher le reste du masque. `.*abc` trouvera "abc" mais `.*+abc`, non, car, `.*+` mange la chaîne complètement. Les quantificateurs possessifs peuvent être utilisés pour accélérer le traitement depuis PHP 4.3.3

Lorsqu'un sous-masque est quantifié avec un nombre minimum de répétitions, qui soit plus grand que 1, ou avec un maximum de répétitions, le masque compilé aura besoin de plus de place de stockage, proportionnellement au minimum et au maximum.

Si un masque commence par `..*` ou `.{0,}` et que l'option PCRE_DOTALL (équivalent en Perl à /s) est activée, c'est-à-dire en autorisant le remplacement des nouvelles lignes par un méta-caractère, alors le masque est implicitement ancré, car tout ce qui suit va être mangé par la première séquence, et se comportera comme si le masque se terminait par le méta-caractère `\A`. Dans le cas où on sait d'avance qu'il n'y aura pas de caractère de nouvelle ligne, activer l'option PCRE_DOTALL et commencer le masque par `.*` permet d'optimiser le masque.

Alternativement, on peut utiliser `^` pour ancrer explicitement le masque. Lorsqu'un sous-masque capturant est répété, la valeur capturée est la dernière. Par exemple, après que "`(inter[net]{3}\s*)+`" ait été appliqué à "`internet interne`", la valeur de la chaîne capturée est "`interne`".

Cependant, s'il y a des sous-masques imbriqués, la valeur capturée correspondante peut l'avoir été lors des précédentes itérations. Par exemple : `/(a|(b))+/` accepte "`aba`" et la deuxième valeur capturée est "`b`".

### Références arrières

En dehors des classes de caractères, un anti-slash suivi d'un nombre plus grand que 0 (et possiblement plusieurs chiffres) est une référence arrière (c'est à dire vers la gauche) dans le masque, en supposant qu'il y ait suffisamment de sous-masques capturants précédents.

Cependant, si le nombre décimal suivant l'anti-slash est plus petit que 10, il sera toujours considéré comme une référence arrière, et cela générera une erreur si le nombre de captures n'est pas suffisant. En d'autres termes, il faut qu'il existe suffisamment de parenthèses ouvrantes à gauche de la référence, surtout si la référence est inférieure à 10.

Reportez-vous à la section "anti-slash" pour avoir de plus amples détails à propos du nombre de chiffres qui suivent l'anti-slash.

La référence arrière remplace ce qui a été capturé par un sous-masque dans le masque courant, plutôt que remplacer le sous-masque lui-même. Ainsi `(calme|rapide)` et `\1ment` trouvera "`calme et calmement`" et "`rapide et rapidement`", mais pas "`calme et rapidement`". Si la recherche tient compte de la casse, alors la casse de la chaîne capturée sera importante. Par exemple, `((?i)rah)\s+\1` trouve "`rah rah`" et "`RAH RAH`", mais pas "`RAH rah`", même si le sous-masque capturant initial ne tenait pas compte de la casse.

Il peut y avoir plusieurs références arrières dans le même sous-masque. Si un sous-masque n'a pas été utilisé dans une recherche, alors les références arrières échoueront. Par exemple "`(a|(bc))\2`" ne réussira jamais si la chaîne sujet commence par "`a`" plutôt que par "`bc`".

Étant donné qu'il peut y avoir jusqu'à 99 références arrières, tous les chiffres après l'anti-slash sont considérés comment faisant potentiellement partie de la référence arrière. Si le masque recherche un chiffre après la référence, alors il faut impérativement utiliser des délimiteurs pour terminer la référence arrière.

Si l'option PCRE_EXTENDED est activée, on peut utiliser un espace. Sinon, un commentaire vide fait l'affaire. Une référence arrière qui intervient à l'intérieur de parenthèses auxquelles elle fait référence échouera dès que le sous-masque sera utilisé. Par exemple, `(a\1)` échouera toujours. Cependant, ces références peuvent être utiles dans les sous-masques répétitifs. Par exemple, le masque "`(a|b\1)+`" pourra convenir pour "`a`", "`aba`", "`ababaa`", etc.

À chaque itération du sous-masque, la référence arrière utilise le résultat du dernier sous-masque. Pour que cela fonctionne, il faut que la première itération n'ait pas besoin d'utiliser la référence arrière. Cela arrive avec les alternatives, comme dans l'exemple ci-dessus, ou avec un quantificateur de minimum 0.

### Assertions

Une assertion est un test sur les caractères suivants ou précédents celui qui est en cours d'étude. Ce test ne consomme par de caractère (ie, on ne déplace pas le pointeur de caractères). Les assertions simples sont codées avec `\b`, `\B`, `\A`, `\Z`, `\z`, `^` et `$`, et sont décrites précédemment.

Il existe cependant des types d'assertions plus complexes, codées sous la forme de sous-masques. Il en existe deux types : celles qui travaillent au-delà de la position courante (`\w+(?=;)`), et celles qui travaillent en-deça (`(?!)\w+`).

Une assertion se comporte comme un sous-masque, hormis le fait qu'elle ne déplace pas le pointeur de position. Les assertions avant commencent par `(?=` pour les assertions positives, et par `(?!`, pour les assertions négatives. Par exemple : `\w+(?=;)` s'assure qu'un mot est suivi d'un point-virgule, mais n'inclut pas le point virgule dans la capture. D'autre part, `(?!foo)bar` en est proche, mais ne trouve pas une occurrence de "`bar`" qui soit précédée par quelque chose d'autre que "`foo`foo"; il trouve toutes les occurrences de "`bar`", quelque soit ce qui le précède, car l'assertion `(?!foo)` est toujours vraie quand les trois caractères suivants sont "`bar`". Une assertion arrière est ici nécessaire.

Les assertions arrières commencent par `(?<=` pour les assertions positives, et `(?<!` pour les assertions négatives. Par exemple : `(?<!foo)bar` trouve les occurrences de "`bar`" qui ne sont pas précédées par "`foo`".

Le contenu d'une référence arrière est limité de telle façon que les chaînes qu'il utilise soient toujours de la même taille. Cependant, lorsqu'il y a plusieurs alternatives, elles n'ont pas besoin d'être de la même taille. Par exemple, `(?<=bullock|donkey)` est autorisé, tandis que `(?<!dogs?|cats?)` provoque une erreur de compilation. Les alternatives qui ont des longueurs différentes ne sont autorisées qu'au niveau supérieur des assertions arrières. C'est une amélioration du fonctionnement de Perl 5.005, qui impose aux alternatives d'avoir toutes la même taille. Une assertion telle que `(?<=ab(c|de))` n'est pas autorisée, car l'assertion de bas niveau (la deuxième, ici) a deux alternatives de longueurs différentes. Pour la rendre acceptable, il faut écrire `(?<=abc|abde)`

L'implémentation des assertions arrières déplace temporairement le pointeur de position vers l'arrière, et cherche à vérifier l'assertion. Si le nombre de caractères est différent, la position ne sera pas correcte, et l'assertion échouera. La combinaison d'assertions arrières avec des sous-masques peut être particulièrement pratique à fin des chaînes. Un exemple est donné à la fin de cette section.

Plusieurs assertions peuvent intervenir successivement. Par exemple, le masque `(?<=\d{3})(?<!999)foo` recherche les chaînes "`foo`" précédées par trois chiffres qui ne sont pas "999". Notez que chaque assertion est appliquées indépendamment, au même point de la chaîne à traiter. Tout d'abord, il est vérifié que les trois premiers caractères ont tous des chiffres, puis on s'assure que ces trois caractères ne sont pas "`999`". Le masque précédant n'accepte pas "`foo`" précédé de 6 caractères, les trois premiers étant des chiffres et les trois suivants étant différents de "`999`". Par exemple, ce masque n'acceptera pas la chaîne "`123abcfoo`". Pour ce faire, il faut utiliser le masque suivant : `(?<=\d{3}...)(?<!999)foo`. Dans ce masque, la première assertion vérifie les six premiers caractères, s'assure que les trois premiers sont des entiers, et la deuxième assertion s'assure que les trois derniers caractères ne sont pas "`999`".

De plus, les assertions peuvent être imbriquées : `(?<=(?<!foo)bar)baz` recherche les occurrences de "`baz`" qui sont précédées par "`bar`", qui, à son tour, n'est pas précédé par "`foo`". Au contraire, `(?<=\d{3}...(?<!999))foo` est un autre masque, qui recherche les caractères "`foo`", précédés par trois chiffres, suivis de trois autres caractères qui ne forment pas "`999`". Les assertions ne sont pas capturantes, et ne peuvent pas être répétées. Si une assertion contient des sous-masques capturants en son sein, ils seront compris dans le nombre de sous-masques capturants du masque entier. La capture est réalisée pour les assertions positives, mais cela n'a pas de sens pour les assertions négatives.

200 assertions au maximum sont autorisées.

### Sous-masques uniques

Avec les quantificateurs de répétitions, l'échec d'une recherche conduit normalement à une autre recherche, avec un nombre différent de répétitions, pour voir si le masque ne s'applique pas dans d'autres conditions. Parfois, il est pratique d'éviter ce comportement, soit pour changer la nature de la recherche, soit pour la faire abandonner plus tôt, si on pense qu'il n'est pas besoin d'aller plus loin.

Considérons, par exemple, le masque `\d+foo` appliqué à la ligne `123456bar`. Après avoir tenté d'utiliser les 6 chiffres suivis de "`foo`" qui font échouer, l'action habituelle sera de réessayer avec 5 chiffres, puis avec 4, et ainsi de suite jusqu'à l'échec final.

Un sous-masque évalué une seule fois permettrait d'indiquer que lorsqu'une partie du masque est trouvée, elle n'a pas besoin d'être réévaluée à chaque tentative. Ceci conduirait à ce que la recherche échoue immédiatement après le premier test. Ces assertions ont leur propre notation, commençant avec `(?>` comme ceci : `(?>\d+)bar`.

Ce type de parenthèses verrouille le sous-masque qu'il contient une fois qu'il a été trouvé, et empêche un échec ultérieur d'y repasser, mais autorise à revenir plus loin en arrière. Une autre description est que les sous-masques de ce type recherchent les chaînes de caractères, et ancre le sous-masque à l'intérieur de la chaîne.

Les sous-masques uniques ne sont pas capturants. Des cas simples comme ceux présentés ci-dessus peuvent être pris comme des situations maximales, qui réservent le maximum de caractères. En effet, alors que `\d+` et `\d+?` ajustent le nombre de chiffres trouvés de manière à laisser la possibilité au masque de réussir, `(?>\d+)` ne peut retenir que la séquence entière de chiffres. Cette construction peut contenir un nombre arbitraire de sous-masques complexes, et ils peuvent être imbriqués.

Les sous-masques uniques ne peuvent être utilisés qu'avec les assertions arrières, pour effectuer une recherche efficace en fin de chaîne. Considérons un masque simple tel "`abcd$`" appliqué à une très longue chaîne qui ne lui correspond pas. À cause du système de recherche de gauche à droite, PCRE va commencer par rechercher un "`a`" dans la chaîne sujet, puis vérifier si ce qui suit convient au reste du masque. Si le masque est spécifié sous la forme `^.*abcd$` alors, la séquence `.*` remplace en premier lieu la chaîne entière, et échoue, repart en arrière, et remplace tous les caractères sauf le dernier, échoue, retourne en arrière, prend un caractère de moins, etc. et ainsi de suite. Encore une fois, la recherche du "`a`" passe en revue toute la chaîne de gauche à droite, ce qui n'est pas très efficace. Par contre, si le masque était écrit `^(?>.*)(?<=abcd)` alors il n'y aurait pas de retour en arrière, pour satisfaire la séquence `.*`, car elle ne peut que remplacer toute la chaîne. L'assertion arrière consécutive va alors faire un test sur les 4 derniers caractères. Si elle échoue, la recherche est immédiatement interrompue.

Pour les chaînes très longues, cette approche fait la différence en termes de performances et de temps de recherche. Lorsqu'un masque contient une répétition illimitée dans un sous-masque, qui contient lui-même un nombre illimité de répétiteurs, l'utilisation des sous-masques à utilisation unique est la seule façon d'éviter l'échec de la recherche après un temps de calcul trop long.

Le masque `(\D+|<\d+>)*[!?]` recherche un nombre illimité de sous-chaînes, qui contiennent soit des non chiffres, soit des chiffres inclus dans <>, suivi soit par `!` ou par `?`. Lorsqu'il trouve une solution, ce masque va très vite. Mais, lorsqu'il est appliqué à une chaîne telle : `aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`, il lui faut beaucoup de temps pour annoncer un échec. Cela est dû au fait que la chaîne peut être divisée en deux sous-chaînes d'un grand nombre de façons, et qu'elles ont toutes été essayées. (Cet exemple utilisait `[!?]` plutôt qu'un caractère simple, car PCRE et PHP utilise une optimisation qui leur permettent de détecter rapidement l'échec lorsqu'un caractère unique est trouvé. Il se souvient du dernier caractère qui est attendu, et s'aperçoit rapidement qu'il n'y a pas ce caractère).

Si le masque utilisé est `((?>\D+)|<\d+>)*[!?]` les séquences de chiffres ne peuvent pas être trouvées, et l'échec intervient rapidement.

### Les sous-masques conditionnels

Il est possible de lier un sous-masque à une condition, ou de choisir entre deux sous-masques alternatifs, en fonction du résultat d'une assertion, ou suivant les résultats de recherche précédents.

Les deux formes possibles de sous-masques conditionnels sont `(?(condition)masque positif)` et `(?(condition) masque positif | masque négatif)`.

Si les conditions sont satisfaites, le masque positif est utilisé, sinon, le masque négatif est utilisé, si présent. S'il y a plus de deux alternatives, une erreur est générée à la compilation.

Il y a deux types de conditions : si le texte entre les parenthèses est une séquence de chiffres, alors la condition est satisfaite si le sous-masque correspondant à ce numéro a réussi. Considérons le masque suivant, qui contient des espaces non significatifs pour le rendre plus compréhensible (on supposera l'option PCRE_EXTENDED activée) et qui est divisée en trois parties pour simplifier les explications : `( \( )? [^()]+ (?(1) \) )`.

La première partie recherche une parenthèse ouvrante optionnelle et, si elle existe, elle est capturée. La deuxième partie recherche un séquence de caractères qui ne contiennent pas de parenthèses. La troisième partie est conditionnée à la première, et s'assure que s'il y a une parenthèse ouvrante, il en existe une fermante. Si une parenthèse ouvrante a été trouvée, elle a été capturée, et donc la première capture existe, et la condition est exécutée. Sinon, elle est ignorée. Ce masque recherche donc une séquence de lettres, éventuellement placées entre parenthèse.

Si la condition est la chaîne `(R)`, elle sera satisfaite si un appel récursif au masque ou au sous-masque a été fait. Au premier appel, la condition n'est pas vérifiée.

Si la condition n'est pas une séquence de chiffres, il faut que ce soit une assertion. Ce peut être une assertion positive ou négative, arrière ou avant. Considérons le masque suivant (même conditions que le précédent) et avec deux alternatives en seconde ligne : `(?(?=[^a-z]*[a-z])\d{2}[a-z]{3}-\d{2} | \d{2}-\d{2}-\d{2} )`. La condition est une assertion avant positive, qui recherche une séquence optionnelle de caractères non-lettre. En d'autres termes, elle teste la présence d'au moins une lettre dans la chaîne sujet. Si une lettre est trouvée, la recherche se poursuit avec la première alternative, et sinon, avec la seconde. Ce masque recherche des chaînes de la forme `dd-aaa-dd` ou `dd-dd-dd`, avec "`aaa`" qui sont des lettres, et `dd` qui sont des chiffres.

### Commentaires

La séquence `(?#` marque le début d'un commentaire, qui se termine à la prochaine parenthèse fermante. Les parenthèses imbriquées ne sont pas autorisées. Les caractères entre ces délimiteurs ne jouent alors aucun rôle dans le masque.

Si l'option PCRE_EXTENDED est activée, les caractères dièses `#` non échappés en dehors d'une classe de caractères introduisent un commentaire qui continuera jusqu'à la prochaine ligne dans le masque.

### Masques récursifs

Considérons le cas où il faut rechercher dans une chaîne avec un niveau d'imbrications infini de parenthèses. Sans l'aide de la récursivité, le mieux que nous puissions obtenir est de créer un masque avec un niveau fixé de profondeur d'imbrication. Il n'est pas possible de traiter des masques à niveau d'imbrication variable. PCRE fournit un nouvel outil expérimental qui permet d'utiliser la récursivité dans les masques (entre autres). L'option `(?R)` est fournie pour servir la cause de la récursivité. Le masque suivant résout le problème des parenthèses (l'option PCRE_EXTENDED est utilisée pour ignorer les espaces) : `\( ( (?>[^()]+) | (?R) )* \)`

Tout d'abord, le masque recherche une parenthèse ouvrante. Puis, il recherche n'importe quel nombre de sous-chaînes qui sont soit des séquences de caractères non-parenthèses, ou bien une recherche récursive avec le même masque (i.e. une chaîne correctement incluse entre parenthèses). Finalement, il recherche une parenthèse fermante.

Cet exemple particulier contient un nombre illimité de répétitions imbriquées, ce qui fait que l'utilisation de sous-chaînes à utilisation unique pour rechercher les séquences de caractères non parenthèses est important, lorsqu'il s'applique à une chaîne qui n'est pas valide. Par exemple, si on l'applique à "`(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa()`" la réponse arrive rapidement. Sinon, si les sous-chaînes à utilisation unique ne sont pas utilisées, la recherche peut prendre un temps très long, car il existe de très nombreuses combinaisons de `+` et `*` à tester avant de conclure à l'échec.

Les valeurs utilisées pour capturer les sous-masques sont celles utilisées par les niveaux les plus hauts de récursivité, auxquels la valeur est fixée. Si le masque précédent est utilisé avec `(ab(cd)ef)` la valeur de la parenthèse capturante est "`ef`", qui est la dernière valeur lue au niveau supérieur. Si de nouvelles parenthèses sont ajoutées, par exemple : `\( ( ( (?>[^()]+) | (?R) )* ) \)` alors la chaîne capturée est "`ab(cd)ef`", c'est-à-dire le contenu de la parenthèse capturante de plus haut niveau. S'il y a plus de 15 parenthèses capturantes dans une chaîne, PCRE doit utiliser plus de mémoire pour stocker ces données. S'il ne peut obtenir cette mémoire supplémentaire, il ne fait que sauver les 15 premières, car il n'y a pas moyen de générer une erreur de mémoire lors d'une récursion.

Depuis PHP 4.3.3, `(?1)`, `(?2)` et suivant peuvent être également utilisés pour les sous masques récursifs. Il est également possible d'utiliser les sous masques nommés : `(?P>foo)`.

Si la syntaxe pour une référence de sous masque récursif (soit par un nombre ou par un nom) est utilisée en dehors des parenthèses à laquelle elle fait référence, il opère comme un sous routine dans un langage de programmation. Un exemple ci-dessus a montré que le masque `(sens|respons)e and \1ibility` trouvera "sense and sensibility" et "response and responsibility", mais pas "sense and responsibility". Si on utilise plutôt le masque `(sens|respons)e and (?1)ibility` alors, il trouvera "sense and responsibility" tout comme les deux autres chaînes. De telles références doivent, dependant, suivre le sous masque auquel elles se réfèrent.

### Performances

Certaines séquences de recherches sont plus efficaces que d'autres. Ainsi, il est plus efficace d'utiliser une classe de caractères telle que `[aeiou]` plutôt qu'une alternative `(a|e|i|o|u)`.

En général, le masque le plus simple, qui permette la recherche désirée est le plus efficace. Le livre de Jeffrey Friedl's contient de nombreuses études à propos de l'optimisation des expressions rationnelles.

Lorsqu'un masque commence par.* et que l'option PCRE_DOTALL est activée, le masque est implicitement ancré par PCRE, étant donné qu'il ne peut que rechercher au début de la chaîne. Cependant, si l'option PCRE_DOTALL n'est pas activée, PCRE ne peut faire aucune optimisation car le méta-caractères point "`.`" ne remplace pas une nouvelle ligne, et si la chaîne sujet contient des nouvelles lignes, le masque peut trouver une solution qui serait située juste après une de ces nouvelles lignes, et non pas seulement au début de la chaîne sujet. Par exemple, le masque, `(.*)second` acceptera la chaîne "`premier \net second`" (avec "`\n`" qui remplace la nouvelle ligne), et la première chaîne capturée sera "`et`".

Afin d'effectuer la recherche, PCRE va essayer d'appliquer le masque à partir de chaque début de ligne. Si vous utilisez un tel masque avec des chaînes qui ne contiennent pas de caractères de nouvelle ligne, les meilleures performances seront atteintes avec l'option PCRE_DOTALL, ou en ancrant le masque avec `^.*`. Cela évite à PCRE de scanner toute la chaîne pour rechercher un caractère de nouvelle ligne et recommencer la recherche.

Attention aux masques qui contiennent des quantificateurs infinis imbriqués. Ils peuvent demander un temps de calcul très long, lorsque appliqués à une chaîne qui ne correspond pas à ce masque. Par exemple, `(a+)*` peut accepter "`aaaa`" de 33 manières différentes, et ce nombre croit rapidement avec la taille de la chaîne (le quantificateur `*` peut prendre les valeurs de 0, 1, 2, 3, ou 4, et pour chaque cas non nul, le quantificateur `+` peut prendre différentes valeurs).

Lorsque le reste de la chaîne est tel que l'on s'achemine vers un échec, PCRE doit en principe vérifier toutes les possibilités, et cela prend un temps extrêmement long. Un optimiseur repère les cas les plus simples, tel que `(a+)*b` où un caractère simple suit les quantificateurs. Avant de partir dans les procédures standards de recherche, PCRE s'assure qu'il y a au moins un "`b`" dans la chaîne, et si ce n'est pas le cas, l'échec est annoncé immédiatement. Sinon, il n'y a pas d'optimisation dans la recherche. Vous pouvez voir la différence de comportement avec le masque suivant : `(a+)*\d`. Le premier retourne un échec quasi-immédiatement, s'il est appliqué à une ligne de "`a`", alors que le second masque prend un temps significatif pour une chaîne de plus de 20 caractères.

Précédent | Sommaire | Suivant
options de recherche | Niveau supérieur | preg_grep