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.

Siehe auch

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.

Siehe auch

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 Eigenschaft lastIndex 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.

Siehe auch

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.

Siehe auch

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 Methoden exec() und test() der RegExp-Klasse aus. Allerdings ignorieren die Methoden match(), replace() und search() der String-Klasse die Eigenschaft lastIndex und beginnen die Suche immer ab dem Anfang eines Strings.

Wenn die Methode exec() oder test() eine Übereinstimmung findet, und das g-Flag (global) für diesen regulären Ausdruck auf true gesetzt ist, setzt die Methode automatisch die Eigenschaft lastIndex 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 Eigenschaft lastIndex von der Methode nicht gesetzt.

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

Siehe auch

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.

Siehe auch

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.

Siehe auch

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.

Siehe auch

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 Eigenschaft lastIndex 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 Eigenschaft lastIndex des regulären Ausdrucks angegeben wird. Wird nach einem Teilstring gesucht, ändert sich die Eigenschaft lastIndex so, dass sie der Position des Endes der Übereinstimmung entspricht.

Parameter

Siehe auch

         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 Eigenschaft lastIndex 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 Eigenschaft lastIndex des regulären Ausdrucks angegeben wird. Wird nach einem Teilstring gesucht, ändert sich die Eigenschaft lastIndex so, dass sie der Position des Endes der Übereinstimmung entspricht.

Parameter

Siehe auch

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