recursal/MDN huggingface dataset:
Reflect.deleteProperty()
========================

La méthode statique **`Reflect.deleteProperty()`** permet de supprimer des propriétés. Il agit comme l'opérateur `delete`.

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

Syntaxe
-------


```js
Reflect.deleteProperty(cible, cléPropriété);
```

### Paramètres

`cible`

L'objet cible sur lequel on souhaite supprimer la propriété.

`cléPropriété`

Le nom de la propriété à supprimer.

### Valeur de retour

Un booléen qui indique si la suppression de la propriété s'est bien passée.

### Exceptions

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

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

La méthode `Reflect.deleteProperty` permet de supprimer une propriété d'un objet. Elle renvoie un `Boolean` qui indique si la propriété a été supprimée correctement. Cette méthode est très proche de l'opérateur `delete`.

Exemples
--------


```js
var obj = { x: 1, y: 2 };
Reflect.deleteProperty(obj, "x"); // true
obj; // { y: 2 }

var arr = [1, 2, 3, 4, 5];
Reflect.deleteProperty(arr, "3"); // true
arr; // [1, 2, 3, , 5]

// Renvoie true si aucune propriété correspondante n'existe
Reflect.deleteProperty({}, "toto"); // true

// Renvoie false si une propriété n'est pas configurable
Reflect.deleteProperty(Object.freeze({ toto: 1 }), "toto"); // false
```

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

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

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

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

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

* `Reflect`
* Opérateur `delete`
Reflect.getPrototypeOf()
========================

La méthode statique **`Reflect.getPrototypeOf()`** est semblable à la méthode `Object.getPrototypeOf()`. Elle renvoie le prototype (c'est-à-dire la valeur de la propriété interne `[[Prototype]]`) de l'objet donné.

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

Syntaxe
-------


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

### Paramètres

`cible`

L'objet cible dont on souhaite obtenir le prototype.

### Valeur de retour

Le prototype de l'objet ou `null` s'il n'y a aucune propriété héritée.

### Exceptions levées

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

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

La méthode `Reflect.getPrototypeOf` renvoie le prototype (qui correspond en réalité à la valeur de la propriété interne `[[Prototype]]`) de l'objet passé en argument.

Exemples
--------

### Utiliser `Reflect.getPrototypeOf()`


```js
Reflect.getPrototypeOf({}); // Object.prototype
Reflect.getPrototypeOf(Object.prototype); // null
Reflect.getPrototypeOf(Object.create(null)); // null
```

### Comparaison avec `Object.getPrototypeOf()`


```js
// Résultat identiques pour les objets
Object.getPrototypeOf({}); // Object.prototype
Reflect.getPrototypeOf({}); // Object.prototype

// Exception levée avec ES5 pour les valeurs qui ne sont pas des objets
Object.getPrototypeOf("toto"); // Throws TypeError
Reflect.getPrototypeOf("toto"); // Throws TypeError

// Avec ES2015 (ES6), seul Reflect lève une exception
// Object convertit automatiquement les valeurs en objets
Object.getPrototypeOf("toto"); // String.prototype
Reflect.getPrototypeOf("toto"); // Throws TypeError

// Pour obtenir le même effet qu'avec Object en ES2015, il
// faut ajouter une opération de conversion explicite
Reflect.getPrototypeOf(Object("toto")); // String.prototype
```

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

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

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

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

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

* `Reflect`
* `Object.getPrototypeOf()`
Reflect.getOwnPropertyDescriptor()
==================================

La méthode statique **`Reflect.getOwnPropertyDescriptor()`** est similaire à `Object.getOwnPropertyDescriptor()`. Elle renvoie un descripteur de propriété pour la propriété visée si elle existe sur l'objet, sinon, elle renvoie `undefined`.

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

Syntaxe
-------


```js
Reflect.getOwnPropertyDescriptor(cible, cléPropriété);
```

### Paramètres

`cible`

L'objet cible sur lequel on cherche la propriété.

`cléPropriété`

Le nom de la propriété dont on veut obtenir le descripteur.

### Valeur de retour

Un objet qui est un descripteur de propriété si elle existe sur l'objet cible ou `undefined` dans le cas contraire.

### Exceptions

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

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

La méthode `Reflect.getOwnPropertyDescriptor` renvoie un descripteur pour la propriété demandée si celle-ci existe sur l'objet, sinon, elle renvoie `undefined`. La seule différence avec `Object.getOwnPropertyDescriptor()` est la façon dont les cibles qui ne sont pas des objets sont gérées.

Exemples
--------

### Utiliser `Reflect.getOwnPropertyDescriptor()`


```js
Reflect.getOwnPropertyDescriptor({ x: "coucou" }, "x");
// {value: "coucou", writable: true, enumerable: true, configurable: true}

Reflect.getOwnPropertyDescriptor({ x: "coucou" }, "y");
// undefined

Reflect.getOwnPropertyDescriptor([], "length");
// {value: 0, writable: true, enumerable: false, configurable: false}
```

### Différence avec `Object.getOwnPropertyDescriptor()`

Si le premier argument passé à la méthode n'est pas un objet (autrement dit si c'est une valeur de type primitif), cela causera une exception `TypeError`. Si on utilise `Object.getOwnPropertyDescriptor`, une valeur qui n'est pas un objet sera d'abord convertie en objet.


```js
Reflect.getOwnPropertyDescriptor("toto", 0);
// TypeError: "toto" is not non-null object

Object.getOwnPropertyDescriptor("toto", 0);
// { value: "toto", writable: false, enumerable: true, configurable: false }
```

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

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

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

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

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

* `Reflect`
* `Object.getOwnPropertyDescriptor()`
Reflect.set()
=============

La méthode statique **`Reflect.set()`** permet de définir ou de modifier une propriété sur un objet.

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

Syntaxe
-------


```js
Reflect.set(cible, cléPropriété, valeur[, récepteur])
```

### Paramètres

`cible`

L'objet cible sur lequel on veut définir ou modifier la propriété.

`cléPropriété`

Le nom de la propriété à définir ou à modifier.

`valeur`

La valeur pour la propriété.

`récepteur`Facultatif

La valeur de `this` pour l'appel à `cible` si un mutateur (*setter*) est utilisé.

### Valeur de retour

Un booléen qui indique si la définition/modification de la propriété a réussi.

### Exceptions

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

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

La méthode `Reflect.set` permet de définir une propriété sur un objet. Elle effectue une affectation de propriété et est semblable à la syntaxe pour accéder à un propriété mais sous la forme d'une fonction.

Exemples
--------

### Utiliser `Reflect.set()`


```js
// Object
var obj = {};
Reflect.set(obj, "prop", "value"); // true
obj.prop; // "value"

// Array
var arr = ["canard", "canard", "canard"];
Reflect.set(arr, 2, "oie"); // true
arr[2]; // "oie"

// On peut l'utiliser pour tronquer un tableau
Reflect.set(arr, "length", 1); // true
arr; // ["canard"];

// Avec un seul argument
// cléPropriété et valeur valent "undefined".
var obj = {};
Reflect.set(obj); // true
Reflect.getOwnPropertyDescriptor(obj, "undefined");
// { value: undefined, writable: true, enumerable: true, configurable: true }
```

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

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

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

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

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

* `Reflect`
* Accesseurs de propriété
Reflect.defineProperty()
========================

La méthode statique **`Reflect.defineProperty()`** est semblable à `Object.defineProperty()` mais renvoie un `Boolean`.

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

Syntaxe
-------


```js
Reflect.defineProperty(cible, cléPropriété, attributs);
```

### Paramètres

`cible`

L'objet cible sur lequel on veut définir la propriété.

`cléPropriété`

Le nom de la propriété qu'on souhaite définir ou modifier.

`attributs`

Les attributs de de la propriété qu'on ajoute ou qu'on modifie.

### Valeur de retour

Un booléen qui indique si la propriété a bien été définie.

### Exceptions

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

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

La méthode `Reflect.defineProperty` permet d'ajouter ou de modifier finement une propriété d'un objet. Pour plus de détails, voir la méthode `Object.defineProperty` qui est très similaire. `Object.defineProperty` renvoie l'objet et lève une `TypeError` si la propriété n'a pas correctement été définie. `Reflect.defineProperty` renvoie simplement un `Boolean` qui indique si la propriété a été définie avec succès ou non.

Exemples
--------

### Utiliser `Reflect.defineProperty()`


```js
var obj = {};
Reflect.defineProperty(obj, "x", { value: 7 }); // true
obj.x; // 7
```

### Vérifier si la définition de propriété a réussi

`Object.defineProperty` renvoie un objet si la définition a réussi ou lève une exception `TypeError` sinon, ce qui implique d'utiliser un bloc `try...catch` pour attraper l'erreur. `Reflect.defineProperty` renvoie un booléen pour indiquer la réussite ou l'échec, un bloc `if...else` suffit :


```js
if (Reflect.defineProperty(cible, propriété, attributs)) {
  // succès
} else {
  // échec
}
```

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

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

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

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

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

* `Reflect`
* `Object.defineProperty()`
Reflect.get()
=============

La méthode statique **`Reflect.get()`** est une fonction qui permet d'obtenir une propriété d'un objet cible. Elle fonctionne comme (`cible[cléPropriété]`) mais sous la forme d'une fonction.

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

Syntaxe
-------


```js
Reflect.get(cible, cléPropriété[, récepteur])
```

### Paramètres

`cible`

L'objet cible dont on souhaite obtenir la propriété.

`cléPropriété`

Le nom de la propriété qu'on souhaite obtenir.

`récepteur` Facultatif

La valeur de `this` à passer à `cible` si l'accesseur est utilisé. Lorsqu'on l'utilise avec `Proxy`, ce peut être un objet qui hérite de la cible.

### Valeur de retour

La valeur de la propriété.

### Exceptions

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

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

La méthode `Reflect.get` permet d'obtenir une propriété d'un objet. Elle est équivalent à un accesseur de propriété mais sous la forme d'une fonction.

Exemples
--------


```js
// Object
var obj = { x: 1, y: 2 };
Reflect.get(obj, "x"); // 1

// Array
Reflect.get(["zero", "un"], 1); // "un"

// Proxy qui intercepte get
var x = { p: 1 };
var obj = new Proxy(x, {
  get(t, k, r) {
    return k + "truc";
  },
});
Reflect.get(obj, "toto"); // "tototruc"
```

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

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

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

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

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

* `Reflect`
* Accesseurs de propriété
Reflect.has()
=============

La méthode statique **`Reflect.has()`** fonctionne comme l'opérateur `in` mais sous forme d'une fonction.

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

Syntaxe
-------


```js
Reflect.has(cible, cléPropriété);
```

### Paramètres

`cible`

L'objet cible dont on souhaite savoir s'il contient la propriété donnée.

`cléPropriété`

Le nom de la propriété dont on souhaite vérifier la présence.

### Valeur de retour

Un booléen qui indique si la propriété recherchée est présente sur l'objet cible.

### Exceptions

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

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

La méthode `Reflect.has` vous permet de vérifier si une propriété est présente sur un objet. C'est une fonction qui agit comme l'opérateur `in`.

Exemples
--------


```js
Reflect.has({ x: 0 }, "x"); // true
Reflect.has({ x: 0 }, "y"); // false

// renvoie true pour les propriétés présentes
// grâce à la chaîne de prototypes
Reflect.has({ x: 0 }, "toString");

// Proxy avec la méthode .has()
obj = new Proxy(
  {},
  {
    has(t, k) {
      return k.startsWith("bou");
    },
  },
);
Reflect.has(obj, "bouchon"); // true
Reflect.has(obj, "bonbon"); // false
```

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

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

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

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

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

* `Reflect`
* Opérateur `in`
Reflect.ownKeys()
=================

La méthode statique **`Reflect.ownKeys()`** renvoie un tableau qui contient les clés des propriétés propres (non héritées) de l'objet `cible`.

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

Syntaxe
-------


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

### Paramètres

`cible`

L'objet cible dont on souhaite obtenir les noms et symboles des propriétés propres.

### Valeur de retour

Un objet `Array` qui contient les clés des propriétés propres de `cible`.

### Exceptions

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

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

La méthode `Reflect.ownKeys` renvoie un tableau dont les éléments sont les clés des propriétés propres de l'objet `cible`. Sa valeur de retour est équivalente à `Object.getOwnPropertyNames(target).concat(Object.getOwnPropertySymbols(target))`.

Exemples
--------


```js
Reflect.ownKeys({ z: 3, y: 2, x: 1 }); // [ "z", "y", "x" ]
Reflect.ownKeys([]); // ["length"]

var sym = Symbol.for("comète");
var sym2 = Symbol.for("météore");
var obj = {
  [sym]: 0,
  str1: 0,
  773: 0,
  0: 0,
  [sym2]: 0,
  "-1": 0,
  8: 0,
  "seconde str": 0,
};
Reflect.ownKeys(obj);
// [ "0", "8", "773", "str1", "-1", "seconde str", Symbol(comète), Symbol(météore) ]
// Indices dans l'ordre numérique
// Chaînes de caractères dans l'ordre d'insertion
// Symboles dans l'ordre d'insertion
```

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

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

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

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

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

* `Reflect`
* `Object.getOwnPropertyNames()`
Reflect.setPrototypeOf()
========================

la méthode statique **`Reflect.setPrototypeOf()`** est semblable à la méthode `Object.setPrototypeOf()` (exception faite de la valeur de retour). Elle permet de définir le prototype (c'est-à-dire la propriété interne `[[Prototype]]`) d'un objet donné avec un autre objet ou `null`. Cette méthode renvoie `true` si l'opération a réussi et `false` sinon.

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

Syntaxe
-------


```js
Reflect.setPrototypeOf(cible, prototype);
```

### Paramètres

`cible`

L'objet cible dont on souhaite modifier le prototype.

`prototype`

Le nouveau prototype à appliquer à l'objet cible (ça peut être un objet ou `null`).

### Valeur de retour

Un booléen qui indique si le prototype a correctement été modifié.

### Exceptions

Une erreur `TypeError` si `cible` n'est pas un `Object` ou si `prototype` n'est ni un objet ni `null`.

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

La méthode `Reflect.setPrototypeOf` permet de modifier le prototype (qui est la valeur de la propriété interne `[[Prototype]]`) d'un objet donné.

Exemples
--------

### Utiliser `Reflect.setPrototypeOf()`


```js
Reflect.setPrototypeOf({}, Object.prototype); // true

// On peut modifier le [[Prototype]] d'un objet
// pour que celui-ci soit null.
Reflect.setPrototypeOf({}, null); // true

// La méthode renvoie false si la cible
// n'est pas extensible.
Reflect.setPrototypeOf(Object.freeze({}), null); // false

// La méthode renvoie false si l'affectation
// entraîne un cycle dans la chaîne de prototypes.
var target = {};
var proto = Object.create(target);
Reflect.setPrototypeOf(target, proto); // false
```

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

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

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

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

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

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

La méthode statique **`Reflect.isExtensible()`** permet de déterminer si un objet est extensible (i.e. si on peut lui ajouter de nouvelles propriétés). Elle est semblable à la méthode `Object.isExtensible()` (modulo quelques différences).

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

Syntaxe
-------


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

### Paramètres

`cible`

L'objet cible dont on souhaite savoir s'il est extensible.

### Valeur de retour

Un booléen qui indique si la cible est extensible ou non.

### Exceptions

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

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

La méthode `Reflect.isExtensible` permet de déterminer si un objet est extensible (autrement dit si on peut lui ajouter de nouvelles propriétés). Cette méthode est semblable à la méthode `Object.isExtensible()`.

Exemples
--------

### Utiliser `Reflect.isExtensible()`

Voir aussi `Object.isExtensible()`.


```js
// Les nouveaux objets sont extensibles.
var vide = {};
Reflect.isExtensible(vide); // true

// ...mais ça peut être changé.
Reflect.preventExtensions(vide);
Reflect.isExtensible(vide); // false

// Par définition, les objets scellés
// ne sont pas extensibles.
var scellé = Object.seal({});
Reflect.isExtensible(scellé); // false

// Par définition, les objets gelés sont
// également non-extensibles.
var gelé = Object.freeze({});
Reflect.isExtensible(gelé); // false
```

### Différence avec `Object.isExtensible()`

Si le premier argument passé à la méthode n'est pas un objet (autrement dit si la valeur est une valeur primitive), cela provoquera une exception `TypeError`. La méthode `Object.isExtensible()` aurait commencé par convertir l'argument en un objet.


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

Object.isExtensible(1);
// false
```

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

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

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

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

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

* `Reflect`
* `Object.isExtensible()`
Constructeur RangeError()
=========================

Le constructeur **`RangeError()`** permet de créer une erreur lorsqu'une valeur n'appartient pas à l'intervalle ou à l'ensemble des valeurs autorisées.

Syntaxe
-------


```js
new RangeError();
new RangeError(message);
new RangeError(message, nomFichier);
new RangeError(message, nomFichier, numeroLigne);
```

### Parameters

`message` Facultatif

Une description, lisible et compréhensible par un humain, de l'erreur.

`nomFichier` Facultatif

Le nom du fichier qui contient le code ayant provoqué l'exception.

`numeroLigne` Facultatif

Le numéro de la ligne dans le fichier de code ayant provoqué l'exception.

Exemples
--------

### Utiliser `RangeError` (pour des valeurs numériques)


```js
function verifier(n) {
  if (!(n >= -500 && n <= 500)) {
    throw new RangeError("L'argument doit être compris entre -500 et 500.");
  }
}

try {
  verifier(2000);
} catch (error) {
  if (error instanceof RangeError) {
    // Gérer l'erreur
  }
}
```

### Utiliser `RangeError` (pour des valeurs non-numériques)


```js
function verifier(valeur) {
  if (["pomme", "banane", "carotte"].includes(valeur) === false) {
    throw new RangeError(
      "L'argument doit valeur 'pomme', 'banane', ou 'carotte'.",
    );
  }
}

try {
  verifier("chou");
} catch (error) {
  if (error instanceof RangeError) {
    // Gérer l'erreur
  }
}
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-nativeerror-constructors |

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

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

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

* `Error`
* `Array`
* `Number.toExponential()`
* `Number.toFixed()`
* `Number.toPrecision()`
* `String.prototype.normalize()`
Generator.prototype.next()
==========================

La méthode **`next()`** renvoie un objet possédant deux propriétés `done` et `value`. Cette méthode peut également recevoir un paramètre pour envoyer une valeur au générateur.

Syntaxe
-------


```js
gen.next(valeur);
```

### Paramètres

`valeur`

La valeur à envoyer au générateur. La valeur sera affectée comme résultat d'une expression `yield`. Autrement dit, lorsque le générateur contient une expression de la forme `variable = yield expression`, c'est l'argument `valeur` qui sera affecté à `variable`*.*

### Valeur de retour

Un `Object` possédant deux propriétés :

* `done` (un booléen)
    + vaut `true` si l'itérateur a atteint la fin de la série sur laquelle il itère. Dans ce cas, la propriété `value` définit la valeur de retour pour l'itérateur.
    + vaut `false` si l'itérateur a pu fournir la prochaine valeur de la série. C'est la valeur par défaut si la propriété `done` n'est pas définie.
* `value` - n'importe quelle valeur JavaScript renvoyée par l'itérateur. Cette propriété peut être absente lorsque `done` vaut `true`.
Exemples
--------

### Utiliser `next()`

L'exemple suivant illustre comment utiliser un générateur simple et les objets renvoyés par la méthode `next` :


```js
function\* gen() {
  yield 1;
  yield 2;
  yield 3;
}

var g = gen(); // "Generator { }"
g.next(); // "Object { value: 1, done: false }"
g.next(); // "Object { value: 2, done: false }"
g.next(); // "Object { value: 3, done: false }"
g.next(); // "Object { value: undefined, done: true }"
```

### Envoyer des valeurs à un générateur

Ici, `next` est appelé avec une valeur. On notera ici que le premier appel n'affiche rien car le générateur n'a encore rien généré.


```js
function\* gen() {
  while (true) {
    var value = yield null;
    console.log(value);
  }
}

var g = gen();
g.next(1);
// "{ value: null, done: false }"
g.next(2);
// 2
// "{ value: null, done: false }"
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-generator.prototype.next |

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

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

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

* `function*`
* Les itérateurs et générateurs