RegExp

  • Raccourci de la révision : JavaScript/Référence_JavaScript/Objets_globaux/RegExp
  • Titre de la révision : RegExp
  • ID de la révision : 266648
  • Créé :
  • Créateur : daniel35310
  • Version actuelle ? Non
  • Commentaire 551 words added, 458 words removed

Contenu de la révision

Sommaire

Créé un objet d'expression régulière  pour la reconnaissance du texte  avec un motif (pattern).

Syntaxe

RegExp(pattern [, flags])
/pattern/flags

Paramètres

pattern
Le texte de l'expression régulière.
flags

Si spécifié, les flags (drapeaux) peuvent avoir n'importe quelles combinaisons des valeurs suivantes:

g
correspondance globale
i
cas ignoré
m
Traite les caractères de début et de fin (^ et $) qui travaillent sur plusieurs lignes (par exemple, correspondent au début ou à la fin de chaque ligne (délimitées pat \n ou \r), pas seulement au début ou à la fin de la chaîne)
y
New in Firefox 3 Non-standard
adhésif; correspond seulement à partir de l'indice indiqué par la propriété lastIndex de cette expression régulière dans la chaîne cible (et ne cherche pas à correspondre avec n'importe quel indexs suivants). Cela permet au contrôle sur la seule  capacité de démarrage du caractère "^" pour être utilisé à n'imprte quel endroit de la chaîne par le changement de la valeur de la propriété lastIndex.

Description

Lors de l'utilisation de la fonction de construction, la chaîne normale echappant les rôles (précédant les caractères spéciaux par \ lorsqu'ils sont inclus dans une chaîne) sont nécessaires . Par exemple, les exemples suivants sont équivalents:

  1. var re = new RegExp("\\w+");  
  2. var re = /\w+/;  

Notez que les paramètres du format littéral n'utilisent pas les guillemets pour indiquer les chaînes, tandis que les paramètres de la fonction du constructeur n'utilise pas de guillemets. Mais les expressions suivantes créent la même expression régulière:

  1. /ab+c/i;  
  2. new RegExp("ab+c""i");  

Caractères spéciaux dans les expression régulières

Character Meaning
\

Pour les caractères qui sont habituellement traités littéralement, indique que le caractère suivant est spécial et ne peut être interprété littéralment.

Par exemple, /b/ correspond au caractère 'b'. Par le placement d'un backslash avant et après, qui est par l'utilisation de /\b/, le caractère devient spécial pour faire corresondre à une limite de mot.

ou

Pour des caractères qui sont habituellement traités spécialement, indique que le caractère suivant n'est pas spécial et pourrait être interprété littéralement.

Par exemple, * est un caractère spécial qui signifie 0 occurence ou plus et le caractère précédent pourrait correpondre; par exemple, /a*/ signifie la correspondance de 0 ou plus de "a". Pour faire correspondre * littéralement, il doit être précédé par un backslash; par exemple, /a\*/ correspond à  'a*'.

^

Fait correspondre le début de l'entrée. Si le drapeau multiligne est mis à true, correspond immédiatement à une ligne située après un saut de ligne.

Par exemple, /^A/ ne fait pas correspondre le 'A' dans un "A", mait peut faire correspondre le premier 'A' dans un "An A."

$

Correspond à la fin de l'entrée. Si le drapeau multiligne est à true, correspond également immédiatement avant un caractère de saut de ligne.

Par exemple, /t$/ de correspond pas à 't' dans "eater", mais correspond dans "eat".

*

Correspond à  l'item précédent à 0 ou plusieurs fois.

Par exemple, /bo*/ correspond à 'boooo' dans "A ghost booooed" et 'b' dans "A bird warbled", mais aucunement dans "A goat grunted".

+

Correspond à l'élément précédent 1 ou plusieurs fois. Équivalent à {1,}.

Par exemple, /a+/ correspond au 'a' dans "candy" et tous les a dans "caaaaaaandy".

?

Correspon à l'élément précédent à 0 ou 1 foi.

Par exemple, /e?le?/ correspond à 'el' dans "angel" et 'le' dans "angle."

Si utilisé immédiatement après les opérateurs *, +, ?, or {}, construit l'opérateur makes the quantifier non-gourmands (correspondant au nombre minimum de fois), à l'opposé de ce qui est fourni pat défaut, ce qui est gourmand (correspondant au nombre maximum de fois).

Également utilisé dans les déclarations, décrites dans (?=), (?!), et (?:) dans la table.

.

(Le point décimal) correspond à tout caractère simple attendant de s caractères de nouvelles lignes: \n \r \u2028 or \u2029. ([\s\S] peut être utilisé pour faire correspondre tout caractère incluant des nouvelles lignes.)

Par exemple, /.n/ correspond à 'an' et 'on' dans "nay, an apple is on the tree", mais pas 'nay'.

(x)

Correspond au nombre x et rappelle le nombre de correspondances. Elles sont appelées parenthèses de capture.

Par exemple, /(foo)/ correspond et rappelle 'foo' dans "foo bar." La chaîne correspondante peut être rappelée à partir des éléments du tableau résultant de [1], ..., [n] ou depuis les propriétés de l'objet prédéfini RegExp $1, ..., $9.

(?:x)

Capture x mais ne rappelle pas la correspondance. Ils appellent les parenthèses de non-capture. La chaîne correspondante ne peut être appelée à partir des éléments de [1], ..., [n] ou depuis les propriétés de l'objet prédéfini RegExp $1, ..., $9.

x(?=y)

Correspond à x seulement si x est suivit par y. Par exemple, /Jack(?=Sprat)/ correspond à 'Jack' seulemnt si il est suivi par 'Sprat'. /Jack(?=Sprat|Frost)/ correspond à 'Jack' seulement si il est suivi par 'Sprat' ou 'Frost'. Toutefois, ni 'Sprat' ni 'Frost' font partie des résultats correspondants.

x(?!y)

Correspond à x seulement si x n'est pas suivit par y. Par exemple, /\d+(?!\.)/ correspond au nombre seulement si il n'est pas suivi par un point décimal.

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

x|y

Correspond soit à x ou y.

Par exemple, /green|red/ correspond à 'green' dans "green apple" et 'red' dans "red apple."

{n}

n est un entier positif. Correspond à n occurrences de l'élément précédent.

Par exemple, /a{2}/ ne correspond pas au 'a' dans "candy," mais il correspond à tous les 'a' dans "caandy," et aux deux premiers dans "caaandy."

{n,}

n est un entier positif. Correspond à la liste de n occurrences de l'élément précédent.

Par exemple, /a{2,}/ ne correspond pas au 'a' dans "candy", mais correspond à tous les 'a' dans "caandy" et dans "caaaaaaandy."

{n,m}

n et m sont des entiers positifs. Correspond à la liste de n et plusieurs m occurrences de l'élément précédent.

Par exemple, /a{1,3}/ ne correspond à rien dans "cndy", le 'a' dans "candy," les deux premiers a dans "caandy," et les trois premiers 'a' dans "caaaaaaandy". Notez que lors des correspondances de "caaaaaaandy", la correspondance est "aaa", même si la chaîne originale avait plus d'un 'a' dans celui-ci.

[xyz]

Un jeu de caractère. Correspond à un caractère joint. Vous pouvez spécifier la plage des caractères par l'utilisation d'un tiret.

Par exemple, [abcd] est le même que [a-d]. Ils correspondent au 'b' dans "brisket" et au 'c' dans "chop".

[^xyz]

Une négation ou un jeu de caractères complémenté. Autrement dit, elle correspond à tout ce qui n'est pas inclus dans les crochets. Vous pouvez spécifier la plage des caractères par l'utilisation d'un tiret.

Par exemple, [^abc] est la même que [^a-c]. Ils correspondent initialement au 'r' dans "brisket" et au 'h' dans "chop."

[\b]

Correspond à un retour en arrière. (Ne pas confondre avec \b.)

\b

Correspond à une limite de mot, comme un espace. (Ne pas confondre avec [\b].)

Par exemple, /\bn\w/ correspond au 'no' dans "noonday"; /\wy\b/ correspond au 'ly' dans "possibly yesterday."

\B

Correspond à une limite de non-mots.

Par exemple, /\w\Bn/ correspond au 'on' dans "noonday", et /y\B\w/ correspond à 'ye' dans "possibly yesterday."

\cX

X est une lettre depuis A - Z. Correspond à un caractère de contrôle dans la file.

Par exemple, /\cM/ correspond au control-M dans la file.

\d

Correspond à un caractère chiffre dans l'alphabet latin de base. Équivalent à [0-9].

Notez: Dans Firefox 2 et supérieur, correspond a un caractère chiffre depuis tous les alphabets. ( bug 378738 )

Par exemple, /\d/ ou /[0-9]/ correspond à '2' dans "B2 is the suite number."

\D
Correspond à tout caractère qui n'est pas un chiffre dans l'alphabet latin de base. Équivalent à [^0-9].

Note: Dans Firefox 2 et supérieur, exclut les caractères numériques de tous les alphabets. ( bug 378738 )

PAr exemple, /\D/ ou /[^0-9]/ correspond à 'B' dans "B2 is the suite number."

\f
Correspond à une forme d'alimentation.
\n

Correspond à un saut de ligne.

\r

Correspond à un retour chariot.

\s
Correspond à un caractère simple espace blanc, y compris l'espace, tabulation, saut de saut de ligne et d'autres espaces unicode.

 [equivalent_s]

Par exemple, /\s\w*/ correspond à ' bar' dans "foo bar."

\S

Correspond à un caractère unique autre que l'espace blanc. [equivalent_S]

Par exemple, /\S\w*/ correspond à 'foo' dans "foo bar."

\t

Correspond à une tabulation.

\v

Correspond à une tabulation verticale.

\w
Correspond à tout caractère alphanumérique de l'alphabet latin de base, y compris le trait de soulignement. Équivalent à [A-Za-z0-9_].

Par exemple, /\w/ correspond à 'a' dans "apple," '5' dans "$5.28," et '3' dans "3D."

\W
Correspond à tout caractère qui n'est pas un caractère de mot de l'alphabet latin de base. Équivalent à [^A-Za-z0-9_].

Par exemple, /\W/ ou /[^A-Za-z0-9_]/ correspond à '%' dans "50%."

\n

n est un entier positif. Un renvoi à la sous-chaîne correspondant à la dernière parenthèse n dans l'expression régulière (en comptant les parenthèses gauche).

Par exemple, /apple(,)\sorange\1/ correspond à 'apple, orange,' dans "apple, orange, cherry, peach." Un exemple plus complet suit ce tableau.

\0

Correspond à un caractère NUL. Ne pas suivre cela avec un autre chiffre.

\xhh

Correspond à un caractère avec un code hh (deux digits hexadécimaux)

\uhhhh

Correspond à un caractère avec une valeur Unicode hhhh (quatre digits hexadécimaux).

La notation littérale fournit une compilation d'expressions régulière quand l'expression est évaluée. Utilise une notation littérale quand l'expression régulière restera constante. Par exemple, si vous utilisez une notation littérale pour construire une expression régulière utilisée dans une boucle, l'expression régulière ne sera pas recompilée à chaque itération.

Le constructeur de l'objet expression régulière, par exemple, new RegExp("ab+c")

permet la compilation d'exécution de l'expression régulière. Utilise le constructeur de fonction lorsque vous connaissez le modèle d'expression régulière va changer, 
ou vous ne connaissez pas le motif et l'obtiennent d'une autre source, tels que saisis de l'utilisateur.
  1. ^Équivalent à:

    [\t\n\v\f\r \u00a0\u2000\u2001\u2002\u2003\u2004\u2005\u2006\u2007\u2008\u2009\u200a\u200b\u2028\u2029\u3000]

  2. ^Équivalent à:

    [^\t\n\v\f\r \u00a0\u2000\u2001\u2002\u2003\u2004\u2005\u2006\u2007\u2008\u2009\u200a\u200b\u2028\u2029\u3000]

Propriétés

Pour les propriétés disponibles sur les instances RegExp, voir Properties of RegExp instances.

prototype
Alloue l'ajout de propriétés pour tous les objets.

 

Propriétés héritées depuis Function:
arity, caller, constructor, length, name

Méthodes

Pour les méthodes disponibles sur les instances RegExp, voir Methods of RegExp instances.

L'objet global RegExp ne possède pas ses propres méthodes, cependant, il n'hérite pas de méthodes via le prototype chain.

 

Méthodes héritées depuis Function:
apply, call, toSource, toString

Propriétés

 

Voir aussi Deprecated RegExp Properties

Notez que plusieurs des propriétés de RegExp ont à la fois des noms courts et longs (Perl). Plusieurs noms se réfèrent à la même valeur. Perl est le langage de programmation depuis que JavaScript modélisait ses expressions régulières.

constructor
Spécifie la fonction créant le prototype d'un objet.
global
Que ce soit pour tester les expressions régulières contre toutes les correspondances possibles dans une chaîne, ou uniquement contre le premier.
ignoreCase
Que ce soit pour ignorer la casse en tentant une correspondance dans une chaîne.
lastIndex
L'indice à partir duquel commencer la prochaine correspondance.
multiline
Que ce soit pour ignorer la casse en tentant une correspondance dans une chaîne.
source
Le texte du modèle.
sticky
New in Firefox 3 Non-standard
Que ce soit ou non la recherche est collant.
Propriétés héritées depuis Object:
__parent__, __proto__

Méthodes

 

Deprecated RegExp Methods
Voir aussi
exec
Exécute une recherche pour la correspondance dans son paramètre de chaîne.
test
Teste la correspondance dans son paramètre de chaîne.
toSource
Non-standard
Retourne un objet litéral représentant l'objet spécifié; vous pouvez utiliser cette valeur pour créer un nouvel objet. Remplace la méthode Object.prototype.toSource.
toString
Retourne la chaîne représentant l'objet spécifié. Remplace la méthode Object.prototype.toString.

Exemples

Exemple: Utilisation d'une expression rationnelle pour changer le format de la date

Le programme suivant utilise la méthode replace héritée depuis l'instance String pour correspondre au nom dans un format first last et sortir dans le format last, first. Dans le texte de remplacement, le script utilise $1 et $2 pour indiquer les résultats de la correspondance des parenthèses de contrôle dans le modèle de l'expression rationnelle.

  1. var re = /(\w+)\s(\w+)/;  
  2. var str = "John Smith";  
  3. var newstr = str.replace(re, "$2, $1");  
  4. print(newstr);  

Il affiche "Smith, John".

Exemple: Utilisation d'une expression rationnelle avec le drapeau  "sticky"

Cet exemple démontre comment on pourrait utiliser un drapeau collant sur les expressions rationnelles pour correspondre à des lignes simples ou multiples.

  1. var text = "First line\nsecond line";  
  2. var regex = /(\S+) line\n?/y;  
  3.   
  4. var match = regex.exec(text);  
  5. print(match[1]);  // prints "First"  
  6. print(regex.lastIndex); // prints 11  
  7.   
  8. var match2 = regex.exec(text);  
  9. print(match2[1]); // prints "Second"  
  10. print(regex.lastIndex); // prints "22"  
  11.   
  12. var match3 = regex.exec(text);  
  13. print(match3 === null); // prints "true"  

On peut tester à l'exécution si le drapeau collant est pris en charge, en utilisant try { … } catch { … }. Pour ceci, soit une expression eval(…) ou la syntaxe RegExp(regex-stringflags-string) doit être utilisée (depuis la notation /regex/flags est traitée au moment de la compilation, mais envoie une exception avant que le bloc catch ne soit rencontré). Par exemple:

  1. var supports_sticky;  
  2. try { RegExp('','y'); supports_sticky = true; }  
  3. catch(e) { supports_sticky = false; }  
  4. alert(supports_sticky); // alerts "false" in Firefox 2, "true" in Firefox 3+  

Voir aussi

Source de la révision

<h2 class="editable" id="Sommaire">Sommaire</h2>
<p>Créé un objet d'expression régulière  pour la reconnaissance du texte  avec un motif (pattern).</p>
<div id="section_2"> <h2 class="editable" id="Syntaxe">Syntaxe</h2> <p><code>RegExp(<em>pattern</em> <em>[, flags]</em>)</code><br> <code>/<em>pattern</em>/<em>flags</em></code></p>
</div>
<div id="section_3"> <h2 class="editable" id="Param.C3.A8tres">Paramètres</h2> <dl> <dt><code>pattern</code></dt> <dd>Le texte de l'expression régulière.</dd> </dl> <dl> <dt><code>flags</code></dt> </dl> <p>Si spécifié, les flags (drapeaux) peuvent avoir n'importe quelles combinaisons des valeurs suivantes:</p> <dl> <dt><code>g</code></dt> <dd>correspondance globale</dd> <dt><code>i</code></dt> <dd>cas ignoré</dd> <dt><code>m</code></dt> <dd>Traite les caractères de début et de fin (^ et $) qui travaillent sur plusieurs lignes (par exemple, correspondent au début ou à la fin de <em>chaque</em> ligne (délimitées pat \n ou \r), pas seulement au début ou à la fin de la chaîne)</dd> </dl> <dl> <dt><code>y</code></dt> <dd><span style="border: 1px solid rgb(129, 129, 81); background-color: rgb(255, 255, 225); font-size: x-small; white-space: nowrap; padding:0px 2px;">New in <a href="../../../../en/Firefox_3_for_developers" rel="custom">Firefox 3</a></span> <span class="lang lang-en"><span class="nonStandardInlineTemplate" style="border: 1px solid rgb(255, 213, 153); background-color: rgb(255, 239, 217); font-size: x-small; white-space: nowrap; padding: 2px;">Non-standard</span></span><br> adhésif; correspond seulement à partir de l'indice indiqué par la propriété <code>lastIndex</code> de cette expression régulière dans la chaîne cible (et ne cherche pas à correspondre avec n'importe quel indexs suivants). Cela permet au contrôle sur la seule  capacité de démarrage du caractère "^" pour être utilisé à n'imprte quel endroit de la chaîne par le changement de la valeur de la propriété <code>lastIndex</code>.</dd> </dl>
</div>
<div id="section_4"> <h2 class="editable" id="Description">Description</h2> <p>Lors de l'utilisation de la fonction de construction, la chaîne normale echappant les rôles (<span id="result_box" lang="fr"><span class="hps">précédant</span> <span class="hps">les caractères spéciaux par</span> <span class="hps">\</span> <span class="hps">lorsqu'ils sont inclus dans</span> <span class="hps">une chaîne</span></span>) sont nécessaires . Par exemple, les exemples suivants sont équivalents:</p> <div class="dp-highlighter"> <div class="bar"> <div class="tools"><a href="/fr/en/JavaScript/Reference/Global_Objects/RegExp#" title="fr/en/JavaScript/Reference/Global_Objects/RegExp#">view plain</a><a href="/fr/en/JavaScript/Reference/Global_Objects/RegExp#" title="fr/en/JavaScript/Reference/Global_Objects/RegExp#">print</a><a href="/fr/en/JavaScript/Reference/Global_Objects/RegExp#" title="fr/en/JavaScript/Reference/Global_Objects/RegExp#">?</a></div> </div> <ol class="dp-c" start="1"> <li class="alt"><span><span class="keyword">var</span><span> re = </span><span class="keyword">new</span><span> RegExp(</span><span class="string">"\\w+"</span><span>);  </span></span></li> <li><span><span class="keyword">var</span><span> re = /\w+/;  </span></span></li> </ol> </div> <p>Notez que les paramètres du format littéral n'utilisent pas les guillemets pour indiquer les chaînes, tandis que les paramètres de la fonction du constructeur n'utilise pas de guillemets. Mais les expressions suivantes créent la même expression régulière:</p> <div class="dp-highlighter"> <div class="bar"> <div class="tools"><a href="/fr/en/JavaScript/Reference/Global_Objects/RegExp#" title="fr/en/JavaScript/Reference/Global_Objects/RegExp#">view plain</a><a href="/fr/en/JavaScript/Reference/Global_Objects/RegExp#" title="fr/en/JavaScript/Reference/Global_Objects/RegExp#">print</a><a href="/fr/en/JavaScript/Reference/Global_Objects/RegExp#" title="fr/en/JavaScript/Reference/Global_Objects/RegExp#">?</a></div> </div> <ol class="dp-c" start="1"> <li class="alt"><span><span>/ab+c/i;  </span></span></li> <li><span><span class="keyword">new</span><span> RegExp(</span><span class="string">"ab+c"</span><span>, </span><span class="string">"i"</span><span>);  </span></span></li> </ol> </div> <div id="section_5"> <h3 class="editable" id="Caract.C3.A8res_sp.C3.A9ciaux_dans_les_expression_r.C3.A9guli.C3.A8res">Caractères spéciaux dans les expression régulières</h3> <table class="fullwidth-table"> <tbody> <tr> <td class="header">Character</td> <td class="header">Meaning</td> </tr> <tr> <td><code>\</code></td> <td> <p>Pour les caractères qui sont habituellement traités littéralement, indique que le caractère suivant est spécial et ne peut être interprété littéralment.</p> <p>Par exemple, <code>/b/</code> correspond au caractère 'b'. Par le placement d'un backslash avant et après, qui est par l'utilisation de <code>/\b/</code>, le caractère devient spécial pour faire corresondre à une limite de mot.</p> <p><em>ou</em></p> <p>Pour des caractères qui sont habituellement traités spécialement, indique que le caractère suivant n'est pas spécial et pourrait être interprété littéralement.</p> <p>Par exemple, * est un caractère spécial qui signifie 0 occurence ou plus et le caractère précédent pourrait correpondre; par exemple, <code>/a*/</code> signifie la correspondance de 0 ou plus de "a". Pour faire correspondre <code>*</code> littéralement, il doit être précédé par un backslash; par exemple, <code>/a\*/</code> correspond à  'a*'.</p> </td> </tr> <tr> <td><code>^</code></td> <td> <p>Fait correspondre le début de l'entrée. Si le drapeau multiligne est mis à true, correspond immédiatement à une ligne située après un saut de ligne.</p> <p>Par exemple, <code>/^A/</code> ne fait pas correspondre le 'A' dans un "A", mait peut faire correspondre le premier 'A' dans un "An A."</p> </td> </tr> <tr> <td><code>$</code></td> <td> <p>Correspond à la fin de l'entrée. Si le drapeau multiligne est à true, correspond également immédiatement avant un caractère de saut de ligne.</p> <p>Par exemple, <code>/t$/</code> de correspond pas à 't' dans "eater", mais correspond dans "eat".</p> </td> </tr> <tr> <td><code>*</code></td> <td> <p>Correspond à  l'item précédent à 0 ou plusieurs fois.</p> <p>Par exemple, <code>/bo*/</code> correspond à 'boooo' dans "A ghost booooed" et 'b' dans "A bird warbled", mais aucunement dans "A goat grunted".</p> </td> </tr> <tr> <td><code>+</code></td> <td> <p>Correspond à l'élément précédent 1 ou plusieurs fois. Équivalent à <code>{1,}</code>.</p> <p>Par exemple, <code>/a+/</code> correspond au 'a' dans "candy" et tous les a dans "caaaaaaandy".</p> </td> </tr> <tr> <td><code>?</code></td> <td> <p>Correspon à l'élément précédent à 0 ou 1 foi.</p> <p>Par exemple, <code>/e?le?/</code> correspond à 'el' dans "angel" et 'le' dans "angle."</p> <p>Si utilisé immédiatement après les opérateurs <code>*</code>, <code>+</code>, <code>?</code>, or <code>{}</code>, construit l'opérateur makes the quantifier non-gourmands (correspondant au nombre minimum de fois), à l'opposé de ce qui est fourni pat défaut, ce qui est gourmand (correspondant au nombre maximum de fois).</p> <p>Également utilisé dans les déclarations, décrites dans <code>(?=)</code>, <code>(?!)</code>, et <code>(?:)</code> dans la table.</p> </td> </tr> <tr> <td><code>.</code></td> <td> <p>(Le point décimal) correspond à tout caractère simple attendant de s caractères de nouvelles lignes: \n \r \u2028 or \u2029. (<code>[\s\S]</code> peut être utilisé pour faire correspondre tout caractère incluant des nouvelles lignes.)</p> <p>Par exemple, <code>/.n/</code> correspond à 'an' et 'on' dans "nay, an apple is on the tree", mais pas 'nay'.</p> </td> </tr> <tr> <td><code>(<em>x</em>)</code></td> <td> <p>Correspond au nombre <code><em>x</em></code> et rappelle le nombre de correspondances. Elles sont appelées parenthèses de capture.</p> <p>Par exemple, <code>/(foo)/</code> correspond et rappelle 'foo' dans "foo bar." La chaîne correspondante peut être rappelée à partir des éléments du tableau résultant de <code>[1], ..., [n]</code> ou depuis les propriétés de l'objet prédéfini <code>RegExp</code> <code>$1, ..., $9</code>.</p> </td> </tr> <tr> <td><code>(?:<em>x</em>)</code></td> <td> <p>Capture <code><em>x</em></code> mais ne rappelle pas la correspondance. Ils appellent les parenthèses de non-capture. La chaîne correspondante ne peut être appelée à partir des éléments de <code>[1], ..., [n]</code> ou depuis les propriétés de l'objet prédéfini <code>RegExp</code> <code>$1, ..., $9</code>.</p> </td> </tr> <tr> <td><code><em>x</em>(?=<em>y</em>)</code></td> <td> <p>Correspond à <code><em>x</em></code> seulement si <code><em>x</em></code> est suivit par <code><em>y</em></code>. Par exemple, <code>/Jack(?=Sprat)/</code> correspond à 'Jack' seulemnt si il est suivi par 'Sprat'. <code>/Jack(?=Sprat|Frost)/</code> correspond à 'Jack' seulement si il est suivi par 'Sprat' ou 'Frost'. Toutefois, ni 'Sprat' ni 'Frost' font partie des résultats correspondants.</p> </td> </tr> <tr> <td><code><em>x</em>(?!<em>y</em>)</code></td> <td> <p>Correspond à <code><em>x</em></code> seulement si <code><em>x</em></code> n'est pas suivit par <code><em>y</em></code>. Par exemple, <code>/\d+(?!\.)/</code> correspond au nombre seulement si il n'est pas suivi par un point décimal.</p> <p><code>/\d+(?!\.)/.exec("3.141")</code> correspond à 141 mais pas à 3.141.</p> </td> </tr> <tr> <td><code><em>x</em>|<em>y</em></code></td> <td> <p>C<span class="short_text" id="result_box" lang="fr"><span class="hps">orrespond soit à x</span> <span class="hps">ou y.</span></span></p> <p>Par exemple, <code>/green|red/</code> correspond à 'green' dans "green apple" et 'red' dans "red apple."</p> </td> </tr> <tr> <td><code>{<em>n</em>}</code></td> <td> <p>Où <code><em>n</em></code> est un entier positif. Correspond à <code><em>n</em></code> occurrences de l'élément précédent.</p> <p>Par exemple, <code>/a{2}/</code> ne correspond pas au 'a' dans "candy," mais il correspond à tous les 'a' dans "caandy," et aux deux premiers dans "caaandy."</p> </td> </tr> <tr> <td><code>{<em>n</em>,}</code></td> <td> <p>Où <code><em>n</em></code> est un entier positif. Correspond à la liste de <code><em>n</em></code> occurrences de l'élément précédent.</p> <p>Par exemple, <code>/a{2,}/</code> ne correspond pas au 'a' dans "candy", mais correspond à tous les 'a' dans "caandy" et dans "caaaaaaandy."</p> </td> </tr> <tr> <td><code>{<em>n</em>,<em>m</em>}</code></td> <td> <p>Où <code><em>n</em></code> et <code><em>m</em></code> sont des entiers positifs. Correspond à la liste de <code><em>n</em></code> et plusieurs <code><em>m</em></code> occurrences de l'élément précédent.</p> <p>Par exemple, <code>/a{1,3}/</code> ne correspond à rien dans "cndy", le 'a' dans "candy," les deux premiers a dans "caandy," et les trois premiers 'a' dans "caaaaaaandy". Notez que lors des correspondances de "caaaaaaandy", la correspondance est "aaa", même si la chaîne originale avait plus d'un 'a' dans celui-ci.</p> </td> </tr> <tr> <td><code>[xyz]</code></td> <td> <p>Un jeu de caractère. Correspond à un caractère joint. Vous pouvez spécifier la plage des caractères par l'utilisation d'un tiret.</p> <p>Par exemple, <code>[abcd]</code> est le même que <code>[a-d]</code>. Ils correspondent au 'b' dans "brisket" et au 'c' dans "chop".</p> </td> </tr> <tr> <td><code>[^xyz]</code></td> <td> <p>Une négation ou un jeu de caractères complémenté. Autrement dit, elle correspond à tout ce qui n'est pas inclus dans les crochets. Vous pouvez spécifier la plage des caractères par l'utilisation d'un tiret.</p> <p>Par exemple, <code>[^abc]</code> est la même que <code>[^a-c]</code>. Ils correspondent initialement au 'r' dans "brisket" et au 'h' dans "chop."</p> </td> </tr> <tr> <td><code>[\b]</code></td> <td> <p>Correspond à un retour en arrière. (Ne pas confondre avec <code>\b</code>.)</p> </td> </tr> <tr> <td><code>\b</code></td> <td> <p><span class="short_text" id="result_box" lang="fr"><span class="hps">Correspond à une limite</span> <span class="hps">de mot, comme</span> <span class="hps">un espace</span></span>. (Ne pas confondre avec <code>[\b]</code>.)</p> <p>Par exemple, <code>/\bn\w/</code> correspond au 'no' dans "noonday"; <code>/\wy\b/</code> correspond au 'ly' dans "possibly yesterday."</p> </td> </tr> <tr> <td><code>\B</code></td> <td> <p><span class="short_text" id="result_box" lang="fr"><span class="hps">Correspond à une limite</span> <span class="hps">de non-mots</span><span>.</span></span></p> <p>Par exemple, <code>/\w\Bn/</code> correspond au 'on' dans "noonday", et <code>/y\B\w/</code> correspond à 'ye' dans "possibly yesterday."</p> </td> </tr> <tr> <td><code>\c<em>X</em></code></td> <td> <p>Où <code><em>X</em></code> est une lettre depuis A - Z. Correspond à un caractère de contrôle dans la file.</p> <p>Par exemple, <code>/\cM/</code> correspond au control-M dans la file.</p> </td> </tr> <tr> <td><code>\d</code></td> <td> <p><span id="result_box" lang="fr"><span class="hps">Correspond à un caractère</span> <span class="hps">chiffre</span> <span class="hps">dans l'alphabet</span> <span class="hps">latin de base</span></span>. Équivalent à <code>[0-9]</code>.</p> <p><strong>Notez</strong>: Dans Firefox 2 et supérieur, correspond a un caractère chiffre depuis tous les alphabets. ( <a class="external" href="https://bugzilla.mozilla.org/show_bug.cgi?id=378738" rel="external" title="VERIFIED FIXED - \d pattern matches characters other than the decimal digits 0-9 (ecma_3/RegExp/15.10.2.12.js)"> bug 378738</a> )</p> <p>Par exemple, <code>/\d/</code> ou <code>/[0-9]/</code> correspond à '2' dans "B2 is the suite number."</p> </td> </tr> <tr> <td><code>\D</code></td> <td> <div class="almost_half_cell" id="gt-res-content"> <div dir="ltr" style="zoom:1"><span id="result_box" lang="fr"><span class="hps">Correspond à tout caractère</span> <span class="hps">qui n'est pas</span> <span class="hps">un chiffre dans</span> <span class="hps">l'alphabet</span> <span class="hps">latin de base</span></span>. Équivalent à <code>[^0-9]</code>.</div> </div> <p><strong>Note</strong>: Dans Firefox 2 et supérieur, <span id="result_box" lang="fr"><span class="hps">exclut</span> <span class="hps">les caractères numériques</span> <span class="hps">de tous les</span> <span class="hps">alphabets</span></span>. ( <a class="external" href="https://bugzilla.mozilla.org/show_bug.cgi?id=378738" rel="external" title="VERIFIED FIXED - \d pattern matches characters other than the decimal digits 0-9 (ecma_3/RegExp/15.10.2.12.js)"> bug 378738</a> )</p> <p>PAr exemple, <code>/\D/</code> ou <code>/[^0-9]/</code> correspond à 'B' dans "B2 is the suite number."</p> </td> </tr> <tr> <td><code>\f</code></td> <td> <div class="almost_half_cell" id="gt-res-content"> <div dir="ltr" style="zoom:1"><span class="short_text" id="result_box" lang="fr"><span class="hps">Correspond à une</span> <span class="hps">forme</span> <span class="hps">d'alimentation</span></span>.</div> </div> </td> </tr> <tr> <td><code>\n</code></td> <td> <p>Correspond à un saut de ligne.</p> </td> </tr> <tr> <td><code>\r</code></td> <td> <p><span class="short_text" id="result_box" lang="fr"><span class="hps">Correspond à un retour</span> <span class="hps">chariot.</span></span></p> </td> </tr> <tr> <td><code>\s</code></td> <td> <div class="almost_half_cell" id="gt-res-content"> <div dir="ltr" style="zoom:1"><span id="result_box" lang="fr"><span class="hps">Correspond à un caractère</span> <span class="hps">simple espace</span> <span class="hps">blanc,</span> <span class="hps">y compris l'espace</span><span>, tabulation,</span> <span class="hps">saut de</span> <span class="hps">saut de ligne</span> <span class="hps">et d'autres espaces</span> <span class="hps">unicode.</span></span></div> </div> <p> <sup class="reference plainlinksneverexpand" id="ref_equivalent_s"><a href="../../../../en/JavaScript/Reference/Global_Objects/RegExp#endnote_equivalent_s" rel="custom">[equivalent_s]</a></sup></p> <p>Par exemple, <code>/\s\w*/</code> correspond à ' bar' dans "foo bar."</p> </td> </tr> <tr> <td><code>\S</code></td> <td> <p><span id="result_box" lang="fr"><span class="hps">Correspond à un caractère</span> <span class="hps">unique autre que</span> <span class="hps">l'espace blanc</span><span>.</span></span> <sup class="reference plainlinksneverexpand" id="ref_equivalent_S"><a href="../../../../en/JavaScript/Reference/Global_Objects/RegExp#endnote_equivalent_S" rel="custom">[equivalent_S]</a></sup></p> <p>Par exemple, <code>/\S\w*/</code> correspond à 'foo' dans "foo bar."</p> </td> </tr> <tr> <td><code>\t</code></td> <td> <p>Correspond à une tabulation.</p> </td> </tr> <tr> <td><code>\v</code></td> <td> <p>Correspond à une tabulation verticale.</p> </td> </tr> <tr> <td><code>\w</code></td> <td> <div class="almost_half_cell" id="gt-res-content"> <div dir="ltr" style="zoom:1"><span id="result_box" lang="fr"><span class="hps">Correspond à tout caractère</span> <span class="hps">alphanumérique</span> <span class="hps">de l'alphabet</span> <span class="hps">latin de base</span><span>, y compris</span> <span class="hps">le trait de soulignement</span></span>. Équivalent à <code>[A-Za-z0-9_]</code>.</div> </div> <p>Par exemple, <code>/\w/</code> correspond à 'a' dans "apple," '5' dans "$5.28," et '3' dans "3D."</p> </td> </tr> <tr> <td><code>\W</code></td> <td> <div class="almost_half_cell" id="gt-res-content"> <div dir="ltr" style="zoom:1"><span id="result_box" lang="fr"><span class="hps">Correspond à tout caractère</span> <span class="hps">qui n'est pas un</span> <span class="hps">caractère de mot</span> <span class="hps">de l'alphabet</span> <span class="hps">latin de base</span></span>. Équivalent à <code>[^A-Za-z0-9_]</code>.</div> </div> <p>Par exemple, <code>/\W/</code> ou <code>/[^A-Za-z0-9_]/</code> correspond à '%' dans "50%."</p> </td> </tr> <tr> <td><code>\<em>n</em></code></td> <td> <p>Où <code><em>n</em></code> est un entier positif. <span id="result_box" lang="fr"><span class="hps">Un</span> <span class="hps">renvoi à</span> <span class="hps">la sous-chaîne</span> <span class="hps">correspondant à la</span> <span class="hps">dernière</span> <span class="hps">parenthèse</span> <span class="hps">n dans</span> <span class="hps">l'expression régulière</span> <span class="hps">(en comptant</span> <span class="hps">les parenthèses</span> <span class="hps">gauche)</span></span>.</p> <p>Par exemple, <code>/apple(,)\sorange\1/</code> correspond à 'apple, orange,' dans "apple, orange, cherry, peach." Un exemple plus complet suit ce tableau.</p> </td> </tr> <tr> <td><code>\0</code></td> <td> <p>Correspond à un caractère NUL. <span class="short_text" id="result_box" lang="fr"><span class="hps">Ne pas suivre</span> <span class="hps">cela avec</span> <span class="hps">un autre chiffre</span></span>.</p> </td> </tr> <tr> <td><code>\x<em>hh</em></code></td> <td> <p>Correspond à un caractère avec un code <code><em>hh</em></code> (deux digits hexadécimaux)</p> </td> </tr> <tr> <td><code>\u<em>hhhh</em></code></td> <td> <p>Correspond à un caractère avec une valeur Unicode <code><em>hhhh</em></code> (quatre digits hexadécimaux).</p> </td> </tr> </tbody> </table> <p>La notation littérale fournit une compilation d'expressions régulière quand l'expression est évaluée. Utilise une notation littérale quand l'expression régulière restera constante. Par exemple, si vous utilisez une notation littérale pour construire une expression régulière utilisée dans une boucle, l'expression régulière ne sera pas recompilée à chaque itération.</p> <p>Le constructeur de l'objet expression régulière, par exemple, <code>new RegExp("ab+c")</code>, </p> <div class="almost_half_cell" id="gt-res-content"> <div dir="ltr" style="zoom:1"><span id="result_box" lang="fr"><span class="hps">permet la compilation</span> <span class="hps">d'exécution de</span> <span class="hps">l'expression régulière</span></span>. Utilise le constructeur de fonction lorsque vous connaissez le modèle d'expression régulière va changer,  <div class="almost_half_cell" id="gt-res-content"> <div dir="ltr" style="zoom:1"><span id="result_box" lang="fr"><span class="hps">ou vous</span> <span class="hps">ne connaissez pas le</span> <span class="hps">motif et</span> <span class="hps">l'obtiennent</span> <span class="hps">d'une autre source</span></span>,<span class="short_text" id="result_box" lang="fr"><span class="hps"> tels que</span> <span class="hps">saisis de l'utilisateur</span></span>.</div> </div> </div> </div> <ol> <li><span id="endnote_equivalent_s"><strong><a href="../../../../en/JavaScript/Reference/Global_Objects/RegExp#ref_equivalent_s" rel="custom">^</a></strong></span>Équivalent à: <p><code>[\t\n\v\f\r \u00a0\u2000\u2001\u2002\u2003\u2004\u2005\u2006\u2007\u2008\u2009\u200a\u200b\u2028\u2029\u3000]</code></p> </li> <li><span id="endnote_equivalent_S"><strong><a href="../../../../en/JavaScript/Reference/Global_Objects/RegExp#ref_equivalent_S" rel="custom">^</a></strong></span>Équivalent à: <p><code>[^\t\n\v\f\r \u00a0\u2000\u2001\u2002\u2003\u2004\u2005\u2006\u2007\u2008\u2009\u200a\u200b\u2028\u2029\u3000]</code></p> </li> </ol> </div>
</div>
<div id="section_6"> <h2 class="editable" id="Propri.C3.A9t.C3.A9s">Propriétés</h2> <p><span class="lang lang-en"><small style="margin-left: 1em;"><em>Pour les propriétés disponibles sur les instances <code>RegExp</code>, voir <a href="../../../../en/JavaScript/Reference/Global_Objects/RegExp#Properties_2" rel="custom">Properties of RegExp instances</a>.</em></small> </span></p> <dl> <dt><a href="../../../../en/JavaScript/Reference/Global_Objects/RegExp/prototype" rel="internal" title="en/JavaScript/Reference/Global_Objects/RegExp/prototype">prototype</a></dt> <dd>Alloue l'ajout de propriétés pour tous les objets.</dd> </dl> <p> </p> <div style="border: 1px solid rgb(204, 204, 204); margin: 10px 0px; padding: 0px 10px; background: rgb(238, 238, 238) none repeat scroll 0% 0%;"><span style="font-weight:bold;">Propriétés héritées depuis <a href="../../../../en/JavaScript/Reference/Global_Objects/Function" rel="internal" title="en/JavaScript/Reference/Global_Objects/Function"><code>Function</code></a></span>:<br> <span style="font-size: smaller;"><a href="../../../../en/JavaScript/Reference/Global_Objects/Function/Arity" rel="internal" title="en/JavaScript/Reference/Global_Objects/Function/Arity"><code>arity</code></a>, <a href="../../../../en/JavaScript/Reference/Global_Objects/Function/Caller" rel="internal" title="en/JavaScript/Reference/Global_Objects/Function/Caller"><code>caller</code></a>, <a href="../../../../en/JavaScript/Reference/Global_Objects/Function/Constructor" rel="internal" title="en/JavaScript/Reference/Global_Objects/Function/Constructor"><code>constructor</code></a>, <a href="../../../../en/JavaScript/Reference/Global_Objects/Function/Length" rel="internal" title="en/JavaScript/Reference/Global_Objects/Function/Length"><code>length</code></a>, <a href="../../../../en/JavaScript/Reference/Global_Objects/Function/Name" rel="internal" title="en/JavaScript/Reference/Global_Objects/Function/Name"><code>name</code></a></span></div>
</div>
<div id="section_7"> <h2 class="editable" id="M.C3.A9thodes">Méthodes</h2> <p><span class="lang lang-en"><small style="margin-left: 1em;"><em>Pour les méthodes disponibles sur les instances <code>RegExp</code>, voir <a href="../../../../en/JavaScript/Reference/Global_Objects/RegExp#Methods_2" rel="custom">Methods of RegExp instances</a>.</em></small> </span></p> <p>L'objet global <code>RegExp</code> ne possède pas ses propres méthodes, cependant, il n'hérite pas de méthodes via le prototype chain.</p> <p> </p> <div style="border: 1px solid rgb(204, 204, 204); margin: 10px 0px; padding: 0px 10px; background: rgb(238, 238, 238) none repeat scroll 0% 0%;"><span style="font-weight:bold;">Méthodes héritées depuis <a href="../../../../en/JavaScript/Reference/Global_Objects/Function" rel="internal" title="en/JavaScript/Reference/Global_Objects/Function"><code>Function</code></a></span>:<br> <span style="font-size: smaller;"><a href="../../../../en/JavaScript/Reference/Global_Objects/Function/Apply" rel="internal" title="en/JavaScript/Reference/Global_Objects/Function/Apply"><code>apply</code></a>, <a href="../../../../en/JavaScript/Reference/Global_Objects/Function/Call" rel="internal" title="en/JavaScript/Reference/Global_Objects/Function/Call"><code>call</code></a>, <a href="../../../../en/JavaScript/Reference/Global_Objects/Function/ToSource" rel="internal" title="en/JavaScript/Reference/Global_Objects/Function/ToSource"><code>toSource</code></a>, <a href="../../../../en/JavaScript/Reference/Global_Objects/Function/ToString" rel="internal" title="en/JavaScript/Reference/Global_Objects/Function/ToString"><code>toString</code></a></span></div> <div id="section_8"> <h3 class="editable" id="Propri.C3.A9t.C3.A9s">Propriétés</h3> <p> </p> <p>Voir aussi <a href="../../../../en/JavaScript/Reference/Deprecated_Features#RegExp_Properties" rel="internal" title="en/JavaScript/Reference/Deprecated_Features#RegExp_Properties">Deprecated RegExp Properties</a></p> <p>Notez que plusieurs des propriétés de <code>RegExp</code> ont à la fois des noms courts et longs (Perl). Plusieurs noms se réfèrent à la même valeur. Perl est le langage de programmation depuis que JavaScript modélisait ses expressions régulières.</p> <dl> <dt><a href="../../../../en/JavaScript/Reference/Global_Objects/RegExp/constructor" rel="internal" title="en/JavaScript/Reference/Global_Objects/RegExp/constructor"><code>constructor</code></a></dt> <dd><span id="result_box" lang="fr"><span class="hps">Spécifie la</span> <span class="hps">fonction créant le prototype</span> <span class="hps">d'un objet</span></span>.</dd> <dt><a href="../../../../en/JavaScript/Reference/Global_Objects/RegExp/global" rel="internal" title="en/JavaScript/Reference/Global_Objects/RegExp/global"><code>global</code></a></dt> <dd><span id="result_box" lang="fr"><span class="hps">Que ce soit</span> <span class="hps">pour tester les</span> <span class="hps">expressions régulières</span> <span class="hps">contre toutes</span> <span class="hps">les correspondances possibles</span> <span class="hps">dans une chaîne</span><span>, ou</span> <span class="hps">uniquement contre</span> <span class="hps">le premier</span></span>.</dd> <dt><a href="../../../../en/JavaScript/Reference/Global_Objects/RegExp/ignoreCase" rel="internal" title="en/JavaScript/Reference/Global_Objects/RegExp/ignoreCase"><code>ignoreCase</code></a></dt> <dd><span id="result_box" lang="fr"><span class="hps">Que ce soit</span> <span class="hps">pour ignorer la casse</span> <span class="hps">en tentant</span> <span class="hps">une</span> <span class="hps">correspondance dans une chaîne</span></span>.</dd> <dt><a href="../../../../en/JavaScript/Reference/Global_Objects/RegExp/lastIndex" rel="internal" title="en/JavaScript/Reference/Global_Objects/RegExp/lastIndex"><code>lastIndex</code></a></dt> <dd><span id="result_box" lang="fr"><span class="hps">L'indice</span> <span class="hps">à partir duquel commencer</span> <span class="hps">la prochaine correspondance</span></span>.</dd> <dt><a href="../../../../en/JavaScript/Reference/Global_Objects/RegExp/multiline" rel="internal" title="en/JavaScript/Reference/Global_Objects/RegExp/multiline"><code>multiline</code></a></dt> <dd><span id="result_box" lang="fr"><span class="hps">Que ce soit</span> <span class="hps">pour ignorer la casse</span> <span class="hps">en tentant</span> <span class="hps">une</span> <span class="hps">correspondance dans une chaîne</span></span>.</dd> <dt><a href="../../../../en/JavaScript/Reference/Global_Objects/RegExp/source" rel="internal" title="en/JavaScript/Reference/Global_Objects/RegExp/source"><code>source</code></a></dt> <dd>Le texte du modèle.</dd> <dt><code><a class="new " href="../../../../en/JavaScript/Reference/Global_Objects/RegExp/sticky" rel="internal" title="en/JavaScript/Reference/Global_Objects/RegExp/sticky">sticky</a></code></dt> <dd><span style="border: 1px solid rgb(129, 129, 81); background-color: rgb(255, 255, 225); font-size: x-small; white-space: nowrap; padding:0px 2px;">New in <a href="../../../../en/Firefox_3_for_developers" rel="custom">Firefox 3</a></span> <span class="lang lang-en"><span class="nonStandardInlineTemplate" style="border: 1px solid rgb(255, 213, 153); background-color: rgb(255, 239, 217); font-size: x-small; white-space: nowrap; padding: 2px;">Non-standard</span></span></dd> <dd><span class="short_text" id="result_box" lang="fr"><span class="hps">Que ce soit</span> <span class="hps">ou non</span> <span class="hps">la recherche</span> <span class="hps">est collant</span></span>.</dd> </dl> <div> <div style="border: 1px solid rgb(204, 204, 204); margin: 10px 0px; padding: 0px 10px; background: rgb(238, 238, 238) none repeat scroll 0% 0%;"><span style="font-weight:bold;">Propriétés héritées depuis <a href="../../../../en/JavaScript/Reference/Global_Objects/Object" rel="internal" title="en/JavaScript/Reference/Global_Objects/Object"><code>Object</code></a></span>:<br> <span style="font-size: smaller;"><a href="../../../../en/JavaScript/Reference/Global_Objects/Object/Parent" rel="internal" title="en/JavaScript/Reference/Global_Objects/Object/Parent"><code>__parent__</code></a>, <a href="../../../../en/JavaScript/Reference/Global_Objects/Object/Proto" rel="internal" title="en/JavaScript/Reference/Global_Objects/Object/Proto"><code>__proto__</code></a></span></div> </div> </div> <div id="section_9"> <h3 class="editable" id="M.C3.A9thodes">Méthodes</h3> <p> </p> <a href="../../../../en/JavaScript/Reference/Deprecated_Features#RegExp_Methods" rel="internal" title="en/JavaScript/Reference/Deprecated_Features#RegExp_Methods">Deprecated RegExp Methods</a> <dl> <dt> Voir aussi<br> </dt></dl> <dl> <dt><a href="../../../../en/JavaScript/Reference/Global_Objects/RegExp/exec" rel="internal" title="en/JavaScript/Reference/Global_Objects/RegExp/exec"><code>exec</code></a></dt> <dd>Exécute une recherche pour la correspondance dans son paramètre de chaîne.</dd> <dt><a href="../../../../en/JavaScript/Reference/Global_Objects/RegExp/test" rel="internal" title="en/JavaScript/Reference/Global_Objects/RegExp/test"><code>test</code></a></dt> <dd>Teste la correspondance dans son paramètre de chaîne.</dd> <dt><a href="../../../../en/JavaScript/Reference/Global_Objects/RegExp/toSource" rel="internal" title="en/JavaScript/Reference/Global_Objects/RegExp/toSource"><code>toSource</code></a></dt> <dd><span class="lang lang-en"><span class="nonStandardInlineTemplate" style="border: 1px solid rgb(255, 213, 153); background-color: rgb(255, 239, 217); font-size: x-small; white-space: nowrap; padding: 2px;">Non-standard</span></span><br> Retourne un objet litéral représentant l'objet spécifié; vous pouvez utiliser cette valeur pour créer un nouvel objet. Remplace la méthode <a href="../../../../en/JavaScript/Reference/Global_Objects/Object/toSource" rel="internal" title="en/JavaScript/Reference/Global_Objects/Object/toSource"><code>Object.prototype.toSource</code></a>.</dd> <dt><a href="../../../../en/JavaScript/Reference/Global_Objects/RegExp/toString" rel="internal" title="en/JavaScript/Reference/Global_Objects/RegExp/toString">toString</a></dt> <dd>Retourne la chaîne représentant l'objet spécifié. Remplace la méthode <a href="../../../../en/JavaScript/Reference/Global_Objects/Object/toString" rel="internal" title="en/JavaScript/Reference/Global_Objects/Object/toString"><code>Object.prototype.toString</code></a>.</dd> </dl> <div> <div style="border: 1px solid rgb(204, 204, 204); margin: 10px 0px; padding: 0px 10px; background: rgb(238, 238, 238) none repeat scroll 0% 0%;"><span style="font-weight:bold;">Méthodes héritées depuis <a href="../../../../en/JavaScript/Reference/Global_Objects/Object" rel="internal" title="en/JavaScript/Reference/Global_Objects/Object"><code>Object</code></a></span>:<br> <span style="font-size: smaller;"><a href="../../../../en/JavaScript/Reference/Global_Objects/Object/DefineGetter" rel="internal" title="en/JavaScript/Reference/Global_Objects/Object/DefineGetter"><code>__defineGetter__</code></a>, <a href="../../../../en/JavaScript/Reference/Global_Objects/Object/DefineSetter" rel="internal" title="en/JavaScript/Reference/Global_Objects/Object/DefineSetter"><code>__defineSetter__</code></a>, <a href="../../../../en/JavaScript/Reference/Global_Objects/Object/HasOwnProperty" rel="internal" title="en/JavaScript/Reference/Global_Objects/Object/HasOwnProperty"><code>hasOwnProperty</code></a>, <a href="../../../../en/JavaScript/Reference/Global_Objects/Object/IsPrototypeOf" rel="internal" title="en/JavaScript/Reference/Global_Objects/Object/IsPrototypeOf"><code>isPrototypeOf</code></a>, <a href="../../../../en/JavaScript/Reference/Global_Objects/Object/LookupGetter" rel="internal" title="en/JavaScript/Reference/Global_Objects/Object/LookupGetter"><code>__lookupGetter__</code></a>, <a href="../../../../en/JavaScript/Reference/Global_Objects/Object/LookupSetter" rel="internal" title="en/JavaScript/Reference/Global_Objects/Object/LookupSetter"><code>__lookupSetter__</code></a>, <a href="../../../../en/JavaScript/Reference/Global_Objects/Object/NoSuchMethod" rel="internal" title="en/JavaScript/Reference/Global_Objects/Object/NoSuchMethod"><code>__noSuchMethod__</code></a>, <a href="../../../../en/JavaScript/Reference/Global_Objects/Object/PropertyIsEnumerable" rel="internal" title="en/JavaScript/Reference/Global_Objects/Object/PropertyIsEnumerable"><code>propertyIsEnumerable</code></a>, <a href="../../../../en/JavaScript/Reference/Global_Objects/Object/ToLocaleString" rel="internal" title="en/JavaScript/Reference/Global_Objects/Object/ToLocaleString"><code>toLocaleString</code></a>, <a href="../../../../en/JavaScript/Reference/Global_Objects/Object/Unwatch" rel="internal" title="en/JavaScript/Reference/Global_Objects/Object/Unwatch"><code>unwatch</code></a>, <a href="../../../../en/JavaScript/Reference/Global_Objects/Object/ValueOf" rel="internal" title="en/JavaScript/Reference/Global_Objects/Object/ValueOf"><code>valueOf</code></a>, <a href="../../../../en/JavaScript/Reference/Global_Objects/Object/Watch" rel="internal" title="en/JavaScript/Reference/Global_Objects/Object/Watch"><code>watch</code></a></span></div> </div> </div>
</div>
<div id="section_10"> <h2 class="editable" id="Exemples">Exemples</h2> <div id="section_11"> <h3 class="editable" id="Exemple:_Utilisation_d'une_expression_rationnelle_pour_changer_le_format_de_la_date">Exemple: Utilisation d'une expression rationnelle pour changer le format de la date</h3> <p>Le programme suivant utilise la méthode <a href="../../../../en/JavaScript/Reference/Global_Objects/String/replace" rel="internal" title="en/JavaScript/Reference/Global_Objects/String/replace">replace</a> héritée depuis l'instance <a href="../../../../en/JavaScript/Reference/Global_Objects/String" rel="internal" title="en/JavaScript/Reference/Global_Objects/String">String</a> pour correspondre au nom dans un format <em>first last</em> et sortir dans le format <em>last</em>, <em>first</em>. Dans le texte de remplacement, le script utilise <code>$1</code> et <code>$2</code> pour indiquer les résultats de la correspondance des parenthèses de contrôle dans le modèle de l'expression rationnelle.</p> <div class="dp-highlighter"> <div class="bar"> <div class="tools"><a href="/fr/en/JavaScript/Reference/Global_Objects/RegExp#" title="fr/en/JavaScript/Reference/Global_Objects/RegExp#">view plain</a><a href="/fr/en/JavaScript/Reference/Global_Objects/RegExp#" title="fr/en/JavaScript/Reference/Global_Objects/RegExp#">print</a><a href="/fr/en/JavaScript/Reference/Global_Objects/RegExp#" title="fr/en/JavaScript/Reference/Global_Objects/RegExp#">?</a></div> </div> <ol class="dp-c" start="1"> <li class="alt"><span><span class="keyword">var</span><span> re = /(\w+)\s(\w+)/;  </span></span></li> <li><span><span class="keyword">var</span><span> str = </span><span class="string">"John Smith"</span><span>;  </span></span></li> <li class="alt"><span><span class="keyword">var</span><span> newstr = str.replace(re, </span><span class="string">"$2, $1"</span><span>);  </span></span></li> <li><span>print(newstr);  </span></li> </ol> </div> <p>Il affiche "Smith, John".</p> </div> <div id="section_12"> <h3 class="editable" id="Exemple:_Utilisation_d'une_expression_rationnelle_avec_le_drapeau.C2.A0_&quot;sticky&quot;">Exemple: Utilisation d'une expression rationnelle avec le drapeau  "sticky"</h3> <p>Cet exemple démontre comment on pourrait utiliser un drapeau collant sur les expressions rationnelles pour correspondre à des lignes simples ou multiples.</p> <div class="dp-highlighter"> <div class="bar"> <div class="tools"><a href="/fr/en/JavaScript/Reference/Global_Objects/RegExp#" title="fr/en/JavaScript/Reference/Global_Objects/RegExp#">view plain</a><a href="/fr/en/JavaScript/Reference/Global_Objects/RegExp#" title="fr/en/JavaScript/Reference/Global_Objects/RegExp#">print</a><a href="/fr/en/JavaScript/Reference/Global_Objects/RegExp#" title="fr/en/JavaScript/Reference/Global_Objects/RegExp#">?</a></div> </div> <ol class="dp-c" start="1"> <li class="alt"><span><span class="keyword">var</span><span> text = </span><span class="string">"First line\nsecond line"</span><span>;  </span></span></li> <li><span><span class="keyword">var</span><span> regex = /(\S+) line\n?/y;  </span></span></li> <li class="alt"><span>  </span></li> <li><span><span class="keyword">var</span><span> match = regex.exec(text);  </span></span></li> <li class="alt"><span>print(match[1]);  <span class="comment">// prints "First"</span><span>  </span></span></li> <li><span>print(regex.lastIndex); <span class="comment">// prints 11</span><span>  </span></span></li> <li class="alt"><span>  </span></li> <li><span><span class="keyword">var</span><span> match2 = regex.exec(text);  </span></span></li> <li class="alt"><span>print(match2[1]); <span class="comment">// prints "Second"</span><span>  </span></span></li> <li><span>print(regex.lastIndex); <span class="comment">// prints "22"</span><span>  </span></span></li> <li class="alt"><span>  </span></li> <li><span><span class="keyword">var</span><span> match3 = regex.exec(text);  </span></span></li> <li class="alt"><span>print(match3 === <span class="keyword">null</span><span>); </span><span class="comment">// prints "true"</span><span>  </span></span></li> </ol> </div> <p>On peut tester à l'exécution si le drapeau collant est pris en charge, en utilisant <code>try { … } catch { … }</code>. Pour ceci, soit une expression <code>eval(…)</code> ou la syntaxe <code>RegExp(<var>regex-string</var>, <var>flags-string</var>)</code> doit être utilisée (depuis la notation <code>/<var>regex</var>/<var>flags</var></code> est traitée au moment de la compilation, mais envoie une exception avant que le bloc <code>catch</code> ne soit rencontré). Par exemple:</p> <div class="dp-highlighter"> <div class="bar"> <div class="tools"><a href="/fr/en/JavaScript/Reference/Global_Objects/RegExp#" title="fr/en/JavaScript/Reference/Global_Objects/RegExp#">view plain</a><a href="/fr/en/JavaScript/Reference/Global_Objects/RegExp#" title="fr/en/JavaScript/Reference/Global_Objects/RegExp#">print</a><a href="/fr/en/JavaScript/Reference/Global_Objects/RegExp#" title="fr/en/JavaScript/Reference/Global_Objects/RegExp#">?</a></div> </div> <ol class="dp-c" start="1"> <li class="alt"><span><span class="keyword">var</span><span> supports_sticky;  </span></span></li> <li><span><span class="keyword">try</span><span> { RegExp(</span><span class="string">''</span><span>,</span><span class="string">'y'</span><span>); supports_sticky = </span><span class="keyword">true</span><span>; }  </span></span></li> <li class="alt"><span><span class="keyword">catch</span><span>(e) { supports_sticky = </span><span class="keyword">false</span><span>; }  </span></span></li> <li><span>alert(supports_sticky); <span class="comment">// alerts "false" in Firefox 2, "true" in Firefox 3+</span><span>  </span></span></li> </ol> </div> </div>
</div>
<div id="section_13"> <h2 class="editable" id="Compatibilit.C3.A9_des_navigateurs">Compatibilité des navigateurs</h2> <p> </p> <div class="htab"><a name="AutoCompatibilityTable"> <ul> <li class="selected">Desktop</li> <li>Mobile</li> </ul> <div id="compat-desktop" style="display: block;"> <table class="compat-table"> <tbody> <tr> <th>Feature</th> <th>Chrome</th> <th>Firefox (Gecko)</th> <th>Internet Explorer</th> <th>Opera</th> <th>Safari (WebKit)</th> </tr> <tr> <td>Basic support</td> <td><span style="color: rgb(255, 153, 0);" title="Compatibility unknown; please update this.">?</span></td> <td><span style="color: #888" title="Please update this with the earliest version of support.">(Supporté)</span></td> <td><span style="color: rgb(255, 153, 0);" title="Compatibility unknown; please update this.">?</span></td> <td><span style="color: rgb(255, 153, 0);" title="Compatibility unknown; please update this.">?</span></td> <td><span style="color: rgb(255, 153, 0);" title="Compatibility unknown; please update this.">?</span></td> </tr> </tbody> </table> </div> </a></div><a name="AutoCompatibilityTable">
</a></div><a name="AutoCompatibilityTable">
<h2 class="editable" id="Voir_aussi">Voir aussi</h2>
</a><ul><a name="AutoCompatibilityTable"> </a><li><a name="AutoCompatibilityTable"></a><a href="../../../../en/JavaScript/Guide/Regular_Expressions" rel="internal" title="en/Core_JavaScript_1.5_Guide/Regular_Expressions">Regular Expressions</a> chapitre du <a href="../../../../en/JavaScript/Guide" rel="internal" title="en/Core_JavaScript_1.5_Guide">Guide JavaScript</a></li>
</ul>
Revenir à cette révision