recursal/MDN huggingface dataset:
Proxy.revocable()
=================

La méthode **`Proxy.revocable()`** est utilisée afin de créer un objet `Proxy` révocable.

Syntaxe
-------


```js
Proxy.revocable(cible, gestionnaire);
```

### Paramètres

`cible`

Un objet cible devant lequel on veut placer un intermédiaire. Ça peut être n'importe quelle sorte d'objet : un tableau, une fonction, voire un autre proxy.

`gestionnaire`

Un objet dont les propriétés sont des fonctions qui définissent les opérations interceptées par le proxy par rapport à l'objet cible.

### Valeur de retour

Un nouvel objet `Proxy` révocable est renvoyé par la méthode.

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

Un `Proxy` révocable est un objet qui possède les propriétés suivantes : `{proxy: proxy, revoke: revoke}`.

`proxy`

Un proxy créé avec un appel à `new Proxy(cible, gestionnaire)`.

`revoke`

Une fonction sans argument qui permet de désactiver le proxy.

Si la fonction `revoke()` est appelée, le proxy devient inutilisable et toutes les trappes définies via un gestionnaire lèveront une exception `TypeError`. Une fois que le proxy est révoqué, il conserve cet état et peut être traité par le ramasse-miettes. D'éventuels appels suivants à `revoke()` n'auront aucun effet.

Exemples
--------

### Utiliser `Proxy.revocable()`


```js
let revocable = Proxy.revocable(
  {},
  {
    get: function (cible, nom) {
      return "[[" + nom + "]]";
    },
  },
);
let proxy = revocable.proxy;
console.log(proxy.toto); // "[[toto]]"

revocable.revoke();

console.log(proxy.toto); // TypeError est levée
proxy.toto = 1; // TypeError à nouveau
delete proxy.toto; // TypeError toujours
typeof proxy; // "object", typeof ne déclenche aucune trappe
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-proxy.revocable |

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

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

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

* `Proxy`
Gestionnaire de Proxy (handler)
===============================

L'objet gestionnaire d'un proxy est un objet qui contient les trappes de captures (*traps*) pour le proxy.

Méthodes
--------

Toutes ces trappes sont optionnelles. Si une trappe n'a pas été définie, le comportement par défaut sera de transmettre l'opération à la cible.

`handler.getPrototypeOf()`

Une trappe pour `Object.getPrototypeOf`.

`handler.setPrototypeOf()`

Une trappe pour `Object.setPrototypeOf`.

`handler.isExtensible()`

Une trappe pour `Object.isExtensible`.

`handler.preventExtensions()`

Une trappe pour `Object.preventExtensions`.

`handler.getOwnPropertyDescriptor()`

Une trappe pour `Object.getOwnPropertyDescriptor`.

`handler.defineProperty()`

Une trappe pour `Object.defineProperty`.

`handler.has()`

Une trappe pour l'opérateur `in`.

`handler.get()`

Une trappe pour l'accès aux valeurs des propriétés.

`handler.set()`

Une trappe pour la définition des valeurs des propriétés.

`handler.deleteProperty()`

Une trappe pour l'opérateur `delete`.

`handler.ownKeys()`

Une trappe pour `Object.getOwnPropertyNames` et `Object.getOwnPropertySymbols`.

`handler.apply()`

Une trappe pour l'appel d'une fonction.

`handler.construct()`

Une trappe pour l'opérateur `new`.

Certaines trappes non standards sont désormais obsolètes et ont été supprimées.

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

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

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

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

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

* `Proxy`
handler.apply()
===============

La méthode **`handler.apply()`** représente une trappe pour un appel de fonctions.

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

Syntaxe
-------


```js
var p = new Proxy(cible, {
  apply: function (cible, thisArg, listeArguments) {},
});
```

### Paramètres

Les paramètres suivants sont passés à la méthode `apply`. Ici, `this` est lié au gestionnaire.

`cible`

L'objet cible.

`thisArg`

L'argument `this` pour cet appel.

`listeArguments`

La liste d'arguments pour l'appel.

### Valeur de retour

La méthode `apply` peut renvoyer n'importe quelle valeur.

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

La méthode **`handler.apply`** est une trappe pour l'appel à une fonction.

### Interceptions

Cette trappe intercepte les opérations suivantes :

* `proxy(...args)`
* `Function.prototype.apply()` et `Function.prototype.call()`
* `Reflect.apply()`
### Invariants

Si les invariants suivants ne sont pas respectés, le proxy lèvera une exception `TypeError` :

* la cible doit pouvoir être « appelable ». Autrement dit, il doit s'agir d'une fonction.
Exemples
--------

Dans l'exemple ci-dessous, on piège un appel de fonction.


```js
var p = new Proxy(function () {}, {
  apply: function (target, thisArg, argumentsList) {
    console.log("called: " + argumentsList.join(", "));
    return argumentsList[0] + argumentsList[1] + argumentsList[2];
  },
});

console.log(p(1, 2, 3)); // "called: 1, 2, 3"
// 6
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-proxy-object-internal-methods-and-internal-slots-call-thisargument-argumentslist |

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

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

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

* `Proxy`
* `handler` (en-US)
* `Function.prototype.apply`
* `Function.prototype.call`
* `Reflect.apply()`
handler.setPrototypeOf()
========================

La méthode **`handler.setPrototypeOf()`** est une trappe pour intercepter `Object.setPrototypeOf()`.

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

Syntaxe
-------


```js
var p = new Proxy(cible, {
  setPrototypeOf: function (cible, prototype) {},
});
```

### Paramètres

Les paramètres suivants sont passés à la méthode `setPrototypeOf`. `this` est lié au gestionnaire.

`cible`

L'objet cible.

`prototype`

Le nouveau prototype de l'objet ou `null`.

### Valeur de retour

La méthode `setPrototypeOf` renvoie `true` si la propriété interne `[[Prototype]]` a bien été modifiée et `false` sinon.

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

La méthode **`handler.setPrototypeOf`** est une trappe utilisée pour intercepter les opérations de `Object.setPrototypeOf()`.

### Interceptions

Cette trappe permet d'intercepter :

* `Object.setPrototypeOf()`
* `Reflect.setPrototypeOf()`
### Invariants

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

* Si `cible` n'est pas extensible, le paramètre `prototype` doit être le même valeur que `Object.getPrototypeOf(cible)`.
Exemples
--------

Si on souhaite interdire la définition d'un nouveau prototype pour un objet, on peut utiliser une méthode `setPrototypeOf` qui renvoie `false` ou qui génère une exception.

Avec cette première approche, toute opération qui voudra modifier le prototype génèrera une exception. On aura par exemple `Object.setPrototypeOf()` qui créera et lèvera l'exception `TypeError`. Si la modification est effectuée par une opération qui ne génère pas d'exception en cas d'échec (comme `Reflect.setPrototypeOf()`), aucune exception ne sera générée.


```js
var handlerReturnsFalse = {
  setPrototypeOf(target, newProto) {
    return false;
  },
};

var newProto = {},
  target = {};

var p1 = new Proxy(target, handlerReturnsFalse);
Object.setPrototypeOf(p1, newProto);
// lève une TypeError
Reflect.setPrototypeOf(p1, newProto);
// renvoie false
```


Avec cette seconde approche, toute tentative de modification génèrera une exception. On utilisera celle-ci lorsqu'on souhaite qu'une erreur se produisent, y compris pour les opérations qui ne génèrent habituellement pas d'exception ou si on souhaite générer une exception sur mesure.


```js
var handlerThrows = {
  setPrototypeOf(target, newProto) {
    throw new Error("erreur custom");
  },
};

var newProto = {},
  target = {};

var p2 = new Proxy(target, handlerThrows);
Object.setPrototypeOf(p2, newProto);
// lève une exception new Error("erreur custom")
Reflect.setPrototypeOf(p2, newProto);
// lève une exception new Error("erreur custom")
```

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

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

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.setPrototypeOf()`
* `Reflect.setPrototypeOf()`
handler.preventExtensions()
===========================

La méthode **`handler.preventExtensions()`** est une trappe pour `Object.preventExtensions()`.

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

Syntaxe
-------


```js
var p = new Proxy(cible, {
  preventExtensions: function (cible) {},
});
```

### Paramètres

Le paramètre suivant est passé à la méthode `preventExtensions`. `this` est lié au gestionnaire (*handler*).

`cible`

L'objet cible.

### Valeur de retour

La méthode `preventExtensions` doit renvoyer une valeur booléenne.

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

La méthode **`handler.preventExtensions()`** est une trappe pour intercepter `Object.preventExtensions()`.

### Interceptions

Cette trappe peut intercepter les opérations de :

* `Object.preventExtensions()`
* `Reflect.preventExtensions()`
### Invariants

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

* `Object.preventExtensions(proxy)` ne renvoie `true` que si `Object.isExtensible(proxy)` vaut `false`.
Exemples
--------

On intercepte l'appel à `Object.preventExtensions()` dans l'exemple suivant :


```js
var p = new Proxy(
  {},
  {
    preventExtensions: function (cible) {
      console.log("appelé");
      Object.preventExtensions(cible);
      return true;
    },
  },
);

console.log(Object.preventExtensions(p)); // "appelé"
// true
```


Le code suivant ne respecte pas l'invariant :


```js
var p = new Proxy(
  {},
  {
    preventExtensions: function (cible) {
      return true;
    },
  },
);

Object.preventExtensions(p); // TypeError est levée
```

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

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

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.preventExtensions()`
* `Reflect.preventExtensions()`
handler.construct()
===================

La méthode **`handler.construct()`** est une trappe pour l'opérateur `new`. Afin que l'opération `new` puisse être valide sur le proxy correspondant, la cible utilisée doit avoir une méthode interne `[[Construct]]` (autrement dit, l'instruction `new cible` doit être valide).

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

Syntaxe
-------


```js
var p = new Proxy(cible, {
  construct: function (cible, listeArguments, newTarget) {},
});
```

### Paramètres

Les paramètres suivants sont passés à la méthode `construct`. `this` est ici lié au gestionnaire (*handler*).

`cible`

L'objet cible.

`listeArguments`

La liste des arguments passés au constructeur.

`newTarget`

Le constructeur originellement appelé.

### Valeur de retour

La méthode `construct` doit renvoyer un objet.

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

La méthode **`handler.construct()`** est une trappe pour l'opérateur `new`.

### Interceptions

Ce trappe intercepte les opérations suivantes :

* `new proxy(...args)`
* `Reflect.construct()`
### Invariants

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

* Le résultat doit être un `Object`.
Exemples
--------

Dans l'exemple qui suit, on piège l'opérateur `new`.


```js
var p = new Proxy(function () {}, {
  construct: function (target, argumentsList) {
    console.log("called: " + argumentsList.join(", "));
    return { value: argumentsList[0] \* 10 };
  },
});

console.log(new p(1).value); // "appel sur : 1"
// 10
```


Dans cette version, on ne respecte pas la contrainte d'invariance :


```js
var p = new Proxy(function () {}, {
  construct: function (target, argumentsList) {
    return 1;
  },
});

new p(); // Une exception TypeError est levée
```


Dans le code qui suit, le proxy n'est pas correctement initialisé. La cible du proxy doit être un constructeur valide qui puisse être utilisé avec `new`.


```js
var p = new Proxy(
  {},
  {
    construct: function (target, argumentsList, newTarget) {
      return {};
    },
  },
);

new p(); // TypeError: p is not a constructor
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-proxy-object-internal-methods-and-internal-slots-construct-argumentslist-newtarget |

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

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

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

* `Proxy`
* `handler` (en-US)
* L'opérateur `new`
* `Reflect.construct()`
handler.get()
=============

La méthode **`handler.get()`** est une trappe pour intercepter l'accès à la valeur d'une propriété.

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

Syntaxe
-------


```js
var p = new Proxy(cible, {
  get: function (cible, propriété, récepteur) {},
});
```

### Paramètres

Les paramètres suivants sont passés à la méthode `get`. `this` est lié au gestionnaire.

`cible`

L'objet cible.

`propriété`

Le nom ou le symbole (`Symbol`) de la propriété qu'on souhaite obtenir.

`récepteur`

Le proxy ou un objet qui hérite du proxy.

### Valeur de retour

La méthode `get` peut renvoyer n'importe quelle valeur.

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

La méthode **`handler.get`** est une trappe pour intercepter l'accès à une propriété.

### Interceptions

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

* l'accès à une propriété : `proxy[toto]` et `proxy.truc`
* L'accès aux propriétés héritées : `Object.create(proxy)[toto]`
* `Reflect.get()`
### Invariants

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

* La valeur renvoyée pour la propriété doit être la même que la valeur de la propriété correspondante de l'objet cible si celle-ci est non-configurable et non accessible en lecture.
* La valeur renvoyée doit valoir `undefined` si la propriété correspondante de l'objet cible est une propriété d'accesseur non-configurable dont l'attribut [[Get]] vaut `undefined`.
Exemples
--------

Dans l'exemple suivant, on intercepte les accès aux propriétés :


```js
var p = new Proxy(
  {},
  {
    get: function (cible, propriété, récepteur) {
      console.log("appelée : " + propriété);
      return 10;
    },
  },
);

console.log(p.a); // "appelée : a"
// 10
```


Le code suivant ne respecte pas l'invariant :


```js
var obj = {};
Object.defineProperty(obj, "a", {
  configurable: false,
  enumerable: false,
  value: 10,
  writable: false,
});

var p = new Proxy(obj, {
  get: function (cible, propriété) {
    return 20;
  },
});

p.a; // exception TypeError levée
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-proxy-object-internal-methods-and-internal-slots-get-p-receiver |

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

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

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

* `Proxy`
* `handler` (en-US)
* `Reflect.get()`
handler.has()
=============

La méthode **`handler.has()`** est une trappe pour l'opérateur `in`.

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

Syntaxe
-------


```js
var p = new Proxy(cible, {
  has: function (cible, prop) {},
});
```

### Paramètres

Les paramètres suivants sont passés à la méthode `has`. `this` est lié au gestionnaire.

`cible`

L'objet cible.

`prop`

Le nom ou le symbole (`Symbol`) de la propriété dont on veut connaître l'existence.

### Valeur de retour

La méthode `has` doit renvoyer une valeur booléenne.

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

La méthode **`handler.has`** est une trappe pour l'opérateur `in`.

### Interceptions

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

* L'accès à une propriété : `toto in proxy`
* L'accès à une propriété héritée : `toto in Object.create(proxy)`
* Accès via l'instruction `with` : `with(proxy) { (foo); }`
* `Reflect.has()`
### Invariants

Si les invariants suivants ne sont pas respectés, le proxy lèvera une exception `TypeError` :

* Une propriété ne peut pas être indiquée comme non-existante s'il existe une propriété correspondante de l'objet cible qui est une propriété propre et non-configurable.
* Une propriété ne peut pas être indiquée comme non-existante s'il existe une propriété correspondante propre sur l'objet cible et que celui-ci n'est pas extensible.
Exemples
--------

Dans l'exemple qui suit, on intercepte l'opérateur `in` :


```js
var p = new Proxy(
  {},
  {
    has: function (cible, prop) {
      console.log("appelée : " + prop);
      return true;
    },
  },
);

console.log("a" in p); // "appelée : a"
// true
```


L'exemple suivant ne respecte pas un invariant :


```js
var obj = { a: 10 };
Object.preventExtensions(obj);
var p = new Proxy(obj, {
  has: function (cible, prop) {
    return false;
  },
});

"a" in p; // TypeError levée
```

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

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

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

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

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

* `Proxy`
* `handler` (en-US)
* L'opérateur `in`
* `Reflect.has()`
handler.ownKeys()
=================

La méthode **`handler.ownKeys()`** est une trappe pour `Object.getOwnPropertyNames()`.

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

Syntaxe
-------


```js
var p = new Proxy(cible, {
  ownKeys: function (cible) {},
});
```

### Paramètres

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

`cible`

L'objet cible.

### Valeur de retour

La méthode `ownKeys` doit renvoyer un objet énumérable.

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

La méthode **`handler.ownKeys()`** est une trappe pour intercepter les opérations de `Object.getOwnPropertyNames()`.

### Interceptions

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

* `Object.getOwnPropertyNames()`
* `Object.getOwnPropertySymbols()`
* `Object.keys()`
* `Reflect.ownKeys()`
### Invariants

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

* Le résultat de `ownKeys` doit être un tableau.
* Le type de chaque élément de ce tableau est soit une `String`, soit un `Symbol`.
* Le tableau résultant doit contenir les clés de toutes les propriétés propres non-configurables de l'objet cible.
* Si l'objet cible n'est pas extensible, la liste obtenue doit contenir toutes les clés pour les propriétés propres et aucune autre valeur.
Exemples
--------

Dans l'exemple suivant, on intercepte l'action de `Object.getOwnPropertyNames()`.


```js
var p = new Proxy(
  {},
  {
    ownKeys: function (target) {
      console.log("appelée");
      return ["a", "b", "c"];
    },
  },
);

console.log(Object.getOwnPropertyNames(p)); // "appelée"
// [ "a", "b", "c"]
```


L'exemple suivant ne respecte pas l'ensemble des invariants :


```js
var obj = {};
Object.defineProperty(obj, "a", {
  configurable: false,
  enumerable: true,
  value: 10,
});

var p = new Proxy(obj, {
  ownKeys: function (cible) {
    return [123, 12.5, true, false, undefined, null, {}, []];
  },
});

console.log(Object.getOwnPropertyNames(p));
// TypeError est levée
```

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

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

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.getOwnPropertyNames()`
* `Reflect.ownKeys()`
handler.isExtensible()
======================

La méthode **`handler.isExtensible()`** est une trappe pour intercepter les opérations de `Object.isExtensible()`.

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

Syntaxe
-------


```js
var p = new Proxy(cible, {
  isExtensible: function (cible) {},
});
```

### Paramètres

Les paramètres suivants sont passés à la méthode `isExtensible`. `this` est ici lié au gestionnaire (*handler*).

`cible`

L'objet cible.

### Valeur de retour

La méthode `isExtensible` doit renvoyer une valeur booléenne.

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

La méthode **`handler.isExtensible()`** est une trappe pour intercepter `Object.isExtensible()`.

### Interceptions

Cette trappe intercepte les opérations suivantes :

* `Object.isExtensible()`
* `Reflect.isExtensible()`
### Invariants

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

* `Object.isExtensible(proxy)` doit renvoyer la même valeur que `Object.isExtensible(cible)`.
Exemples
--------

Dans l'exemple qui suit, on intercepte `Object.isExtensible()`.


```js
var p = new Proxy(
  {},
  {
    isExtensible: function (cible) {
      console.log("appelée");
      return true;
    },
  },
);

console.log(Object.isExtensible(p)); // "appelée"
// true
```


Le code suivante ne respecte pas l'invariant et entraîne donc une exception.


```js
var p = new Proxy(
  {},
  {
    isExtensible: function (cible) {
      return false;
    },
  },
);

Object.isExtensible(p); // TypeError est levée
```

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

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

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.isExtensible()`
* `Reflect.isExtensible()`
handler.deleteProperty()
========================

La méthode **`handler.deleteProperty()`** est une trappe pour l'opérateur `delete`.

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

Syntaxe
-------


```js
var p = new Proxy(cible, {
  deleteProperty: function (cible, propriété) {},
});
```

### Paramètres

Les paramètres suivants sont passés à la méthode `deleteProperty`. `this` est lié au gestionnaire.

`cible`

L'objet cible.

`propriété`

Le nom ou le symbole (`Symbol`) de la propriété à supprimer.

### Valeur de retour

La méthode `deleteProperty()` doit renvoyer un booléen qui indique si oui ou non la propriété a été supprimée.

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

La méthode **`handler.deleteProperty()`** est une trappe permettant d'intercepter les opérations de l'opérateur `delete`.

### Interceptions

Cette trappe peut intercepter les opérations suivantes :

* La suppression d'une propriété : `delete proxy[toto]` et `delete proxy.toto`
* `Reflect.deleteProperty()`
### Invariants

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

* Une propriété ne peut pas être supprimée s'il existe une propriété correspondante sur l'objet cible qui est une propriété propre et non-configurable.
Exemples
--------

Dans l'exemple qui suit, on intercepte les opérations de `delete`.


```js
var p = new Proxy(
  {},
  {
    deleteProperty: function (cible, prop) {
      console.log("appelée sur : " + prop);
      return true;
    },
  },
);

delete p.a; // "appelée sur : a"
```

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

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

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

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

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

* `Proxy`
* `handler` (en-US)
* L'opérateur `delete`
* `Reflect.deleteProperty()`