Indicateurs et propriétés -- Flash CS3

Le tableau suivant répertorie les cinq indicateurs que vous pouvez définir pour des expressions régulières. Vous pouvez accéder à chaque indicateur en tant que propriété de l'objet d'expression régulière.

Indicateur	Propriété	Description
`g`	`global`	A plusieurs correspondances.
`i`	`ignoreCase`	Correspondance sensible à la casse. S'applique aux caractères `A`--`Z` et `a`--`z` mais pas à des caractères étendus tels que `É` et `é`.
`m`	`multiline`	Lorsque cet indicateur est défini, `$` et `^` peuvent correspondre au début d'une ligne et à la fin d'une ligne, respectivement.
`s`	`dotall`	Lorsque cet indicateur est défini, `.` (point) peut correspondre au caractère de nouvelle ligne (`\n`).
`x`	`extended`	Autorise les expressions régulières étendues. Vous pouvez tapez des espaces dans l'expression régulière. Ils sont ignorés dans le cadre du modèle. Ceci vous permet de taper un code d'expression régulière de façon plus lisible.

Ces propriétés sont en lecture seule. Vous pouvez définir les indicateurs (g, i, m, s, x) lorsque vous définissez une variable d'expression régulière, comme suit :

var re:RegExp = /abc/gimsx;

Cependant, vous ne pouvez pas définir directement les propriétés nommées. Par exemple, le code suivant génère une erreur :

var re:RegExp = /abc/;
re.global = true; // Génération d'une erreur.

Par défaut, à moins de les spécifier dans la déclaration d'expression régulière, les indicateurs ne sont pas définis, et les propriétés correspondantes sont également définies sur false.

Sous-rubriques

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)) // résultat : 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;
// Le même modèle, mais cette fois, l'indicateur g EST défini.
trace(str.match(pattern)); // résultat : 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/)); // résultat : 13 -- Pas le premier caractère

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)); // résultat : 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)); // Correspondance avec un mot au début de la chaîne.

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

var str:String = "Test\n";
str += "Multiline";
trace(str.match(/^\w*/gm)); // Correspondance avec un mot au début des lignes.

Test,Multiline

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

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 the 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. Voici un 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. Par exemple, considérez le code suivant :

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 :

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 démarrent 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 façon à 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. Voici un exemple :

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