RegExp

Package	Niveau supérieur
Classe	public dynamic class RegExp
Héritage	RegExp Object

Version du langage:

ActionScript 3.0

Versions du moteur d’exécution:

AIR 1.0, Flash Player 9, Flash Lite 4

La classe RegExp vous permet d’utiliser des expressions régulières, à savoir des modèles destinés à effectuer des recherches dans les chaînes et à remplacer du texte dans ces dernières.

Pour créer un objet RegExp, utilisez le constructeur new RegExp() ou affectez un littéral RegExp à une variable :

 var pattern1:RegExp = new RegExp("test-\\d", "i");
     var pattern2:RegExp = /test-\d/i;

Pour plus d’informations, voir le chapitre « Utilisation d’expressions régulières » dans le Guide du développeur d’ActionScript 3.0.

Consulter les exemples

Plus d’exemples

Syntaxe d’expression régulière

Eléments de l’API associés

String.match()
String.replace()
String.search()

Propriétés publiques

Masquer les propriétés publiques héritées

Afficher les propriétés publiques héritées

	Propriété		Défini par
		constructor : Object Référence à l’objet de classe ou à la fonction constructeur d’une occurrence donnée d’un objet.	Object
		dotall : Boolean [lecture seule] Spécifie si le caractère point (.) d’un modèle d’expression régulière correspond à des caractères de nouvelle ligne.	RegExp
		extended : Boolean [lecture seule] Indique si le mode étendu est activé pour l’expression régulière.	RegExp
		global : Boolean [lecture seule] Indique si la mise en correspondance globale est activée pour l’expression régulière.	RegExp
		ignoreCase : Boolean [lecture seule] Indique si l’expression régulière prend ou non en charge la casse.	RegExp
		lastIndex : Number Spécifie la position d’index où démarrer la recherche suivante dans la chaîne.	RegExp
		multiline : Boolean [lecture seule] Spécifie si l’indicateur m (multiline) est défini.	RegExp
		source : String [lecture seule] Spécifie la partie modèle de l’expression régulière.	RegExp

Méthodes publiques

Masquer les méthodes publiques héritées

Afficher les méthodes publiques héritées

	Méthode		Défini par
		RegExp(re:String, flags:String) Vous permet de générer une expression régulière à partir de deux chaînes.	RegExp
		exec(str:String):Object Recherche l’expression régulière dans la chaîne str indiquée.	RegExp
		hasOwnProperty(name:String):Boolean Indique si la propriété spécifiée d’un objet est définie.	Object
		isPrototypeOf(theClass:Object):Boolean Indique si une occurrence de la classe Object figure dans la chaîne de prototype de l’objet spécifié en tant que paramètre.	Object
		propertyIsEnumerable(name:String):Boolean Indique si la propriété spécifiée existe et est énumérable.	Object
		setPropertyIsEnumerable(name:String, isEnum:Boolean = true):void Définit la disponibilité d’une propriété dynamique pour les opérations en boucle.	Object
		test(str:String):Boolean Recherche la correspondance de l’expression régulière dans la chaîne str indiquée.	RegExp
		toLocaleString():String Renvoie la représentation de chaîne de cet objet, formatée selon les paramètres régionaux en vigueur.	Object
		toString():String Renvoie la représentation sous forme de chaîne de l’objet spécifié.	Object
		valueOf():Object Renvoie la valeur primitive de l’objet spécifié.	Object

Détails de la propriété

dotall

propriété

dotall:Boolean [lecture seule]

Version du langage:

ActionScript 3.0

Versions du moteur d’exécution:

AIR 1.0, Flash Player 9, Flash Lite 4

Spécifie si le caractère point (.) d’un modèle d’expression régulière correspond à des caractères de nouvelle ligne. Utilisez l’indicateur s lorsque vous générez une expression régulière pour définir dotall = true.

Implémentation
public function get dotall():Boolean

Plus d’exemples

Syntaxe d’expression régulière
Indicateurs et propriétés

Exemple ( Comment utiliser cet exemple )

L’exemple suivant indique l’effet de l’indicateur s (dotall) sur une expression régulière :

var str:String = "<p>Hello\n"
        + "again</p>"
        + "<p>Hello</p>";

var pattern:RegExp = /<p>.*?<\/p>/;
trace(pattern.dotall) // false
trace(pattern.exec(str)); // <p>Hello</p>

pattern = /<p>.*?<\/p>/s;
trace(pattern.dotall) // true
trace(pattern.exec(str));

extended

propriété

extended:Boolean [lecture seule]

Version du langage:

ActionScript 3.0

Versions du moteur d’exécution:

AIR 1.0, Flash Player 9, Flash Lite 4

Indique si le mode étendu est activé pour l’expression régulière. Si un objet RegExp est en mode étendu, les caractères d’espace blanc que contient la chaîne du constructeur sont ignorés. Les constructeurs sont ainsi plus lisibles.

Utilisez l’indicateur x lorsque vous générez une expression régulière pour définir extended = true.

Implémentation
public function get extended():Boolean

Plus d’exemples

Syntaxe d’expression régulière
Indicateurs et propriétés

Exemple ( Comment utiliser cet exemple )

L’exemple suivant présente différentes façons de construire la même expression régulière. Pour chaque façon, l’expression régulière doit correspondre au modèle de numéro de téléphone xxx-xxx-xxxx ou (xxx) xxx-xxxx ou (xxx)xxx-xxxx. La deuxième expression régulière utilise l’indicateur x, ce qui permet d’ignorer les espaces blancs de la chaîne.

var rePhonePattern1:RegExp = /\d{3}-\d{3}-\d{4}|\(\d{3}\)\s?\d{3}-\d{4}/; 
var str:String = "The phone number is (415)555-1212.";

trace(rePhonePattern1.extended) // false
trace(rePhonePattern1.exec(str)); // (415)555-1212

var rePhonePattern2:RegExp = / \d{3}-\d{3}-\d{4}  |   \( \d{3} \) \ ? \d{3}-\d{4}  /x; 
trace(rePhonePattern2.extended) // true
trace(rePhonePattern2.exec(str)); // (415)555-1212

global

propriété

global:Boolean [lecture seule]

Version du langage:

ActionScript 3.0

Versions du moteur d’exécution:

AIR 1.0, Flash Player 9, Flash Lite 4

Indique si la mise en correspondance globale est activée pour l’expression régulière. Lorsque global == true, la propriété lastIndex est définie après détection d’une correspondance. Lors de la demande suivante de correspondance, le moteur de l’expression régulière démarre à partir de la position lastIndex dans la chaîne. Utilisez l’indicateur g lorsque vous générez une expression régulière pour régler global sur true.

Implémentation
public function get global():Boolean

Plus d’exemples

Syntaxe d’expression régulière
Indicateurs et propriétés

Exemple ( Comment utiliser cet exemple )

L’exemple suivant indique l’effet de l’indicateur g (global) sur la méthode exec() :

var pattern:RegExp = /foo\d/; 
var str:String = "foo1 foo2";
trace(pattern.global); // false
trace(pattern.exec(str)); // foo1
trace(pattern.lastIndex); // 0
trace(pattern.exec(str)); // foo1

pattern = /foo\d/g;
trace(pattern.global); // true
trace(pattern.exec(str)); // foo1
trace(pattern.lastIndex); // 4
trace(pattern.exec(str)); // foo2

ignoreCase

propriété

ignoreCase:Boolean [lecture seule]

Version du langage:

ActionScript 3.0

Versions du moteur d’exécution:

AIR 1.0, Flash Player 9

Indique si l’expression régulière prend ou non en charge la casse. Utilisez l’indicateur i lorsque vous générez une expression régulière pour définir ignoreCase = true.

Implémentation
public function get ignoreCase():Boolean

Plus d’exemples

Syntaxe d’expression régulière
Indicateurs et propriétés

Exemple ( Comment utiliser cet exemple )

L’exemple suivant indique l’effet de la définition de l’indicateur i (ignoreCase) :

var pattern:RegExp = /bob/; 
var str:String = "Bob bob";
trace(pattern.ignoreCase); // false
trace(pattern.exec(str)); // bob

pattern = /bob/i;
trace(pattern.ignoreCase); // true
trace(pattern.exec(str)); // Bob

lastIndex

propriété

lastIndex:Number

Version du langage:

ActionScript 3.0

Versions du moteur d’exécution:

AIR 1.0, Flash Player 9, Flash Lite 4

Spécifie la position d’index où démarrer la recherche suivante dans la chaîne. Cette propriété affecte les méthodes exec() et test() de la classe RegExp. Toutefois, les méthodes match(), replace() et search() de la classe String ignorent la propriété lastIndex et démarrent toutes les recherches au début de la chaîne.

Si la méthode exec() ou test() trouve une correspondance et que l’indicateur g (global) est réglé sur true pour l’expression régulière, elle règle automatiquement la propriété lastIndex sur la position d’index du caractère qui after le dernier caractère de la sous-chaîne correspondante de la dernière correspondance. Si l’indicateur g (global) est réglé sur false, la méthode ne définit pas la propriété lastIndex.

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.

Implémentation
public function get lastIndex():Number
public function set lastIndex(value:Number):void

Plus d’exemples

Syntaxe d’expression régulière
Indicateurs et propriétés

Exemple ( Comment utiliser cet exemple )

L’exemple suivant indique l’effet de la définition de la propriété lastIndex et indique comment elle est mise à jour après un appel à la méthode exec() sur une expression régulière où l’indicateur g (global) est défini :

var pattern:RegExp = /\w\d/g; 
var str:String = "a1 b2 c3 d4";
pattern.lastIndex = 2; 
trace(pattern.exec(str)); // b2
trace(pattern.lastIndex); // 5
trace(pattern.exec(str)); // c3
trace(pattern.lastIndex); // 8
trace(pattern.exec(str)); // d4
trace(pattern.lastIndex); // 11
trace(pattern.exec(str)); // null

multiline

propriété

multiline:Boolean [lecture seule]

Version du langage:

ActionScript 3.0

Versions du moteur d’exécution:

AIR 1.0, Flash Player 9, Flash Lite 4

Spécifie si l’indicateur m (multiline) est défini. S’il est défini, le caractère circonflexe (^) et le symbole du dollar ($) établissent une correspondance avant et après les caractères de nouvelle ligne dans une expression régulière. Utilisez l’indicateur m lorsque vous générez une expression régulière pour définir multiline = true.

Implémentation
public function get multiline():Boolean

Plus d’exemples

Syntaxe d’expression régulière
Indicateurs et propriétés

Exemple ( Comment utiliser cet exemple )

L’exemple suivant indique l’effet de la définition de l’indicateur m (multiline) :

var pattern:RegExp = /^bob/; 
var str:String = "foo\n"
                + "bob";
trace(pattern.multiline); // false
trace(pattern.exec(str)); // null

pattern = /^bob/m;
trace(pattern.multiline); // true
trace(pattern.exec(str)); // bob

source

propriété

source:String [lecture seule]

Version du langage:

ActionScript 3.0

Versions du moteur d’exécution:

AIR 1.0, Flash Player 9, Flash Lite 4

Spécifie la partie modèle de l’expression régulière.

Implémentation
public function get source():String

Plus d’exemples

Syntaxe d’expression régulière
Indicateurs et propriétés

Exemple ( Comment utiliser cet exemple )

Le code suivant renvoie le paramètre source de deux expressions régulières :

var re1:RegExp = /aabb/gi;
trace (re1.source); // aabb

var re2:RegExp = new RegExp("x+y*", "i");
trace(re2.source); // x+y*

Détails du constructeur

()

Constructeur

public function RegExp(re:String, flags:String)

Version du langage:

ActionScript 3.0

Versions du moteur d’exécution:

AIR 1.0, Flash Player 9

Vous permet de générer une expression régulière à partir de deux chaînes. La première définit le modèle de l’expression régulière, tandis que la seconde définit les indicateurs utilisés dans l’expression régulière.

Paramètres

re:String — Modèle de l’expression régulière (également appelée chaîne du constructeur). Il s’agit de la partie principale de l’expression régulière, à savoir la partie associée aux caractères « / ».

Remarques :

N’incluez pas les caractères « / » de début et de fin. N’utilisez ceux-ci que lorsque vous définissez un littéral d’expression régulière sans utiliser de constructeur. Par exemple, les deux expressions régulières suivantes sont équivalentes :
```
 var re1:RegExp = new RegExp("bob", "i"); 
        var re2:RegExp = /bob/i;
```
Dans une expression régulière définie à l’aide de la méthode constructeur RegExp(), tapez deux fois le caractère barre oblique inversée (\) pour utiliser une métaséquence débutant par le caractère barre oblique inversée, telle que \d (qui remplace n’importe quel chiffre). Par exemple, les deux expressions régulières suivantes sont équivalentes :
```
 var re1:RegExp = new RegExp("\\d+", ""); 
        var re2:RegExp = /\d/;
```
Dans la première expression, vous devez taper deux fois le caractère barre oblique inversée, car le premier paramètre de la méthode constructeur RegExp() est une chaîne. Dans un littéral de chaîne, ce caractère doit être entré deux fois pour être interprété comme une barre oblique inversée unique.

flags:String — Les modificateurs de l’expression régulière, parmi lesquels figurent :

g — Lorsque la méthode replace() de la classe String est utilisée, spécifiez ce modificateur pour remplacer toutes les correspondances, plutôt que la première uniquement. Ce modificateur correspond à la propriété global de l’occurrence de RegExp.
i — L’expression régulière est évaluée sans respect de la casse. Ce modificateur correspond à la propriété ignoreCase de l’occurrence de RegExp.
s — Caractère point (.) correspond aux caractères de nouvelle ligne. Remarque : ce modificateur correspond à la propriété dotall de l’occurrence de RegExp.
m — Le caractère circonflexe (^) et le symbole du dollar ($) établissent une correspondance avant et après les caractères de nouvelle ligne. Ce modificateur correspond à la propriété multiline de l’occurrence de RegExp.
x — Les caractères d’espace blanc de la chaîne re sont ignorés, afin de vous permettre d’écrire des constructeurs plus lisibles. Ce modificateur correspond à la propriété extended de l’occurrence de RegExp.

Aucun autre caractère de la chaîne flags n’est pris en compte.

Plus d’exemples

Syntaxe d’expression régulière

Détails de la méthode

exec

()

méthode

AS3 function exec(str:String):Object

Version du langage:

ActionScript 3.0

Versions du moteur d’exécution:

AIR 1.0, Flash Player 9, Flash Lite 4

Recherche l’expression régulière dans la chaîne str indiquée.

Si l’indicateur g (global) n’est pas défini pour l’expression régulière, la recherche débute au début de la chaîne (position d’index 0) et ignore la propriété lastIndex de l’expression régulière.

Si l’indicateur g (global) est défini pour l’expression régulière, la recherche débute à la position d’index spécifiée par la propriété lastIndex de l’expression régulière. Si la recherche correspond à une sous-chaîne, la propriété lastIndex est modifiée pour indiquer la position de la fin de la correspondance.

Paramètres

str:String — Chaîne à rechercher.

Valeur renvoyée

Object — Renvoie null si aucune correspondance n’est détectée, un objet aux propriétés suivantes dans le cas contraire :

Un tableau dont l’élément 0 contient la sous-chaîne correspondante entière, et les autres éléments du tableau (compris entre 1 et n) contiennent des sous-chaînes correspondant aux groupes entre parenthèses de l’expression régulière.
index — Position des caractères de la sous-chaîne correspondante au sein de la chaîne
input — Chaîne (str)

Plus d’exemples

Méthodes d’utilisation d’expressions régulières avec des chaînes

Eléments de l’API associés

String.match()
String.search()

Exemple ( Comment utiliser cet exemple )

Lorsque l’indicateur g (global) n’est pas défini dans l’expression régulière, vous pouvez utiliser exec() pour rechercher dans la chaîne la première correspondance :

         var myPattern:RegExp = /(\w*)sh(\w*)/ig;   
         var str:String = "She sells seashells by the seashore";
         var result:Object = myPattern.exec(str);
         trace(result);

L’objet result est défini comme suit :

result[0] est défini sur "She" (correspondance exacte).
result[1] est défini sur une chaîne vide (premier groupe entre parenthèses correspondant).
result[2] est réglé sur "e" (second groupe entre parenthèses correspondant).
result.index est défini sur 0.
result.input est défini sur la chaîne d’entrée : "She sells seashells by the seashore".

Dans l’exemple suivant, l’indicateur g (global) étant défini dans l’expression régulière, vous pouvez utiliser exec() à plusieurs reprises pour trouver les correspondances multiples :

         var myPattern:RegExp = /(\w*)sh(\w*)/ig;  
         var str:String = "She sells seashells by the seashore";
         var result:Object = myPattern.exec(str);
         
         while (result != null) {
             trace ( result.index, "\t", result);
             result = myPattern.exec(str);
         }

Le résultat du code est le suivant :


            0      She,,e
            10     seashells,sea,ells
            27     seashore,sea,ore

test

()

méthode

AS3 function test(str:String):Boolean

Version du langage:

ActionScript 3.0

Versions du moteur d’exécution:

AIR 1.0, Flash Player 9, Flash Lite 4

Recherche la correspondance de l’expression régulière dans la chaîne str indiquée.

Paramètres

str:String — Chaîne à tester.

Valeur renvoyée

Boolean — Renvoie true si une correspondance est détectée, false dans le cas contraire.

Plus d’exemples

Méthodes d’utilisation d’expressions régulières avec des chaînes

Exemple ( Comment utiliser cet exemple )

L’exemple suivant indique comment utiliser la méthode test() sur une expression régulière où l’indicateur g (global) est défini :

var re1:RegExp = /\w/g;
var str:String = "a b c";
trace (re1.lastIndex); // 0
trace (re1.test(str)); // true
trace (re1.lastIndex); // 1
trace (re1.test(str)); // true
trace (re1.lastIndex); // 3
trace (re1.test(str)); // true
trace (re1.lastIndex); // 5
trace (re1.test(str)); // false

Exemples Comment utiliser cet exemple

RegExpExample.as

L’exemple suivant indique comment utiliser des expressions régulières pour analyser des chaînes et renvoyer une nouvelle chaîne ou une valeur booléenne, en fonction de la chaîne transmise. La méthode informalizeGreeting() remplace simplement le mot Hello par Hi, quelle qu’en soit la casse. Elle sépare également le nom du prénom dans la chaîne (en supposant que le nom corresponde au modèle spécifié). Dans les méthodes validateEmail() et validatePhoneNumber(), la chaîne transmise est vérifiée pour vérifier si son modèle correspond bien à celui d’une adresse électronique valide ou celui d’un numéro de téléphone, puis les méthodes renvoient des valeurs booléennes en fonction des résultats.

package {
    import flash.display.Sprite;

    public class RegExpExample extends Sprite {        
        public function RegExpExample() {            
            var formalGreeting:String = "Hello, John Smith.";
            trace(informalizeGreeting(formalGreeting));    // Hi, John.

            var validEmail:String = "name@domain.com";
            trace(validateEmail(validEmail));        // true
            
            var invalidEmail:String = "foo";
            trace(validateEmail(invalidEmail));  // false
            
            var validPhoneNumber:String = "415-555-1212";
            trace(validatePhoneNumber(validPhoneNumber));    // true
            
            var invalidPhoneNumber:String = "312-867-530999";
            trace(validatePhoneNumber(invalidPhoneNumber));  // false
        }
        private function informalizeGreeting(str:String):String {
            var pattern:RegExp = new RegExp("hello, (\\w+) \\w+", "i");
            return str.replace(pattern, "Hi, $1");
        }
        private function validateEmail(str:String):Boolean {
            var pattern:RegExp = /(\w|[_.\-])+@((\w|-)+\.)+\w{2,4}+/;
            var result:Object = pattern.exec(str);
            if(result == null) {
                return false;
            }
            return true;
        }
        private function validatePhoneNumber(str:String):Boolean {
            var pattern:RegExp = /^\d{3}-\d{3}-\d{4}$/;
            var result:Object = pattern.exec(str);
            if(result == null) {
                return false;
            }
            return true;
        }
    }
}

Informations juridiques | Politique de confidentialité en ligne

RegExp - AS3

Classes x

dotall

extended

global

ignoreCase

lastIndex

multiline

source

RegExp

exec

test