Exemplo de expressões regulares: um analisador Wiki

A classe WikiParser inclui métodos que convertem texto de entrada Wiki em saída HTML equivalente. Esse não é um aplicativo de conversão Wiki muito robusto, mas ele ilustra alguns bons usos de expressões regulares para correspondência de padrão e conversão de strings.

A função de construtor, junto com o método setWikiData(), simplesmente inicializa uma string de amostra do texto de entrada Wiki, como se segue:

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

Quando o usuário clica no botão Testar no aplicativo de amostra, o aplicativo chama o método parseWikiString() do objeto WikiParser. Esse método chama vários outros métodos, que por sua vez montam a string HTML resultante.

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

Cada um dos métodos chamados — parseBold(), parseItalic(), linesToParagraphs() e parseBullets()— usa o método replace() da string para substituir os padrões de correspondência, definidos por uma expressão regular, para transformar o texto de entrada Wiki em texto no formato HTML.

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, "");

Quando o usuário clica no botão Testar no aplicativo de amostra, se ele marcou a caixa de seleção urlToATag, o aplicativo chama o método estático URLParser.urlToATag() para converter as strings URL da string Wiki de entrada em tags HTML <a>.

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>");

A função do construtor RegExp() é usada para montar uma expressão regular (urlPattern) a partir de inúmeras partes constituintes. Essas partes constituintes são cada string que define parte do padrão da expressão regular.

A primeira parte do padrão da expressão regular, definida pela string protocol, define um protocolo de URL: http:// ou ftp://. Os parênteses definem um grupo de não captura, indicado pelo símbolo ?. Isso significa que os parênteses são usados simplesmente para definir um grupo para o padrão de alternação |; o grupo não corresponderá a códigos de referência anterior ($1, $2, $3) na string de substituição do método replace().

As outras partes constituintes da expressão regular usam grupos de captura (indicado por parênteses no padrão), que são usados nos códigos de referência anterior ($1, $2, $3) na string de substituição do método replace().

A parte do padrão definido pela string urlPart corresponde a pelo menos um destes caracteres: a-z, 0-9, _ ou-. O quantificador + indica que pelo menos um caractere tem correspondência. \. indica um caractere de ponto (.) exigido. E o restante corresponde a outra string de pelo menos um destes caracteres: a-z, 0-9, _ ou-.

A parte do padrão definido pela string optionalUrlPart corresponde a nenhum ou mais destes caracteres: um ponto (.) seguido por qualquer número de caracteres alfanuméricos (incluindo _ e -). O quantificador * indica que nenhum ou mais caracteres têm correspondência.

A chamada do método replace() aplica a expressão regular e monta a string HTML de substituição, utilizando referências anteriores.

O método urlToATag() chama o método emailToATag(), que usa técnicas semelhantes para substituir padrões de email por string de hiperlinks HTML <a>. As expressões regulares utilizadas para corresponder HTTP, FTP e URLs de email nesse arquivo de amostra são muito simples, com o objetivo de exemplificação; há expressões regulares muito mais complicadas para correspondência com esses URLs.

Quando o usuário clica no botão Testar do aplicativo de exemplo, se ele marcou a caixa de seleção dollarToEuro, o aplicativo chama o método estático CurrencyConverter.usdToEuro() para converter as strings com dólares norte-americanos (como "$9,95") em strings com euros (como "8,24 €"), da seguinte maneira:

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

A primeira linha define um padrão simples para correspondência de strings de dólar americano. Observe que o caractere $ é precedido por um caractere escape de barra invertida (\).

O método replace() usa a expressão regular como o correspondente padrão e chama a função usdStrToEuroStr() para determinar a string de substituição (um valor em euros).

Quando um nome de função for utilizado como o parâmetro secundário do método replace(), o seguinte será transmitido como parâmetros para a função chamada:

• A parte correspondente da string.

• Qualquer correspondência de grupo em parênteses capturado. O número de argumentos transmitidos dessa maneira irá variar dependendo do número de correspondências de grupo entre parênteses capturado. É possível determinar o número de correspondências de grupo entre parênteses capturado, verificando arguments.length -3 no código da função.

• A posição de índice na string em que a correspondência começa.

• A string completa.

O método usdStrToEuroStr() converte padrões de string de dólar americano para string de euro, como se segue:

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;  
}

Observe que args[1] representa o grupo entre parênteses capturado, correspondido pela expressão regular usdPrice. Essa é uma parte numérica da string de dólar americano: isto é, a quantidade de dólar sem o sinal $. O método aplica uma conversão de taxa de câmbio e retorna a string resultante (com o símbolo € à direita em vez do símbolo $ à esquerda).