☰ JavascriptRegexp
 

Les expressions régulières en javascript

string.search(regex)

Retourne la position de la première sous-chaîne correspondant à regex dans string.

Retourne -1 s'il n'y a aucune correspondance.

string.match(regex)

Recherche la première ou toutes les correspondance de regex dans string et retourne le résultat dans un tableau.

Retourne un tableau vide s'il n'y a aucune correspondance.

string.replace(regex, str)

Retourne une chaine dans laquelle une ou de toutes les sous-chaînes correspondant à regex dans string, sont remplacées par la chaine str.

str peut être une fonction de callback qui renvoie une chaine.

Les modificateurs

g pour global : toutes les correspondances sont cherchées, au lieu de seulement la première.

i pour ignore-case : ignore la "casse" (aucune distinction entre les majuscules et les miniscules)

m pour multi-lines : ^ et $ matches les débuts et les fins de toutes les lignes

Ecriture du modèle de l'expression rationnelle

De manière littérale, compacte

On peut écrire une expression rationnelle de manière littérale et compacte en l'insérant entre deux "/", comme dans /d+/.

Les éventuels modificateurs se placent après le deuxième "/", comme dans /[0-9a-z]*/gi.

A l'aide du constructeur

On peut aussi écrire une expression rationnelle à l'aide de son constructeur, comme dans var expression = new RegExp("d+");.

Les éventuels modificateurs se placent en deuxième paramètre, comme dans new RegExp("[0-9a-z]*" , "gi");.

Application du modèle dans search, match ou replace

En une ligne

var ret = string.search(/monexpression/); expression constante sans modificateur.

var ret = string.match(eval("/" + var + "/gi")); expression variable avec modificateur.

var ret = string.replace(/ab([a-f]+)c(d)/i , "$1 $2"); expression constante avec modificateur, utilisation des parenthèses de capture.

En deux lignes

Sur la première ligne on écrit l'expression le modèle de l'expression rationelle, littéralement ou à l'aide de son constructeur:

var r = /monexpression/g; ou var r = new RegExp('monexpression' , 'g'); sont équivalents.

Sur la deuxième ligne, on applique le modèle:

var ret = string.match(r);

Mettre une variable dans le masque

On utilise le constructeur: var rg = new RegExp(today , 'ig');

On peut aussi utiliser eval: var rg = eval("/"+today+"/gi");

Pour échapper les caractères spéciaux qui peuvent exister dans la variable, on peut utiliser

function regExpEscape(str) {
    return str.replace(/[-[\]{}()*+!<=:?.\/\\^$|#\s,]/g, '\\$&');
}

Cette function fait un "full escape" d'une chaine pour tous les usages dans des RegExp:

Special Characters Covered:

    -: Creates a character range in a character class.
    [ / ]: Starts / ends a character class.
    { / }: Starts / ends a numeration specifier.
    ( / ): Starts / ends a group.
    * / + / ?: Specifies repetition type.
    .: Matches any character.
    \: Escapes characters, and starts entities.
    ^: Specifies start of matching zone, and negates matching in a character class.
    $: Specifies end of matching zone.
    |: Specifies alternation.
    #: Specifies comment in free spacing mode.
    \s: Ignored in free spacing mode.
    ,: Separates values in numeration specifier.
    /: Starts or ends expression.
    :: Completes special group types, and part of Perl-style character classes.
    !: Negates zero-width group.
    < / =: Part of zero-width group specifications.

Notes:

    / is not strictly necessary in any flavor of regular expression. However, it protects in case someone (shudder) does eval("/" + pattern + "/");.
    , ensures that if the string is meant to be an integer in the numerical specifier, it will properly cause a RegExp compiling error instead of silently compiling wrong.
    #, and \s do not need to be escaped in JavaScript, but do in many other flavors. They are escaped here in case the regular expression will later be passed to another program.

If you also need to future-proof the regular expression against potential additions to the JavaScript regex engine capabilities, I recommend using the more paranoid:

function regExpEscape(str) { {
    return str.replace(/[^A-Za-z0-9_]/g, '\\$&');
}

This function escapes every character except those explicitly guaranteed not be used for syntax in future regular expression flavors.

Enfin, la function suivante est généralement tout à fait suffisante:

function regExpEscape(str) {
    return str.replace(/[-\/\\^$*+?.()|[\]{}]/g, '\\$&');
};

Exemples

Pour vérifier un pseudonyme

var pseudook = pseudo.match(/^[a-zA-Z0-9_-]{3,16}$/);

Pour vérifier une adresse e-mail

var mailok = mail.match(/^[a-zA-Z0-9._-]+@[a-z0-9._-]{2,}.[a-z]{2,4}$/);

Quelques remarques