Exemple d’expression régulière : analyseur Wiki

Flash Player 9 et les versions ultérieures, Adobe AIR 1.0 et les versions ultérieures

Cet exemple simple de conversion de texte Wiki illustre des utilisations d’expressions régulières :

  • Conversion de lignes de texte qui mettent en correspondance un modèle Wiki source et les chaînes de sortie HTML appropriées.

  • Utilisation d’une expression régulière pour convertir des modèles URL en balises de lien hypertexte HTML <a>

  • Utilisation d’une expression régulière pour convertir les chaînes dollar américain ("$9.95", par exemple) en chaînes euro ("8.24 €", par exemple)

Pour obtenir les fichiers d’application de cet exemple, voir www.adobe.com/go/learn_programmingAS3samples_flash_fr. Les fichiers de l’application WikiEditor se trouvent dans le dossier Samples/WikiEditor. L’application se compose des fichiers suivants :

Fichier

Description

WikiEditor.mxml

ou

WikiEditor.fla

Fichier d’application principal dans Flash (FLA) ou Flex (MXML).

com/example/programmingas3/regExpExamples/WikiParser.as

Une classe qui comprend des méthodes utilisant des expressions régulières pour convertir des modèles de texte d’entrée Wiki en sortie HTML équivalente.

com/example/programmingas3/regExpExamples/URLParser.as

Une classe qui comprend des méthodes utilisant des expressions régulières pour convertir des chaînes URL en balises de lien hypertexte HTML <a>.

com/example/programmingas3/regExpExamples/CurrencyConverter.as

Une classe qui comprend des méthodes utilisant des expressions régulières pour convertir des chaînes dollar américain en chaînes euro.

Définition de la classe WikiParser

La classe WikiParser inclut des méthodes qui convertissent le texte d’entrée Wiki en sortie HTML équivalente. Il ne s’agit pas d’une application de conversion Wiki très puissante, mais elle illustre des utilisations d’expressions régulières pour la mise en correspondance de modèle et la conversion de chaîne.

La fonction constructeur et la méthode setWikiData() initialisent un exemple de chaîne de texte d’entrée Wiki, comme suit :

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

Lorsque l’utilisateur clique sur le bouton de test dans l’application exemple, cette dernière appelle la méthode parseWikiString() de l’objet WikiParser. Cette méthode appelle plusieurs autres méthodes, qui assemblent à leur tour la chaîne HTML résultante.

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

Chaque méthode appelée—parseBold(), parseItalic(), linesToParagraphs(), et parseBullets()—utilise la méthode replace() de la chaîne pour remplacer les modèles de correspondance, définis par une expression régulière, de façon à transformer le texte Wiki en texte formaté HTML.

Conversion des modèles de texte en gras et en italique

La méthode parseBold() recherche un modèle de texte Wiki en gras ('''foo''', par exemple) et le transforme en son équivalent HTML (<b>foo</b>, par exemple), comme suit :

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

Notez que la portion (.?*) de l’expression régulière correspond à des caractères (*) entre les deux modèles de définition '''. Le quantificateur ? rend la correspondance nongreedy, de façon à ce que pour une chaîne telle que '''aaa''' bbb '''ccc''', la première chaîne mise en correspondance soit '''aaa''' et non la chaîne entière (qui commence et se termine par le modèle ''').

Les parenthèses dans l’expression régulière définissent un groupe capturé, et la méthode replace() se réfère à ce groupe en utilisant le code $1 dans la chaîne de remplacement. L’indicateur g (global) dans l’expression régulière vérifie que la méthode replace() remplace toutes les correspondances dans la chaîne (pas simplement la première).

La méthode parseItalic() fonctionne comme la méthode parseBold(), sauf qu’elle recherche deux apostrophes ('') comme séparateur pour le texte en italique (au lieu de trois) :

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

Conversion de modèles de puce

Comme dans l’exemple suivant, la méthode parseBullet() recherche le modèle de puce Wiki (* foo, par exemple) et le transforme en son équivalent HTML (<li>foo</li>, par exemple) :

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

Le symbole ^ au début de l’expression régulière correspond au début d’une ligne. L’indicateur m (multiline) dans l’expression régulière fait en sorte que cette dernière compare le symbole ^ au début d’une ligne, et non simplement au début de la chaîne.

Le modèle \* correspond à un astérisque (la barre oblique est utilisée pour signaler un astérisque littéral au lieu d’un quantificateur *).

Les parenthèses dans l’expression régulière définissent un groupe capturé, et la méthode replace() se réfère à ce groupe en utilisant le code $1 dans la chaîne de remplacement. L’indicateur g (global) dans l’expression régulière vérifie que la méthode replace() remplace toutes les correspondances dans la chaîne (pas simplement la première).

Conversion de modèles Wiki de paragraphe

La méthode linesToParagraphs() convertit chaque ligne dans la chaîne Wiki d’entrée en une balise de paragraphe HTML <p>. Ces lignes dans la méthode extraient des lignes vides de la chaîne d’entrée Wiki :

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

Les symboles ^ et $ dans l’expression régulière correspondent au début et à la fin d’une ligne. L’indicateur m (multiline) dans l’expression régulière fait en sorte que cette dernière compare le symbole ^ au début d’une ligne, et non simplement au début de la chaîne.

La méthode replace() remplace toutes les chaînes de correspondance (lignes vides) par une chaîne vide (""). L’indicateur g (global) dans l’expression régulière vérifie que la méthode replace() remplace toutes les correspondances dans la chaîne (pas simplement la première).

Conversion d’URL en balises HTML <a>

Lorsque l’utilisateur clique sur le bouton de test dans l’exemple d’application et qu’il a coché la case urlToATag, l’application appelle la méthode statique URLParser.urlToATag() pour convertir les chaînes URL de la chaîne Wiki d’entrée en balises 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>");

La fonction constructeur RegExp() sert à assembler une expression régulière (urlPattern) à partir de plusieurs parties constituantes. Ces parties constituantes sont représentées par chaque chaîne définissant une partie du modèle de l’expression régulière.

La première partie du modèle de l’expression régulière, définie par la chaîne protocol, définit un protocole URL : http:// ou ftp://. Les parenthèses définissent un groupe non capturé, indiqué par le symbole ?. Ceci signifie que les parenthèses servent simplement à définir un groupe pour le modèle de permutation | ; le groupe ne correspondra pas à des codes de backreference ($1, $2, $3) dans la chaîne de remplacement de la méthode replace().

Les autres parties constituantes de l’expression régulière utilisent chacune des groupes capturés (indiqués par des parenthèses dans le modèle) qui sont ensuite utilisés dans les codes de backreference ($1, $2, $3) dans la chaîne de remplacement de la méthode replace().

La partie du modèle définie par la chaîne urlPart correspond au moins à l’un des caractères suivants : a-z, 0-9, _ ou -. La quantificateur + indique qu’au moins un caractère a une correspondance. Le \. indique un point obligatoire (.). Et le reste correspond à une autre chaîne d’au moins un de ces caractères : a-z, 0-9, _ ou -.

La partie du modèle définie par la chaîne optionalUrlPart correspond à zéro ou plus des caractères suivants : un point (.) suivi par n’importe quel nombre de caractères alphanumériques (y compris _ et -). Le quantificateur * indique que zéro ou plus de caractères ont une correspondance.

L’appel à la méthode replace() utilise l’expression régulière et assemble la chaîne HTML de remplacement, à l’aide de backreferences.

La méthode urlToATag() appelle ensuite la méthode emailToATag(), qui utilise des techniques semblables pour remplacer des modèles de courrier électronique par des chaînes de lien hypertexte HTML <a>. Les expressions régulières utilisées pour correspondre à des URL HTTP, FTP et de courrier électronique dans le fichier sont assez simples car elles sont données à titre d’exemple. Elles sont beaucoup plus compliquées si l’on souhaite établir une correspondance plus correcte.

Conversion des chaînes dollar américain en chaînes euro

Lorsque l’utilisateur clique sur le bouton de test dans l’exemple d’application et qu’il a coché la case dollarToEuro , l’application appelle la méthode statique CurrencyConverter.usdToEuro() pour convertir des chaînes dollar américain ("$9.95", par exemple) en chaînes euro ("8.24€", par exemple), comme suit :

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

La première ligne définit un modèle simple pour établir une correspondance avec des chaînes dollar américain. Le caractère $ est précédé du caractère d’échappement (\).

La méthode replace() utilise l’expression régulière pour établir une correspondance avec le modèle et appelle la fonction usdStrToEuroStr() pour déterminer la chaîne de remplacement (une valeur en euros).

Lorsqu’un nom de fonction est utilisé comme deuxième paramètre de la méthode replace(), les éléments suivants sont transmis comme paramètres à la fonction appelée :

  • La partie correspondante de la chaîne.

  • Tout groupe entre parenthèses capturé correspondant. Le nombre d’arguments transmis de cette façon varie selon le nombre de correspondances de groupes entre parenthèses capturées. Pour déterminer le nombre de correspondances de groupes entre parenthèses capturés, vérifiez arguments.length - 3 dans le code de la fonction.

  • La position d’index dans la chaîne où débute la correspondance.

  • La chaîne complète.

La méthode usdStrToEuroStr() convertit les modèles de chaîne dollar américain en chaînes euro, comme suit :

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

args[1] représente le groupe entre parenthèses capturé mis en correspondance par l’expression régulière usdPrice. Il s’agit de la portion numérique de la chaîne dollar américain, c’est-à-dire la quantité en dollar, sans le signe $. La méthode applique une conversion de taux de change et renvoie la chaîne résultante (avec un symbole de fin de ligne € au lieu du symbole $ placé à gauche).