Flaggor och egenskaper

g-flaggan (global)

När du inte använder g-flaggan (global) kommer det reguljära uttrycket endast att utföra en matchning. När g-flaggan inte ingår i det reguljära uttrycket kommer metoden String.match() endast att returnera en matchande delsträng, vilket visas i nästa exempel:

var str:String = "she sells seashells by the seashore."; 
var pattern:RegExp = /sh\w*/; 
trace(str.match(pattern)) // output: she

När g-flaggan är angiven kommer metoden Sting.match(), som framgår av nästa exempel, att returnera flera matchningar:

var str:String = "she sells seashells by the seashore."; 
var pattern:RegExp = /sh\w*/g; 
// The same pattern, but this time the g flag IS set. 
trace(str.match(pattern)); // output: she,shells,shore

i-flaggan (ignoreCase)

Enligt standarden är matchningar i reguljära uttryck versalkänsliga. När du väljer att använda i-flaggan (ignoreCase) kommer versalkänsligheten att ignoreras. I nästa exempel kommer gemenen s i det reguljära uttrycket inte att matcha versalen S (det första tecknet i strängen):

var str:String = "She sells seashells by the seashore."; 
trace(str.search(/sh/)); // output: 13 -- Not the first character

När du emellertid väljer att använda i-flaggan kommer det reguljära uttrycket att matcha versalen S:

var str:String = "She sells seashells by the seashore."; 
trace(str.search(/sh/i)); // output: 0

Flaggan i ignorerar versalkänsligheten bara för tecknen A–Z och a–z, men inte för utökade tecken som É och é.

m-flaggan (multiline)

Om du väljer att inte ställa in m-flaggan (multiline), kommer ^ att matcha början av strängen och $ slutet av strängen. Om m-flaggan är angiven matchar dessa tecken början respektive slutet av en rad. Titta på följande exempel där det finns ett radmatningstecken:

var str:String = "Test\n"; 
str += "Multiline"; 
trace(str.match(/^\w*/g)); // Match a word at the beginning of the string.

Trots att g-flaggan (global) är angiven i det reguljära uttrycket matchar metoden match() endast en delsträng, eftersom det bara finns en matchning för ^, strängens början. Resultatet blir:

Test

Här är samma kod, men det här gången används m-flaggan:

var str:String = "Test\n"; 
str += "Multiline"; 
trace(str.match(/^\w*/gm)); // Match a word at the beginning of lines. 

Nu visas i resultatet orden i början av de båda raderna.

Test,Multiline

Observera att det bara är tecknet \n som signalerar radslut. Följande tecken gör det inte:

• Returtecknet (\r)

• Unicode-tecknet för radavskiljare (\u2028)

• Unicode-tecknet för stryckeavskiljare (\u2029)

s-flaggan (dotall)

Om s-flaggan (dotall) är angiven, matchar en punkt (.) i mönstret för det reguljära uttrycket inte ett radmatningstecken (\n). Detta medför att inte finns några matchningar i följande exempel:

var str:String = "<p>Test\n"; 
str += "Multiline</p>"; 
var re:RegExp = /<p>.*?<\/p>/; 
trace(str.match(re)); 

Om däremot s-flaggan används kommer punkten att matcha ett radmatningstecken:

var str:String = "<p>Test\n"; 
str += "Multiline</p>"; 
var re:RegExp = /<p>.*?<\/p>/s; 
trace(str.match(re)); 

I nästa exempel gäller matchningen hela delsträngen inom <p>-taggarna, inklusive radmatningstecknet:

<p>Test 
Multiline</p>

x-flaggan (extended)

Reguljära uttryck kan vara svåra att läsa och detta gäller speciellt när de innehåller metasymboler och metasekvenser. Till exempel:

/<p(>|(\s*[^>]*>)).*?<\/p>/gi

När du använder x-flaggan (extended) i ett reguljärt uttryck kommer blanksteg som du skriver i mönstret att ignoreras. Följande reguljära uttryck är identiskt med det föregående:

/     <p    (>  | (\s* [^>]* >))    .*?    <\/p>  /gix

Om du väljer att använda x-flaggan och om du vill matcha ett blanksteg måste du före blanksteget skriva ett omvänt snedstreck. Följande två reguljära uttryck är likvärdiga:

/foo bar/ 
/foo \ bar/x

Egenskapen lastIndex

Egenskapen lastIndex anger indexpositionen i strängen där nästa sökning ska starta. Den här egenskapen påverkar metoderna exec() och test() vilka båda anropar ett reguljärt uttryck där g-flaggan är satt till true. Titta på följande kod:

var pattern:RegExp = /p\w*/gi; 
var str:String = "Pedro Piper picked a peck of pickled peppers."; 
trace(pattern.lastIndex); 
var result:Object = pattern.exec(str); 
while (result != null) 
{ 
    trace(pattern.lastIndex); 
    result = pattern.exec(str); 
}

Egenskapen lastIndex är enligt standard 0 (sökningen startar vid början av strängen). Efter varje matchning ändras indexpositionen enligt matchningen. Detta innebär att föregående kod kommer att resultera i följande utmatning:

0 
5 
11 
18 
25 
36 
44

Om global-flaggan är false, kommer egenskapen lastIndex inte att användas eller anges i metoderna exec() och test().

Metoderna match(), replace() och search() i klassen String startar alla sökningarna från början av strängen, oberoende av inställningen i egenskapen lastIndex i det reguljära uttrycket som används för att anropa metoden. (Emellertid sätter metoden match()lastIndex till 0.)

Du kan ställa in egenskapen lastIndex om du vill justera startpositionen i strängen för reguljär uttrycksmatchning.

Egenskapen source

Med egenskapen source anger du strängen som definierar mönsterdelen av det reguljära uttrycket. Till exempel:

var pattern:RegExp = /foo/gi; 
trace(pattern.source); // foo