Exempel på reguljära uttryck: en Wiki-parser

Klassen WikiParser innehåller metoder för att konvertera Wiki-indata till motsvarande HTML-utdata. Detta är inget stabilt Wiki-konverteringsprogram, men det innehåller några bra exempel på hur reguljära uttryck kan användas för mönstermatchning och strängkonvertering.

Konstruktorfunktionen tillsammans med metoden setWikiData() initierar en enkel sträng med Wiki-indata enligt följande:

public function WikiParser() 
{ 
    wikiData = setWikiData(); 
}

När användaren klickar på knappen Test i exempelprogrammet anropas metoden parseWikiString() för WikiParser-objektet. Den här metoden anropar ett antal andra metoder vilka i sin tur sätter samma den resulterade HTML-strängen.

public function parseWikiString(wikiString:String):String 
{ 
    var result:String = parseBold(wikiString); 
    result = parseItalic(result); 
    result = linesToParagraphs(result); 
    result = parseBullets(result); 
    return result; 
}

I de anropade metoderna – parseBold(), parseItalic(), linesToParagraphs() och parseBullets() – används metoden replace() för strängen för att ersätta matchande mönster, definierade i ett reguljärt uttryck, så att Wiki-texten kan omformas till HTML-formaterad text.

private function parseBold(input:String):String 
{ 
    var pattern:RegExp = /'''(.*?)'''/g; 
    return input.replace(pattern, "<b>$1</b>"); 
}

private function parseItalic(input:String):String 
{ 
    var pattern:RegExp = /''(.*?)''/g; 
    return input.replace(pattern, "<i>$1</i>"); 
}

private function parseBullets(input:String):String 
{ 
    var pattern:RegExp = /^\*(.*)/gm; 
    return input.replace(pattern, "<li>$1</li>"); 
}

var pattern:RegExp = /^$/gm; 
var result:String = input.replace(pattern, "");

När användaren klickar på knappen Test i exempelprogrammet och om användaren markerat kryssrutan urlToATag, anropas den statiska metoden URLParser.urlToATag() så att URL-strängar från Wiki-strängen konverteras till <a>-taggar i HTML.

var protocol:String = "((?:http|ftp)://)"; 
var urlPart:String = "([a-z0-9_-]+\.[a-z0-9_-]+)"; 
var optionalUrlPart:String = "(\.[a-z0-9_-]*)"; 
var urlPattern:RegExp = new RegExp(protocol + urlPart + optionalUrlPart, "ig"); 
var result:String = input.replace(urlPattern, "<a href='$1$2$3'><u>$1$2$3</u></a>");

Konstruktorfunktionen RegExp() används för att sätta ihop ett reguljärt uttryck (urlPattern) av ett antal beståndsdelar. Dessa beståndsdelar är alla strängar som definierar delar i mönstret för det reguljära uttrycket.

Den första delen av mönstret för det reguljära uttrycket, som definieras med strängen protocol, definierar ett URL-protokoll: antingen http:// eller ftp://. Med parenteserna definieras en icke-hämtad grupp vilket visas med symbolen ?. Detta betyder att parenteser endast används för att definiera en grupp för växlingsmönstret |. Gruppen kommer inte att matcha bakåtreferenskoder ($1, $2, $3) i ersättningssträngen för metoden replace().

För övriga beståndsdelar av det reguljära uttrycket används hämtningsgrupper (vilket visas med parenteser i mönstret), vilka sedan används i bakåtreferenskoderna ($1, $2, $3) i ersättningssträngen för metoden replace().

Den del av mönstret som definieras med strängen urlPart matchar åtminstone ett av följande tecken: a-z, 0-9, _ eller -. Kvantifieraren + anger att minst ett tecken matchar. Med händelsen \. anger ett obligatoriskt punkttecken (.). Återstoden matchar en annan sträng med åtminstone ett av dessa tecken: a-z, 0-9, _ eller -.

Den del av mönstret som definieras med strängen optionalUrlPart matchar noll eller flera av följande tecken: ett punkttecken (.) följt av ett eller flera alfanumeriska tecken (inklusive _ och -). Kvantifieraren * visar att noll eller flera tecken matchade.

I anropet till metoden replace() används det reguljära uttrycket och HTML-ersättningssträngen sätts ihop med bakåtreferenser.

Från metoden urlToATag() anropas sedan metoden emailToATag() där en liknande teknik används för att ersätta e-postmönster med hyperlänkssträngen <a> i HTML. De reguljära uttryck som används för att matcha URL-strängar för HTTP, FTP och e-post i den här exempelfilen är enkelt uppbyggda och är endast avsedda som exempel. Det finns andra mer sofistikerade reguljära uttryck för att matcha sådana URL-strängar på ett bättre sätt.

När användaren klickar på knappen Test i exempelprogrammet och har markerat kryssrutan dollarToEuro, anropar programmet den statiska metoden CurrencyConverter.usdToEuro() för att konvertera dollarsträngar (t.ex. "$9.95") till eurosträngar (t.ex. "8.24 €"), enligt följande:

var usdPrice:RegExp = /\$([\d,]+.\d+)+/g; 
return input.replace(usdPrice, usdStrToEuroStr); 

På den första raden definieras ett enkelt mönster för att matcha dollarsträngar. Observera att $-tecknet föregås av ett omvänt snedstreck (\) som escape-tecken.

I metoden replace() används det reguljära uttrycket för mönsterpassning och det anropar funktionen usdStrToEuroStr() för att bestämma ersättningssträngen (ett värde i euro).

När ett funktionsnamn används som den andra parametern för metoden replace() skickas följande som parametrar till den anropade funktionen:

• Den matchande delen av strängen.

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

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

• Den fullständiga strängen.

Med metoden usdStrToEuroStr() konverteras mönster för dollarsträngar till eurosträngar enligt följande:

private function usdToEuro(...args):String 
{ 
    var usd:String = args[1]; 
    usd = usd.replace(",", ""); 
    var exchangeRate:Number = 0.828017; 
    var euro:Number = Number(usd) * exchangeRate; 
    trace(usd, Number(usd), euro); 
    const euroSymbol:String = String.fromCharCode(8364); // € 
    return euro.toFixed(2) + " " + euroSymbol;  
}

Observera att args[1] representerar den hämtade parentetiska gruppen som matchas av det reguljära uttrycket usdPrice. Detta är den numeriska delen av dollarsträngen: dvs. dollarbeloppet utan tecknet $. I metoden tillämpas en växelkurs och den resulterande strängen returneras (med den efterföljande €-symbolen i stället för den inledande $-symbolen).