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 : 266646
  • Créé :
  • Créateur : daniel35310
  • Version actuelle ? Non
  • Commentaire 281 words added, 239 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 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 rappellematches 'foo' dans "foo bar." La chaîne correspondante peut être rappelée à partir des éléments résultants du tableau [1], ..., [n] ou depuis les objets RegExp prédéfinies des propriétés $1, ..., $9.

(?:x)

Matches x but does not remember the match. These are called non-capturing parentheses. The matched substring can not be recalled from the resulting array's elements [1], ..., [n] or from the predefined RegExp object's properties $1, ..., $9.

x(?=y)

Matches x only if x is followed by y. For example, /Jack(?=Sprat)/ matches 'Jack' only if it is followed by 'Sprat'. /Jack(?=Sprat|Frost)/ matches 'Jack' only if it is followed by 'Sprat' or 'Frost'. However, neither 'Sprat' nor 'Frost' is part of the match results.

x(?!y)

Matches x only if x is not followed by y. For example, /\d+(?!\.)/ matches a number only if it is not followed by a decimal point.

/\d+(?!\.)/.exec("3.141") matches 141 but not 3.141.

x|y

Correspond soit à x ou y.

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

{n}

Where n is a positive integer. Matches exactly n occurrences of the preceding item.

For example, /a{2}/ doesn't match the 'a' in "candy," but it matches all of the a's in "caandy," and the first two a's in "caaandy."

{n,}

Where n is a positive integer. Matches at least n occurrences of the preceding item.

For example, /a{2,}/ doesn't match the 'a' in "candy", but matches all of the a's in "caandy" and in "caaaaaaandy."

{n,m}

Where n and m are positive integers. Matches at least n and at most m occurrences of the preceding item.

For example, /a{1,3}/ matches nothing in "cndy", the 'a' in "candy," the first two a's in "caandy," and the first three a's in "caaaaaaandy". Notice that when matching "caaaaaaandy", the match is "aaa", even though the original string had more a's in it.

[xyz]

A character set. Matches any one of the enclosed characters. You can specify a range of characters by using a hyphen.

For example, [abcd] is the same as [a-d]. They match the 'b' in "brisket" and the 'c' in "chop".

[^xyz]

A negated or complemented character set. That is, it matches anything that is not enclosed in the brackets. You can specify a range of characters by using a hyphen.

For example, [^abc] is the same as [^a-c]. They initially match 'r' in "brisket" and 'h' in "chop."

[\b]

Matches a backspace. (Not to be confused with \b.)

\b

Matches a word boundary, such as a space. (Not to be confused with [\b].)

For example, /\bn\w/ matches the 'no' in "noonday"; /\wy\b/ matches the 'ly' in "possibly yesterday."

\B

Matches a non-word boundary.

For example, /\w\Bn/ matches 'on' in "noonday", and /y\B\w/ matches 'ye' in "possibly yesterday."

\cX

Where X is a letter from A - Z. Matches a control character in a string.

For example, /\cM/ matches control-M in a string.

\d

Matches a digit character in the basic Latin alphabet. Equivalent to [0-9].

Note: In Firefox 2 and earlier, matches a digit character from any alphabet. ( bug 378738 )

For example, /\d/ or /[0-9]/ matches '2' in "B2 is the suite number."

\D

Matches any character that is not a digit in the basic Latin alphabet. Equivalent to [^0-9].

Note: In Firefox 2 and earlier, excludes digit characters from all alphabets. ( bug 378738 )

For example, /\D/ or /[^0-9]/ matches 'B' in "B2 is the suite number."

\f

Matches a form-feed.

\n

Matches a linefeed.

\r

Matches a carriage return.

\s

Matches a single white space character, including space, tab, form feed, line feed and other unicode spaces. [equivalent_s]

For example, /\s\w*/ matches ' bar' in "foo bar."

\S

Matches a single character other than white space. [equivalent_S]

For example, /\S\w*/ matches 'foo' in "foo bar."

\t

Matches a tab.

\v

Matches a vertical tab.

\w

Matches any alphanumeric character from the basic Latin alphabet, including the underscore. Equivalent to [A-Za-z0-9_].

For example, /\w/ matches 'a' in "apple," '5' in "$5.28," and '3' in "3D."

\W

Matches any character that is not a word character from the basic Latin alphabet. Equivalent to [^A-Za-z0-9_].

For example, /\W/ or /[^A-Za-z0-9_]/ matches '%' in "50%."

\n

Where n is a positive integer. A back reference to the last substring matching the n parenthetical in the regular expression (counting left parentheses).

For example, /apple(,)\sorange\1/ matches 'apple, orange,' in "apple, orange, cherry, peach." A more complete example follows this table.

\0

Matches a NUL character. Do not follow this with another digit.

\xhh

Matches the character with the code hh (two hexadecimal digits)

\uhhhh

Matches the character with the Unicode value hhhh (four hexadecimal digits).

The literal notation provides compilation of the regular expression when the expression is evaluated. Use literal notation when the regular expression will remain constant. For example, if you use literal notation to construct a regular expression used in a loop, the regular expression won't be recompiled on each iteration.

The constructor of the regular expression object, for example, new RegExp("ab+c"), provides runtime compilation of the regular expression. Use the constructor function when you know the regular expression pattern will be changing, or you don't know the pattern and are getting it from another source, such as user input.

  1. ^Equivalent to:

    [\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.

 

Methods inherited from Function:
apply, call, toSource, toString

Properties

 

Voir aussi Deprecated RegExp Properties

Note that several of the RegExp properties have both long and short (Perl-like) names. Both names always refer to the same value. Perl is the programming language from which JavaScript modeled its regular expressions.

constructor
Specifies the function that creates an object's prototype.
global
Whether to test the regular expression against all possible matches in a string, or only against the first.
ignoreCase
Whether to ignore case while attempting a match in a string.
lastIndex
The index at which to start the next match.
multiline
Whether or not to search in strings across multiple lines.
source
The text of the pattern.
sticky
New in Firefox 3 Non-standard
Whether or not the search is sticky.
Properties inherited from Object:
__parent__, __proto__

Methods

 

Deprecated RegExp Methods
See also
exec
Executes a search for a match in its string parameter.
test
Tests for a match in its string parameter.
toSource
Non-standard
Returns an object literal representing the specified object; you can use this value to create a new object. Overrides the Object.prototype.toSource method.
toString
Returns a string representing the specified object. Overrides the Object.prototype.toString method.

Examples

Example: Using a regular expression to change data format

The following script uses the replace method inherited by the String instance to match a name in the format first last and output it in the format last, first. In the replacement text, the script uses $1 and $2 to indicate the results of the corresponding matching parentheses in the regular expression pattern.

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

This displays "Smith, John".

Example: Using a regular expression with the "sticky" flag

This example demonstrates how one could use the sticky flag on regular expressions to match individual lines of multiline input.

  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"  

One can test at run-time whether the sticky flag is supported, using try { … } catch { … }. For this, either an eval(…) expression or the RegExp(regex-stringflags-string) syntax must be used (since the /regex/flags notation is processed at compile-time, so throws an exception before the catch block is encountered). For example:

  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+  

See also

Source de la révision

<h2 class="editable">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">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">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 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">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">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 rappellematches 'foo' dans "foo bar." La chaîne correspondante peut être rappelée à partir des éléments résultants du tableau <code>[1], ..., [n]</code> ou depuis les objets <code>RegExp</code> prédéfinies des propriétés <code>$1, ..., $9</code>.</p> </td> </tr> <tr> <td><code>(?:<em>x</em>)</code></td> <td> <p>Matches <code><em>x</em></code> but does not remember the match. These are called non-capturing parentheses. The matched substring can not be recalled from the resulting array's elements <code>[1], ..., [n]</code> or from the predefined <code>RegExp</code> object's properties <code>$1, ..., $9</code>.</p> </td> </tr> <tr> <td><code><em>x</em>(?=<em>y</em>)</code></td> <td> <p>Matches <code><em>x</em></code> only if <code><em>x</em></code> is followed by <code><em>y</em></code>. For example, <code>/Jack(?=Sprat)/</code> matches 'Jack' only if it is followed by 'Sprat'. <code>/Jack(?=Sprat|Frost)/</code> matches 'Jack' only if it is followed by 'Sprat' or 'Frost'. However, neither 'Sprat' nor 'Frost' is part of the match results.</p> </td> </tr> <tr> <td><code><em>x</em>(?!<em>y</em>)</code></td> <td> <p>Matches <code><em>x</em></code> only if <code><em>x</em></code> is not followed by <code><em>y</em></code>. For example, <code>/\d+(?!\.)/</code> matches a number only if it is not followed by a decimal point.</p> <p><code>/\d+(?!\.)/.exec("3.141")</code> matches 141 but not 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>Where <code><em>n</em></code> is a positive integer. Matches exactly <code><em>n</em></code> occurrences of the preceding item.</p> <p>For example, <code>/a{2}/</code> doesn't match the 'a' in "candy," but it matches all of the a's in "caandy," and the first two a's in "caaandy."</p> </td> </tr> <tr> <td><code>{<em>n</em>,}</code></td> <td> <p>Where <code><em>n</em></code> is a positive integer. Matches at least <code><em>n</em></code> occurrences of the preceding item.</p> <p>For example, <code>/a{2,}/</code> doesn't match the 'a' in "candy", but matches all of the a's in "caandy" and in "caaaaaaandy."</p> </td> </tr> <tr> <td><code>{<em>n</em>,<em>m</em>}</code></td> <td> <p>Where <code><em>n</em></code> and <code><em>m</em></code> are positive integers. Matches at least <code><em>n</em></code> and at most <code><em>m</em></code> occurrences of the preceding item.</p> <p>For example, <code>/a{1,3}/</code> matches nothing in "cndy", the 'a' in "candy," the first two a's in "caandy," and the first three a's in "caaaaaaandy". Notice that when matching "caaaaaaandy", the match is "aaa", even though the original string had more a's in it.</p> </td> </tr> <tr> <td><code>[xyz]</code></td> <td> <p>A character set. Matches any one of the enclosed characters. You can specify a range of characters by using a hyphen.</p> <p>For example, <code>[abcd]</code> is the same as <code>[a-d]</code>. They match the 'b' in "brisket" and the 'c' in "chop".</p> </td> </tr> <tr> <td><code>[^xyz]</code></td> <td> <p>A negated or complemented character set. That is, it matches anything that is not enclosed in the brackets. You can specify a range of characters by using a hyphen.</p> <p>For example, <code>[^abc]</code> is the same as <code>[^a-c]</code>. They initially match 'r' in "brisket" and 'h' in "chop."</p> </td> </tr> <tr> <td><code>[\b]</code></td> <td> <p>Matches a backspace. (Not to be confused with <code>\b</code>.)</p> </td> </tr> <tr> <td><code>\b</code></td> <td> <p>Matches a word boundary, such as a space. (Not to be confused with <code>[\b]</code>.)</p> <p>For example, <code>/\bn\w/</code> matches the 'no' in "noonday"; <code>/\wy\b/</code> matches the 'ly' in "possibly yesterday."</p> </td> </tr> <tr> <td><code>\B</code></td> <td> <p>Matches a non-word boundary.</p> <p>For example, <code>/\w\Bn/</code> matches 'on' in "noonday", and <code>/y\B\w/</code> matches 'ye' in "possibly yesterday."</p> </td> </tr> <tr> <td><code>\c<em>X</em></code></td> <td> <p>Where <code><em>X</em></code> is a letter from A - Z. Matches a control character in a string.</p> <p>For example, <code>/\cM/</code> matches control-M in a string.</p> </td> </tr> <tr> <td><code>\d</code></td> <td> <p>Matches a digit character in the basic Latin alphabet. Equivalent to <code>[0-9]</code>.</p> <p><strong>Note</strong>: In Firefox 2 and earlier, matches a digit character from any alphabet. ( <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>For example, <code>/\d/</code> or <code>/[0-9]/</code> matches '2' in "B2 is the suite number."</p> </td> </tr> <tr> <td><code>\D</code></td> <td> <p>Matches any character that is not a digit in the basic Latin alphabet. Equivalent to <code>[^0-9]</code>.</p> <p><strong>Note</strong>: In Firefox 2 and earlier, excludes digit characters from all 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>For example, <code>/\D/</code> or <code>/[^0-9]/</code> matches 'B' in "B2 is the suite number."</p> </td> </tr> <tr> <td><code>\f</code></td> <td> <p>Matches a form-feed.</p> </td> </tr> <tr> <td><code>\n</code></td> <td> <p>Matches a linefeed.</p> </td> </tr> <tr> <td><code>\r</code></td> <td> <p>Matches a carriage return.</p> </td> </tr> <tr> <td><code>\s</code></td> <td> <p>Matches a single white space character, including space, tab, form feed, line feed and other unicode spaces. <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>For example, <code>/\s\w*/</code> matches ' bar' in "foo bar."</p> </td> </tr> <tr> <td><code>\S</code></td> <td> <p>Matches a single character other than white space. <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>For example, <code>/\S\w*/</code> matches 'foo' in "foo bar."</p> </td> </tr> <tr> <td><code>\t</code></td> <td> <p>Matches a tab.</p> </td> </tr> <tr> <td><code>\v</code></td> <td> <p>Matches a vertical tab.</p> </td> </tr> <tr> <td><code>\w</code></td> <td> <p>Matches any alphanumeric character from the basic Latin alphabet, including the underscore. Equivalent to <code>[A-Za-z0-9_]</code>.</p> <p>For example, <code>/\w/</code> matches 'a' in "apple," '5' in "$5.28," and '3' in "3D."</p> </td> </tr> <tr> <td><code>\W</code></td> <td> <p>Matches any character that is not a word character from the basic Latin alphabet. Equivalent to <code>[^A-Za-z0-9_]</code>.</p> <p>For example, <code>/\W/</code> or <code>/[^A-Za-z0-9_]/</code> matches '%' in "50%."</p> </td> </tr> <tr> <td><code>\<em>n</em></code></td> <td> <p>Where <code><em>n</em></code> is a positive integer. A back reference to the last substring matching the n parenthetical in the regular expression (counting left parentheses).</p> <p>For example, <code>/apple(,)\sorange\1/</code> matches 'apple, orange,' in "apple, orange, cherry, peach." A more complete example follows this table.</p> </td> </tr> <tr> <td><code>\0</code></td> <td> <p>Matches a NUL character. Do not follow this with another digit.</p> </td> </tr> <tr> <td><code>\x<em>hh</em></code></td> <td> <p>Matches the character with the code <code><em>hh</em></code> (two hexadecimal digits)</p> </td> </tr> <tr> <td><code>\u<em>hhhh</em></code></td> <td> <p>Matches the character with the Unicode value <code><em>hhhh</em></code> (four hexadecimal digits).</p> </td> </tr> </tbody> </table> <p>The literal notation provides compilation of the regular expression when the expression is evaluated. Use literal notation when the regular expression will remain constant. For example, if you use literal notation to construct a regular expression used in a loop, the regular expression won't be recompiled on each iteration.</p> <p>The constructor of the regular expression object, for example, <code>new RegExp("ab+c")</code>, provides runtime compilation of the regular expression. Use the constructor function when you know the regular expression pattern will be changing, or you don't know the pattern and are getting it from another source, such as user input.</p> <ol> <li><span id="endnote_equivalent_s"><strong><a href="../../../../en/JavaScript/Reference/Global_Objects/RegExp#ref_equivalent_s" rel="custom">^</a></strong></span>Equivalent to: <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">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">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;">Methods inherited from <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">Properties</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>Note that several of the <code>RegExp</code> properties have both long and short (Perl-like) names. Both names always refer to the same value. Perl is the programming language from which JavaScript modeled its regular expressions.</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>Specifies the function that creates an object's prototype.</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>Whether to test the regular expression against all possible matches in a string, or only against the first.</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>Whether to ignore case while attempting a match in a string.</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>The index at which to start the next match.</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>Whether or not to search in strings across multiple lines.</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>The text of the pattern.</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>Whether or not the search is sticky.</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;">Properties inherited from <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">Methods</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> See also </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>Executes a search for a match in its string parameter.</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>Tests for a match in its string parameter.</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> Returns an object literal representing the specified object; you can use this value to create a new object. Overrides the <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> method.</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>Returns a string representing the specified object. Overrides the <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> method.</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;">Methods inherited from <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">Examples</h2> <div id="section_11"> <h3 class="editable">Example: Using a regular expression to change data format</h3> <p>The following script uses the <a href="../../../../en/JavaScript/Reference/Global_Objects/String/replace" rel="internal" title="en/JavaScript/Reference/Global_Objects/String/replace">replace</a> method inherited by the <a href="../../../../en/JavaScript/Reference/Global_Objects/String" rel="internal" title="en/JavaScript/Reference/Global_Objects/String">String</a> instance to match a name in the format <em>first last</em> and output it in the format <em>last</em>, <em>first</em>. In the replacement text, the script uses <code>$1</code> and <code>$2</code> to indicate the results of the corresponding matching parentheses in the regular expression pattern.</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>This displays "Smith, John".</p> </div> <div id="section_12"> <h3 class="editable">Example: Using a regular expression with the "sticky" flag</h3> <p>This example demonstrates how one could use the sticky flag on regular expressions to match individual lines of multiline input.</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>One can test at run-time whether the sticky flag is supported, using <code>try { … } catch { … }</code>. For this, either an <code>eval(…)</code> expression or the <code>RegExp(<var>regex-string</var>, <var>flags-string</var>)</code> syntax must be used (since the <code>/<var>regex</var>/<var>flags</var></code> notation is processed at compile-time, so throws an exception before the <code>catch</code> block is encountered). For example:</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">Browser compatibility</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.">(Supported)</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">See also</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> chapter in the <a href="../../../../en/JavaScript/Guide" rel="internal" title="en/Core_JavaScript_1.5_Guide">JavaScript Guide</a></li>
</ul>
Revenir à cette révision