RegExp

Description

Notation littrale et constructeur

Il existe deux faons de crer un objet RegExp : une notation littrale ou un constructeur.

• La notation littrale prend un motif entre deux barres obliques, suivi des indicateurs optionnels, aprs la deuxime barre oblique.
• La fonction constructeur prend soit une chane de caractres, soit un objet RegExp comme premier paramtre et une chane de caractres d'indicateurs optionnels comme second paramtre.

Ainsi, les expressions suivantes crent le mme objet d'expression rationnelle :

const re = /ab+c/i; // notation littrale
// OU
const re = new RegExp("ab+c", "i"); // constructeur avec une chane de caractres comme premier argument
// OU
const re = new RegExp(/ab+c/, "i"); // constructeur avec une expression rationnelle littrale comme premier argument

Avant de pouvoir utiliser des expressions rationnelles, elles doivent tre compiles. Ce processus leur permet d'effectuer des correspondances plus efficacement. Plus d'informations sur ce processus peuvent tre trouves dans les documents dotnet (angl.).

La notation littrale effectue la compilation de l'expression rationnelle lorsque l'expression est value. En revanche, le constructeur de l'objet RegExp, new RegExp('ab+c'), effectue la compilation de l'expression rationnelle au moment de l'excution.

Utilisez une chane de caractres comme premier argument du constructeur RegExp() lorsque vous souhaitez construire l'expression rationnelle partir d'une entre dynamique.

Indicateurs dans le constructeur

L'expression new RegExp(/ab+c/, flags) cre une nouvelle RegExp en utilisant la source du premier paramtre et les indicateurs fournis par le second.

Lors de l'utilisation de la fonction constructeur, les rgles normales d'chappement des chanes de caractres (faire prcder les caractres spciaux d'un \ lorsqu'ils sont inclus dans une chane de caractres) sont ncessaires.

Par exemple, les dfinitions suivantes sont quivalentes :

const re = /\w+/;
// OU
const re = new RegExp("\\w+");

Gestion spciale pour les expressions rationnelles

Certaines mthodes intgres traitent les expressions rationnelles de manire spciale. Elles dcident si x est une expression rationnelle travers plusieurs tapes (angl.) :

1. x doit tre un objet (et non un type primitif).
2. Si x[Symbol.match] n'est pas undefined, vrifiez si sa valeur est quivalente vrai.
3. Sinon, si x[Symbol.match] est undefined, vrifiez si x a t cr avec le constructeur RegExp. (Cette tape doit rarement se produire, car si x est un objet RegExp qui n'a pas t modifi, il doit avoir une proprit Symbol.match.)

Notez que dans la plupart des cas, il passe par la vrification Symbol.match, ce qui signifie :

• Un vritable objet RegExp dont la valeur de la proprit Symbol.match est quivalente faux, mais pas undefined (mme si tout le reste reste intact, comme exec et [Symbol.replace]()), peut tre utilis comme s'il ne s'agit pas d'une expression rationnelle.
• Un objet qui n'est pas un RegExp et qui possde une proprit Symbol.match est trait comme s'il s'agit d'une expression rationnelle.

Ce choix est fait parce que [Symbol.match]() est la proprit qui indique le mieux qu'un lment est destin tre utilis pour faire des correspondances. (exec peut aussi tre utilis, mais comme ce n'est pas une proprit de symbole, il y a trop de faux positifs.) Les endroits qui traitent les expressions rationnelles de manire particulire comprennent :

• String.prototype.endsWith(), startsWith() et includes() lvent une TypeError si le premier argument est une expression rationnelle.
• String.prototype.matchAll() et replaceAll() vrifient si l'indicateur global est dfini si le premier argument est une expression rationnelle, avant d'appeler sa mthode [Symbol.matchAll]() ou [Symbol.replace]().
• Le constructeur RegExp() retourne directement l'argument pattern uniquement si pattern est une expression rationnelle (parmi quelques autres conditions). Si pattern est une expression rationnelle, il examine galement les proprits source et flags de pattern au lieu de contraindre pattern en chane de caractres.

Par exemple, String.prototype.endsWith() contraint toutes les entres en chanes de caractres, mais lve une exception si l'argument est une expression rationnelle, parce qu'elle est uniquement conue pour faire correspondre des chanes de caractres, et utiliser une expression rationnelle est probablement une erreur de dveloppement.

"tototruc".endsWith({ toString: () => "truc" }); // true
"tototruc".endsWith(/truc/); // TypeError: First argument to String.prototype.endsWith must not be a regular expression

Vous pouvez contourner la vrification en dfinissant [Symbol.match] sur une valeur quivalente faux qui n'est pas undefined. Cela signifie que l'expression rationnelle ne peut pas tre utilise avec String.prototype.match() (puisque sans [Symbol.match], match() construit un nouvel objet RegExp avec les deux barres obliques d'encadrement ajoutes par re.toString()), mais qu'elle peut tre utilise pour pratiquement tout le reste.

const re = /truc/g;
re[Symbol.match] = false;
"/truc/g".endsWith(re); // true
re.exec("truc"); // [ 'truc', index: 0, input: 'truc', groups: undefined ]
"truc & truc".replace(re, "toto"); // 'toto & toto'

Proprits de RegExp similaires celles de Perl

Notez que plusieurs proprits de RegExp ont la fois un nom long et un nom court (similaires ceux de Perl). Les deux noms dsignent toujours la mme valeur. (Perl est le langage de programmation dont JavaScript reprend le modle pour ses expressions rationnelles.) Consultez aussi les proprits RegExp obsoltes.

Constructeur

RegExp()

Cre un nouvel objet RegExp.

Proprits statiques

RegExp.$1, , RegExp.$9

Proprits statiques en lecture seule contenant des correspondances de sous-chanes de caractre entre parenthses.

RegExp.input ($_)

Une proprit statique qui contient la dernire chane de caractres contre laquelle une expression rationnelle a t correctement apparie.

RegExp.lastMatch ($&)

Une proprit statique en lecture seule qui contient la dernire sous-chane de caractres apparie.

RegExp.lastParen ($+)

Une proprit statique en lecture seule qui contient la dernire sous-chane de caractres entre parenthses apparie.

RegExp.leftContext ($`)

Une proprit statique en lecture seule qui contient la sous-chane de caractres prcdant le dernier appariement.

RegExp.rightContext ($')

Une proprit statique en lecture seule qui contient la sous-chane de caractres suivant le dernier appariement.

RegExp[Symbol.species]

La fonction constructeur qui est utilise pour crer des objets drivs.

Mthodes statiques

RegExp.escape()

chappe tous les caractres de syntaxe regex potentiels dans une chane de caractres, et retourne une nouvelle chane de caractres qui peut tre utilise en toute scurit comme motif littral pour le constructeur RegExp().

Proprits d'instance

Ces proprits sont dfinies sur RegExp.prototype et partages par toutes les instances de RegExp.

RegExp.prototype.constructor

La fonction constructeur qui a cr l'objet instance. Pour les instances de RegExp, la valeur initiale est le constructeur RegExp.

RegExp.prototype.dotAll

Indique si le caractre . correspond aux caractres de nouvelle ligne.

RegExp.prototype.flags

Une chane de caractres qui contient les indicateurs de l'objet RegExp.

RegExp.prototype.global

Indique si l'expression rationnelle doit tre teste par rapport toutes les correspondances possibles dans une chane de caractres, ou uniquement la premire.

RegExp.prototype.hasIndices

Indique si le rsultat de l'expression rationnelle expose les indices de dbut et de fin des sous-chanes de caractres captures.

RegExp.prototype.ignoreCase

Indique si la casse doit tre ignore lors de la tentative d'une correspondance dans une chane de caractres.

RegExp.prototype.multiline

Indique si la recherche dans les chanes de caractres porte sur plusieurs lignes.

RegExp.prototype.source

Le texte du motif.

RegExp.prototype.sticky

Indique si la recherche est persistante.

RegExp.prototype.unicode

Indique si les fonctionnalits Unicode sont actives.

RegExp.prototype.unicodeSets

Indique si l'indicateur v, une volution du mode u, est activ.

Ces proprits sont des proprits propres chaque instance de RegExp.

lastIndex

L'indice auquel commence la correspondance suivante.

Mthodes d'instance

RegExp.prototype.compile()

Compile ou recompile une expression rationnelle pendant l'excution d'un script.

RegExp.prototype.exec()

Excute une recherche de correspondance dans son paramtre chane de caractres.

RegExp.prototype.test()

Vrifie la prsence d'une correspondance dans son paramtre chane de caractres.

RegExp.prototype.toString()

Retourne une chane de caractres qui reprsente l'objet dfini. Remplace la mthode Object.prototype.toString().

RegExp.prototype[Symbol.match]()

Effectue une correspondance avec la chane de caractres fournie et retourne le rsultat de la correspondance.

RegExp.prototype[Symbol.matchAll]()

Retourne toutes les correspondances de l'expression rationnelle dans une chane de caractres.

RegExp.prototype[Symbol.replace]()

Remplace les correspondances dans la chane de caractres fournie par une nouvelle portion de texte.

RegExp.prototype[Symbol.search]()

Recherche la correspondance dans la chane de caractres fournie et retourne l'indice auquel le motif se trouve dans la chane de caractres.

RegExp.prototype[Symbol.split]()

Divise la chane de caractres fournie en tableau en sparant la chane de caractres en portions de texte.

Exemples

Utiliser une expression rationnelle pour changer le format des donnes

Le script suivant utilise la mthode String.prototype.replace() pour faire correspondre un nom au format prnom nom et le produire au format nom, prnom.

Dans le texte de remplacement, le script utilise $1 et $2 pour indiquer les rsultats des parenthses correspondantes dans le motif de l'expression rationnelle.

const re = /(\w+)\s(\w+)/;
const str = "Maria Cruz";
const nouveauChr = str.replace(re, "$2, $1");
console.log(nouveauChr);

Cela affiche "Cruz, Maria".

Utiliser une expression rationnelle pour sparer les lignes avec diffrentes fins de ligne/fins de ligne/sauts de ligne

La fin de ligne par dfaut varie selon la plateforme (Unix, Windows, etc.). La sparation des lignes fournie dans cet exemple fonctionne sur toutes les plateformes.

const texte = "Du texte\nEt bien plus\r\nEt encore\nC'est la fin";
const lignes = texte.split(/\r?\n/);
console.log(lignes); // [ 'Du texte', 'Et bien plus', 'Et encore', "C'est la fin" ]

Notez que l'ordre des motifs dans l'expression rationnelle est important.

Utiliser une expression rationnelle sur plusieurs lignes

Par dfaut, le caractre . ne correspond pas aux caractres de nouvelle ligne. Pour lui faire correspondre ces caractres, utilisez l'indicateur s (mode dotAll).

const s = "Oui s'il vous plat\ngayez ma journe!";

s.match(/Oui.*journe/);
// Retourne null

s.match(/Oui.*journe/s);
// Retourne ["Oui s'il vous plat\ngayez ma journe!"]

Utiliser une expression rationnelle avec l'indicateur de recherche persistante

L'indicateur sticky indique que l'expression rationnelle effectue une recherche persistante dans la chane de caractres cible en tentant une correspondance partir de RegExp.prototype.lastIndex.

const str = "#toto#";
const regex = /toto/y;

regex.lastIndex = 1;
regex.test(str); // true
regex.lastIndex = 5;
regex.test(str); // false (lastIndex est pris en compte avec l'indicateur sticky)
regex.lastIndex; // 0 (rinitialis aprs l'chec de la correspondance)

La diffrence entre l'indicateur de recherche persistante et l'indicateur global

Avec l'indicateur de recherche persistante y, la correspondance suivante a lieu la position lastIndex, tandis qu'avec l'indicateur global g, la correspondance peut avoir lieu la position lastIndex ou aprs :

const re = /\d/y;
let r;
while ((r = re.exec("123 456"))) {
  console.log(r, "ET re.lastIndex", re.lastIndex);
}

// [ '1', index: 0, input: '123 456', groups: undefined ] ET re.lastIndex 1
// [ '2', index: 1, input: '123 456', groups: undefined ] ET re.lastIndex 2
// [ '3', index: 2, input: '123 456', groups: undefined ] ET re.lastIndex 3
//   et plus aucune correspondance.

Avec l'indicateur global g, les 6 chiffres correspondent, et pas seulement 3.

Expression rationnelle et caractres Unicode

\w et \W correspondent uniquement aux caractres fonds sur ASCII ; par exemple, de a z, de A Z, de 0 9 et _.

Pour faire correspondre des caractres d'autres langues, telles que le cyrillique ou l'hbreu, utilisez \uHHHH, o HHHH est la valeur Unicode du caractre en hexadcimal.

Cet exemple montre comment sparer les caractres Unicode d'un mot.

const texte = " texte   ";
const regex = /[\u0400-\u04ff]+/g;

const correspondance = regex.exec(texte);
console.log(correspondance[0]); // ''
console.log(regex.lastIndex); // 7

const correspondance2 = regex.exec(texte);
console.log(correspondance2[0]); // '' (n'affiche pas 'texte')
console.log(regex.lastIndex); // 16

// et ainsi de suite

La fonctionnalit des chappements de proprits Unicode fournit une manire plus simple de cibler certaines plages Unicode, en autorisant des expressions comme \p{scx=Cyrl} (pour faire correspondre n'importe quelle lettre cyrillique), ou \p{L}/u (pour faire correspondre une lettre de n'importe quelle langue).

Extraction du nom de sous-domaine d'une URL

const url = "http://xxx.example.com";
console.log(/^https?:\/\/(.+?)\./.exec(url)[1]); // 'xxx'

Construire une expression rationnelle partir d'entres dynamiques

const petitsDejeuners = ["lard", "ufs", "avoine", "pain", "fruits"];
const commande = "Je prends du lard et des ufs, merci";

commande.match(new RegExp(`\\b(${petitsDejeuners.join("|")})\\b`, "g"));
// Retourne ['lard', 'ufs']

Spcifications

Compatibilit des navigateurs

Notes spcifiques Firefox

partir de Firefox 34, dans le cas d'un groupe capturant avec des quantificateurs qui empchent son exercice, le texte correspondant un groupe capturant vaut maintenant undefined au lieu d'une chane de caractres vide :

// Firefox 33 ou antrieur
"x".replace(/x(.)?/g, (m, group) => {
  console.log(`group: ${JSON.stringify(group)}`);
});
// group: ""

// Firefox 34 ou ultrieur
"x".replace(/x(.)?/g, (m, group) => {
  console.log(`group: ${group}`);
});
// group: undefined

Notez que, pour des raisons de compatibilit web, RegExp.$N retourne toujours une chane de caractres vide au lieu de undefined (bogue 1053944 (angl.)).

Voir aussi

• La prothse d'mulation de nombreuses fonctionnalits modernes de RegExp (dotAll, indicateurs sticky, groupes de capture nomms, etc.) dans core-js (angl.)
• Le guide des expressions rationnelles
• Les expressions rationnelles
• La mthode String.prototype.match()
• La mthode String.prototype.replace()
• La mthode String.prototype.split()