Haxe supporte nativement les expression régulières. Elles peuvent être utilisées pour vérifier le format d'une chaine de caractères ou pour extraire des données régulières d'un texte. Une expression régulière débute avec ~/ et se termine avec un seul / :

    var r : EReg = ~/world/;
    var str = "hello world";
    trace(r.match(str)); // true : 'world' a été trouvé dans la chaine
    trace(r.match("hello !")); // false

Vous pouvez utiliser des motifs (patterns) d'expression régulières comme (mais pas uniquement) :

• . : n'importe quel caractère
• * : répéter 0 ou plusieurs fois
• + : répéter une fois ou plus
• ? : optionnel (non présent ou présent une fois)
• [A-Z0-9] : ensemble de caractères
• [^\r\n\t] : caractère non-présent dans l'ensemble de caractères
• (...) : parentheses pour faire correspondre plusieurs groupes de caractères
• ^ : Début de chaine ou de ligne
• $ : Fin de chaine ou de ligne

Par exemple, l'expression régulière suivante correspond à une adresse e-mail valide :

    ~/[A-Z0-9._%-]+@[A-Z0-9.-]+\.[A-Z][A-Z][A-Z]?/i;

Notez que le i à la fin de l'expression régulière est un drapeau qui rend la correspondance insensible à la casse.

Les drapeaux possibles sont les suivants :

• i : correspondance insensible à la casse
• g : substitution ou découpage global, voir plus bas
• m : correspondance multi-ligne, ^ et $ representent le début et la fin de la chaine
• s : le point . correspondra avec les nouvelles lignes (Haxe/Server uniquement)

Groupes

Vous pouvez extraire des informations en utilisant les groupes :

   var str = "Nicolas is 26 years old";
   var r = ~/([A-Za-z]+) is ([0-9]+) years old/;
   r.match(str);
   trace(r.matched(1)); // "Nicolas"
   trace(r.matched(2)); // "26"

La valeur de retour de r.matched(0) sera toujours la sous-chaine correspondante entière, et r.matchedPos() retourne la position de cette sous-chaine dans la chaine originale :

   var str = "abcdeeeeefghi";
   var r = ~/e*/;
   r.match(str);
   trace(r.matched(0)); // "eeeee"
   trace(r.matchedPos()); // { pos : 4, len : 5 }

Substitution

Une expression régulière peut être utilisée pour remplacer une partie de la chaine :

   var str = "aaabcbcbcbz";
   var r = ~/b[^c]/g; // g : remplace toutes les instances
   trace(r.replace(str,"xx")); // "aaaxxxxxxbz"

Vous pouvez utiliser $X pour réutiliser un groupe correspondant dans la subsitution :

   var str = "{hello} {0} {again}";
   var r = ~/{([a-z]+)}/g;
   trace(r.replace(str,"*$1*")); // "*hello* {0} *again*"

Split

A regular expression can also be used to split a string into several substrings. In that case, the delimiter used to split is not a constant string but a regular expression :

  var str = "XaaaYababZbbbW";
  var r = ~/[ab]+/g;
  trace(r.split(str)); // ["X","Y","Z","W"]

Implementation Details

Regular Expressions are implemented :

• in Javascript, the Browser is providing the implementation with the object RegExp.
• in Neko, the PCRE library is used
• in Flash9, the native implementation is used
• FIXME in Flash 6/8, the implementation is not yet available but will a pure Haxe version (hence very since not native slow, but compatible)