Apache Adobe Flex TutorialTutoriaux Adobe Flex & AIR en Français

Expressions Régulières (RegExp) en ActionScript 3-1

Une expression régulière permet de décrire un motif (pattern en anglais) de caractères. Elles représentent un bon moyen pour vérifier, rechercher et manipuler des chaînes de caractères.

Par exemple, l'expression régulière suivante définit un motif tel que les lettres A, B et C sont à la suite:

/ABC/

Notez qu'une expression régulière littérale est délimitée par le caractère slash ("/").

La plupart du temps, vous voudrez utiliser les expressions régulières pour vérifier des motifs plus complexes qu'une simple chaîne de caractères. Par exemple, l'expression régulière suivante définit un motif tel que les lettres A, B et C sont consécutives et que cette séquence soit suivie par un chiffre.

/ABC\d/

Le code "\d" représente "n'importe quel chiffre". Le caractère backslash ("\") est appelé caractère d'échappement, et combiné avec le caractère qui le suit (dans ce cas la lettre "d"), il a un sens spécial dans une expression régulière. Cet article décrit ces caractères d'échappement et d'autres syntaxes des expressions régulières.

L'expression régulière suivante définit un motif de lettres ABC suivies par n'importe quel nombre de chiffres (notez l'astérisque):

/ABC\d*/

Le caractère astérisque ("*") est un metacharacter. Un metacharacter est un caractère spécial dans une expression régulière. L'astérisque est un type spécial de metachatacter appelé quantifier, qui est utilisé pour quantifier le nombre de répétition d'un caractère ou d'un groupe de caractères.

En plus de ces motifs, une expression régulières peut contenir des flags, qui spécifient comment l'expression régulière doit être vérifiée. Par exemple, l'expression régulière suivant utilise le flag "i", qui spécifie que l'expression régulière ignore la casse (différence majuscule/minuscule) dans les chaînes correspondantes:

/ABC\d*/i

Pour rechercher des motifs dans des chaînes (String) et remplacer des caractères, vous pouvez utiliser les expressions régulières comme paramètre des méthodes de la classe String. Par exemple:

var pattern:RegExp = /\d+/; // motif comprenant un ou plusieurs chiffres à la suite
var str:String = "Test: 337, 4, or 57.33.";
trace(str.search(pattern));     // retourne 6 : index du premier motif identifié

trace(str.match(pattern));     // retourne 337 : premier motif identifié

var pattern:RegExp = /\d+/g; // Le flag "g" rend la recherche globale

trace(str.match(pattern)); // retourne 337,4, 57, 33: l'ensemble des résultats

Les méthodes suivantes de la classe String prennent des expressions régulières comme paramètres:

• match ()
• replace ()
• search ()
• split ()

Voir la deuxième partie de l'article sur les Expressions Régulières en ActionScript3

Syntaxe des expressions régulières

Créer une instance d'expression régulière

Il y a deux manières de créer des instances d'expressions régulières. La première est d'utiliser le caractère slash (/) pour délimiter l'expression régulière; l'autre utilise le constructeur new. Par exemple, les expressions régulières suivantes sont équivalentes:

var pattern1:RegExp = /bob/i;
var pattern2:RegExp = new RegExp("bob", "i");

Le slash délimite une expression régulière littérale de la même manière que des guillemets délimitent une chaîne de caractères. La partie de l'expression régulière à l'intérieur des slashs représente le pattern (motif). Une expression régulière peut aussi contenir des flags immédiatement après le slash final. Les flags sont considérés comme partie de l'expression régulière mais sont séparés du motif.

Quand vous utilisez le constructeur new, vous utilisez deux chaînes pour définir l'expression régulière. La première définit le motif, l'autre définit les flags comme dans l'exemple juste au dessus.

Lorsque vous utilisez le slash à l'intérieur d'une expression régulière qui est définie en utilisant les slash comme délimiteurs, vous devez précéder ce slash par un caractère d'échappement backslash (\). Par exemple, l'expression régulière suivante reconnait le motif "1/2":

var pattern:RegExp = /1\/2/;

Pour inclure des guillemets dans une expression régulière définie avec le constructeur new, vous devez ajouter un backslash avant les guillemets (tout comme vous le feriez pour une String). Par exemple, l'expression régulière reconnait le motif eat at "joe's":

var pattern1:RegExp = new RegExp("eat at \"joe's\"", "");
var pattern2:RegExp = new RegExp('eat at "joe\'s"', "");

Les expressions régulières sont équivalentes, et définissent le pattern 1/2 "joe's":

 var pattern1:RegExp = /1\/2 "joe's"/;
var pattern2:RegExp = new RegExp("1/2 \"joe's\"", "");
var pattern3:RegExp = new RegExp('1/2 "joe\'s"', '');

Dans une expression régulière définie avec le constructeur new, pour utiliser une séquence qui commence par le caractère "\", telle que "\d" (n'importe quel nombre), tapez le caractère d'échappement 2 fois:

 var pattern:RegExp = new RegExp("\\d+", "");

Caractères, metacharacters, et metasequences

La plus simple des expressions régulières est celle qui reconnaît une séquence de caractères comme l'exemple suivant:

var pattern:RegExp = /hello/;

Cependant, les caractères suivant, connus en tant que metacharacters, ont des interprétations différentes dans des expressions régulières:

^ $ \ . * + ? ( ) [ ] { } |

Par exemple, l'expression régulière suivante reconnaît la lettre A suivie par 0 ou plusieurs instance de la lettre B (l'astérisque marque cette répetition), suivie par la lettre C:

/AB*C/

Pour inclure un metacharacter sans son sens spécial aux expressions régulières, utilisez le caractère d'échappement "\". Par exemple, l'expression régulière suivant reconnaît la lettre A suivie par la lettre B, suivie par une astérisque, suivie par la lettre C:

var pattern:RegExp = /AB\*C/;

Une metasequence, comme un metacharacter a un sens particulier dans une expression régulière. Une metasequence est faîte de plusieurs de ces metacharacters.

Les metacharacters

• ^ : Reconnaît le début d'une chaîne. Avec le flag m (multiline), le caractère ^ reconnaît le début d'une ligne.
• $ : Reconnaît la fin d'une chaîne. Avec le flag m (multiline), le caractère $ reconnait une position avant le caractère de nouvelle ligne (\n)
• \ : Echappe les caractères spéciaux pour qu'ils se comportent comme de simples caractères.
• . : Reconnaît un caractère isolé
• * : Reconnaît une répétition du caractère (entre 0 et plus)
• + : Reconnaît une répétition du caractère (entre 1 et plus)
• ? : Reconnaît une répétition du caractère (soit 0 fois, soit 1 fois)
• (exp) : Définit des groupes à l'intérieur d'une expression régulière. Vous pouvez utiliser des groupes dans les cas suivant
  • Pour restreindre la reconnaissance en utilisant le pipe ("|") : /(a|b|c)d/
  • Pour restreindre un quantifier: /(walla.){1,2}/
• [exp] : Définit une classe de caractères (voir plus loin dans le tutorial)
• | : Utilisé pour l'alternance, pour reconnaître la partie gauche ou la partie droite du pipe | : /abc|xyz/ reconnaitra "abc" ou "xyz"

Les metasequences

• {n} {n, } et {n,n} : Spécifie un quantifieur numérique ou un intervalle pour l'item précédent
  • /A{27}/ reconnaît le caractère A répété 27 fois
  • /A{3,}/ reconnaît le caractère A répété 3 fois ou plus
  • /A{3,5}/ reconnaît le caractère A répété de 3 à 5 fois
• \d : Permet de reconnaître un caractère numérique
• \D : Permet de reconnaître tous les caractères sauf les caractères numériques
• \n : Reconnaître un caractère nouvelle ligne
• \r : Reconnaître un retour chariot
• \s : Reconnaître un caractère espace ( espace, tabulation, nouvelle ligne ou retour chariot)
• \S : Reconnaître tous les caractères sauf les caractères espace
• \t : Reconnaître une tabulation
• \unnnn : Reconnaître un caractère Unicode avec le code du caractère spécifié (nnnn). Par exemple, \u263a est un caractère smiley
• \w : Reconnaître un mot (A-Z, a-z, 0-9, ou _). Il faut noter que \w ne reconnaît pas le caractères non-anglais (é, à ou ç…)
• \W : Reconnaître tous les caractères qui ne sont pas des mots

Classes de caractères

Vous pouvez utiliser les classes de caractères pour spécifier une liste de caractères à reconnaître à une certaine position dans une expression régulière. Les classes de caractères sont définies entre crochers ( [ abc ] ). Par exemple, l'expression régulière suivante reconnaîtra les mots bag, beg, big, bog ou bug:

/b[aeiou]g/

La plupart des metacharacters et des metasequences qui ont normalement un sens spécial dans une expression régulière n'ont pas le même sens dans une classe de caractères. Par exemple, dans une expression régulière, l'astérisque est utilisée pour indiquer une répétition, mais pas dans le cas ou l'astérisque apparaît dans une classe de caractères. La classe de caractère suivante reconnaîtra l'astérisque en tant que caractère, tout comme les autres caractères de la liste:

/[abc*123]/

Intervalle de caractères dans une classe de caractère

Pour spécifier un intervalle de caractère, il faut utiliser le tiret ("-"), comme pour A-Z, a-z, 0-9. Par exemple, l'exemple suivant reconnaît n'importe quel caractère dans l'intervalle a-z ou n'importe quel chiffre.

/[a-z0-9]/

Complémentaire d'une classe de caractère

Vous pouvez utiliser un accent circonflexe (^) au début d'une classe de caractère pour prendre le complémentaire de celle-ci. C'est-à-dire pour reconnaître n'importe quel caractère qui n'est pas dans l'intervalle spécifié ensuite. L'exemple suivant reconnaitra tous les caractères sauf les lettres minuscules (a-z) et les chiffres:

/[^a-z0-9]/

Quantifieurs

Pour pouvez utiliser les quantifieurs pour signaler la répétition d'un caractère ou d'une séquence dans un pattern:

• * : Reconnaît une répétition du caractère (entre 0 et plus)
• + : Reconnaît une répétition du caractère (entre 1 et plus)
• ? : Reconnaît une répétition du caractère (soit 0 fois, soit 1 fois)
• {n} {n, } et {n,n} : Spécifie un quantifieur numérique ou un intervalle pour l'item précédent
  • /A{27}/ reconnaît le caractère A répété 27 fois
  • /A{3,}/ reconnaît le caractère A répété 3 fois ou plus
  • /A{3,5}/ reconnaît le caractère A répété de 3 à 5 fois

Vous pouvez appliquer un quantifieur à un caractère isolé, à une classe de caractères, ou à un groupe:

• /a+/ : reconnaît un caractère "a" répété une ou plusieurs fois
• /\d+/ : reconnaît une ou plusieurs chiffres
• /[abc]+/ : correspond à la répétition d'un ou plusieurs caractères, qui doit être a ou b ou c
• /(very, )*/ : reconnaît le mot "very" suivi par une virgule et un espace répété zéro ou plusieurs fois

Vous pouvez utiliser des quantifiers sur des groupes (entre parenthèses) qui ont déjà des quantifieurs qui leur sont appliqués. Par exemple, l'expression régulière suivante reconnaitra des chaînes telles que "word" et "word-word-word":

/\w+(-\w+)*/

Alternatives

Utilisez le pipe ("|") dans une expression régulière pour que repérer des alternatives (liste de choix). Par exemple, l'expression régulière suivante reconnaît n'importe quel des mots cat, dog, pig, rat:

var pattern:RegExp = /cat|dog|pig|rat/;

Vous pouvez utilisez les parenthèses pour définir des groupes de restriction au niveau du pipe. L'expression régulière suivant reconnaît le mot "cat" suivi du "nap" ou de "nip".

var pattern:RegExp = /cat(nap|nip)/;

Les deux expressions régulière suivantes sont équivalentes. La première utilise le pipe |, l'autre utilise une classe de caractères:

/1|3|5|7|9/
/[13579]/

Flags et propriétés

• g : (global) -> Retourne plus d'un seul résultat si possible
• i : (ignoreCase) -> Ne pas prendre en compte la casse (différence majuscules/minuscules)
• m : (multiline) -> Avec ce flag, $ et ^ peuvent reconnaitre le commencement et la fin d'un ligne, respectivement
• s : (dotall) -> Avec ce flag, le point . peut reconnaître le caractère de nouvelle ligne (\n)
• x : (extended) -> Autorise l'écriture d'expressions régulières aux propriétés étendues. Vous pouvez taper des espaces dans l'expression qui seront ignorés à l'exécution.

Voir la deuxième partie de l'article sur les Expressions Régulières en ActionScript3