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)

Groups

You can extract some informations by using groups :

   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"

The r.matched(0) result will always return the whole matched substring, and r.matchedPos() will return the position of this substring in the original string :

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

Replace

A regular expression can also be used to replace a part of the string :

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

You can use $X to reuse a matched group in the replacement :

   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)