Indicateurs et propriétés

L’indicateur g (global)

Lorsque l’indicateur g ( global ) n’est pas inclus, une expression régulière n’a pas plus d’une correspondance. Par exemple, avec l’indicateur g exclu de l’expression régulière, la méthode String.match() renvoie une sous-chaîne de correspondance uniquement :

var str:String = "she sells seashells by the seashore."; 
var pattern:RegExp = /sh\w*/; 
trace(str.match(pattern)) // output: she

Lorsque l’indicateur g est défini, la méthode Sting.match() renvoie plusieurs correspondances, comme suit :

var str:String = "she sells seashells by the seashore."; 
var pattern:RegExp = /sh\w*/g; 
// The same pattern, but this time the g flag IS set. 
trace(str.match(pattern)); // output: she,shells,shore

L’indicateur i (ignoreCase)

Par défaut, les correspondances d’expression régulière sont sensibles à la casse. Lorsque vous définissez l’indicateur i ( ignoreCase ), le respect de la casse est ignoré. Par exemple, la lettre minuscule s dans l’expression régulière ne correspond pas à la lettre majuscule S , le premier caractère de la chaîne :

var str:String = "She sells seashells by the seashore."; 
trace(str.search(/sh/)); // output: 13 -- Not the first character

Lorsque l’indicateur i est défini, cependant, l’expression régulière correspond à la lettre majuscule S :

var str:String = "She sells seashells by the seashore."; 
trace(str.search(/sh/i)); // output: 0

L’indicateur i ignore le respect de la casse uniquement pour les caractères A – Z et a – z , mais par pour les caractères étendus tels que É et é .

L’indicateur m (multiline)

Si l’indicateur m ( multiline ) n’est pas défini, le ^ correspond au début de la chaîne et le $ à sa fin. Si l’indicateur m est défini, ces caractères correspondent au début d’une ligne et à la fin d’une ligne, respectivement. Considérez la chaîne suivante, qui inclut un caractère de nouvelle ligne :

var str:String = "Test\n"; 
str += "Multiline"; 
trace(str.match(/^\w*/g)); // Match a word at the beginning of the string.

Même si l’indicateur g ( global ) est défini dans l’expression régulière, la méthode match() correspond à une seule sous-chaîne, car il n’existe qu’une seule correspondance pour le ^ (le début de la chaîne). Le résultat est le suivant :

Test

Voici le même code avec l’indicateur m défini :

var str:String = "Test\n"; 
str += "Multiline"; 
trace(str.match(/^\w*/gm)); // Match a word at the beginning of lines. 

Cette fois, le résultat inclut les mots au début des deux lignes :

Test,Multiline

Seul le caractère \n signale la fin d’une ligne. Ce n’est pas le cas des caractères suivants :

• Retour de chariot ( \r )

• Séparateur de ligne Unicode ( \u2028 )

• Séparateur de paragraphe Unicode ( \u2028 )

L’indicateur s (dotall)

Si l’indicateur s ( dotall ou “dot all”) n’est pas défini, un point ( . ) dans un modèle d’expression régulière ne correspond pas à un caractère de nouvelle ligne ( \n ). Par conséquent, il n’existe aucune correspondance pour l’exemple suivant :

var str:String = "<p>Test\n"; 
str += "Multiline</p>"; 
var re:RegExp = /<p>.*?<\/p>/; 
trace(str.match(re)); 

Néanmoins, si l’indicateur s est défini, le point correspond au caractère de nouvelle ligne :

var str:String = "<p>Test\n"; 
str += "Multiline</p>"; 
var re:RegExp = /<p>.*?<\/p>/s; 
trace(str.match(re)); 

Dans ce cas, la correspondance est la sous-chaîne entière dans les balises <p> , y compris le caractère de nouvelle ligne :

<p>Test 
Multiline</p>

L’indicateur x (extended)

Les expressions régulières peuvent être difficiles à lire, notamment lorsqu’elles comprennent de nombreux métasymboles et métaséquences. Exemple :

/<p(>|(\s*[^>]*>)).*?<\/p>/gi

Lorsque vous utilisez l’indicateur x ( extended ) dans une expression régulière, les espaces vides que vous tapez dans le modèle sont ignorés. Par exemple, l’expression régulière suivante est identique à l’exemple précédent :

/     <p    (>  | (\s* [^>]* >))    .*?    <\/p>  /gix

Si l’indicateur x est défini et que vous souhaitez établir une correspondance avec un espace vide, faites précéder l’espace vide d’une barre oblique. Par exemple, les deux expressions régulières suivantes sont équivalentes :

/foo bar/ 
/foo \ bar/x

La propriété lastIndex

La propriété lastIndex spécifie la position d’index dans la chaîne à laquelle la recherche suivante doit démarrer. Cette propriété affecte les méthodes exec() et test() appelées sur une expression régulière dont l’indicateur g est défini sur true . Considérons par exemple le code qui suit :

var pattern:RegExp = /p\w*/gi; 
var str:String = "Pedro Piper picked a peck of pickled peppers."; 
trace(pattern.lastIndex); 
var result:Object = pattern.exec(str); 
while (result != null) 
{ 
    trace(pattern.lastIndex); 
    result = pattern.exec(str); 
}

La propriété lastIndex est défini sur 0 par défaut (pour commencer les recherches au début de la chaîne). Après chaque correspondance, elle est définie sur la position d’index suivant la correspondance. Par conséquent, le résultat pour le code précédent est le suivant :

0 
5 
11 
18 
25 
36 
44

Si l’indicateur global est défini sur false , les méthodes exec() et test() n’utilisent pas ni ne définissent la propriété lastIndex .

Les méthodes match() , replace() et search() de la classe String lancent toutes les recherches du début de la chaîne, indépendamment du réglage de la propriété lastIndex de l’expression régulière utilisée dans l’appel à la méthode (néanmoins, la méthode match() définit lastIndex sur 0).

Vous pouvez définir la propriété lastIndex de sorte à ajuster la position de début dans la chaîne pour la mise en correspondance des expressions régulières.

La propriété source

La propriété source spécifie la chaîne qui définit la portion de modèle d’une expression régulière. Exemple :

var pattern:RegExp = /foo/gi; 
trace(pattern.source); // foo