recursal/MDN huggingface dataset:
String.prototype.matchAll()
===========================

La méthode **`matchAll()`** renvoie un itérateur contenant l'ensemble des correspondances entre une chaîne de caractères d'une part et une expression rationnelle d'autre part (y compris les groupes capturants).

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

Syntaxe
-------


```js
str.matchAll(regexp);
```

### Paramètres

`regexp`

Un objet représentant une expression rationnelle. Si cet objet n'est pas une instance de `RegExp`, il est automatiquement et implicitement converti en une telle instance à l'aide de `new RegExp(obj)`.

### Valeur de retour

Un itérateur.

Exemples
--------

### `Regexp.exec()` et `matchAll()`

Avant l'apparition de `matchAll()` en JavaScript, il était possible d'utiliser `RegExp.exec` (et des expressions rationnelles utilisant le marqueur `/g`) dans une boucle afin d'obtenir l'ensemble des correspondances :


```js
const regexp = RegExp("foo\*", "g");
const str = "table football, foosball";

while ((matches = regexp.exec(str)) !== null) {
  console.log(
    `${matches[0]} trouvé. Prochaine recherche à partir de ${regexp.lastIndex}.`,
  );
  // dans la console : "foo trouvé. Prochaine recherche à partir de 9."
  // dans la console : "foo trouvé. Prochaine recherche à partir de 19."
}
```


Avec `matchAll()`, on peut éviter la boucle `while` et le marqueur global. On récupère l'itérateur et on utilise une boucle `for...of`, la décomposition de tableau ou encore `Array.from()` :


```js
const regexp = RegExp("foo\*", "g");
const str = "table football, foosball";
let matches = str.matchAll(regexp);

for (const match of matches) {
  console.log(match);
}
// Array [ "foo" ]
// Array [ "foo" ]

// l'itérateur est épuise après l'itération via for..of
// On rappelle matchAll afin de créer un nouvel itérateur
matches = str.matchAll(regexp);

Array.from(matches, (m) => m[0]);
// Array [ "foo", "foo" ]
```

### Meilleur accès aux groupes capturants

Un autre avantage de `matchAll()` est un meilleur accès aux groupes capturants. De fait, les groupes capturants sont ignorés par `match()` lorsqu'on utilise le marqueur global `/g` :


```js
var regexp = /t(e)(st(\d?))/g;
var str = "test1test2";

str.match(regexp);
// Array ['test1', 'test2']
```


Avec `matchAll()`, on peut y accéder :


```js
let array = [...str.matchAll(regexp)];

array[0];
// ['test1', 'e', 'st1', '1', index: 0, input: 'test1test2', length: 4]
array[1];
// ['test2', 'e', 'st2', '2', index: 5, input: 'test1test2', length: 4]
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-string.prototype.matchall |

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

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

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

* `RegExp`
* `RegExp.prototype.exec()`
* `RegExp.prototype.test()`
String.prototype.endsWith()
===========================

La méthode **`endsWith()`** renvoie un booléen indiquant si la chaine de caractères se termine par la chaine de caractères fournie en argument.

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

Syntaxe
-------


```js
str.endsWith(chaîneRecherchée[, position]);
```

### Paramètres

`chaîneRecherchée`

Les caractères à rechercher à la fin de la chaine de caractères.

`position` Facultatif

Paramètre optionnel. Permet de rechercher dans la chaine de caractères comme si elle faisait cette longueur ; par défaut il s'agit de la longueur de la chaine de caractères `chaîneRecherchée`. Si la valeur fournie est supérieure à la longueur de la chaine de caractères, elle ne sera pas prise en compte.

### Valeur de retour

`true` si la chaîne de caractères se termine par la sous-chaîne indiquée, `false` sinon.

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

Cette méthode permet de savoir si une chaine de caractères se termine avec une certaine chaine de caractères (comme les autres méthodes fonctionnant avec des chaînes de caractères, cette méthode est sensible à la casse).

Exemples
--------


```js
var str = "Être, ou ne pas être : telle est la question.";

console.log(str.endsWith("question.")); // true
console.log(str.endsWith("pas être")); // false
console.log(str.endsWith("pas être", 20)); // true
```

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

Cette méthode a été ajoutée dans la spécification ECMAScript 6 et peut ne pas être disponible dans toutes les implémentations de JavaScript. Cependant, il est possible d'émuler le comportement de `String.prototype.endsWith` avec le fragment de code suivant :


```js
if (!String.prototype.endsWith) {
  String.prototype.endsWith = function (searchString, position) {
    var subjectString = this.toString();
    if (
      typeof position !== "number" ||
      !isFinite(position) ||
      Math.floor(position) !== position ||
      position > subjectString.length
    ) {
      position = subjectString.length;
    }
    position -= searchString.length;
    var lastIndex = subjectString.lastIndexOf(searchString, position);
    return lastIndex !== -1 && lastIndex === position;
  };
}
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-string.prototype.endswith |

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

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

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

* `String.prototype.startsWith()`
* `String.prototype.includes()`
* `String.prototype.indexOf()`
* `String.prototype.lastIndexOf()`
String.prototype.link()
=======================

La méthode **`link()`** permet de créer une chaîne de caractères représentant un élément HTML `<a>`, ce qui permet d'afficher la chaîne de caractères comme un lien hypertexte vers une URL donnée.

Syntaxe
-------


```js
str.link(url);
```

### Paramètres

`url`

Toute chaîne de caractères pouvant être utilisée comme valeur pour l'attribut `href` de la balise `a`. Cette chaîne doit être une URL valide (relative ou absolue) dont les caractères `&` sont échappés en `&amp;`, et dont les doubles quotes (`"`) doivent être échappées avec l'entité `&quot;`.

### Valeur de retour

Une chaîne de caractères représentant un élément HTML `<a>`.

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

La méthode `link` permet de créer un fragment HTML avec un lien hypertexte. Le chaîne renvoyée par la méthode peut ensuite être ajoutée au document grâce aux méthodes `document.write()` ou `element.innerHTML`.

Les liens créés avec la méthode `link` deviennent des éléments du tableau `links`, membre de l'objet `document`. Voir `document.links` (en-US).

Exemples
--------

L'exemple qui suit affiche le texte "MDN" avec un hyperlien qui envoie l'utilisateur vers le site du Mozilla Developer Network.


```js
var texteAffiché = "MDN";
var URL = "https://developer.mozilla.org/";

console.log("Cliquer ici pour revenir sur " + texteAffiché.link(URL));
// Cliquer ici pour revenir sur <a href="https://developer.mozilla.org/">MDN</a>
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-string.prototype.link |

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

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

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

* `String.prototype.anchor()`
SharedArrayBuffer.prototype.slice()
===================================

La méthode **`SharedArrayBuffer.prototype.slice()`** renvoie un nouvel objet `SharedArrayBuffer` dont le contenu est une copie des octets de l'objet `SharedArrayBuffer` courant entre un indice de début (inclus) et un indice de fin (exclus) (autrement dit, on copie une « tranche » du tampon courant). Si l'indice de début ou de fin est négatif, la position sera comptée à partir de la fin du tableau plutôt qu'à partir du début. L'algorithme appliqué est le même que `Array.prototype.slice()`*.*

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

Syntaxe
-------


```js
sab.slice();
sab.slice(début);
sab.slice(début, fin);
```

### Paramètres

`début` Facultatif

L'indice auquel commencer l'extraction (le début du tableau se situe à l'indice 0).

Si la valeur est négative, `début` indique le décalage à partir de la fin du tableau. Ainsi `slice(-2)` permettra d'extraire les deux derniers éléments du tableau.

Si `début` est absent, `slice` commencera l'extraction à partir de l'indice 0.

`fin` Facultatif

L'indice auquel finir l'extraction. Attention, la valeur du tableau pour cet indice n'est pas incluse dans l'extraction.

Ainsi, `slice(1,4)` permettra d'extraire entre le deuxième et le quatrième élément (c'est-à-dire les trois éléments dont les indices sont respectivement 1, 2 et 3).

Si `fin` est un indice négatif, il indique le décalage à partir de la fin du tableau. Autrement dit `slice(2,-1)` permettra d'extraire les éléments du tampon à partir du troisième élément et jusqu'à l'avant-avant-dernier élément.

Si `fin` est absent, `slice` réalisera l'extraction jusqu'à la fin de la séquence (`sab.byteLength`).

### Valeur de retour

Un nouvel objet `SharedArrayBuffer` qui contient les éléments extraits.

Exemples
--------


```js
var sab = new SharedArrayBuffer(1024);
sab.slice(); // SharedArrayBuffer { byteLength: 1024 }
sab.slice(2); // SharedArrayBuffer { byteLength: 1022 }
sab.slice(-2); // SharedArrayBuffer { byteLength: 2 }
sab.slice(0, 1); // SharedArrayBuffer { byteLength: 1 }
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-sharedarraybuffer.prototype.slice |

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

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

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

* `SharedArrayBuffer`
* `Array.prototype.slice()`
SharedArrayBuffer.prototype.byteLength
======================================

La propriété d'accesseur **`byteLength`** représente la longueur d'un `SharedArrayBuffer` exprimée en octets.

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

Syntaxe
-------


```js
sab.byteLength;
```

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

La propriété `byteLength` est une propriété d'accesseur dont le mutateur associé vaut `undefined`. Autrement dit, cette propriété est en lecture seule. La valeur est établie lorsque le tableau partagé est construit et elle ne peut être modifiée par la suite.

Exemples
--------


```js
var sab = new SharedArrayBuffer(1024);
sab.byteLength; // 1024
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-get-sharedarraybuffer.prototype.bytelength |

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

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

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

* `SharedArrayBuffer`
Constructeur SharedArrayBuffer()
================================

**Note :** `SharedArrayBuffer` a été désactivé par défaut pour l'ensemble des navigateurs principaux le 5 janvier 2018 en réponse à la faille Spectre. Chrome a réactivé cette fonctionnalité à partir de la version 67 sur les plateformes où la fonctionnalité d'isolation des sites est activée et protège des vulnérabilités analogues à Spectre.

Le **constructeur `SharedArrayBuffer()`** permet de créer un objet `SharedArrayBuffer` qui représente un tampon de mémoire binaire brute de taille fixe, similaire à un objet `ArrayBuffer`.

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

Syntaxe
-------


```js
new SharedArrayBuffer();
new SharedArrayBuffer(longueur);
```

### Paramètres

`longueur` Facultatif

La longueur, exprimée en octets, du tampon de mémoire à créer.

### Valeur de retour

Un nouvel objet `SharedArrayBuffer` de la taille indiquée et dont les éléments du tableau sont initialisés à `0`.

Exemples
--------

### L'opérateur `new` est obligatoire

Le constructeur `SharedArrayBuffer()` doit être appelé avec l'opérateur `new`. Appeler le constructeur `SharedArrayBuffer()` comme une fonction, c'est-à-dire sans utiliser `new`, déclenchera une exception `TypeError`.


```js
const sab = SharedArrayBuffer(1024);
// TypeError: calling a builtin SharedArrayBuffer constructor
// without new is forbidden
```



```js
const sab = new SharedArrayBuffer(1024);
```

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

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

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

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

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

* `Atomics`
* `ArrayBuffer`
* Les tableaux typés en JavaScript
Function.length
===============

La propriété **`length`** définit le nombre de paramètres attendus par la fonction.

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

| Attributs de `Function.length` |
| --- |
| Écrivable | Non |
| Énumérable | Non |
| Configurable | Oui |

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

`length` est une propriété des fonctions qui indique le nombre d'arguments attendus par la fonction (ce qui correspond au nombre d'arguments formellement déclarés). Cette quantité n'inclue pas les paramètres du reste et ne compte que les paramètres situés avant le premier paramètre avec une valeur par défaut. Cette propriété est différente de `arguments.length` qui est locale à la fonction et qui décrit le nombre d'arguments réellement passés à la fonction.

### Propriété du constructeur `Function`

Le constructeur `Function` est lui-même un objet `Function`. Sa propriété `length` vaut 1. Les attributs de cette propriété sont : Écrivable : `false`, Énumérable : `false`, Configurable : `true`.

### Propriété du prototype de `Function`

La propriété `length` du prototype de `Function` vaut 0.

Exemples
--------


```js
console.log(Function.length); /\* 1 \*/

console.log(function () {}.length); /\* 0 \*/
console.log(function (a) {}.length); /\* 1 \*/
console.log(function (a, b) {}.length); /\* 2 etc. \*/
console.log(function (...args) {}.length);
// 0, le paramètre du reste n'est pas compté
console.log(function (a, b = 1, c) {}.length);
// 1, seuls les paramètres avant les valeurs par
// défaut sont comptés
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-function-instances-length |

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

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

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

* `Function`
Function.caller
===============

**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é **`function.caller`** renvoie la fonction qui a appelé la fonction donnée. Cette propriété est interdite en mode strict.

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

Si la fonction `f` a été invoquée par du code situé au plus haut niveau, la valeur de `f.caller` sera `null`, sinon, ce sera la fonction qui a appelé `f`.

Cette propriété remplace la propriété obsolète `arguments.caller` de l'objet `arguments`.

La propriété spéciale `__caller__` qui renvoyait l'objet qui dans lequel était fait l'appel a été supprimée pour des raisons de sécurités.

### Notes

Dans une fonction récursive, cette propriété ne peut pas être utilisée pour reconstituer la pile d'appels (*call stack*). Par exemple, si on a :


```js
function f(n) {
  g(n - 1);
}
function g(n) {
  if (n > 0) {
    f(n);
  } else {
    stop();
  }
}
f(2);
```


Au moment où `stop()` est appelé, la pile sera :


```js
f(2) -> g(1) -> f(1) -> g(0) -> stop()
```


Et ceci est vrai :


```js
stop.caller === g && f.caller === g && g.caller === f;
```


Donc si on essaie d'obtenir la pile de cette façon :


```js
var f = stop;
var stack = "Stack trace:";
while (f) {
  stack += "\n" + f.name;
  f = f.caller;
}
```


la boucle ne s'arrêterait jamais.

Exemples
--------

### Vérifier la valeur de la propriété `caller`

Dans l'exemple suivant, on verifie la propriété `caller` de la fonction.


```js
function maFonction() {
  if (maFonction.caller == null) {
    return "Fonction appelée au plus haut niveau !";
  } else {
    return "Fonction appelée par " + maFonction.caller;
  }
}
```

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

Ne fait partie d'aucune spécification. Implémentée avec JavaScript 1.5.

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

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

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

* Le bug d'implémentation pour SpiderMonkey bug Firefox 65683
Function.prototype.toString()
=============================

La méthode **`toString()`** renvoie une chaîne de caractères représentant le code source de la fonction.

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

Syntaxe
-------


```js
function.toString(indentation)
```

### Valeur de retour

Une chaîne de caractères qui représente le code source de la fonction.

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

L'objet `Function` redéfinit la méthode `toString` de l'objet `Object` ; il n'hérite donc pas de `Object.prototype.toString`. Pour les objets `Function`, la méthode `toString` renvoie une chaîne de caractères représentant l'objet sous la forme d'une déclaration de fonction. Pour ce faire, `toString` décompile la fonction pour renvoyer une chaîne qui contient le mot-clé `function`, la liste des arguments, les accolades et la source correspondant au corps de la fonction.

Le moteur JavaScript appelle la méthode `toString` automatiquement lorsqu'un objet `Function` doit être représenté textuellement (par exemple lorsqu'une fonction doit être concaténée avec une chaîne de caractères).

La méthode `toString()` lèvera une exception `TypeError` (« Function.prototype.toString called on incompatible object ») si la valeur this n'est pas un objet `Function`.


```js
Function.prototype.toString.call("toto"); // TypeError
```


Si la méthode `toString()` est appelée sur des fonctions natives qui ne sont pas définies dans le script, `toString()` renvoie une chaîne de caractères indiquant le caractère natif :


```js
Math.abs.toString();

"function abs() {
    [native code]
}"
```


Si la méthode `toString()` est appelée sur une fonction créée avec le constructeur `Function`, `toString()` renverra le code source d'une fonction intitulée `anonymous` et utilisera les paramètres et le corps de la fonction fournis.

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-function.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()`
Function.arguments
==================

**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 propriété **`function.arguments`** fait référence à un objet dont la structure est semblable à celle d'un tableau dont les éléments correspondent aux arguments passés à une fonction. En lieu et place, il faut désormais utiliser `arguments`. Cette propriété est interdite en mode stricte à cause de l'optimisation de la queue des appels (*tail call optimization*).

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

La syntaxe `function.arguments` est obsolète. La méthode recommandée pour accéder à l'objet `arguments` disponible au sein des fonctions est simplement de faire référence à la variable `arguments`.

Si on utilise la récursivité (autrement dit si une fonction `f` apparaît plusieurs fois dans la pile d'appels ou encore qu'une fonction `f` s'appelle elle-même), la valeur de `f.arguments` représentera les arguments correspondant à l'appel le plus « récent » de la fonction.

La valeur de la propriété `arguments` est normalement `null` si la fonction n'est pas « en cours » (au sens où elle aurait été appelée et qu'elle n'ait pas fini son exécution).

Exemples
--------


```js
function f(n) {
  g(n - 1);
}

function g(n) {
  console.log("avant : " + g.arguments[0]);
  if (n > 0) f(n);
  console.log("après : " + g.arguments[0]);
}

f(2);

console.log("fonction terminée : " + g.arguments);

// On aura l'affichage de :

// avant : 1
// avant : 0
// après : 0
// après : 1
// fonction terminée : null
```

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

#### No specification found

No specification data found for `javascript.builtins.Function.arguments`.  
Check for problems with this page or contribute a missing `spec_url` to mdn/browser-compat-data. Also make sure the specification is included in w3c/browser-specs.

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

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

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

* L'objet `arguments`
* Les fonctions et les portées de fonctions
Function.displayName
====================

**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é **`function.displayName`** renvoie le nom affiché de la fonction.

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

Lorsque la propriété `displayName` est définie, elle renvoie le nom affiché de la fonction :


```js
function faireTruc() {}

console.log(faireTruc.displayName); // "undefined"

var logMessage = function (contenu) {
  console.log(contenu);
};

logMessage.displayName = "Afficher les messages dans le journal";

console.log(logMessage.displayName); // "Afficher les messages dans le journal"
```


Il est possible de définir une fonction avec un nom d'affichage grâce à une expression de fonctions:


```js
var objet = {
  uneMéthode: function () {},
};

objet.uneMéthode.displayName = "uneMéthode";

console.log(objet.uneMéthode.displayName);
// "uneMéthode"

try {
  uneMéthode;
} catch (e) {
  console.log(e);
}
// ReferenceError: uneMéthode is not defined
```


La propriété `displayName` peut être changée dynamiquement :


```js
var objet = {
  // anonyme
  uneMéthode: function (valeur) {
    this.displayName = "uneMéthode (" + valeur + ")";
  },
};

console.log(objet.uneMéthode.displayName); // "undefined"

objet.uneMéthode("123");
console.log(objet.uneMéthode.displayName); // "uneMéthode (123)"
```

Exemples
--------

On souhaite généralement utiliser cette propriété dans les consoles et profileurs plutôt que `func.name`

Le code suivant devrait afficher quelque chose comme "function Ma Fonction()":


```js
var a = function () {};
a.displayName = "Ma Fonction";

a;
```

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

N'appartient à aucune spécification.

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

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.
Constructeur FinalizationRegistry()
===================================

Le constructeur **`FinalizationRegistry`** crée un objet `FinalizationRegistry` qui utilise la fonction de rappel passée en argument comme fonction de nettoyage pour les objets du registre.

Syntaxe
-------


```js
// Fonction de rappel avec une fonction fléchée
new FinalizationRegistry(valeurTenue => { ... } )

// Référence à une fonction de rappel
new FinalizationRegistry(callbackFn)

// Fonction de rappel en ligne
new FinalizationRegistry(function(valeurTenue) { ... })
```

### Paramètres

`callback`

La fonction de rappel de nettoyage à utiliser par le registre.

Exemples
--------

### Créer un nouveau registre

On crée le registre en fournissant la fonction de rappel :


```js
const registre = new FinalizationRegistry((valeurTenue) => {
  // ....
});
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-finalization-registry-constructor |

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

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

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

* `FinalizationRegistry`