recursal/MDN huggingface dataset:
handler.getPrototypeOf()
========================

La méthode **`handler.getPrototypeOf()`** représente une trappe pour la méthode interne `[[GetPrototypeOf]]`.

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

Syntaxe
-------


```js
var p = new Proxy(obj, {
  getPrototypeOf(cible) {
  ...
  }
});
```

### Paramètres

Le paramètre suivant est passé à la méthode `getPrototypeOf`. `this` est lié au gestionnaire.

`cible`

L'objet cible.

### Valeur de retour

La méthode `getPrototypeOf` doit renvoyer un objet ou `null`.

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

### Interceptions

Cette trappe permet d'intercepter les opérations suivantes :

* `Object.getPrototypeOf()`
* `Reflect.getPrototypeOf()`
* `Object.prototype.__proto__`
* `Object.prototype.isPrototypeOf()`
* `instanceof`
### Invariants

Si les invariants suivant ne sont pas respectés, le proxy renverra une exception `TypeError` :

* `getPrototypeOf` doit renvoyer un objet ou `null`.
* Si la `cible` n'est pas extensible, `Object.getPrototypeOf(proxy)` doit renvoyer la même valeur que `Object.getPrototypeOf(cible)`.
Exemples
--------

### Utilisation simple


```js
var obj = {};
var proto = {};
var gestionnaire = {
  getPrototypeOf(cible) {
    console.log(cible === obj); // true
    console.log(this === gestionnaire); // true
    return proto;
  },
};

var p = new Proxy(obj, gestionnaire);
console.log(Object.getPrototypeOf(p) === proto); // true
```

### Cinq façons de déclencher la trappe `getPrototypeOf`


```js
var obj = {};
var p = new Proxy(obj, {
  getPrototypeOf(cible) {
    return Array.prototype;
  },
});
console.log(
  Object.getPrototypeOf(p) === Array.prototype, // true
  Reflect.getPrototypeOf(p) === Array.prototype, // true
  p.__proto__ === Array.prototype, // true
  Array.prototype.isPrototypeOf(p), // true
  p instanceof Array, // true
);
```

### Deux types d'exceptions


```js
var obj = {};
var p = new Proxy(obj, {
  getPrototypeOf(cible) {
    return "toto";
  },
});
Object.getPrototypeOf(p); // TypeError : "toto" n'est pas un objet ou null

var obj = Object.preventExtensions({});
var p = new Proxy(obj, {
  getPrototypeOf(cible) {
    return {};
  },
});
Object.getPrototypeOf(p); // TypeError : on attend la même valeur pour le prototype
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-proxy-object-internal-methods-and-internal-slots-getprototypeof |

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

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

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

* `Proxy`
* `handler` (en-US)
* `Object.getPrototypeOf()`
* `Reflect.getPrototypeOf()`
Constructeur AggregateError()
=============================

Le **constructeur `AggregateError()`** permet de créer une erreur qui agrège plusieurs erreurs.

Syntaxe
-------


```js
new AggregateError(erreurs);
new AggregateError(erreurs, message);
```

### Paramètres

`erreurs`

Un objet itérable contenant des erreurs (qui peuvent ne pas être des instances de `Error`).

`message` Facultatif

Une description optionnelle, compréhensible par un humain, de l'erreur agrégée.

Exemples
--------

### Créer une exception `AggregateError`


```js
try {
  throw new AggregateError([new Error("une erreur")], "Coucou");
} catch (e) {
  console.log(e instanceof AggregateError); // true
  console.log(e.message); // "Coucou"
  console.log(e.name); // "AggregateError"
  console.log(e.errors); // [ Error: "une erreur" ]
}
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-aggregate-error-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'émulation pour `AggregateError` avec la bibliothèque `core-js`
* `Promise.any()`
Set.prototype.forEach()
=======================

La méthode **`forEach()`** permet d'exécuter une fonction donnée, une fois pour chaque valeur de l'ensemble `Set`. L'ordre appliqué est celui dans lequel les valeurs ont été ajoutées à l'ensemble.

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

Syntaxe
-------


```js
monSet.forEach(callback[, thisArg])
```

### Valeur de retour

`undefined`.

### Paramètres

`callback`

La fonction qu'on souhaite exécuter pour chaque élément et qui sera appelée avec trois arguments :

`valeurCourante`, `cléCourante`

L'élément courant appartenant à l'ensemble `Set`. Un ensemble n'ayant pas de clé, c'est la même valeur qui est passée pour deux arguments de la fonction de rappel.

`set`

L'objet `Set` courant (celui sur lequel `forEach()` a été appelé).


`thisArg`

Paramètre optionnel. La valeur à utiliser comme `this` lors de l'exécution de `callback`.

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

La méthode `forEach()` exécute la fonction `callback` fournie pour chaque valeur contenue au sein de l'objet `Set`. Elle n'est pas appelée pour les valeurs qui ont été supprimées. Cependant, elle est exécutée si jamais la valeur vaut `undefined`.

`callback` est appelé avec **trois arguments** :

* la **valeur de l'élément**
* la **clé de l'élément**
* l'objet **`Set` qui est parcouru**

Les objets `Set` n'ont pas de clé (*key*). Cependant les deux premiers arguments correspondent à la **valeur** contenue dans l'objet `Set`. Cela permet d'utiliser les fonctions callback de façon cohérente avec les méthodes `forEach()` de `Map` et `Array`.

Si un paramètre `thisArg` est fourni, il sera passé à la fonction `callback` lors de l'appel comme valeur `this`. Par défaut, la valeur `undefined` sera passée comme argument `this`. La valeur `this` effectivement reçue par la fonction `callback` est déterminée selon les règles usuelles de détermination de `this` par une fonction.

Chacune des valeurs sera traitée une fois sauf si celle-ci a été supprimée puis réajoutée avant la fin de `forEach`. `callback` n'est pas appelé pour les valeurs qui sont supprimés avant le passage de la fonction. Les valeurs qui sont ajoutées avant que `forEach` ait parcouru l'ensemble seront traitées

`forEach` exécute la fonction `callback` une fois pour chaque élément de l'objet `Set`. Cette méthode ne renvoie pas de valeur.

Exemples
--------

Le code qui suit permet d'enregistrer une ligne pour chaque élément contenu dans l'objet `Set` :


```js
function logSetElements(valeur1, valeur2, set) {
  console.log("s[" + valeur1 + "] = " + valeur2);
}

new Set(["toto", "truc", undefined]).forEach(logSetElements);

// affichera :
// "s[toto] = toto"
// "s[truc] = truc"
// "s[undefined] = undefined"
```

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

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

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

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

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

* `Array.prototype.forEach()`
* `Map.prototype.forEach()`
Set.prototype.values()
======================

La méthode **`values()`** renvoie un nouvel objet `Iterator` (en-US) qui contient les valeurs de chaque élément de l'objet `Set`, dans leur ordre d'insertion.

La méthode **`keys()`** est un alias pour cette méthode (afin de conserver une certaine similarité avec les objets `Map`) et se comportera exactement de la même façon en renvoyant les **valeurs** des éléments du `Set`.

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

Syntaxe
-------


```js
monSet.values();
```

### Valeur de retour

Un nouvel objet `Iterator` qui contient les valeurs de chaque élément de l'ensemble `Set`, dans leur ordre d'insertion.

Exemples
--------


```js
var monSet = new Set();
monSet.add("toto");
monSet.add("truc");
monSet.add("machin");

var setIter = monSet.values();

console.log(setIter.next().value); // "toto"
console.log(setIter.next().value); // "truc"
console.log(setIter.next().value); // "machin"
```

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

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

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

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

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

* `Set.prototype.entries()`
get Set[@@species]
==================

**`Set[@@species]`** renvoie le constructeur `Set`.

Syntaxe
-------


```js
Set[Symbol.species];
```

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

L'accesseur `species` renvoie le constructeur par défaut pour les objets `Set`. Les constructeurs pour les classes filles peuvent surcharger cette propriété afin de modifier le constructeur utilisé lors de l'affectation.

Exemples
--------

La propriété `species` renvoie la fonction utilisée comme constructeur par défaut, dans le cas des objets `Set`, c'est le constructeur `Set` :


```js
Set[Symbol.species]; // function Set()
```


Pour les objets dérivés (par exemple une classe `MonSet` que vous auriez construite), la propriété species pour `MonSet` sera le constructeur `MonSet`. Cependant, si vous souhaitez surcharger ce comportement afin de renvoyer le constructeur `Set` dans les méthodes des classes dérivées, vous pourrez utiliser :


```js
class MonSet extends Set
  // On surcharge la propriété species de MonSet
  // avec le constructeur Set de la classe parente
  static get [Symbol.species()]() { return Set;}
}
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-get-set-@@species |

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

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

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

* `Set`
* `Symbol.species`
Set.prototype[@@iterator]()
===========================

La valeur initiale de la propriété **`@@iterator`** est le même objet fonction que la valeur initiale de la propriété `Set.prototype.values`.

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

Syntaxe
-------


```js
monSet[Symbol.iterator];
```

### Valeur de retour

La fonction associée au symbole `@@iterator` de l'objet. Par défaut, c'est la fonction `values()`.

Exemples
--------

### Utiliser `[@@iterator]()`


```js
const monSet = new Set();
monSet.add("0");
monSet.add(1);
monSet.add({});

const setIter = monSet[Symbol.iterator]();

console.log(setIter.next().value); // "0"
console.log(setIter.next().value); // 1
console.log(setIter.next().value); // {}
```

### Utiliser `[@@iterator]()` avec une boucle `for..of`


```js
const monSet = new Set();
monSet.add("0");
monSet.add(1);
monSet.add({});

for (const v of monSet) {
  console.log(v);
}
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-set.prototype-@@iterator |

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

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

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

* `Set.prototype.entries()`
* `Set.prototype.keys()`
* `Set.prototype.values()`
Set.prototype.clear()
=====================

La méthode **`clear()`** permet de retirer tous les éléments d'un ensemble `Set`.

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

Syntaxe
-------


```js
monSet.clear();
```

### Valeur de retour

`undefined`.

Exemples
--------


```js
var monSet = new Set();
monSet.add(1);
monSet.add("toto");

monSet.size; // 2
monSet.has("toto"); // true

monSet.clear();

monSet.size; // 0
monSet.has("truc"); // false
```

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

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

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

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

### Voir aussi

* `Set`
* `Set.prototype.delete()`
Set.prototype.size
==================

L'accesseur **`size`** est une propriété qui renvoie le nombre d'éléments contenus dans un objet `Set`. Un objet `Set` correspondant à un ensemble, chaque élément qu'il contient y est unique.

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

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

La valeur de `size` est un entier représentant le nombre d'éléments contenus dans l'ensemble. Le mutateur associée pour `size` vaut `undefined`. Cette propriété ne peut pas être changée directement.

Exemples
--------


```js
var monSet = new Set();
monSet.add(1);
monSet.add(5);
monSet.add("du texte");

monSet.size; // 3
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-get-set.prototype.size |

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

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

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

* `Set`
Set.prototype.delete()
======================

La méthode **`delete()`** permet de retirer un élément donné d'un objet `Set`.

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

Syntaxe
-------


```js
monSet.delete(valeur);
```

### Paramètres

`valeur`

Ce paramètre est obligatoire. Il représente la valeur de l'élément qu'on souhaite retirer de l'objet `Set`.

### Valeur de retour

`true` si un élément de l'objet `Set` a été retiré lors de l'opération, `false` sinon.

Exemples
--------

### Utiliser la méthode `delete()`


```js
var monSet = new Set();
monSet.add("toto");

monSet.delete("truc"); // Renvoie false. Aucun élément "truc" n'a pu être supprimé.
monSet.delete("toto"); // Renvoie true. L'élément a pu être supprimé.

monSet.has("toto"); // Renvoie false. L'élément "toto" ne fait plus partie de l'ensemble.
```

### Utiliser `delete()` avec `forEach()`


```js
var objetSet = new Set();
objetSet.add({ x: 10, y: 20 }); // On ajoute un nouvel objet dans l'ensemble
objetSet.add({ x: 20, y: 30 }); // On ajoute un nouvel objet dans l'ensemble

// On supprime les points de l'ensemble pour lesquels
// x est supérieur à 10
objetSet.forEach(function (point) {
  if (point.x > 10) {
    objetSet.delete(point);
  }
});
```

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

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

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

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

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

* `Set`
* `Set.prototype.clear()`
Constructeur Set()
==================

Le **constructeur `Set()`** permet de créer des objets `Set` qui sont des ensembles de valeurs uniques de n'importe quel type (des valeurs primitives ou des objets).

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

Syntaxe
-------


```js
new Set();
new Set(iterable);
```

### Paramètres

`iterable` Facultatif

Si un objet itérable est passé en argument, ses différents éléments seront ajoutés au nouvel objet `Set` créé.

Si ce paramètre est absent ou s'il vaut `null`, le nouvel ensemble créé sera vide.

### Valeur de retour

Un nouvel objet `Set`.

Exemples
--------

### Utiliser `Set()`


```js
let monSet = new Set();

monSet.add(1); // Set [ 1 ]
monSet.add(5); // Set [ 1, 5 ]
monSet.add(5); // Set [ 1, 5 ]
monSet.add("du texte"); // Set [ 1, 5, 'du texte' ]
let o = { a: 1, b: 2 };
monSet.add(o);
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-set-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'émulation pour `Set` avec la bibliothèque `core-js`
* `Set`
Set.prototype.add()
===================

La méthode **`add()`** permet d'ajouter un nouvel élément ayant une valeur donnée à un ensemble `Set`. Cette valeur sera ajoutée à la fin de l'objet `Set`.

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

Syntaxe
-------


```js
monSet.add(valeur);
```

### Paramètres

`valeur`

Ce paramètre est obligatoire. La valeur de l'élément qu'on souhaite ajouter à l'objet `Set`.

### Valeur de retour

L'objet `Set` (ce qui permet de chaîner une suite d'instructions utilisant cette méthode).

Exemples
--------


```js
var monSet = new Set();

monSet.add(1);
monSet.add(5).add("du texte"); // ajouts en chaîne

console.log(monSet);
// Set [1, 5, "du texte"]
```

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

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

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

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

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

* `Set`
* `Set.prototype.delete()`
* `Set.prototype.has()`
Set.prototype.entries()
=======================

La méthode **`entries()`** renvoie un nouvel objet `Iterator` qui contient un tableau composé de **`[valeur, valeur]`** pour chaque élément de l'objet `Set`, dans leur ordre d'insertion. En raison de leur structure, les objets `Set` n'ont pas de clé (`key`), à la différence des objets `Map`. Pour garder une structure et une API sembables à celle d'un objet `Map`, chaque entrée (*entry*) aura la même valeur pour la *clé* (*key*) et pour la *valeur* (*value*), c'est pourquoi un tableau de `[valeur, valeur]` est renvoyé.

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

Syntaxe
-------


```js
monSet.entries();
```

### Valeur de retour

Un nouvel objet `Iterator` qui contient un tableau de tuples [`valeur, valeur`] pour chaque élément de l'ensemble, dans leur ordre d'insertion.

Exemples
--------


```js
var monSet = new Set();
monSet.add("totobidule");
monSet.add(1);
monSet.add("machin");

var setIter = monSet.entries();

console.log(setIter.next().value); // ["totobidule", "totobidule"]
console.log(setIter.next().value); // [1, 1]
console.log(setIter.next().value); // ["machin", "machin"]
```

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

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

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

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

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

* `Set.prototype.keys()`
* `Set.prototype.values()`
Set.prototype.has()
===================

La méthode **`has()`** renvoie un booléen qui indique s'il existe un élément de l'ensemble `Set` avec une certaine valeur.

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

Syntaxe
-------


```js
monSet.has(valeur);
```

### Paramètres

`valeur`

Ce paramètre est obligatoire. C'est la valeur dont on souhaite savoir si elle est présente ou non dans l'objet `Set`.

### Valeur de retour

Un booléen : `true` s'il existe un élément avec la valeur donnée au sein du `Set`, `false` sinon.

**Note :** L'existence d'un élément avec la valeur testée est vérifiée avec l'algorithme d'égalité des valeurs nulles (`sameValueZero`).

Exemples
--------


```js
var monSet = new Set();
monSet.add("toto");

monSet.has("toto"); // renvoie true
monSet.has("truc"); // renvoie false

var set1 = new Set();
var obj1 = { cle1: 1 };
set1.add(obj1);

set1.has(obj1); // renvoie true
set1.has({ cle1: 1 }); // renvoie false car ce sont deux objets distincts
set1.add({ cle1: 1 }); // set1 contient désormais 2 éléments
```

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

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

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

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

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

* `Set`
* `Set.prototype.add()`
* `Set.prototype.delete()`
Reflect.preventExtensions()
===========================

La méthode statique **`Reflect.preventExtensions()`** permet d'empêcher d'ajouter de nouvelles propriétés à un objet. Cette méthode est semblable à la méthode `Object.preventExtensions()` (modulo quelques différences).

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

Syntaxe
-------


```js
Reflect.preventExtensions(cible);
```

### Paramètres

`cible`

L'objet cible dont on veut empêcher l'ajout d'autres propriétés.

### Valeur de retour

Un booléen qui indique si l'interdiction a bien été mise en place sur l'objet cible.

### Exceptions

Une erreur `TypeError` si `cible` n'est pas un `Object`.

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

La méthode `Reflect.preventExtensions` permet d'empêcher l'ajout de nouvelles propriétés sur un objet. Cette méthode est semblable à `Object.preventExtensions()`.

Exemples
--------

### Utiliser `Reflect.preventExtensions()`

Voir aussi `Object.preventExtensions()`.


```js
// Par défaut les objets sont extensibles
var vide = {};
Reflect.isExtensible(vide); // === true

// ...mais cela peut être modifié
Reflect.preventExtensions(vide);
Reflect.isExtensible(vide); // === false
```

### Différences avec `Object.preventExtensions()`

Si le premier argument de cette méthode n'est pas un objet (autrement dit c'est une valeur primitive), cela provoquera une `TypeError`. `Object.preventExtensions()`, quant à elle, convertira l'argument passé en un objet.


```js
Reflect.preventExtensions(1);
// TypeError: 1 is not an object

Object.preventExtensions(1);
// 1
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-reflect.preventextensions |

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

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

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

* `Reflect`
* `Object.isExtensible()`
Reflect.apply()
===============

La méthode statique **`Reflect.apply()`** permet d'appeler une fonction cible avec des arguments donnés.

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

Syntaxe
-------


```js
Reflect.apply(cible, argumentThis, listeArguments);
```

### Paramètres

`cible`

La fonction cible à appeler.

`argumentThis`

La valeur fournie pour `this` lors de l'appel à *`cible`*.

`listeArguments`

Un objet semblable à un tableau qui définit les arguments à passer à *`cible`*. S'il vaut `null` ou `undefined`, aucun argument ne sera passé.

### Valeur de retour

Le résultat de l'appel de la fonction cible indiquée avec la valeur `this` et les arguments indiqués.

### Exceptions levées

Une exception `TypeError`, si *cible* ne peut pas être appelée.

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

Avec ES5, on utilise généralement `Function.prototype.apply()` pour appeler une fonction avec une valeur `this` donnée et des arguments donnés.


```js
Function.prototype.apply.call(Math.floor, undefined, [1.75]);
```


`Reflect.apply` permet de rendre cela plus concis et facile à comprendre.

Exemples
--------


```js
Reflect.apply(Math.floor, undefined, [1.75]);
// 1;

Reflect.apply(String.fromCharCode, undefined, [104, 101, 108, 108, 111]);
// "hello"

Reflect.apply(RegExp.prototype.exec, /ab/, ["confabulation"]).index;
// 4

Reflect.apply("".charAt, "poneys", [3]);
// "e"
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-reflect.apply |

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

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

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

* `Reflect`
* `Function.prototype.apply()`