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

Flash Player 9 och senare, Adobe AIR 1.0 och senare

Detta enkla exempel på Wiki-textkonvertering visar några användningsområden för reguljära uttryck. Det visar hur du:

  • konverterar textrader som matchar ett käll-Wiki-mönster med rätt HTML-sträng

  • använder ett reguljärt uttryck för att konvertera URL-mönster till hyperlänkstaggen <a> i HTML

  • använder ett reguljärt uttryck för att konvertera dollarsträngar (som "$9.95" ) till eurosträngar (som "8.24 €" ).

Programfilerna för det här exemplet finns på www.adobe.com/go/learn_programmingAS3samples_flash_se . Du hittar programfiler för WikiEditor i mappen Samples/WikiEditor. Programmet består av följande filer:

Fil

Beskrivning

WikiEditor.mxml

eller

WikiEditor.fla

Huvudprogramfilen i Flash (FLA) eller Flex (MXML).

com/example/programmingas3/regExpExamples/WikiParser.as

En klass som innehåller metoder där reguljära uttryck används för att konvertera Wiki-textmönster till motsvarande HTML-strängar.

com/example/programmingas3/regExpExamples/URLParser.as

En klass som innehåller metoder där reguljära uttryck används för att konvertera URL-strängarna till hyperlänkstaggen <a> i HTML.

com/example/programmingas3/regExpExamples/CurrencyConverter.as

En klass som innehåller metoder där reguljära uttryck används för att konvertera dollarsträngar till eurosträngar.

Definiera klassen WikiParser

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.

Konvertera mönster för fet och kursiv stil

Med metoden parseBold() kan du söka efter ett Wiki-textmönster med fet stil (t.ex. '''foo''' ) och omforma det till dess HTML-motsvarighet (t.ex. <b>foo</b> ), enligt följande:

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

Observera att delen med (.?*) i det reguljära uttrycket matchar alla tecken ( * ) mellan de båda definierade ''' -mönstren. Med händelsen ?Med kvantifieraren görs en matchning som inte är ”girig” så att för en sträng som '''aaa''' bbb '''ccc''' , kommer den första matchande delsträngen att vara '''aaa''' och inte den kompletta strängen (vilken startar och slutar med mönstret ''' ).

Parenteser i reguljära uttryck används för att definiera en hämtad grupp och metoden replace() refererar till gruppen med hjälp av koden $1 i ersättningssträngen. g -flaggan ( global ) i det reguljära uttrycket gör att metoden replace() ersätter alla matchningar i strängen (inte bara den första).

Metoden parseItalic() fungerar som metoden parseBold() med undantag för att den kontrollerar två apostrofer ( '' ) som avgränsare för kursiv text (inte här):

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

Konvertera mönster för punktlistor

I exemplet nedan används metoden parseBullet() för att leta efter punktlistemönstret för Wiki (t.ex. * foo ) och omformar det till dess HTML-motsvarighet (t.ex. <li>foo</li> ):

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

Symbolen ^ i början av det reguljära uttrycket matchar radens början. m -flaggan ( multiline ) i det reguljära uttrycket leder till att det reguljära uttrycket matchar symbolen ^ mot början av raden, inte bara början av strängen.

Mönstret \* matchar en asterisk (det omvända snedstrecket används för att ange att det är en litteral asterisk och inte en * -kvantifierare).

Parenteser i reguljära uttryck används för att definiera en hämtad grupp och metoden replace() refererar till gruppen med hjälp av koden $1 i ersättningssträngen. g -flaggan ( global ) i det reguljära uttrycket gör att metoden replace() ersätter alla matchningar i strängen (inte bara den första).

Konvertera Wiki-styckemönster

Med metoden linesToParagraphs() kan du konvertera varje rad i en Wiki-sträng till HTML-stycketaggen <p> . Dessa rader i metoden tar bort tomma rader från Wiki-strängen:

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

Symbolerna ^ och $ i det reguljära uttrycket matchar början och slutet av en rad. m -flaggan ( multiline ) i det reguljära uttrycket leder till att det reguljära uttrycket matchar symbolen ^ mot början av raden, inte bara början av strängen.

Metoden replace() används för att ersätta alla matchande delsträngar (tomma rader) med en tom sträng ( "" ). g -flaggan ( global ) i det reguljära uttrycket gör att metoden replace() ersätter alla matchningar i strängen (inte bara den första).

Konvertera URL-adresser till <a>-taggar i HTML

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.

Konvertera dollarsträngar till eurosträngar

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).