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