recursal/MDN huggingface dataset:
RegExp.prototype.flags
======================

La propriété **`flags`** renvoie une chaîne de caractères contenant les drapeaux (*flags*) de l'objet `RegExp` auquel elle appartient.

Exemple interactif
------------------

| Attributs de `RegExp.prototype.flags` |
| --- |
| Écrivable | Non |
| Énumérable | Non |
| Configurable | Oui |

Description
-----------

Les drapeaux de la propriété `flags` sont rangés par ordre alphabétique de gauche à droite.

Exemples
--------

### Utiliser `flags`


```js
/toto/gi.flags; // "gi"
/truc/muy.flags; // "muy"
```

Prothèse d'émulation (*polyfill*)
---------------------------------


```js
if (RegExp.prototype.flags === undefined) {
  Object.defineProperty(RegExp.prototype, "flags", {
    configurable: true,
    get: function () {
      return this.toString().match(/[gimuy]\*$/)[0];
    },
  });
}
```

Spécifications
--------------

| Specification |
| --- |
| ECMAScript Language Specification # sec-get-regexp.prototype.flags |

Compatibilité des navigateurs
-----------------------------

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

Voir aussi
----------

* `RegExp.prototype.source`
regExp.lastIndex
================

La propriété **`lastIndex`** est un entier en lecture/écriture qui permet de définir l'indice (position) à partir duquel chercher la prochaine correspondance pour une instance d'expression rationnelle donnée.

Exemple interactif
------------------

| Attributs de `regExp.lastIndex` |
| --- |
| Écrivable | Oui |
| Énumérable | Non |
| Configurable | Non |

Syntaxe
-------


```js
regExpObj.lastIndex;
```

Description
-----------

Cette propriété n'est définie que si l'instance d'expression rationnelle utilise le marqueur (*flag*) `"g"` pour effectuer une recherche globale ou le marqueur `"y"` afin d'effectuer une recherche adhérente. Les règles suivantes s'appliquent :

* Si `lastIndex` est supérieur à la longueur de la chaîne de caractères, `regexp.test` et `regexp.exec` échoueront et `lastIndex` sera redéfini à 0.
* Si `lastIndex` est égal à la longueur de la chaîne de caractères et si l'expression rationnelle correspond avec la chaîne vide, il y aura une correspondance à partir de `lastIndex`.
* Si `lastIndex` est égal à la longueur de la chaîne de caractères et que l'expression rationnelle ne peut correspondre à la chaîne vide, on n'aura pas de correspondance et `lastIndex` sera réinitialisé à 0.
* Sinon, `lastIndex` sera défini à la position suivant la correspondance la plus récente.
Exemples
--------

Si on a la séquence d'instructions suivante :


```js
var re = /(hi)?/g;
```


Correspond à la chaîne vide.


```js
console.log(re.exec("hi"));
console.log(re.lastIndex);
```


Renvoie `["hi", "hi"]` avec `lastIndex` égal à 2.


```js
console.log(re.exec("hi"));
console.log(re.lastIndex);
```


Renvoie `["", undefined]`, un tableau dont le premier élément est la chaîne vide car `lastIndex` valait 2 (et vaut toujours 2) et `"hi"` était de longueur 2.

Spécifications
--------------

| Specification |
| --- |
| ECMAScript Language Specification # sec-properties-of-regexp-instances |

Compatibilité des navigateurs
-----------------------------

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

Voir aussi
----------

* `RegExp.prototype.ignoreCase`
* `RegExp.prototype.global`
* `RegExp.prototype.multiline`
* `RegExp.prototype.source`
* `RegExp.prototype.sticky`
RegExp.prototype[@@split]()
===========================

La méthode **`[@@split]()`** permet de découper une chaîne de caractères (`String`) en un tableau de sous-chaînes.

Exemple interactif
------------------

Syntaxe
-------


```js
regexp[Symbol.split](str[, limite])
```

### Paramètres

`str`

La chaîne de caractères qu'on souhaite découper.

`limite`

Paramètre optionnel. Un entier indiquant le nombre maximal de sous-chaînes à trouver. La méthode `[@@split]()` découpe la chaîne pour chaque correspondance de l'expression rationnelle `this` jusqu'à ce que le nombre d'éléments obtenus atteigne cette limite ou que la chaîne n'ait plus de correspondances.

### Valeur de retour

Un tableau (`Array`) dont les éléments sont les sous-chaînes de caractères issues de la découpe.

Description
-----------

Cette méthode est appelée de façon interne par la méthode `String.prototype.split()` lorsque l'argument `str` est un objet `RegExp`. Ainsi, les deux exemples qui suivent sont équivalents et le second est la version interne du premier :


```js
"a-b-c".split(/-/);

/-/[Symbol.split]("a-b-c");
```


Cette méthode existe afin de pouvoir adapter le fonctionnement de la découpe pour les sous-classes de `RegExp`.

Si le séparateur n'est pas un objet `RegExp`, la méthode `String.prototype.split()` n'appellera pas cette méthode et ne créera pas d'objet `RegExp`.

Exemples
--------

### Appel direct

Cette méthode peut être utilisée comme `String.prototype.split()`, l'objet `this` est différent et l'ordre des arguments également.


```js
var re = /-/g;
var str = "2016-01-02";
var résultat = re[Symbol.split](str);
console.log(résultat); // ["2016", "01", "02"]
```

### Utiliser `@@split` avec une sous-classe

Les sous-classes de `RegExp` peuvent surcharger `[@@split]()` afin de modifier le comportement de la découpe :


```js
class MaRegExp extends RegExp {
  [Symbol.split](str, limit) {
    var résultat = RegExp.prototype[Symbol.split].call(this, str, limit);
    return résultat.map((x) => "(" + x + ")");
  }
}

var re = new MaRegExp("-");
var str = "2016-01-02";
var résultat = str.split(re); // String.prototype.split appelle re[@@split].
console.log(résultat); // ["(2016)", "(01)", "(02)"]
```

Spécifications
--------------

| Specification |
| --- |
| ECMAScript Language Specification # sec-regexp.prototype-@@split |

Compatibilité des navigateurs
-----------------------------

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

Voir aussi
----------

* `String.prototype.split()`
* `RegExp.prototype[@@match]()`
* `RegExp.prototype[@@replace]()`
* `RegExp.prototype[@@search]()`
* `RegExp.prototype.exec()`
* `RegExp.prototype.test()`
RegExp.prototype[@@search]()
============================

La méthode **`[@@search]()`** recherche une correspondance entre une expression rationnelle décrite par `this` et une chaîne de caractères donnée.

Exemple interactif
------------------

Syntaxe
-------


```js
regexp[Symbol.search](str);
```

### Paramètres

`str`

Une chaîne de caractères (`String`) sur laquelle on veut rechercher une correspondance.

### Valeur de retour

`entier`

Si la recherche réussit, `[@@search]()` renvoie la position de la première correspondance de l'expression rationnelle au sein de la chaîne, sinon elle renvoie `-1`.

Description
-----------

Cette méthode est appelée en interne lors de l'utilisation de `String.prototype.search()`. Ainsi, les deux exemples qui suivent sont équivalents et le second est la version interne du premier :


```js
"abc".search(/a/);

/a/[Symbol.search]("abc");
```


Cette méthode existe afin de pouvoir adapter le comportement de la recherche pour les sous-classes de `RegExp`.

Exemples
--------

### Appel direct

Cette méthode peut être utilisée comme `String.prototype.search()`, elle utilise simplement un objet `this` différent et un ordre de paramètres différent :


```js
var re = /-/g;
var str = "2016-01-02";
var résultat = re[Symbol.search](str);
console.log(résultat); // 4
```

### Utiliser `@@search` avec une sous-classe

Les sous-classes de `RegExp` peuvent surcharger `[@@search]()` afin de modifier le comportement obtenu :


```js
class MaRegExp extends RegExp {
  constructor(str) {
    super(str);
    this.pattern = str;
  }
  [Symbol.search](str) {
    return str.indexOf(this.pattern);
  }
}

var re = new MaRegExp("a+b");
var str = "ab a+b";
var résultat = str.search(re); // String.prototype.search appelle re[@@search].
console.log(résultat); // 3
```

Spécifications
--------------

| Specification |
| --- |
| ECMAScript Language Specification # sec-regexp.prototype-@@search |

Compatibilité des navigateurs
-----------------------------

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

Voir aussi
----------

* `String.prototype.search()`
* `RegExp.prototype[@@match]()`
* `RegExp.prototype[@@replace]()`
* `RegExp.prototype[@@split]()`
* `RegExp.prototype.exec()`
* `RegExp.prototype.test()`
RegExp.prototype.toString()
===========================

La méthode **`toString()`** renvoie une chaîne de caractères représentant l'expression rationnelle.

Exemple interactif
------------------

Syntaxe
-------


```js
regexObj.toString();
```

### Valeur de retour

Une chaîne de caractères représentant l'expression rationnelle appelante.

Description
-----------

L'objet `RegExp` surcharge la méthode `toString` de l'objet `Object`. Il n'hérite donc pas de `Object.prototype.toString()`. Pour les objets `RegExp`, la méthode `toString()` renvoie une représentation de l'expression rationnelle sous la forme d'une chaîne de caractères.

Exemples
--------

### Utiliser `toString()`

L'exemple qui suit affiche la chaîne correspondant à la valeur de l'objet `RegExp` :


```js
var maRegExp = new RegExp("a+b+c");
console.log(maRegExp.toString()); // affiche "/a+b+c/"

var toto = new RegExp("truc", "g");
console.log(toto.toString()); // affiche "/truc/g"
```

### Les expressions ratonnelles vides et l'échappement

À partir d'ECMAScript 5, la méthode renvoie la chaîne `"(?:)"` pour les expressions vides. De plus, les fins de lignes (telles que "\n") sont désormais échappées.


```js
new RegExp().toString(); // "(?:)"

new RegExp("\n").toString() === "/\n/"; // true avant ES5
new RegExp("\n").toString() === "/\\n/"; // true à partir d'ES5
```

Spécifications
--------------

| Specification |
| --- |
| ECMAScript Language Specification # sec-regexp.prototype.tostring |

Compatibilité des navigateurs
-----------------------------

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

Voir aussi
----------

* `Object.prototype.toString()`
RegExp.prototype.multiline
==========================

La propriété **`multiline`** indique si le drapeau (*flag*) "`m`" a été utilisé ou non pour l'expression rationnelle. `multiline` est une propriété liée à l'instance, accessible en lecture seule.

Exemple interactif
------------------

| Attributs de `RegExp.prototype.multiline` |
| --- |
| Écrivable | Non |
| Énumérable | Non |
| Configurable | Oui |

Description
-----------

La valeur de `multiline` est un booléen. Elle vaut `true` si le drapeau "`m`" a été utilisé et `false` sinon. Le flag "`m`" indique qu'une chaine de caractères qui s'étend sur plusieurs lignes doit être traitée comme une série de ligne. Ainsi, si "`m`" est utilisé, "`^`" et "`$`" ne correspondent plus au début et à la fin de la chaîne mais aux débuts et aux fins de chaque ligne de la chaîne.

Cette propriété ne peut pas être modifiée directement.

Exemples
--------


```js
var regex = new RegExp("toto", "m");

console.log(regex.multiline); // true
```

Spécifications
--------------

| Specification |
| --- |
| ECMAScript Language Specification # sec-get-regexp.prototype.multiline |

Compatibilité des navigateurs
-----------------------------

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

Voir aussi
----------

* `RegExp.prototype.global`
* `RegExp.prototype.lastIndex`
* `RegExp.prototype.ignoreCase`
* `RegExp.prototype.source`
* `RegExp.prototype.sticky`
RegExp.prototype.dotAll
=======================

La propriété **`dotAll`** indique si le marqueur "`s`" est utilisé pour l'expression rationnelle. `dotAll` est une propriété en lecture seule et qui renseigne à propos de l'expression rationnelle courante.

| Attributs de `RegExp.prototype.dotAll` |
| --- |
| Écrivable | Non |
| Énumérable | Non |
| Configurable | Oui |

Description
-----------

`dotAll` est un booléen qui vaut `true` si le marqueur "`s`" a été utilisé pour l'expression et `false` sinon. Le marqueur "`s`" indique que le caractère spécial point ("`.`") doit également correspondre aux caractères de saut de ligne (et pour lesquels il ne correspondrait pas s'il n'était pas activé) :

* U+000A LINE FEED (LF) ("`\n`")
* U+000D CARRIAGE RETURN (CR) ("`\r`")
* U+2028 LINE SEPARATOR
* U+2029 PARAGRAPH SEPARATOR

Cela signifie ainsi que le point peut correspondre à n'importe quel caractère du plan multilingue de base Unicode (ou *Basic Multilingual Plane* (BMP)). Si on souhaite également cibler les caractères des plans astraux, il faudra utiliser le marqueur "`u`" (unicode). En utilisant les deux marqueurs simultanément, on peut alors cibler n'importe quel caractère Unicode.

Cette propriété est uniquement accessible en lecture et ne peut pas être modifiée.

Compatibilité des navigateurs
-----------------------------

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

Voir aussi
----------

* `RegExp.lastIndex`
* `RegExp.prototype.global`
* `RegExp.prototype.ignoreCase`
* `RegExp.prototype.multiline`
* `RegExp.prototype.source`
* `RegExp.prototype.sticky`
* `RegExp.prototype.unicode`
RegExp.prototype.compile()
==========================

**Obsolète:** Cette fonctionnalité a été supprimée des standards du Web. Bien que quelques navigateurs puissent encore la supporter, elle est en cours d'éradication. Ne l'utilisez ni dans d'anciens projets, ni dans de nouveaux. Les pages et applications Web l'utilisant peuvent cesser de fonctionner à tout moment.

La méthode dépréciée **`compile()`** est utilisée afin de (re)compiler une expression rationnelle lors de l'exécution d'un script. Cette méthode effectue essentiellement les mêmes actions que le constructeur `RegExp`.

Syntaxe
-------


```js
regexObj.compile(motif, flags);
```

### Paramètres

`motif`

Le texte de l'expression rationnelle.

`flags`

S'ils sont utilisés, les drapeaux (*flags*) peuvent être combinés avec les valeurs suivantes :

`g`

correspondance globale

`i`

ignorer la casse

`m`

multiligne : on traite les caractères de début et de fin (^ et $) de façon à travailler sur plusieurs lignes (ils correspondent au début et à la fin de chaque ligne et non au début ou à la fin de la chaîne entière)

`y`

adhérence : ne recherche les correspondances qu'à partir de l'indice fourni par la propriété `lastIndex` de l'expression rationnelle dans la chaîne cible (la recherche n'est pas effectuée pour les indices suivants).


Description
-----------

La méthode `compile` est dépréciée. Pour obtenir le même effet, on utilisera le constructeur `RegExp`.

Exemples
--------

Dans l'exemple qui suit, on voit comment réinitialiser le motif et les drapeaux d'une expression rationnelle grâce à la méthode `compile()`.


```js
var regexObj = new RegExp("toto", "gi");
regexObj.compile("nouveau toto", "g");
```

Spécifications
--------------

| Specification |
| --- |
| ECMAScript Language Specification # sec-regexp.prototype.compile |

Compatibilité des navigateurs
-----------------------------

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

Voir aussi
----------

* `RegExp`
RegExp.lastMatch ($&)
=====================

**Non standard:** Cette fonctionnalité n'est ni standard, ni en voie de standardisation. Ne l'utilisez pas pour des sites accessibles sur le Web : elle ne fonctionnera pas pour tout utilisateur. Il peut également y avoir d'importantes incompatibilités entre les implémentations et son comportement peut être modifié dans le futur.

La propriété non-standard **`lastMatch`** est une propriété statique en lecture seule pour les expressions rationnelles qui contient les caractères de la dernière correspondance. `RegExp.$&` est un alias pour cette propriété.

Syntaxe
-------


```js
RegExp.lastMatch;
RegExp["$&"];
```

Description
-----------

La propriété `lastMatch` est une propriété statique, ce n'est pas une propriété pour chaque objet qui représente une expression rationnelle. Cette propriété doit donc toujours être utilisée avec la syntaxe `RegExp.lastMatch` ou `RegExp['$&'].`

La valeur de la propriété `lastMatch` n'est accessible qu'en lecture seule et est modifiée à chaque fois qu'une correspondance est trouvée.

Il n'est pas possible d'utiliser l'alias avec la notation utilisant le point pour accéder à la propriété (`RegExp.$&`) car le parseur attend une expression avec "&" dans ce cas, ce qui provoque une exception `SyntaxError`. Pour utiliser l'alias, on prendra donc la notation utilisant les crochets.

Exemples
--------

### Utiliser `lastMatch` et `$&`


```js
var re = /coucou/g;
re.test("coucou toi!");
RegExp.lastMatch; // "coucou"
RegExp["$&"]; // "coucou"
```

Spécifications
--------------

Cette propriété n'est pas standard. Elle ne fait partie d'aucune spécification.

Compatibilité des navigateurs
-----------------------------

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

Voir aussi
----------

* Non-standard
 `RegExp.input ($_)`
* Non-standard
 `RegExp.lastParen ($+)`
* Non-standard
 `RegExp.leftContext ($`)`
* Non-standard
 `RegExp.rightContext ($')`
* Non-standard
 `RegExp.$1-$9`
WeakMap.prototype.get()
=======================

La méthode **`get()`** permet de renvoyer un élément donné d'un objet `WeakMap`.

Exemple interactif
------------------

Syntaxe
-------


```js
wm.get(clé);
```

### Paramètre

`clé`

Ce paramètre est obligatoire. Il correspond à la clé de l'élément qu'on souhaite récupérer depuis l'objet `WeakMap`.

### Valeur de retour

L'élément associé à la clé donnée ou `undefined` si la clé ne peut pas être trouvée dans l'objet `WeakMap`.

Exemples
--------


```js
var wm = new WeakMap();
wm.set(window, "toto");

wm.get(window); // Renvoie "toto"
wm.get("machin"); // Renvoie undefined.
```

Spécifications
--------------

| Specification |
| --- |
| ECMAScript Language Specification # sec-weakmap.prototype.get |

Compatibilité des navigateurs
-----------------------------

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

Voir aussi
----------

* `WeakMap`
* `WeakMap.set()`
* `WeakMap.has()`
WeakMap.prototype.has()
=======================

La méthode **`has()`** renvoie un booléen qui indique s'il existe (ou non) un élément avec une clé donnée au sein de l'objet `WeakMap`.

Exemple interactif
------------------

Syntaxe
-------


```js
wm.has(clé);
```

### Paramètre

`clé`

Ce paramètre est obligatoire. Il correspond à la clé de l'élément dont on souhaite savoir s'il est présent dans l'objet `WeakMap`.

### Valeur de retour

La méthode renvoie `true` s'il existe un élément du `WeakMap` avec la clé donné, `false` sinon.

Exemples
--------


```js
var wm = new WeakMap();
wm.set(window, "toto");

wm.has(window); // renvoie true
wm.has("machin"); // renvoie false
```

Spécifications
--------------

| Specification |
| --- |
| ECMAScript Language Specification # sec-weakmap.prototype.has |

Compatibilité des navigateurs
-----------------------------

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

Voir aussi
----------

* `WeakMap`
* `WeakMap.prototype.set()`
* `WeakMap.prototype.get()`
Constructeur WeakMap()
======================

Le **constructeur `WeakMap()`** permet de créer un nouvel objet `WeakMap` éventuellement basé sur un autre objet itérable fourni en argument (par exemple, un tableau).

Syntaxe
-------


```js
new WeakMap();
new WeakMap(iterable);
```

### Paramètres

`iterable`

Un tableau (`Array`) ou tout autre objet itérable qui implémente une méthode `@@iterator` renvoyant un objet itérateur qui produit des objets semblables à des tableaux avec deux éléments, le premier qui sera utilisé comme clé de la `WeakMap` et le second comme valeur associée à cette clé. Chaque paire de clé/valeur sera ainsi ajoutée au nouveau `WeakMap`. `null` est traité comme `undefined`.

Exemples
--------

### Utiliser `WeakMap()`


```js
const wm1 = new WeakMap();
const wm2 = new WeakMap();
const wm3 = new WeakMap();

const o1 = {};
const o2 = function () {};
const o3 = window;

wm1.set(o1, 37);
wm1.set(o2, "azerty");
wm2.set(o1, o2); // une valeur peut être de n'importe quel type (objet ou fonction)
wm2.set(o3, undefined);
wm2.set(wm1, wm2); // les clés et les valeurs peuvent être des objets, même des WeakMaps

wm1.get(o2); // "azerty"
wm2.get(o2); // undefined, car il n'y a pas de clé pour o2 sur wm2
wm2.get(o3); // undefined, car c'est la valeur associée

wm1.has(o2); // true
wm2.has(o2); // false
wm2.has(o3); // true (même si la valeur associée est 'undefined')

wm3.set(o1, 37);
wm3.get(o1); // 37

wm1.has(o1); // true
wm1.delete(o1);
wm1.has(o1); // false
```

Spécifications
--------------

| Specification |
| --- |
| ECMAScript Language Specification # sec-weakmap-constructor |

Compatibilité des navigateurs
-----------------------------

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

Voir aussi
----------

* Une prothèse d'implémentation pour `WeakMap` avec la bibliothèque `core-js`
* Les objets `WeakMap` dans le guide JavaScript
* Masquer des détails d'implémentation avec les `WeakMap` ECMAScript 6 (billet de blog en anglais)
* `Map`
* `Set`
* `WeakSet`
WeakMap.prototype.delete()
==========================

La méthode **`delete()`** retire un élément donné de l'objet `WeakMap`.

Exemple interactif
------------------

Syntaxe
-------


```js
wm.delete(clé);
```

### Paramètre

`clé`

Il correspond à la clé de l'élément qu'on souhaite retirer de l'objet `WeakMap`.

### Valeur de retour

`true` si un élément de l'objet `WeakMap` a bien été retiré, `false` si la clé n'a pas été trouvée ou si la clé n'est pas un objet.

Exemples
--------


```js
var wm = new WeakMap();
wm.set(window, "toto");

wm.delete(window); // Renvoie true. La suppression a bien eu lieu.

wm.has(window); // Renvoie false. L'objet window n'est plus dans la WeakMap.
```

Spécifications
--------------

| Specification |
| --- |
| ECMAScript Language Specification # sec-weakmap.prototype.delete |

Compatibilité des navigateurs
-----------------------------

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

Voir aussi
----------

* `WeakMap`
WeakMap.prototype.set()
=======================

s

La méthode **`set()`** permet d'ajouter un nouvel élément avec une `clé` et une `valeur` à un objet `WeakMap`.

Exemple interactif
------------------

Syntaxe
-------


```js
wm.set(clé, valeur);
```

### Paramètres

`clé`

Ce paramètre est obligatoire et doit être un objet. Il correspond à la clé de l'élément qu'on souhaite ajouter à l'objet `WeakMap`.

`valeur`

Ce paramètre est obligatoire et peut avoir n'importe quel type. Il correspond à la valeur de l'élément qu'on souhaite ajouter à l'objet `WeakMap`.

### Valeur de retour

Cette méthode renvoie l'objet `WeakMap` potentiellement mis à jour.

Exemples
--------


```js
var wm = new WeakMap();
var obj = {};

// Ajouter un nouvel élément à la WeakMap
wm.set(obj, "toto").set(window, "truc"); // on peut chaîner les instructions

// Mettre à jour un élément de la WeakMap
wm.set(obj, "machin");
```

Spécifications
--------------

| Specification |
| --- |
| ECMAScript Language Specification # sec-weakmap.prototype.set |

Compatibilité des navigateurs
-----------------------------

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

Voir aussi
----------

* `WeakMap`
* `WeakMap.prototype.get()`
* `WeakMap.prototype.has()`