mozilla
Vos résultats de recherche

    RegExp

    Résumé

    Le constructeur RegExp permet de créer un objet représentant une expression rationnelle permettant de reconnaître un motif (pattern en anglais) dans un texte.

    Pour une introduction sur les expressions rationnelles et ce qu'elles permettent de faire, voir le chapitre sur les expressions rationnelles du guide JavaScript.

    Syntaxe

    Il est possible d'utiliser le constructeur ou une notation littérale :

    /motif/flags
    new RegExp(motif[, flags])
    

    Parameters

    motif
    Le motif qu'on cherche à faire correspondre pour l'expression rationnelle.
    flags

    S'ils sont utilisés, ils peuvent être combinés entre eux. Ils signifient :

    g
    La correspondance est cherchée partout (sur plusieurs lignes)
    i
    La casse est ignorée.
    m
    Multi-ligne : Les caractères de début et de fin (^ et $) sont utilisés sur plusieurs lignes (correspondent au début et à la fin de chaque ligne) (délimitée par \n ou \r), et non plus au début ou à la fin de l'ensemble de la chaîne.
    y
    Adhésion : ne correspond qu'à partir de l'indice fourni par la propriété lastIndex (toutes les correspondances suivantes ne sont pas utilisées).

    Description

    Il existe deux façons de créer un objet RegExp : en utilisant une notation littéralle ou un constructeur. La notation littérale n'utilise pas de simples quotes pour indiquer la chaîne du motif alors que le constructeur utilise les quotes pour délimiter le motif. Ainsi, les deux expressions suivantes permettent de créer la même expression rationnelle :

    /ab+c/i;
    new RegExp('ab+c', 'i');
    

    La notation littérale permet de compiler l'expression rationnelle lorsque l'expression est évaluée. Ainsi, il faut privilégier la notation littérale lorsque l'expression rationnelle reste constante. Par exemple, si on utilise la notation littérale pour une expression rationnelle utilisée dans une boucle, l'expression rationnelle ne sera pas recalculée à chaque itération.

    Le constructeur de l'objet new RegExp('ab+c') permet que l'expression soit compilée au moment de l'exécution. Cela permet d'utiliser une expression rationnelle dont le motif peut être modifié car provenant d'une autre source (entrée utilisateur, etc.).

    Lorsqu'on utilise le constructeur, il est nécessaire d'échapper les caractères spéciaux comme pour les chaînes de caractères (c'est-à-dire de précéder les caractères spéciaux avec \). Les deux définitions suivantes sont donc équivalentes :

    var re = /\w+/;
    var re = new RegExp('\\w+');
    

    Signification des caractères spéciaux dans les expressions rationnelles

    Classes de caractères
    Caractère Signification
    .

    (Le point) correspond à n'importe quel caractère exceptés les caractères de nouvelle ligne : \n, \r, \u2028 ou \u2029.

    Le drapeau (flag) de multi-ligne m multiline ne modifie pas le comportement de ce caractère. Ainsi, si on souhaite créer un motif pour plusieurs lignes, on pourra utiliser l'ensemble [^] qui correspondra à n'importe quel caractère, nouvelles lignes comprises.

    Ainsi, /.a/ correspond à "ma" et "la", mais ne correspond pas à "aujourd'hui", dans "aujourd'hui j'ai fait des crêpes".

    \d

    Correspond à un caractère numérique de l'alphabet latin classique. Cette classe est équivalente à l'ensemble [0-9].

    Ainsi, /\d/ ou /[0-9]/ correspon à "2" dans "B2 touché coulé".

    \D

    Correspond à n'importe quel caractère qui n'est pas un chiffre de l'alphabet latin classique. Cette classe est équivalente à l'ensemble [^0-9].

    Ainsi, /\D/ ou /[^0-9]/ correspond à "B" dans "B2 touché coulé".

    \w

    Correspond à n'importe quel caractère alpha-numérique de l'alphabet latin classique et aussi au tiret bas (underscore). Cette classe est équivalente à l'ensemble [A-Za-z0-9_].

    Ainsi, /\w/ correspond à  "b" dans "banane", à "5" dans "5.28 €", et à "3" dans "3D".

    \W

    Correspond à n'importe quel caractère qui n'est pas un caractère alpha-numérique de l'alphabet latin et qui n'est pas le tiret-bas. Cette classe est équivalente à l'ensemble [^A-Za-z0-9_].

    Ainsi, /\W/ ou /[^A-Za-z0-9_]/ correspondra à "%" dans "50%".

    \s

    Correspond à un caractère de blanc (ce qui inclut l'espace, la tabulation la tabulation verticale, le saut de page et les autres espaces Unicode). Cette classe est équivalente à l'ensemble [ \f\n\r\t\v​\u00a0\u1680​\u180e\u2000​\u2001\u2002​\u2003\u2004\u2005\u2006​\u2007\u2008​\u2009\u200a​\u2028\u2029​\u202f\u205f​\u3000].

    Ainsi, /\s\w*/ correspond à " truc" dans "toto truc".

    \S

    Correspond à un caractère qui n'est pas un caractère de blanc. Cette classe est équivalente à l'ensemble [^ \f\n\r\t\v​\u00a0\u1680​\u180e\u2000​\u2001\u2002​\u2003\u2004\u2005\u2006​\u2007\u2008​\u2009\u200a​\u2028\u2029​\u202f\u205f​\u3000].

    Ainsi, /\S\w*/ correspond à "toto" dans "toto truc".

    \t Correspond à une tabulation.
    \r Correspond à un retour chariot.
    \n Correspond à une nouvelle ligne.
    \v Correspond à une tabulation verticale.
    \f Correspond à un saut de page.
    [\b] Correspond à un retour arrière. (à ne pas confondre avec \b)
    \0 Correspond au caractère NUL. Cette classe ne doit pas être suivie par un autre chiffre.
    \cX

    Avec X une lettre entre A et Z. Correspond au caractère de contrôle correspondant dans la chaîne de caractères.

    Ainsi, /\cM/ correspond au caractère control-M d'une chaîne.

    \xhh Correspond au caractère de code hh (deux chiffres hexadécimaux).
    \uhhhh Correspond au caractère dont la valeur Unicode est hhhh (quatre chiffres hexadécimaux).
    \

    Permet d'utiliser des caractères de façon spéciale là où on pourrait les utiliser de façon littérale.

    Ainsi, /b/ correspond au caractère "b". En plaçant une barre oblique inversée (backslash) avant le "b" (on utilise donc /\b/), le caractère acquiert une signification spéciale (ici on souhaite qu'il corresponde à une limite de mot).

    ou

    Pour les caractères qui sont traités de façon spéciale, cela indique que le caractère suivant doit être interprété littéralement.

    Ainsi, "*" est un caractère spécial qui signifie qu'on a 0 ou plusieurs occurences du caractère précédent à faire correspondre (/a*/ signifie par exemple qu'on cherche 0 ou plusieurs "a"). Pour effectuer une correspondance littérale sur "*" on utilise la barre oblique inversée. Ainsi /a\*/ correspond à "a*".

    Ensembles de caractères
    Caractère Signification
    [xyz]

    Un ensemble de caractères. Il correspond à l'un des caractères inclus. Il est possible de définir des intervalles de caractères en utilisant un tiret.

    Ainsi [abcd] correspond à [a-d]. Il permet d'avoir une correspondance pour le "b" de "boulet" et le "c" de "cher".

    [^xyz]

    La négation (ou le complément) d'un ensemble de caractères. On a une correspondance pour tout ce qui n'est pas compris dans les crochets. Il est possible de définir des intervalles de caractères avec un tiret.

    Ainsi, [^abc] correspond à [^a-c]. Il correspond au "o" dans "bacon" et au "h" dans "cher".

    Limites
    Caractère Signification
    ^

    Correspond au début d'une entrée. Si le drapeau (flag) multiligne est utilisé, cela correspond également à ce qui suit immédiatement le caractère de saut de ligne.

    Ainsi, /^A/ ne correspond pas à "A" dans "un A", mais correspond au premier "A" dans "Ah Ah".

    $

    Correspond à la fin d'une entrée. Si le drapeau (flag) multiligne est utilisé, cela correspond également à ce qui précède le caractère de saut de ligne.

    Ainsi, /t$/ ne correspond pas au "t" de "été", mais à celui de "est".

    \b

    Correspond à une limite de mot de largeur nulle (telle que celle trouvée entre une lettre et un blanc). (Ne pas confondre avec [\b])

    Par exemple, /\bmi/ correspond à "mi" dans "à midi" ; /re\b/ correspond à "re" dans "peut-être hier".

    \B

    Correspond à une limite de largeur nulle entre deux lettres ou entre deux blancs.

    Par exemple, /\Bdi/ correspond à "di" dans "à midi", et /hi\B/ correspond à "hi" dans "peut-être hier".

    Groupes et références arrières
    Caractère Signification
    (x)

    Correspond à x et garde en mémoire la correspondance. On appelle cela des parenthèses capturantes.

    Ainsi, /(toto)/ correspond à "toto" dans "toto truc" et garde en mémoire la correspondace. La sous-chaîne correspondante peut ensuite être rappelée dans le tableau résultant avec les indices [1], ..., [n] ou depuis les propriétés $1, ..., $9 de l'objet RegExp.

    Si on utilise des groupes capturants, cela implique une diminution des performances. Si on n'a pas besoin d'utiliser la sous-chaîne, on utilisera des parenthèses non-capturantes (voir ci-après).

    \n

    Avec n un entier positif. Cela constitue une référence arrière à la dernière sous-chaîne correspondante du n-ième groupe (en comptant la parenthèse gauche).

    Ainsi, /pomme(,)\sorange\1/ correspond à "pomme, orange," dans "pomme, orange, cerise, pêche". Un exemple plus détaillé illustre cela après le tableau.

    (?:x) Correspond à x mais ne mémorise pas la correspondance. Ces parenthèses sont dites non-capturantes. La sous-chaîne correspondante ne peut pas être réutilisée dans le tableau résultant ou depuis les propriétés de l'objet RegExp.
    Quantificateurs
    Caractère Signification
    x*

    Correspond à l'élément précédent répété 0 ou plusieurs fois.

    Ainsi, /bo*/ correspond à "boooo" dans "un gros booonbon" et à "b" dans "un bateau", il ne correspond à rien dans "un oiseau".

    x+

    Correspond à l'élément précédent répété 1 ou plusieurs fois. Ce quantificateur est équivalent au quantificateur {1,}.

    Ainsi, /a+/ correspond au "a" dans "maison" et à tous les "a" dans "maaaaison".

    x*?
    x+?

    Correspond à l'élément précédent de la même façon que * et + présentés ci-avant. Cependant, la correspondance conservée est la plus petite possible.

    Ainsi, /".*?"/ correspond à '"toto"' dans '"toto" "truc"' et ne correspond pas à '"toto" "truc"' car il y a un point d'interrogation qui suit *.

    x?

    Correspond à l'élément précédent présent 0 ou 1 fois.

    Ainsi, /e?le?/ correspond à "el" dans "angel" et à "le" dans "angle."

    S'il est utilisé immédiatement après les quantificateurs *, +, ?, ou {}, le point d'interrogation rendra le quantificateur « non-glouton » (la correspondance sera la plus petite possible), contrairement au comportement par défaut où la correspondance est la plus granded possible (« glouton »).

    Le point d'interrogation est également utilisé dans les assertions d'anticipation (?=), (?!), et (?:) décrites ci-après.

    x(?=y)

    Correspond à x uniquement si x est suivi par y.

    Ainsi, /Jack(?=Sprat)/ correspond à "Jack" uniquement si celui-ci est suivi par "Sprat". /Jack(?=Sprat|Frost)/ correspond à "Jack" uniquement si celui-ci est suivi par "Sprat" ou "Frost". En revanche, ni "Sprat" ni "Frost" ne font partie de la correspondance enregistrée.

    x(?!y)

    Correspond à x uniquement si x n'est pas suivi par y. Par exemple, /\d+(?!\.)/ correspond à un nombre uniquement si celui-ci n'est pas suivi d'un point décimal.

    /\d+(?!\.)/.exec('3.141') correspond à "141" mais pas à "3.141".

    x|y

    Correspond à x ou à y.

    Ainsi, /rouge|verte/ correspond à "rouge" dans "pomme rouge" et à "verte" dans "pomme verte".

    x{n}

    Avec n un entier positif. Correspond exactement à n occurences de l'élément précédent, x.

    Ainsi, /a{2}/ ne correspond pas à "a" dans "maison", mais correspond à tous les "a" de "maaison", et aux deux premiers "a" de "maaaaison".

    x{n,}

    Avec n un entier positif, correspond à au moins n occurrences de l'élément précédent, x.

    Ainsi, /a{2,}/ ne correspond pas à "a" dans "maison", mais correspond à tous les "a" dans "maaison" et dans "maaaaison".

    x{n,m}

    Avec n et m des entiers positifs, correspond à au moins n occurences et au plus m occurrences de l'élément précédent, x.

    Ainsi, /a{1,3}/, ne correspond à rien dans "mison", à "a" dans "maison", aux deux "a" dans "maaison", et aux trois premiers "a" dans "maaaaaaison". On remarquera que bien pour la dernière correspondance, on ne récupère que trois fois "a" bien que le mot ait plus d'occurences.

    Propriétés

    Pour les propriétés héritées par les instances de RegExp, consultez Propriétés des instances de RegExp.
    RegExp.prototype
    Cette propriété permet d'ajouter des propriétés à tous les objets qui sont des expressions rationnelles.
    RegExp.length
    La valeur de longueur pour le constructeur dont la valeur est 2.
    RegExp.lastIndex
    L'indice à partir duquel chercher la prochaine correspondance.

    Méthodes

    Pour les méthodes héritées par les instances de RegExp, consultez Méthodes des instances de RegExp.

    L'objet global RegExp ne possède pas de méthode propre. En revanche, il hérite de certaines méthodes via sa chaîne de prototypes.

    Le prototype de RegExp et les instances

    Propriétés

    Voir également la page sur les propriétés dépréciées de RegExp

    On notera que plusieurs des propriétés de RegExp ont un nom court et un nom long (semblable aux noms Perl). Le nom court et le nom long font référence à la même propriété. La modélisation des expressions rationnelles JavaScript est basée sur celle de Perl, un autre langage de programmation.

    RegExp.prototype.constructor
    Définit la fonction qui crée le prototype d'un objet.
    RegExp.prototype.flags
    Une chaîne qui contient les drapeaux (flags) utilisés pour l'objet RegExp.
    RegExp.prototype.global
    Définit si l'expression rationnelle doit relever la première correspondance d'une chaîne ou toutes les correspondances.
    RegExp.prototype.ignoreCase
    Définit si l'expression rationnelle doit ignorer la casse ou non pour détecter une correspondance.
    RegExp.prototype.multiline
    Définit si la recherche de la correspondance s'effectue sur plusieurs lignes ou sur une seule.
    RegExp.prototype.source
    Le texte du motif (pattern) à rechercher.
    RegExp.prototype.sticky
    Définit si la recherche s'effectue uniquement à partir de lastIndex ou non.
    RegExp.prototype.unicode
    Cette propriété indique si les fonctionnalités Unicode sont activées ou non.

    Méthodes

    Regexp.prototype.compile()
    (Re)compile une expression rationnelle lors de l'exécution d'un script.
    RegExp.prototype.exec()
    Exécute une recherche de correspondance sur la chaîne de caractères fournie en paramètre.
    RegExp.prototype.test()
    Teste s'il y a une correspondance dans la chaîne de caractères fournie en paramètre.
    RegExp.prototype.toSource()
    Renvoie un littéral objet représentant l'objet spécifié. Cette méthode peut être utilisée pour créer un nouvel objet. Elle surcharge la méthode Object.prototype.toSource().
    RegExp.prototype.toString()
    Renvoie une chaîne de caractères représentant l'objet spécifié. Cette méthode surcharge Object.prototype.toString().

    Exemples

    Utiliser une expression rationnelle pour modifier un format de données

    Dans le script suivant, on utilise la méthode replace() de String pour effectuer une correspondance sur le prénom et le nom pour les inverser. On utilise des parenthèses capturantes pour pouvoir utiliser les correspondances dans la construction du résultat (avec $1 et $2).

    var re = /(\w+)\s(\w+)/;
    var chaîne = 'Alain Dupont';
    var nouvelleChaîne = str.replace(re, '$2, $1');
    console.log(nouvelleChaîne);
    

    Cela affichera "Dupont, Alain".

    Utiliser une expression rationnelle pour découper des lignes avec différents sauts de ligne/fins de ligne

    La fin de ligne par défaut dépend de la plateforme (Unix, Windows, etc.). Cette méthode de découpage fournie permet de découper indépendamment de la plateforme utilisée.

    var texte = 'Un texte\net un autre\r\npuis ensuite\rla fin';
    var lignes = text.split(/\r\n|\r|\n/);
    console.log(lignes); // affiche [ 'Un texte', 'et un autre', 'puis ensuite', 'la fin' ]
    

    On voit ici que l'ordre des motifs dans l'expression rationnelle importe.

    Utiliser une expression rationnelle sur plusieurs lignes

    var s = 'Et voici\nune autre ligne !';
    s.match(/voici.*ligne/);
    // Renvoie null
    s.match(/voici[^]*ligne/);
    // Renvoie 'voici\nune autre ligne'
    

    Utiliser une expression rationnelle avec le drapeau (flag) d'adhérence

    Cet exemple illustre comment on peut utiliser ce drapeau pour faire correspondre des lignes uniques dans une entrée sur plusieurs lignes.

    var texte = 'Première ligne\nSeconde ligne';
    var regex = /(\S+) ligne\n?/y;
    
    var corresp = regex.exec(texte);
    console.log(corresp[1]);      // affiche 'Première'
    console.log(regex.lastIndex); // affiche '15'
    
    var corresp2 = regex.exec(texte);
    console.log(corresp2[1]);     // affiche 'Seconde'
    console.log(regex.lastIndex); // affiche '28'
    
    var corresp3 = regex.exec(texte);
    console.log(corresp3 === null); // affiche 'true'
    

    Il est possible de tester le support de ce drapeau lors de l'exécution grâce à try { … } catch { … }. Pour cela, on doit utiliser RegExp(chaîne-regex, chaîne-drapeaux) car la syntaxe littérale est traitée lors de la compilation et l'exception sera levée avant que le bloc catch soit rencontré). Par exemple :

    var supports_sticky;
    try { RegExp('', 'y'); supports_sticky = true; }
    catch(e) { supports_sticky = false; }
    console.log(supports_sticky); // affiche 'true'
    

    Les expressions rationnelles et les caractères Unicode

    Comme mentionné ci-avant, les classes \w ou \W ne correspondent qu'à des caractères ASCII "a" à "z", "A" à "Z", "0" à "9" et "_". Pour effectuer des correspondances sur d'autres caractères (comme par exemple les caractères cyrilliques), on utilisera \uhhhh, où "hhhh" représente la valeur Unicode exprimée en hexadécimal. Cet exemple illustre comment il est possible de séparer les caractères Unicode d'un mot.

    var texte = 'Образец text на русском языке';
    var regex = /[\u0400-\u04FF]+/g;
    
    var corresp = regex.exec(texte);
    console.log(corresp[0]);      // affiche 'Образец'
    console.log(regex.lastIndex); // affiche '7'
    
    var corresp2 = regex.exec(texte);
    console.log(corresp2[0]);     // affiche 'на' (n'affiche pas text
    console.log(regex.lastIndex); // affiche '15'
    
    // et ainsi de suite
    

    Voici une ressource tierce pour obtenir les différents intervalles Unicode des différents alphabets : Regexp-unicode-block.

    Extraire un sous-domaine d'une URL

    var url = 'http://xxx.domaine.com';
    console.log(/[^.]+/.exec(url)[0].substr(7)); // affiche 'xxx'
    

    Spécifications

    Spécification Statut Commentaires
    Première édition d'ECMAScript. Standard Définition initiale. Implémentée avec JavaScript 1.1.
    ECMAScript 5.1 (ECMA-262)
    La définition de 'RegExp' dans cette spécification.
    Standard  
    ECMAScript 6 (ECMA-262)
    La définition de 'RegExp' dans cette spécification.
    Draft  

    Compatibilité des navigateurs

    Fonctionnalité Chrome Firefox (Gecko) Internet Explorer Opera Safari
    Support simple (Oui) (Oui) (Oui) (Oui) (Oui)
    Drapeau d'adhérence ("y") 39 (derrière une préférence) 3.0 (1.9) Style ES4 bug 773687 Pas de support Pas de support Pas de support
    Fonctionnalité Android Chrome pour Android Firefox Mobile (Gecko) IE Mobile Opera Mobile Safari Mobile
    Support simple (Oui) (Oui) (Oui) (Oui) (Oui) (Oui)
    Drapeau d'adhérence ("y") Pas de support Pas de support 1.0 (1.9) Style ES4 bug 773687 Pas de support Pas de support Pas de support

    Notes spécifiques à Gecko

    À partir de Gecko 34 (Firefox 34 / Thunderbird 34 / SeaMonkey 2.31), dans le cas où on utilise un groupe capturant avec des quantificateurs qui l'invalident, le texte correspondant au groupe est désormais undefined et non la chaîne vide :

    // Firefox 33 ou antérieur
    'x'.replace(/x(.)?/g, function(m, group) {
      console.log("'group:" + group + "'");
    }); // 'group:'
    
    // Firefox 34 ou supérieur
    'x'.replace(/x(.)?/g, function(m, group) {
      console.log("'group:" + group + "'");
    }); // 'group:undefined'
    

    Pour des raisons de compatibilité web, RegExp.$N renverra une chaîne vide au lieu de undefined (bug 1053944).

    Voir aussi

    Étiquettes et contributeurs liés au document

    Contributors to this page: Mr21, SphinxKnight, psegalen, lovasoa, daniel35310, teoli, vvision
    Dernière mise à jour par : SphinxKnight,