Returnera delsträngar och mönster i strängar

Returnera matchande delsträngar

Metoden search() returnerar indexpositionen för den första delsträngen som matchar ett givet mönster, enligt följande exempel:

var str:String = "The more the merrier."; 
// (This search is case-sensitive.) 
trace(str.search("the")); // output: 9 

Du kan även använda reguljära uttryck för att definiera mönstret:

var pattern:RegExp = /the/i; 
var str:String = "The more the merrier."; 
trace(str.search(pattern)); // 0

Utdata för metoden trace() är 0, eftersom det första tecknet i strängen är indexpositionen 0. Genom att flaggan i anges i det reguljära uttrycket är sökningen inte skiftlägeskänslig.

Metoden search() hittar endast en matchning och returnerar motsvarande startindexposition, även om den globala flaggan g anges i det reguljära uttrycket.

I följande exempel visas ett mer komplicerat reguljärt uttryck som matchar en sträng inom citattecken:

var pattern:RegExp = /"[^"]*"/; 
var str:String = "The \"more\" the merrier."; 
trace(str.search(pattern)); // output: 4 
 
str = "The \"more the merrier."; 
trace(str.search(pattern)); // output: -1  
// (Indicates no match, since there is no closing double quotation mark.)

Metoden match() fungerar på liknande sätt. Den söker efter en matchande delsträng. När du däremot använder den globala flaggan i ett mönster med reguljärt uttryck så returnerar match() en array med matchande delsträngar, enligt följande:

var str:String = "bob@example.com, omar@example.org"; 
var pattern:RegExp = /\w*@\w*\.[org|com]+/g; 
var results:Array = str.match(pattern);

Arrayen results anges enligt följande:

["bob@example.com","omar@example.org"]

Mer information om reguljära uttryck finns i Använda reguljära uttryck.

Ersätta matchade delsträngar

Du kan använda metoden replace() för att söka efter ett specifikt mönster i en sträng och ersätta matchningar med angiven sträng, enligt följande exempel:

var str:String = "She sells seashells by the seashore."; 
var pattern:RegExp = /sh/gi; 
trace(str.replace(pattern, "sch")); //sche sells seaschells by the seaschore. 

Observera, att i exemplet är de matchade strängarna inte skiftlägeskänsliga eftersom flaggan i (ignoreCase) anges i det reguljära uttrycket. Flera matchningar ersätts därför att flaggan g (global) anges. Mer information om publicering finns i Använda reguljära uttryck.

Du kan inkludera följande $-ersättningskoder i ersättningssträngen. Ersättningstexten som visas i följande tabell infogas när ersättningskoden $påträffas.

I följande exempel visas användningen av ersättningskoderna $2 och $1 som representerar den första och andra hämtade gruppen som matchar varandra:

var str:String = "flip-flop"; 
var pattern:RegExp = /(\w+)-(\w+)/g; 
trace(str.replace(pattern, "$2-$1")); // flop-flip

Du kan även använda en funktion som den andra parametern i metoden replace(). Den matchande texten ersätts med funktionens returnerade värde.

var str:String = "Now only $9.95!"; 
var price:RegExp = /\$([\d,]+.\d+)+/i; 
trace(str.replace(price, usdToEuro)); 
 
function usdToEuro(matchedSubstring:String,                                  capturedMatch1:String,                                  index:int,                                  str:String):String 
{ 
    var usd:String = capturedMatch1; 
    usd = usd.replace(",", ""); 
    var exchangeRate:Number = 0.853690; 
    var euro:Number = parseFloat(usd) * exchangeRate; 
    const euroSymbol:String = String.fromCharCode(8364); 
    return euro.toFixed(2) + " " + euroSymbol; 
}

Om du använder en funktion som den andra parametern för metoden replace() så skickas följande argument till funktionen:

• Den matchande delen av strängen.

• Eventuella hämtade parentetiska gruppmatchningar. Hur många argument som skickas på det här sättet beror på antalet parentetiska matchningar. Du kan bestämma antalet parentetiska matchningar genom att kontrollera arguments.length - 3 i funktionskoden.

• Indexpositionen i strängen där matchningen börjar.

• Den fullständiga strängen.