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

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

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

Les méthodes pour utiliser les expressions régulières avec des chaînes (String)

La classe RegExp contient deux méthodes: exec() et test().

En plus de ces deux méthodes de la classe RegExp, la classe String contient les méthodes match(), replace(), search(), splice().

La méthode test()

La méthode test() de la classe RegExp vérifie simplement que la chaîne contient un résultat pour l'expression régulière, comme dans l'exemple suivant:

var pattern:RegExp = /Class-\w/;
var str = "Class-A";
trace(pattern.test(str)); // résultat: true

La méthode exec()

La méthode exec() de la classe RegExp vérifie la chaîne avec l'expression régulière fournie et retourne un tableau de résultats. Le tableau contient aussi une propriété index indiquant la position du début de la chaîne trouvée:

var pattern:RegExp = /\d{3}\-\d{3}-\d{4}/; //U.S phone number
var str:String = "phone: 415-555-1212";
var result:Array = pattern.exec(str);
trace (result.index, " - ", result);
// 7 - 415-555-1212

Utilisez la méthode exec() plusieurs fois pour reconnaître plusieurs sous-chaînes quand le flag g (global) est défini pour l'expression régulière:

var pattern:RegExp = /\w*sh\w*/gi;
var str:String = "She sells seashells by the seashore";
var result:Array = pattern.exec(str);

while (result != null) {
trace (result.index, "\t", pattern.lastIndex, "\t", result);
result = pattern.exec(str);
}
// résultat:
// 5 8 She
// 15 24 seashells
// 32 40 seashore

Trouver des motifs dans des chaînes et les remplacer par des sous-chaînes (AS3)

More…
La classe String contient les méthodes suivantes pour travailler avec les motifs et les chaînes:

• Utilisez les méthodes match() et search() pour localiser les sous-chaînes correspondant au pattern
• Utilisez la méthode replace() pour localiser les sous-chaînes correspondant au motif et les remplacer par une sous-chaîne

Trouver des sous-chaînes correspondant au pattern

La méthode search() retourne l'index de la position de la première sous-chaîne trouvée pour un pattern donné comme dans cet exemple:

var str:String = "The more the merrier.";
trace(str.search("the"));
// résultat: 9
// (cette recherche est sensible à la casse.)

Vous pouvez aussi utiliser une expression régulière pour définir le motif à trouver:

var pattern:RegExp = /the/i;
var str:String = "The more the merrier.";
trace(str.search(pattern)); // 0

Le résultat de la trace() est 0 car le premier caractère de la chaîne a un index de 0. Le flag i sert à ignorer la casse dans cette recherche.

La méthode search() trouve un seul résultat et retourne l'index de sa position, même si le flag g (global) est appliqué à l'expression régulière.

L'exemple suivant cherche une sous-chaîne entre guillemets:

var pattern:RegExp = /"[^"]*"/;
var str:String = "The \"more\" the merrier.";
trace(str.search(pattern));
// output: 4

str = "The \"more the merrier.";
trace(str.search(pattern));
// output: -1
// (indique qu'il n'y a aucun résultat car il n'y a pas de guillemets fermant.)

La méthode match() fonctionne de manière similaire. Elle cherche une sous-chaîne. Cependant, quand vous utilisez le flag global dans une expression régulière, comme dans l'exemple suivant, match() retourne un tableau de résultats:

var str:String = "bob@example.com, omar@example.org";
var pattern:RegExp = /\w*@\w*\.[org|com]+/g;
var results:Array = str.match(pattern);

Le tableau results contiendra les valeurs suivantes:

["bob@example.com","omar@example.org"]

Remplacement de sous-chaînes

Vous pouvez utiliser la méthode replace() pour chercher un motif et le remplacer par une autre chaîne, comme dans cet exemple:

var str:String = "She sells seashells by the seashore.";
var pattern:RegExp = /sh/gi;
trace(str.replace(pattern, "sch"));
//sche sells seaschells by the seaschore.

Notez que dans cet exemple, les sous-chaînes trouvées ne sont pas sensibles à la casse car le flag i (ignoreCase) est appliqué à l'expression régulière.

Vous pouvez inclure les codes de remplacement $ suivants:

• $$ : remplacer la chaîne par $
• $& : remplacer la chaîne par la chaîne trouvée
• $` : remplacer la chaîne par la portin de chaîne qui précède la sous-chaîne trouvée
• $' : remplacer par la portion de chaîne qui suit le résultat
• $n : remplacer la chaîne par le nième groupe entre parenthèses, où n est un nombre entre 01 et 99

Par exemple, le code suivant montre l'utilisation des codes de remplacement $1 et $2, qui représentent la première et seconde capture du résultat:

var str:String = "flip-flop";
var pattern:RegExp = /(\w+)-(\w+)/g;
trace(str.replace(pattern, "$2-$1")); // flop-flip

Vous pouvez aussi utiliser une fonction comme second paramètre de replace(). La sous-chaîne trouvée sera alors remplacée par la valeur retournée par la fonction:

var str:String = "Now only $9.95!";
var price:RegExp = /\$([\d,]+.\d+)+/i;
trace(str.replace(price, usdToEuro));

function usdToEuro(matchedSubstring:String,
capturedMatch1:String,
index:int,
str:String):String {
var usd:String = capturedMatch1;
usd = usd.replace(",", "");
var exchangeRate:Number = 0.853690;
var euro:Number = usd * exchangeRate;
const euroSymbol:String = String.fromCharCode(8364);
return euro.toFixed(2) + " " + euroSymbol;
}

Quand vous utilisez une fonction comme second paramètre de la fonction replace(), les arguments suivants sont passés à la fonction:

• La portion de texte trouvée
• Un certain nombre de groupe trouvés. Le nombre d'arguments passés à la fonction peut ainsi varier. Utilisez arguments.length – 3 pour déterminer ce nombre de groupes dans la fonction
• La position de l'index de la sous-chaîne trouvée
• La chaîne complète

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