RegExp  - AS3

Gibt an, ob ein Punkt (.) in einem regulären Ausdruck nach Zeilenumbrüchen sucht. Verwenden Sie das s-Flag, um einen regulären Ausdruck zu erstellen, der dotall = true setzt.

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)); 
   

Gibt an, ob für den regulären Ausdruck der erweiterte Modus verwendet werden soll. Befindet sich ein RegExp-Objekt im erweiterten Modus, werden Leerraumzeichen im Konstruktorstring ignoriert. Dadurch können die Konstruktoren lesbarer gestaltet werden.

Verwenden Sie das x-Flag, um einen regulären Ausdruck zu erstellen, der extended = true setzt.

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

Gibt an, ob für den regulären Ausdruck eine globale Suche verwendet werden soll. Wenn global == true, wird die lastIndex-Eigenschaft gesetzt, nachdem eine Übereinstimmung gefunden wurde. Wenn das nächste Mal eine Suche ausgelöste wird, beginnt die Engine für reguläre Ausdrücke ab der Position lastIndex in dem String. Verwenden Sie das g-Flag, um einen regulären Ausdruck zu erstellen, der global auf true setzt.

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

Gibt an, ob der reguläre Ausdruck die Groß-/Kleinschreibung ignoriert. Verwenden Sie das i-Flag, um einen regulären Ausdruck zu erstellen, der ignoreCase = true setzt.

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

Gibt die Indexposition im String an, ab der die nächste Suche beginnen soll. Diese Eigenschaft wirkt sich auf die exec()- und test()-Methode der RegExp-Klasse aus. Allerdings ignorieren die match()-, replace()- und search()-Methoden der String-Klasse die lastIndex-Eigenschaft und beginnen die Suche immer ab dem Anfang eines Strings.

Wenn die exec()- oder test()-Methode eine Übereinstimmung findet, und das g-Flag (global) für diesen regulären Ausdruck auf true gesetzt ist, setzt die Methode automatisch die lastIndex-Eigenschaft auf die Indexposition des Zeichens nach dem letzten Zeichen im gefundenen passenden Teilstring der letzten Suche. Ist das g-Flag (global) auf false gesetzt, wird die lastIndex-Eigenschaft von der Methode nicht gesetzt.

Sie können die lastIndex-Eigenschaft setzen, um die Anfangsposition in dem String zu setzen, in dem nach einem regulären Ausdruck gesucht werden soll.

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

Gibt an, ob das m-Flag (multiline) gesetzt wurde. Ist das Flag gesetzt, wird mit dem Caret- (^) und dem Dollarzeichen ($) in einem regulären Ausdruck nach Übereinstimmungen vor und nach einem Zeilenumbruch gesucht. Verwenden Sie das m-Flag, um einen regulären Ausdruck zu erstellen, der multiline = true setzt.

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

Gibt das Muster des regulären Ausdrucks an.

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

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

Dient zur Erstellung eines regulären Ausdrucks aus zwei Strings. Ein String definiert das Muster des regulären Ausdrucks, und der zweite definiert die im regulären Ausdruck verwendeten Flags.

Führt in dem gegebenen String str eine Suche nach dem regulären Ausdruck durch.

Ist das g-Flag (global) für den regulären Ausdruck not gesetzt, so beginnt die Suche am Anfang des Strings (bei Indexposition 0); die Suche ignoriert die lastIndex-Eigenschaft des regulären Ausdrucks.

Ist das g-Flag (global) für den regulären Ausdruck gesetzt, so beginnt die Suche bei der Indexposition, die durch die lastIndex-Eigenschaft des regulären Ausdrucks angegeben wird. Wird nach einem Teilstring gesucht, ändert sich die lastIndex-Eigenschaft so, dass sie der Position des Endes der Übereinstimmung entspricht.

Parameter

Verwandte API-Elemente

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

         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);
         }
         

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

Prüft den gegebenen String str auf eine Übereinstimmung mit dem regulären Ausdruck.

Ist das g-Flag (global) für den regulären Ausdruck not gesetzt, so beginnt die Suche am Anfang des Strings (bei Indexposition 0); die Suche ignoriert die lastIndex-Eigenschaft des regulären Ausdrucks.

Ist das g-Flag (global) für den regulären Ausdruck gesetzt, so beginnt die Suche bei der Indexposition, die durch die lastIndex-Eigenschaft des regulären Ausdrucks angegeben wird. Wird nach einem Teilstring gesucht, ändert sich die lastIndex-Eigenschaft so, dass sie der Position des Endes der Übereinstimmung entspricht.

Parameter

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