RegExp

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".

?

Correspond à 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

Étiquettes et contributeurs liés au document

Contributeurs ayant participé à cette page : daniel35310, vvision
Dernière mise à jour par : vvision,