initial commit

14 files changed, 1790 insertions, 0 deletions

diff --git a/files/fr/web/javascript/reference/objets_globaux/proxy/handler/apply/index.html b/files/fr/web/javascript/reference/objets_globaux/proxy/handler/apply/index.html
new file mode 100644
index 0000000000..21f1d44817
--- /dev/null
+++ b/files/fr/web/javascript/reference/objets_globaux/proxy/handler/apply/index.html
@@ -0,0 +1,118 @@
+---
+title: handler.apply()
+slug: Web/JavaScript/Reference/Objets_globaux/Proxy/handler/apply
+tags:
+  - ECMAScript 2015
+  - JavaScript
+  - Méthode
+  - Proxy
+  - Reference
+translation_of: Web/JavaScript/Reference/Global_Objects/Proxy/Proxy/apply
+---
+<div>{{JSRef}}</div>
+
+<p>La méthode <strong><code>handler.apply()</code></strong> représente une trappe pour un appel de fonctions.</p>
+
+<div>{{EmbedInteractiveExample("pages/js/proxyhandler-apply.html", "taller")}}</div>
+
+<p class="hidden">Le code source de cet exemple interactif est disponible dans un dépôt GitHub. Si vous souhaitez contribuez à ces exemples, n'hésitez pas à cloner <a href="https://github.com/mdn/interactive-examples">https://github.com/mdn/interactive-examples</a> et à envoyer une <em>pull request</em> !</p>
+
+<h2 id="Syntaxe">Syntaxe</h2>
+
+<pre class="brush: js">var p = new Proxy(cible, {
+  apply: function(cible, thisArg, listeArguments) {
+  }
+});
+</pre>
+
+<h3 id="Paramètres">Paramètres</h3>
+
+<p>Les paramètres suivants sont passés à la méthode <code>apply</code>. Ici, <code>this</code> est lié au gestionnaire.</p>
+
+<dl>
+ <dt><code>cible</code></dt>
+ <dd>L'objet cible.</dd>
+ <dt><code>thisArg</code></dt>
+ <dd>L'argument {{jsxref("Opérateurs/L_opérateur_this","this")}} pour cet appel.</dd>
+ <dt><code>listeArguments</code></dt>
+ <dd>La liste d'arguments pour l'appel.</dd>
+</dl>
+
+<h3 id="Valeur_de_retour">Valeur de retour</h3>
+
+<p>La méthode <code>apply</code> peut renvoyer n'importe quelle valeur.</p>
+
+<h2 id="Description">Description</h2>
+
+<p>La méthode <code><strong>handler.apply</strong></code> est une trappe pour l'appel à une fonction.</p>
+
+<h3 id="Interceptions">Interceptions</h3>
+
+<p>Cette trappe intercepte les opérations suivantes :</p>
+
+<ul>
+ <li><code>proxy(...args)</code></li>
+ <li>{{jsxref("Function.prototype.apply()")}} et {{jsxref("Function.prototype.call()")}}</li>
+ <li>{{jsxref("Reflect.apply()")}}</li>
+</ul>
+
+<h3 id="Invariants">Invariants</h3>
+
+<p>Si les invariants suivants ne sont pas respectés, le proxy lèvera une exception <code>TypeError</code> :</p>
+
+<ul>
+ <li>la cible doit pouvoir être « appelable ». Autrement dit, il doit s'agir d'une fonction.</li>
+</ul>
+
+<h2 id="Exemples">Exemples</h2>
+
+<p>Dans l'exemple ci-dessous, on piège un appel de fonction.</p>
+
+<pre class="brush: 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
+</pre>
+
+<h2 id="Spécifications">Spécifications</h2>
+
+<table class="standard-table">
+ <tbody>
+  <tr>
+   <th scope="col">Spécification</th>
+   <th scope="col">État</th>
+   <th scope="col">Commentaires</th>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES2015', '#sec-proxy-object-internal-methods-and-internal-slots-call-thisargument-argumentslist', '[[Call]]')}}</td>
+   <td>{{Spec2('ES2015')}}</td>
+   <td>Définition initiale.</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-proxy-object-internal-methods-and-internal-slots-call-thisargument-argumentslist', '[[Call]]')}}</td>
+   <td>{{Spec2('ESDraft')}}</td>
+   <td> </td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
+
+<div class="hidden">Ce tableau de compatibilité a été généré à partir de données structurées. Si vous souhaitez contribuer à ces données, n'hésitez pas à envoyer une <em>pull request</em> sur <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a>.</div>
+
+<p>{{Compat("javascript.builtins.Proxy.handler.apply")}}</p>
+
+<h2 id="Voir_aussi">Voir aussi</h2>
+
+<ul>
+ <li>{{jsxref("Proxy")}}</li>
+ <li>{{jsxref("Proxy.handler", "handler")}}</li>
+ <li>{{jsxref("Function.prototype.apply")}}</li>
+ <li>{{jsxref("Function.prototype.call")}}</li>
+ <li>{{jsxref("Reflect.apply()")}}</li>
+</ul>
diff --git a/files/fr/web/javascript/reference/objets_globaux/proxy/handler/construct/index.html b/files/fr/web/javascript/reference/objets_globaux/proxy/handler/construct/index.html
new file mode 100644
index 0000000000..90eb5f0105
--- /dev/null
+++ b/files/fr/web/javascript/reference/objets_globaux/proxy/handler/construct/index.html
@@ -0,0 +1,137 @@
+---
+title: handler.construct()
+slug: Web/JavaScript/Reference/Objets_globaux/Proxy/handler/construct
+tags:
+  - ECMAScript 2015
+  - JavaScript
+  - Méthode
+  - Proxy
+  - Reference
+translation_of: Web/JavaScript/Reference/Global_Objects/Proxy/Proxy/construct
+---
+<div>{{JSRef}}</div>
+
+<p>La méthode <code><strong>handler.construct()</strong></code> est une trappe pour l'opérateur {{jsxref("Opérateurs/L_opérateur_new", "new")}}. Afin que l'opération <code>new</code> puisse être valide sur le proxy correspondant, la cible utilisée doit avoir une méthode interne <code>[[Construct]]</code> (autrement dit, l'instruction <code>new cible</code> doit être valide).</p>
+
+<div>{{EmbedInteractiveExample("pages/js/proxyhandler-construct.html", "taller")}}</div>
+
+<p class="hidden">Le code source de cet exemple interactif est disponible dans un dépôt GitHub. Si vous souhaitez contribuez à ces exemples, n'hésitez pas à cloner <a href="https://github.com/mdn/interactive-examples">https://github.com/mdn/interactive-examples</a> et à envoyer une <em>pull request</em> !</p>
+
+<h2 id="Syntaxe">Syntaxe</h2>
+
+<pre class="brush: js">var p = new Proxy(cible, {
+  construct: function(cible, listeArguments, newTarget) {
+  }
+});
+</pre>
+
+<h3 id="Paramètres">Paramètres</h3>
+
+<p>Les paramètres suivants sont passés à la méthode <code>construct</code>.  <code>this</code> est ici lié au gestionnaire (<em>handler</em>).</p>
+
+<dl>
+ <dt><code>cible</code></dt>
+ <dd>L'objet cible.</dd>
+ <dt><code>listeArguments</code></dt>
+ <dd>La liste des arguments passés au constructeur.</dd>
+ <dt><code>newTarget</code></dt>
+ <dd>Le constructeur originellement appelé.</dd>
+</dl>
+
+<h3 id="Valeur_de_retour">Valeur de retour</h3>
+
+<p>La méthode <code>construct</code> doit renvoyer un objet.</p>
+
+<h2 id="Description">Description</h2>
+
+<p>La méthode <code><strong>handler.construct()</strong></code> est une trappe pour l'opérateur {{jsxref("Opérateurs/L_opérateur_new", "new")}}.</p>
+
+<h3 id="Interceptions">Interceptions</h3>
+
+<p>Ce trappe intercepte les opérations suivantes :</p>
+
+<ul>
+ <li><code>new proxy(...args)</code></li>
+ <li>{{jsxref("Reflect.construct()")}}</li>
+</ul>
+
+<h3 id="Invariants">Invariants</h3>
+
+<p>Si les invariants suivants ne sont pas respectés, le proxy renverra une exception {{jsxref("TypeError")}} :</p>
+
+<ul>
+ <li>Le résultat doit être un <code>Object</code>.</li>
+</ul>
+
+<h2 id="Exemples">Exemples</h2>
+
+<p>Dans l'exemple qui suit, on piège l'opérateur {{jsxref("Opérateurs/L_opérateur_new", "new")}}.</p>
+
+<pre class="brush: 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
+</pre>
+
+<p>Dans cette version, on ne respecte pas la contrainte d'invariance :</p>
+
+<pre class="brush: js">var p = new Proxy(function() {}, {
+  construct: function(target, argumentsList) {
+    return 1;
+  }
+});
+
+new p(); // Une exception TypeError est levée
+</pre>
+
+<p>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 <code>new</code>.</p>
+
+<pre class="brush: js">var p = new Proxy({}, {
+  construct: function(target, argumentsList, newTarget){
+    return {};
+  }
+});
+
+new p(); // TypeError: p is not a constructor</pre>
+
+<h2 id="Spécifications">Spécifications</h2>
+
+<table class="standard-table">
+ <tbody>
+  <tr>
+   <th scope="col">Spécification</th>
+   <th scope="col">État</th>
+   <th scope="col">Commentaires</th>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES2015', '#sec-proxy-object-internal-methods-and-internal-slots-construct-argumentslist-newtarget', '[[Construct]]')}}</td>
+   <td>{{Spec2('ES2015')}}</td>
+   <td>Définition initiale.</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-proxy-object-internal-methods-and-internal-slots-construct-argumentslist-newtarget', '[[Construct]]')}}</td>
+   <td>{{Spec2('ESDraft')}}</td>
+   <td> </td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
+
+<div class="hidden">Ce tableau de compatibilité a été généré à partir de données structurées. Si vous souhaitez contribuer à ces données, n'hésitez pas à envoyer une <em>pull request</em> sur <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a>.</div>
+
+<p>{{Compat("javascript.builtins.Proxy.handler.construct")}}</p>
+
+<h2 id="Voir_aussi">Voir aussi</h2>
+
+<ul>
+ <li>{{jsxref("Proxy")}}</li>
+ <li>{{jsxref("Proxy.handler", "handler")}}</li>
+ <li>L'opérateur {{jsxref("Opérateurs/L_opérateur_new", "new")}}</li>
+ <li>{{jsxref("Reflect.construct()")}}</li>
+</ul>
diff --git a/files/fr/web/javascript/reference/objets_globaux/proxy/handler/defineproperty/index.html b/files/fr/web/javascript/reference/objets_globaux/proxy/handler/defineproperty/index.html
new file mode 100644
index 0000000000..ea23d3c8e3
--- /dev/null
+++ b/files/fr/web/javascript/reference/objets_globaux/proxy/handler/defineproperty/index.html
@@ -0,0 +1,144 @@
+---
+title: handler.defineProperty()
+slug: Web/JavaScript/Reference/Objets_globaux/Proxy/handler/defineProperty
+tags:
+  - ECMAScript 2015
+  - JavaScript
+  - Méthode
+  - Proxy
+  - Reference
+translation_of: Web/JavaScript/Reference/Global_Objects/Proxy/Proxy/defineProperty
+---
+<div>{{JSRef}}</div>
+
+<p>La méthode <strong><code>handler.defineProperty()</code></strong> est une trappe pour {{jsxref("Object.defineProperty()")}}.</p>
+
+<div>{{EmbedInteractiveExample("pages/js/proxyhandler-defineproperty.html", "taller")}}</div>
+
+<p class="hidden">Le code source de cet exemple interactif est disponible dans un dépôt GitHub. Si vous souhaitez contribuez à ces exemples, n'hésitez pas à cloner <a href="https://github.com/mdn/interactive-examples">https://github.com/mdn/interactive-examples</a> et à envoyer une <em>pull request</em> !</p>
+
+<h2 id="Syntaxe">Syntaxe</h2>
+
+<pre class="brush: js">var p = new Proxy(cible, {
+  defineProperty: function(cible, propriété, descripteur) {
+  }
+});
+</pre>
+
+<h3 id="Paramètres">Paramètres</h3>
+
+<p>Les paramètres suivants sont passés à la méthode <code>defineProperty</code>. <code>this</code> est ici lié au gestionnaire.</p>
+
+<dl>
+ <dt><code>cible</code></dt>
+ <dd>L'objet cible.</dd>
+ <dt><code>propriété</code></dt>
+ <dd>Le nom ou le symbole ({{jsxref("Symbol")}}) de la propriété dont on veut modifier la description.</dd>
+ <dt><code>descripteur</code></dt>
+ <dd>Le descripteur de la propriété qui est à modifier ou à définir.</dd>
+</dl>
+
+<h3 id="Valeur_de_retour">Valeur de retour</h3>
+
+<p>La méthode <code>defineProperty()</code> doit renvoyer un booléen qui indique si la propriété a correctement été définie sur la cible.</p>
+
+<h2 id="Description">Description</h2>
+
+<p>La méthode <code><strong>handler.defineProperty()</strong></code> est une trappe pour {{jsxref("Object.defineProperty()")}}.</p>
+
+<h3 id="Interceptions">Interceptions</h3>
+
+<p>Cette trappe intercepte les opérations suivantes :</p>
+
+<ul>
+ <li>{{jsxref("Object.defineProperty()")}}</li>
+ <li>{{jsxref("Reflect.defineProperty()")}}</li>
+</ul>
+
+<h3 id="Invariants">Invariants</h3>
+
+<p>Si les contraintes d'invariances suivantes ne sont pas respectées, le proxy renverra une exception {{jsxref("TypeError")}} :</p>
+
+<ul>
+ <li>Une propriété ne peut pas être ajoutée si l'objet cible n'est pas extensible.</li>
+ <li>Une propriété ne peut pas être ajoutée ou modifiée pour être rendue non-configurable si elle n'existe pas comme une propriété propre non-configurable de l'objet cible.</li>
+ <li>Une propriété ne peut pas être non-configurable s'il existe une propriété correspondante de l'objet cible qui est configurable.</li>
+ <li>Si une propriété correspondante existe pour l'objet cible <code>Object.defineProperty(cible, propriété, descripteur)</code> ne lèvera pas d'exception.</li>
+ <li>En mode stricte, si le gestionnaire defineProperty renvoie une valeur fausse (dans un contexte booléen), cela entraînera une exception {{jsxref("TypeError")}}.</li>
+</ul>
+
+<h2 id="Exemples">Exemples</h2>
+
+<p>Dans le code suivant, on piège l'appel à {{jsxref("Object.defineProperty()")}}.</p>
+
+<pre class="brush: js">var p = new Proxy({}, {
+  defineProperty: function(target, prop, descriptor) {
+    console.log("appelé avec : " + prop);
+  }
+});
+
+var desc = { configurable: true, enumerable: true, value: 10 };
+Object.defineProperty(p, "a", desc); // "appelé avec : a"
+</pre>
+
+<p>Lorsqu'on appelle {{jsxref("Object.defineProperty()")}} ou {{jsxref("Reflect.defineProperty()")}}, le descripteur passé à la trappe <code>defineProperty</code> doit respecter une contrainte : seules les propriétés suivants sont utilisables, les propriétés non-standards seront ignorées :</p>
+
+<ul>
+ <li><code>enumerable</code></li>
+ <li><code>configurable</code></li>
+ <li><code>writable</code></li>
+ <li><code>value</code></li>
+ <li><code>get</code></li>
+ <li><code>set</code></li>
+</ul>
+
+<pre class="brush: js">var p = new Proxy({}, {
+  defineProperty(target, prop, descriptor) {
+    console.log(descriptor);
+    return Reflect.defineProperty(target, prop, descriptor);
+  }
+});
+
+Object.defineProperty(p, "name, {
+  value: "proxy",
+  type: "custom"
+});
+// { value: "proxy" }
+</pre>
+
+<h2 id="Spécifications">Spécifications</h2>
+
+<table class="standard-table">
+ <tbody>
+  <tr>
+   <th scope="col">Spécification</th>
+   <th scope="col">État</th>
+   <th scope="col">Commentaires</th>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES2015', '#sec-proxy-object-internal-methods-and-internal-slots-defineownproperty-p-desc', '[[DefineOwnProperty]]')}}</td>
+   <td>{{Spec2('ES2015')}}</td>
+   <td>Définition initiale.</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-proxy-object-internal-methods-and-internal-slots-defineownproperty-p-desc', '[[DefineOwnProperty]]')}}</td>
+   <td>{{Spec2('ESDraft')}}</td>
+   <td> </td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
+
+<div class="hidden">Ce tableau de compatibilité a été généré à partir de données structurées. Si vous souhaitez contribuer à ces données, n'hésitez pas à envoyer une <em>pull request</em> sur <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a>.</div>
+
+<p>{{Compat("javascript.builtins.Proxy.handler.defineProperty")}}</p>
+
+<h2 id="Voir_aussi">Voir aussi</h2>
+
+<ul>
+ <li>{{jsxref("Proxy")}}</li>
+ <li>{{jsxref("Proxy.handler", "handler")}}</li>
+ <li>{{jsxref("Object.defineProperty()")}}</li>
+ <li>{{jsxref("Reflect.defineProperty()")}}</li>
+</ul>
diff --git a/files/fr/web/javascript/reference/objets_globaux/proxy/handler/deleteproperty/index.html b/files/fr/web/javascript/reference/objets_globaux/proxy/handler/deleteproperty/index.html
new file mode 100644
index 0000000000..15828b99b3
--- /dev/null
+++ b/files/fr/web/javascript/reference/objets_globaux/proxy/handler/deleteproperty/index.html
@@ -0,0 +1,113 @@
+---
+title: handler.deleteProperty()
+slug: Web/JavaScript/Reference/Objets_globaux/Proxy/handler/deleteProperty
+tags:
+  - ECMAScript 2015
+  - JavaScript
+  - Méthode
+  - Proxy
+  - Reference
+translation_of: Web/JavaScript/Reference/Global_Objects/Proxy/Proxy/deleteProperty
+---
+<div>{{JSRef}}</div>
+
+<p>La méthode <strong><code>handler.deleteProperty()</code></strong> est une trappe pour l'opérateur {{jsxref("Opérateurs/L_opérateur_delete", "delete")}}.</p>
+
+<div>{{EmbedInteractiveExample("pages/js/proxyhandler-deleteproperty.html","taller")}}</div>
+
+<p class="hidden">Le code source de cet exemple interactif est disponible dans un dépôt GitHub. Si vous souhaitez contribuez à ces exemples, n'hésitez pas à cloner <a href="https://github.com/mdn/interactive-examples">https://github.com/mdn/interactive-examples</a> et à envoyer une <em>pull request</em> !</p>
+
+<h2 id="Syntaxe">Syntaxe</h2>
+
+<pre class="brush: js">var p = new Proxy(cible, {
+  deleteProperty: function(cible, propriété) {
+  }
+});
+</pre>
+
+<h3 id="Paramètres">Paramètres</h3>
+
+<p>Les paramètres suivants sont passés à la méthode <code>deleteProperty</code>. <code>this</code> est lié au gestionnaire.</p>
+
+<dl>
+ <dt><code>cible</code></dt>
+ <dd>L'objet cible.</dd>
+ <dt><code>propriété</code></dt>
+ <dd>Le nom ou le symbole ({{jsxref("Symbol")}}) de la propriété à supprimer.</dd>
+</dl>
+
+<h3 id="Valeur_de_retour">Valeur de retour</h3>
+
+<p>La méthode <code>deleteProperty()</code> doit renvoyer un booléen qui indique si oui ou non la propriété a été supprimée.</p>
+
+<h2 id="Description">Description</h2>
+
+<p>La méthode <code><strong>handler.deleteProperty()</strong></code> est une trappe permettant d'intercepter les opérations de l'opérateur {{jsxref("Opérateurs/L_opérateur_delete", "delete")}}.</p>
+
+<h3 id="Interceptions">Interceptions</h3>
+
+<p>Cette trappe peut intercepter les opérations suivantes :</p>
+
+<ul>
+ <li>La suppression d'une propriété : <code>delete proxy[toto]</code> et <code>delete proxy.toto</code></li>
+ <li>{{jsxref("Reflect.deleteProperty()")}}</li>
+</ul>
+
+<h3 id="Invariants">Invariants</h3>
+
+<p>Si les invarians suivants ne sont pas respectés, le proxy renverra une exception {{jsxref("TypeError")}} :</p>
+
+<ul>
+ <li>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.</li>
+</ul>
+
+<h2 id="Exemples">Exemples</h2>
+
+<p>Dans l'exemple qui suit, on intercepte les opérations de {{jsxref("Opérateurs/L_opérateur_delete", "delete")}}.</p>
+
+<pre class="brush: js">var p = new Proxy({}, {
+  deleteProperty: function(cible, prop) {
+    console.log("appelée sur : " + prop);
+    return true;
+  }
+});
+
+delete p.a; // "appelée sur : a"
+</pre>
+
+<h2 id="Spécifications">Spécifications</h2>
+
+<table class="standard-table">
+ <tbody>
+  <tr>
+   <th scope="col">Spécification</th>
+   <th scope="col">État</th>
+   <th scope="col">Commentaires</th>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES2015', '#sec-proxy-object-internal-methods-and-internal-slots-delete-p', '[[Delete]]')}}</td>
+   <td>{{Spec2('ES2015')}}</td>
+   <td>Définition initiale.</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-proxy-object-internal-methods-and-internal-slots-delete-p', '[[Delete]]')}}</td>
+   <td>{{Spec2('ESDraft')}}</td>
+   <td> </td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
+
+<div class="hidden">Ce tableau de compatibilité a été généré à partir de données structurées. Si vous souhaitez contribuer à ces données, n'hésitez pas à envoyer une <em>pull request</em> sur <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a>.</div>
+
+<p>{{Compat("javascript.builtins.Proxy.handler.deleteProperty")}}</p>
+
+<h2 id="Voir_aussi">Voir aussi</h2>
+
+<ul>
+ <li>{{jsxref("Proxy")}}</li>
+ <li>{{jsxref("Proxy.handler", "handler")}}</li>
+ <li>L'opérateur {{jsxref("Opérateurs/L_opérateur_delete", "delete")}}</li>
+ <li>{{jsxref("Reflect.deleteProperty()")}}</li>
+</ul>
diff --git a/files/fr/web/javascript/reference/objets_globaux/proxy/handler/get/index.html b/files/fr/web/javascript/reference/objets_globaux/proxy/handler/get/index.html
new file mode 100644
index 0000000000..0173263d99
--- /dev/null
+++ b/files/fr/web/javascript/reference/objets_globaux/proxy/handler/get/index.html
@@ -0,0 +1,136 @@
+---
+title: handler.get()
+slug: Web/JavaScript/Reference/Objets_globaux/Proxy/handler/get
+tags:
+  - ECMAScript 2015
+  - JavaScript
+  - Méthode
+  - Proxy
+  - Reference
+translation_of: Web/JavaScript/Reference/Global_Objects/Proxy/Proxy/get
+---
+<div>{{JSRef}}</div>
+
+<p>La méthode <strong><code>handler.get()</code></strong> est une trappe pour intercepter l'accès à la valeur d'une propriété.</p>
+
+<div>{{EmbedInteractiveExample("pages/js/proxyhandler-get.html", "taller")}}</div>
+
+<p class="hidden">Le code source de cet exemple interactif est disponible dans un dépôt GitHub. Si vous souhaitez contribuez à ces exemples, n'hésitez pas à cloner <a href="https://github.com/mdn/interactive-examples">https://github.com/mdn/interactive-examples</a> et à envoyer une <em>pull request</em> !</p>
+
+<h2 id="Syntaxe">Syntaxe</h2>
+
+<pre class="brush: js">var p = new Proxy(cible, {
+  get: function(cible, propriété, récepteur) {
+  }
+});
+</pre>
+
+<h3 id="Paramètres">Paramètres</h3>
+
+<p>Les paramètres suivants sont passés à la méthode <code>get</code>. <code>this</code> est lié au gestionnaire.</p>
+
+<dl>
+ <dt><code>cible</code></dt>
+ <dd>L'objet cible.</dd>
+ <dt><code>propriété</code></dt>
+ <dd>Le nom ou le symbole ({{jsxref("Symbol")}}) de la propriété qu'on souhaite obtenir.</dd>
+ <dt><code>récepteur</code></dt>
+ <dd>Le proxy ou un objet qui hérite du proxy.</dd>
+</dl>
+
+<h3 id="Valeur_de_retour">Valeur de retour</h3>
+
+<p>La méthode <code>get</code> peut renvoyer n'importe quelle valeur.</p>
+
+<h2 id="Description">Description</h2>
+
+<p>La méthode <code><strong>handler.get</strong></code> est une trappe pour intercepter l'accès à une propriété.</p>
+
+<h3 id="Interceptions">Interceptions</h3>
+
+<p>Cette trappe permet d'intercepter les opérations suivantes :</p>
+
+<ul>
+ <li>l'accès à une propriété : <code>proxy[toto]</code> et <code>proxy.truc</code></li>
+ <li>L'accès aux propriétés héritées : <code>Object.create(proxy)[toto]</code></li>
+ <li>{{jsxref("Reflect.get()")}}</li>
+</ul>
+
+<h3 id="Invariants">Invariants</h3>
+
+<p>Si les invariants suivants ne sont pas respectés, le proxy renverra une exception {{jsxref("TypeError")}} :</p>
+
+<ul>
+ <li>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.</li>
+ <li>La valeur renvoyée doit valoir <code>undefined</code> si la propriété correspondante de l'objet cible est une propriété d'accesseur non-configurable dont l'attribut [[Get]] vaut <code>undefined</code>.</li>
+</ul>
+
+<h2 id="Exemples">Exemples</h2>
+
+<p>Dans l'exemple suivant, on intercepte les accès aux propriétés :</p>
+
+<pre class="brush: 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
+</pre>
+
+<p>Le code suivant ne respecte pas l'invariant :</p>
+
+<pre class="brush: 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
+</pre>
+
+<h2 id="Spécifications">Spécifications</h2>
+
+<table class="standard-table">
+ <tbody>
+  <tr>
+   <th scope="col">Spécification</th>
+   <th scope="col">État</th>
+   <th scope="col">Commentaires</th>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES2015', '#sec-proxy-object-internal-methods-and-internal-slots-get-p-receiver', '[[Get]]')}}</td>
+   <td>{{Spec2('ES2015')}}</td>
+   <td>Définition initiale.</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-proxy-object-internal-methods-and-internal-slots-get-p-receiver', '[[Get]]')}}</td>
+   <td>{{Spec2('ESDraft')}}</td>
+   <td> </td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Compatiblité_des_navigateurs">Compatiblité des navigateurs</h2>
+
+<div class="hidden">Ce tableau de compatibilité a été généré à partir de données structurées. Si vous souhaitez contribuer à ces données, n'hésitez pas à envoyer une <em>pull request</em> sur <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a>.</div>
+
+<p>{{Compat("javascript.builtins.Proxy.handler.get")}}</p>
+
+<h2 id="Voir_aussi">Voir aussi</h2>
+
+<ul>
+ <li>{{jsxref("Proxy")}}</li>
+ <li>{{jsxref("Proxy.handler", "handler")}}</li>
+ <li>{{jsxref("Reflect.get()")}}</li>
+</ul>
diff --git a/files/fr/web/javascript/reference/objets_globaux/proxy/handler/getownpropertydescriptor/index.html b/files/fr/web/javascript/reference/objets_globaux/proxy/handler/getownpropertydescriptor/index.html
new file mode 100644
index 0000000000..457d906b81
--- /dev/null
+++ b/files/fr/web/javascript/reference/objets_globaux/proxy/handler/getownpropertydescriptor/index.html
@@ -0,0 +1,132 @@
+---
+title: handler.getOwnPropertyDescriptor()
+slug: Web/JavaScript/Reference/Objets_globaux/Proxy/handler/getOwnPropertyDescriptor
+tags:
+  - ECMAScript 2015
+  - JavaScript
+  - Méthode
+  - Proxy
+  - Reference
+translation_of: Web/JavaScript/Reference/Global_Objects/Proxy/Proxy/getOwnPropertyDescriptor
+---
+<div>{{JSRef}}</div>
+
+<p>La méthode <strong><code>handler.getOwnPropertyDescriptor()</code></strong> est une trappe pour intercepter {{jsxref("Object.getOwnPropertyDescriptor()")}}.</p>
+
+<div>{{EmbedInteractiveExample("pages/js/proxyhandler-getownpropertydescriptor.html", "taller")}}</div>
+
+<p class="hidden">Le code source de cet exemple interactif est disponible dans un dépôt GitHub. Si vous souhaitez contribuez à ces exemples, n'hésitez pas à cloner <a href="https://github.com/mdn/interactive-examples">https://github.com/mdn/interactive-examples</a> et à envoyer une <em>pull request</em> !</p>
+
+<h2 id="Syntaxe">Syntaxe</h2>
+
+<pre class="brush: js">var p = new Proxy(cible, {
+  getOwnPropertyDescriptor: function(cible, prop) {
+  }
+});
+</pre>
+
+<h3 id="Paramètres">Paramètres</h3>
+
+<p>Les paramètres suivants sont passés à la méthode <code>getOwnPropertyDescriptor</code>. <code>this</code> est ici lié au gestionnaire (<em>handler</em>).</p>
+
+<dl>
+ <dt><code>cible</code></dt>
+ <dd>L'objet cible</dd>
+ <dt><code>prop</code></dt>
+ <dd>Le nom de la propriété dont on souhaite obtenir le descripteur.</dd>
+</dl>
+
+<h3 id="Valeur_de_retour">Valeur de retour</h3>
+
+<p>La méthode <code>getOwnPropertyDescriptor</code> doit renvoyer un objet ou <code>undefined</code>.</p>
+
+<h2 id="Description">Description</h2>
+
+<p>La méthode <code><strong>handler.getOwnPropertyDescriptor()</strong></code> est une trappe pour un proxy afin d'intercepter les opérations effectuées avec {{jsxref("Object.getOwnPropertyDescriptor()")}}.</p>
+
+<h3 id="Interceptions">Interceptions</h3>
+
+<p>Cette trappe permet d'intercepter :</p>
+
+<ul>
+ <li>{{jsxref("Object.getOwnPropertyDescriptor()")}}</li>
+ <li>{{jsxref("Reflect.getOwnPropertyDescriptor()")}}</li>
+</ul>
+
+<h3 id="Invariants">Invariants</h3>
+
+<p>Si les invariants suivants ne sont pas respectés, le proxy lèvera une exception {{jsxref("TypeError")}} :</p>
+
+<ul>
+ <li><code>getOwnPropertyDescriptor</code> doit renvoyer un objet ou <code>undefined</code>.</li>
+ <li>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.</li>
+ <li>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 que l'objet cible n'est pas extensible.</li>
+ <li>Une propriété ne peut pas être indiquée comme existante si elle n'existe pas de façon correspondante sur l'objet cible et que l'objet cible n'est pas extensible.</li>
+ <li>Une propriété ne peut pas être indiquée comme non-configurable si la propriété correspondante n'existe pas pour l'objet cible ou si elle existe comme un propriété propre configurable.</li>
+ <li>Le résultat de <code>Object.getOwnPropertyDescriptor(cible)</code> peut être appliqué à l'objet cible avec <code>Object.defineProperty</code> sans que cela lève une exception.</li>
+</ul>
+
+<h2 id="Exemples">Exemples</h2>
+
+<p>Dans l'exemple qui suit, on intercepte {{jsxref("Object.getOwnPropertyDescriptor()")}}.</p>
+
+<pre class="brush: js">var p = new Proxy({ a: 20 }, {
+  getOwnPropertyDescriptor: function(cible, prop) {
+    console.log("appelée : " + prop);
+    return { configurable: true, enumerable: true, value: 10 };
+  }
+});
+
+console.log(Object.getOwnPropertyDescriptor(p, "a").value); // "appelée : a"
+                                                            // 10
+</pre>
+
+<p>L'exemple suivant ne respecte pas un invariant :</p>
+
+<pre class="brush: js">var obj = { a: 10 };
+Object.preventExtensions(obj);
+var p = new Proxy(obj, {
+  getOwnPropertyDescriptor: function(cible, prop) {
+    return undefined;
+  }
+});
+
+Object.getOwnPropertyDescriptor(p, "a"); // Une exception TypeError est renvoyée
+</pre>
+
+<h2 id="Spécifications">Spécifications</h2>
+
+<table class="standard-table">
+ <tbody>
+  <tr>
+   <th scope="col">Spécification</th>
+   <th scope="col">État</th>
+   <th scope="col">Commentaires</th>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES2015', '#sec-proxy-object-internal-methods-and-internal-slots-getownproperty-p', '[[GetOwnProperty]]')}}</td>
+   <td>{{Spec2('ES2015')}}</td>
+   <td>Définition initiale.</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-proxy-object-internal-methods-and-internal-slots-getownproperty-p', '[[GetOwnProperty]]')}}</td>
+   <td>{{Spec2('ESDraft')}}</td>
+   <td> </td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
+
+<div class="hidden">Ce tableau de compatibilité a été généré à partir de données structurées. Si vous souhaitez contribuer à ces données, n'hésitez pas à envoyer une <em>pull request</em> sur <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a>.</div>
+
+<p>{{Compat("javascript.builtins.Proxy.handler.getOwnPropertyDescriptor")}}</p>
+
+<h2 id="Voir_aussi">Voir aussi</h2>
+
+<ul>
+ <li>{{jsxref("Proxy")}}</li>
+ <li>{{jsxref("Proxy.handler", "handler")}}</li>
+ <li>{{jsxref("Object.getOwnPropertyDescriptor()")}}</li>
+ <li>{{jsxref("Reflect.getOwnPropertyDescriptor()")}}</li>
+</ul>
diff --git a/files/fr/web/javascript/reference/objets_globaux/proxy/handler/getprototypeof/index.html b/files/fr/web/javascript/reference/objets_globaux/proxy/handler/getprototypeof/index.html
new file mode 100644
index 0000000000..1b5f73d3db
--- /dev/null
+++ b/files/fr/web/javascript/reference/objets_globaux/proxy/handler/getprototypeof/index.html
@@ -0,0 +1,154 @@
+---
+title: handler.getPrototypeOf()
+slug: Web/JavaScript/Reference/Objets_globaux/Proxy/handler/getPrototypeOf
+tags:
+  - ECMAScript 2015
+  - JavaScript
+  - Méthode
+  - Proxy
+  - Reference
+translation_of: Web/JavaScript/Reference/Global_Objects/Proxy/Proxy/getPrototypeOf
+---
+<div>{{JSRef}}</div>
+
+<p>La méthode <strong><code>handler.getPrototypeOf()</code></strong> représente une trappe pour la méthode interne <code>[[GetPrototypeOf]]</code>.</p>
+
+<div>{{EmbedInteractiveExample("pages/js/proxyhandler-getprototypeof.html", "taller")}}</div>
+
+<p class="hidden">Le code source de cet exemple interactif est disponible dans un dépôt GitHub. Si vous souhaitez contribuez à ces exemples, n'hésitez pas à cloner <a href="https://github.com/mdn/interactive-examples">https://github.com/mdn/interactive-examples</a> et à envoyer une <em>pull request</em> !</p>
+
+<h2 id="Syntaxe">Syntaxe</h2>
+
+<pre class="brush: js">var p = new Proxy(obj, {
+  getPrototypeOf(cible) {
+  ...
+  }
+});
+</pre>
+
+<h3 id="Paramètres">Paramètres</h3>
+
+<p>Le paramètre suivant est passé à la méthode <code>getPrototypeOf</code>. <code>this</code> est lié au gestionnaire.</p>
+
+<dl>
+ <dt><code>cible</code></dt>
+ <dd>L'objet cible.</dd>
+</dl>
+
+<h3 id="Valeur_de_retour">Valeur de retour</h3>
+
+<p>La méthode <code>getPrototypeOf</code> doit renvoyer un objet ou <code>null</code>.</p>
+
+<h2 id="Description">Description</h2>
+
+<h3 id="Interceptions">Interceptions</h3>
+
+<p>Cette trappe permet d'intercepter les opérations suivantes :</p>
+
+<ul>
+ <li>{{jsxref("Object.getPrototypeOf()")}}</li>
+ <li>{{jsxref("Reflect.getPrototypeOf()")}}</li>
+ <li>{{jsxref("Object/proto", "__proto__")}}</li>
+ <li>{{jsxref("Object.prototype.isPrototypeOf()")}}</li>
+ <li>{{jsxref("Opérateurs/instanceof", "instanceof")}}</li>
+</ul>
+
+<h3 id="Invariants">Invariants</h3>
+
+<p>Si les invariants suivant ne sont pas respectés, le proxy renverra une exception {{jsxref("TypeError")}} :</p>
+
+<ul>
+ <li><code>getPrototypeOf</code> doit renvoyer un objet ou <code>null</code>.</li>
+ <li>Si la <code>cible</code> n'est pas extensible, <code>Object.getPrototypeOf(proxy)</code> doit renvoyer la même valeur que <code>Object.getPrototypeOf(cible)</code>.</li>
+</ul>
+
+<h2 id="Exemples">Exemples</h2>
+
+<h3 id="Utilisation_simple">Utilisation simple</h3>
+
+<pre class="brush: 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
+</pre>
+
+<h3 id="Cinq_façons_de_déclencher_la_trappe_getPrototypeOf">Cinq façons de déclencher la trappe <code>getPrototypeOf</code></h3>
+
+<pre class="brush: 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
+);
+</pre>
+
+<h3 id="Deux_types_d'exceptions">Deux types d'exceptions</h3>
+
+<pre class="brush: 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
+</pre>
+
+<h2 id="Spécifications">Spécifications</h2>
+
+<table class="standard-table">
+ <tbody>
+  <tr>
+   <th scope="col">Spécification</th>
+   <th scope="col">État</th>
+   <th scope="col">Commentaires</th>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES2015', '#sec-proxy-object-internal-methods-and-internal-slots-getprototypeof', '[[GetPrototypeOf]]')}}</td>
+   <td>{{Spec2('ES2015')}}</td>
+   <td>Définition initiale.</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-proxy-object-internal-methods-and-internal-slots-getprototypeof', '[[GetPrototypeOf]]')}}</td>
+   <td>{{Spec2('ESDraft')}}</td>
+   <td> </td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
+
+<div class="hidden">Ce tableau de compatibilité a été généré à partir de données structurées. Si vous souhaitez contribuer à ces données, n'hésitez pas à envoyer une <em>pull request</em> sur <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a>.</div>
+
+<p>{{Compat("javascript.builtins.Proxy.handler.getPrototypeOf")}}</p>
+
+<h2 id="Voir_aussi">Voir aussi</h2>
+
+<ul>
+ <li>{{jsxref("Proxy")}}</li>
+ <li>{{jsxref("Proxy.handler", "handler")}}</li>
+ <li>{{jsxref("Object.getPrototypeOf()")}}</li>
+ <li>{{jsxref("Reflect.getPrototypeOf()")}}</li>
+</ul>
diff --git a/files/fr/web/javascript/reference/objets_globaux/proxy/handler/has/index.html b/files/fr/web/javascript/reference/objets_globaux/proxy/handler/has/index.html
new file mode 100644
index 0000000000..faded452ad
--- /dev/null
+++ b/files/fr/web/javascript/reference/objets_globaux/proxy/handler/has/index.html
@@ -0,0 +1,130 @@
+---
+title: handler.has()
+slug: Web/JavaScript/Reference/Objets_globaux/Proxy/handler/has
+tags:
+  - ECMAScript 2015
+  - JavaScript
+  - Méthode
+  - Proxy
+  - Reference
+translation_of: Web/JavaScript/Reference/Global_Objects/Proxy/Proxy/has
+---
+<div>{{JSRef}}</div>
+
+<p>La méthode <strong><code>handler.has()</code></strong> est une trappe pour l'opérateur {{jsxref("Opérateurs/L_opérateur_in", "in")}}.</p>
+
+<div>{{EmbedInteractiveExample("pages/js/proxyhandler-has.html", "taller")}}</div>
+
+<p class="hidden">Le code source de cet exemple interactif est disponible dans un dépôt GitHub. Si vous souhaitez contribuez à ces exemples, n'hésitez pas à cloner <a href="https://github.com/mdn/interactive-examples">https://github.com/mdn/interactive-examples</a> et à envoyer une <em>pull request</em> !</p>
+
+<h2 id="Syntaxe">Syntaxe</h2>
+
+<pre class="brush: js">var p = new Proxy(cible, {
+  has: function(cible, prop) {
+  }
+});
+</pre>
+
+<h3 id="Paramètres">Paramètres</h3>
+
+<p>Les paramètres suivants sont passés à la méthode <code>has</code>. <code>this</code> est lié au gestionnaire.</p>
+
+<dl>
+ <dt><code>cible</code></dt>
+ <dd>L'objet cible.</dd>
+ <dt><code>prop</code></dt>
+ <dd>Le nom ou le symbole ({{jsxref("Symbol")}}) de la propriété dont on veut connaître l'existence.</dd>
+</dl>
+
+<h3 id="Valeur_de_retour">Valeur de retour</h3>
+
+<p>La méthode <code>has</code> doit renvoyer une valeur booléenne.</p>
+
+<h2 id="Description">Description</h2>
+
+<p>La méthode <code><strong>handler.has</strong></code> est une trappe pour l'opérateur {{jsxref("Opérateurs/L_opérateur_in", "in")}}.</p>
+
+<h3 id="Interceptions">Interceptions</h3>
+
+<p>Cette trappe permet d'intercepter les opérations suivantes :</p>
+
+<ul>
+ <li>L'accès à une propriété : <code>toto in proxy</code></li>
+ <li>L'accès à une propriété héritée : <code>toto in Object.create(proxy)</code></li>
+ <li>Accès via l'instruction <code><a href="/fr/docs/Web/JavaScript/Reference/Instructions/with">with</a></code> : <code>with(proxy) { (foo); }</code></li>
+ <li>{{jsxref("Reflect.has()")}}</li>
+</ul>
+
+<h3 id="Invariants">Invariants</h3>
+
+<p>Si les invariants suivants ne sont pas respectés, le proxy lèvera une exception {{jsxref("TypeError")}} :</p>
+
+<ul>
+ <li>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.</li>
+ <li>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.</li>
+</ul>
+
+<h2 id="Exemples">Exemples</h2>
+
+<p>Dans l'exemple qui suit, on intercepte l'opérateur {{jsxref("Opérateurs/L_opérateur_in", "in")}} :</p>
+
+<pre class="brush: 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
+</pre>
+
+<p>L'exemple suivant ne respecte pas un invariant :</p>
+
+<pre class="brush: 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
+</pre>
+
+<h2 id="Spécifications">Spécifications</h2>
+
+<table class="standard-table">
+ <tbody>
+  <tr>
+   <th scope="col">Spécification</th>
+   <th scope="col">État</th>
+   <th scope="col">Commentaires</th>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES2015', '#sec-proxy-object-internal-methods-and-internal-slots-hasproperty-p', '[[HasProperty]]')}}</td>
+   <td>{{Spec2('ES2015')}}</td>
+   <td>Définition initiale.</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-proxy-object-internal-methods-and-internal-slots-hasproperty-p', '[[HasProperty]]')}}</td>
+   <td>{{Spec2('ESDraft')}}</td>
+   <td> </td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
+
+<div class="hidden">Ce tableau de compatibilité a été généré à partir de données structurées. Si vous souhaitez contribuer à ces données, n'hésitez pas à envoyer une <em>pull request</em> sur <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a>.</div>
+
+<p>{{Compat("javascript.builtins.Proxy.handler.has")}}</p>
+
+<h2 id="Voir_aussi">Voir aussi</h2>
+
+<ul>
+ <li>{{jsxref("Proxy")}}</li>
+ <li>{{jsxref("Proxy.handler", "handler")}}</li>
+ <li>L'opérateur {{jsxref("Opérateurs/L_opérateur_in", "in")}}</li>
+ <li>{{jsxref("Reflect.has()")}}</li>
+</ul>
diff --git a/files/fr/web/javascript/reference/objets_globaux/proxy/handler/index.html b/files/fr/web/javascript/reference/objets_globaux/proxy/handler/index.html
new file mode 100644
index 0000000000..9b825973e9
--- /dev/null
+++ b/files/fr/web/javascript/reference/objets_globaux/proxy/handler/index.html
@@ -0,0 +1,82 @@
+---
+title: Gestionnaire de Proxy (handler)
+slug: Web/JavaScript/Reference/Objets_globaux/Proxy/handler
+tags:
+  - ECMAScript 2015
+  - JavaScript
+  - Proxy
+  - Reference
+translation_of: Web/JavaScript/Reference/Global_Objects/Proxy/Proxy
+---
+<div>{{JSRef}}</div>
+
+<p>L'objet gestionnaire d'un proxy est un objet qui contient les trappes de captures (<em>traps</em>) pour le  {{jsxref("Proxy", "proxy", "", 1)}}.</p>
+
+<h2 id="Méthodes">Méthodes</h2>
+
+<p>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.</p>
+
+<dl>
+ <dt>{{jsxref("Objets_globaux/Proxy/handler/getPrototypeOf", "handler.getPrototypeOf()")}}</dt>
+ <dd>Une trappe pour {{jsxref("Object.getPrototypeOf")}}.</dd>
+ <dt>{{jsxref("Objets_globaux/Proxy/handler/setPrototypeOf", "handler.setPrototypeOf()")}}</dt>
+ <dd>Une trappe pour {{jsxref("Object.setPrototypeOf")}}.</dd>
+ <dt>{{jsxref("Objets_globaux/Proxy/handler/isExtensible", "handler.isExtensible()")}}</dt>
+ <dd>Une trappe pour {{jsxref("Object.isExtensible")}}.</dd>
+ <dt>{{jsxref("Objets_globaux/Proxy/handler/preventExtensions", "handler.preventExtensions()")}}</dt>
+ <dd>Une trappe pour {{jsxref("Object.preventExtensions")}}.</dd>
+ <dt>{{jsxref("Objets_globaux/Proxy/handler/getOwnPropertyDescriptor", "handler.getOwnPropertyDescriptor()")}}</dt>
+ <dd>Une trappe pour {{jsxref("Object.getOwnPropertyDescriptor")}}.</dd>
+ <dt>{{jsxref("Objets_globaux/Proxy/handler/defineProperty", "handler.defineProperty()")}}</dt>
+ <dd>Une trappe pour {{jsxref("Object.defineProperty")}}.</dd>
+ <dt>{{jsxref("Objets_globaux/Proxy/handler/has", "handler.has()")}}</dt>
+ <dd>Une trappe pour l'opérateur {{jsxref("Opérateurs/L_opérateur_in", "in")}}.</dd>
+ <dt>{{jsxref("Objets_globaux/Proxy/handler/get", "handler.get()")}}</dt>
+ <dd>Une trappe pour l'accès aux valeurs des propriétés.</dd>
+ <dt>{{jsxref("Objets_globaux/Proxy/handler/set", "handler.set()")}}</dt>
+ <dd>Une trappe pour la définition des valeurs des propriétés.</dd>
+ <dt>{{jsxref("Objets_globaux/Proxy/handler/deleteProperty", "handler.deleteProperty()")}}</dt>
+ <dd>Une trappe pour l'opérateur {{jsxref("Opérateurs/L_opérateur_delete", "delete")}}.</dd>
+ <dt>{{jsxref("Objets_globaux/Proxy/handler/ownKeys", "handler.ownKeys()")}}</dt>
+ <dd>Une trappe pour {{jsxref("Object.getOwnPropertyNames")}} et {{jsxref("Object.getOwnPropertySymbols")}}.</dd>
+ <dt>{{jsxref("Objets_globaux/Proxy/handler/apply", "handler.apply()")}}</dt>
+ <dd>Une trappe pour l'appel d'une fonction.</dd>
+ <dt>{{jsxref("Objets_globaux/Proxy/handler/construct", "handler.construct()")}}</dt>
+ <dd>Une trappe pour l'opérateur {{jsxref("Opérateurs/L_opérateur_new", "new")}}.</dd>
+</dl>
+
+<p>Certaines trappes non standards sont désormais <a href="/fr/docs/JavaScript/Reference/Annexes/Fonctionnalités_dépréciées#Proxy">obsolètes et ont été supprimées</a>.</p>
+
+<h2 id="Spécifications">Spécifications</h2>
+
+<table class="standard-table">
+ <tbody>
+  <tr>
+   <th scope="col">Spécification</th>
+   <th scope="col">État</th>
+   <th scope="col">Commentaires</th>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES2015', '#sec-proxy-object-internal-methods-and-internal-slots', 'Proxy Object Internal Methods and Internal Slots')}}</td>
+   <td>{{Spec2('ES2015')}}</td>
+   <td>Définition initiale.</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-proxy-object-internal-methods-and-internal-slots', 'Proxy Object Internal Methods and Internal Slots')}}</td>
+   <td>{{Spec2('ESDraft')}}</td>
+   <td>La trappe pour <code>enumerate</code> a été retirée.</td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
+
+<div class="hidden">Ce tableau de compatibilité a été généré à partir de données structurées. Si vous souhaitez contribuer à ces données, n'hésitez pas à envoyer une <em>pull request</em> sur <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a>.</div>
+
+<p>{{Compat("javascript.builtins.Proxy.handler")}}</p>
+
+<h2 id="Voir_aussi">Voir aussi</h2>
+
+<ul>
+ <li>{{jsxref("Proxy")}}</li>
+</ul>
diff --git a/files/fr/web/javascript/reference/objets_globaux/proxy/handler/isextensible/index.html b/files/fr/web/javascript/reference/objets_globaux/proxy/handler/isextensible/index.html
new file mode 100644
index 0000000000..df26cad63d
--- /dev/null
+++ b/files/fr/web/javascript/reference/objets_globaux/proxy/handler/isextensible/index.html
@@ -0,0 +1,123 @@
+---
+title: handler.isExtensible()
+slug: Web/JavaScript/Reference/Objets_globaux/Proxy/handler/isExtensible
+tags:
+  - ECMAScript 2015
+  - JavaScript
+  - Méthode
+  - Proxy
+  - Reference
+translation_of: Web/JavaScript/Reference/Global_Objects/Proxy/Proxy/isExtensible
+---
+<div>{{JSRef}}</div>
+
+<p>La méthode <strong><code>handler.isExtensible()</code></strong> est une trappe pour intercepter les opérations de {{jsxref("Object.isExtensible()")}}.</p>
+
+<div>{{EmbedInteractiveExample("pages/js/proxyhandler-isextensible.html", "taller")}}</div>
+
+<p class="hidden">Le code source de cet exemple interactif est disponible dans un dépôt GitHub. Si vous souhaitez contribuez à ces exemples, n'hésitez pas à cloner <a href="https://github.com/mdn/interactive-examples">https://github.com/mdn/interactive-examples</a> et à envoyer une <em>pull request</em> !</p>
+
+<h2 id="Syntaxe">Syntaxe</h2>
+
+<pre class="brush: js">var p = new Proxy(cible, {
+  isExtensible: function(cible) {
+  }
+});
+</pre>
+
+<h3 id="Paramètres">Paramètres</h3>
+
+<p>Les paramètres suivants sont passés à la méthode <code>isExtensible</code>. <code>this</code> est ici lié au gestionnaire (<em>handler</em>).</p>
+
+<dl>
+ <dt><code>cible</code></dt>
+ <dd>L'objet cible.</dd>
+</dl>
+
+<h3 id="Valeur_de_retour">Valeur de retour</h3>
+
+<p>La méthode <code>isExtensible</code> doit renvoyer une valeur booléenne.</p>
+
+<h2 id="Description">Description</h2>
+
+<p>La méthode <code><strong>handler.isExtensible()</strong></code> est une trappe pour intercepter {{jsxref("Object.isExtensible()")}}.</p>
+
+<h3 id="Interceptions">Interceptions</h3>
+
+<p>Cette trappe intercepte les opérations suivantes :</p>
+
+<ul>
+ <li>{{jsxref("Object.isExtensible()")}}</li>
+ <li>{{jsxref("Reflect.isExtensible()")}}</li>
+</ul>
+
+<h3 id="Invariants">Invariants</h3>
+
+<p>Si les invariants suivants ne sont pas respectés, le proxy renverra une exception  {{jsxref("TypeError")}} :</p>
+
+<ul>
+ <li><code>Object.isExtensible(proxy)</code> doit renvoyer la même valeur que <code>Object.isExtensible(cible)</code>.</li>
+</ul>
+
+<h2 id="Exemples">Exemples</h2>
+
+<p>Dans l'exemple qui suit, on intercepte {{jsxref("Object.isExtensible()")}}.</p>
+
+<pre class="brush: js">var p = new Proxy({}, {
+  isExtensible: function(cible) {
+    console.log("appelée");
+    return true;
+  }
+});
+
+console.log(Object.isExtensible(p)); // "appelée"
+                                     // true
+</pre>
+
+<p>Le code suivante ne respecte pas l'invariant et entraîne donc une exception.</p>
+
+<pre class="brush: js">var p = new Proxy({}, {
+  isExtensible: function(cible) {
+    return false;
+  }
+});
+
+Object.isExtensible(p); // TypeError est levée
+</pre>
+
+<h2 id="Spécifications">Spécifications</h2>
+
+<table class="standard-table">
+ <tbody>
+  <tr>
+   <th scope="col">Spécification</th>
+   <th scope="col">État</th>
+   <th scope="col">Commentaires</th>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES2015', '#sec-proxy-object-internal-methods-and-internal-slots-isextensible', '[[IsExtensible]]')}}</td>
+   <td>{{Spec2('ES2015')}}</td>
+   <td>Définition initiale.</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-proxy-object-internal-methods-and-internal-slots-isextensible', '[[IsExtensible]]')}}</td>
+   <td>{{Spec2('ESDraft')}}</td>
+   <td> </td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
+
+<div class="hidden">Ce tableau de compatibilité a été généré à partir de données structurées. Si vous souhaitez contribuer à ces données, n'hésitez pas à envoyer une <em>pull request</em> sur <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a>.</div>
+
+<p>{{Compat("javascript.builtins.Proxy.handler.isExtensible")}}</p>
+
+<h2 id="Voir_aussi">Voir aussi</h2>
+
+<ul>
+ <li>{{jsxref("Proxy")}}</li>
+ <li>{{jsxref("Proxy.handler", "handler")}}</li>
+ <li>{{jsxref("Object.isExtensible()")}}</li>
+ <li>{{jsxref("Reflect.isExtensible()")}}</li>
+</ul>
diff --git a/files/fr/web/javascript/reference/objets_globaux/proxy/handler/ownkeys/index.html b/files/fr/web/javascript/reference/objets_globaux/proxy/handler/ownkeys/index.html
new file mode 100644
index 0000000000..b60a836ded
--- /dev/null
+++ b/files/fr/web/javascript/reference/objets_globaux/proxy/handler/ownkeys/index.html
@@ -0,0 +1,136 @@
+---
+title: handler.ownKeys()
+slug: Web/JavaScript/Reference/Objets_globaux/Proxy/handler/ownKeys
+tags:
+  - ECMAScript 2015
+  - JavaScript
+  - Méthode
+  - Proxy
+  - Reference
+translation_of: Web/JavaScript/Reference/Global_Objects/Proxy/Proxy/ownKeys
+---
+<div>{{JSRef}}</div>
+
+<p>La méthode <strong><code>handler.ownKeys()</code></strong> est une trappe pour {{jsxref("Object.getOwnPropertyNames()")}}.</p>
+
+<div>{{EmbedInteractiveExample("pages/js/proxyhandler-ownkeys.html", "taller")}}</div>
+
+<p class="hidden">Le code source de cet exemple interactif est disponible dans un dépôt GitHub. Si vous souhaitez contribuez à ces exemples, n'hésitez pas à cloner <a href="https://github.com/mdn/interactive-examples">https://github.com/mdn/interactive-examples</a> et à envoyer une <em>pull request</em> !</p>
+
+<h2 id="Syntaxe">Syntaxe</h2>
+
+<pre class="brush: js">var p = new Proxy(cible, {
+  ownKeys: function(cible) {
+  }
+});
+</pre>
+
+<h3 id="Paramètres">Paramètres</h3>
+
+<p>Le paramètre suivant est passé à la méthode <code>ownKeys</code>. <code>this</code> est lié au gestionnaire.</p>
+
+<dl>
+ <dt><code>cible</code></dt>
+ <dd>L'objet cible.</dd>
+</dl>
+
+<h3 id="Valeur_de_retour">Valeur de retour</h3>
+
+<p>La méthode <code>ownKeys</code> doit renvoyer un objet énumérable.</p>
+
+<h2 id="Description">Description</h2>
+
+<p>La méthode <code><strong>handler.ownKeys()</strong></code> est une trappe pour intercepter les opérations de {{jsxref("Object.getOwnPropertyNames()")}}.</p>
+
+<h3 id="Interceptions">Interceptions</h3>
+
+<p>Cette trappe permet d'intercepter les opérations suivantes :</p>
+
+<ul>
+ <li>{{jsxref("Object.getOwnPropertyNames()")}}</li>
+ <li>{{jsxref("Object.getOwnPropertySymbols()")}}</li>
+ <li>{{jsxref("Object.keys()")}}</li>
+ <li>{{jsxref("Reflect.ownKeys()")}}</li>
+</ul>
+
+<h3 id="Invariants">Invariants</h3>
+
+<p>Si les invariants suivants ne sont pas respectés, le proxy renverra une exception {{jsxref("TypeError")}} :</p>
+
+<ul>
+ <li>Le résultat de <code>ownKeys</code> doit être un tableau.</li>
+ <li>Le type de chaque élément de ce tableau est soit une {{jsxref("String")}}, soit un {{jsxref("Symbol")}}.</li>
+ <li>Le tableau résultant doit contenir les clés de toutes les propriétés propres non-configurables de l'objet cible.</li>
+ <li>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.</li>
+</ul>
+
+<h2 id="Exemples">Exemples</h2>
+
+<p>Dans l'exemple suivant, on intercepte l'action de {{jsxref("Object.getOwnPropertyNames()")}}.</p>
+
+<pre class="brush: 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"]
+</pre>
+
+<p>L'exemple suivant ne respecte pas l'ensemble des invariants :</p>
+
+<pre class="brush: js  example-bad">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
+</pre>
+
+<h2 id="Spécifications">Spécifications</h2>
+
+<table class="standard-table">
+ <tbody>
+  <tr>
+   <th scope="col">Spécification</th>
+   <th scope="col">État</th>
+   <th scope="col">Commentaires</th>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES2015', '#sec-proxy-object-internal-methods-and-internal-slots-ownpropertykeys', '[[OwnPropertyKeys]]')}}</td>
+   <td>{{Spec2('ES2015')}}</td>
+   <td>Définition initiale.</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-proxy-object-internal-methods-and-internal-slots-ownpropertykeys', '[[OwnPropertyKeys]]')}}</td>
+   <td>{{Spec2('ESDraft')}}</td>
+   <td> </td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
+
+<div class="hidden">Ce tableau de compatibilité a été généré à partir de données structurées. Si vous souhaitez contribuer à ces données, n'hésitez pas à envoyer une <em>pull request</em> sur <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a>.</div>
+
+<p>{{Compat("javascript.builtins.Proxy.handler.ownKeys")}}</p>
+
+<h2 id="Voir_aussi">Voir aussi</h2>
+
+<ul>
+ <li>{{jsxref("Proxy")}}</li>
+ <li>{{jsxref("Proxy.handler", "handler")}}</li>
+ <li>{{jsxref("Object.getOwnPropertyNames()")}}</li>
+ <li>{{jsxref("Reflect.ownKeys()")}}</li>
+</ul>
diff --git a/files/fr/web/javascript/reference/objets_globaux/proxy/handler/preventextensions/index.html b/files/fr/web/javascript/reference/objets_globaux/proxy/handler/preventextensions/index.html
new file mode 100644
index 0000000000..e62fa36d4e
--- /dev/null
+++ b/files/fr/web/javascript/reference/objets_globaux/proxy/handler/preventextensions/index.html
@@ -0,0 +1,124 @@
+---
+title: handler.preventExtensions()
+slug: Web/JavaScript/Reference/Objets_globaux/Proxy/handler/preventExtensions
+tags:
+  - ECMAScript 2015
+  - JavaScript
+  - Méthode
+  - Proxy
+  - Reference
+translation_of: Web/JavaScript/Reference/Global_Objects/Proxy/Proxy/preventExtensions
+---
+<div>{{JSRef}}</div>
+
+<p>La méthode <strong><code>handler.preventExtensions()</code></strong> est une trappe pour {{jsxref("Object.preventExtensions()")}}.</p>
+
+<div>{{EmbedInteractiveExample("pages/js/proxyhandler-preventextensions.html", "taller")}}</div>
+
+<p class="hidden">Le code source de cet exemple interactif est disponible dans un dépôt GitHub. Si vous souhaitez contribuez à ces exemples, n'hésitez pas à cloner <a href="https://github.com/mdn/interactive-examples">https://github.com/mdn/interactive-examples</a> et à envoyer une <em>pull request</em> !</p>
+
+<h2 id="Syntaxe">Syntaxe</h2>
+
+<pre class="brush: js">var p = new Proxy(cible, {
+  preventExtensions: function(cible) {
+  }
+});
+</pre>
+
+<h3 id="Paramètres">Paramètres</h3>
+
+<p>Le paramètre suivant est passé à la méthode <code>preventExtensions</code>. <code>this</code> est lié au gestionnaire (<em>handler</em>).</p>
+
+<dl>
+ <dt><code>cible</code></dt>
+ <dd>L'objet cible.</dd>
+</dl>
+
+<h3 id="Valeur_de_retour">Valeur de retour</h3>
+
+<p>La méthode <code>preventExtensions</code> doit renvoyer une valeur booléenne.</p>
+
+<h2 id="Description">Description</h2>
+
+<p>La méthode <code><strong>handler.preventExtensions()</strong></code> est une trappe pour intercepter {{jsxref("Object.preventExtensions()")}}.</p>
+
+<h3 id="Interceptions">Interceptions</h3>
+
+<p>Cette trappe peut intercepter les opérations de :</p>
+
+<ul>
+ <li>{{jsxref("Object.preventExtensions()")}}</li>
+ <li>{{jsxref("Reflect.preventExtensions()")}}</li>
+</ul>
+
+<h3 id="Invariants">Invariants</h3>
+
+<p>Si les invariants suivants ne sont pas respectés, le proxy renverra une execption {{jsxref("TypeError")}} :</p>
+
+<ul>
+ <li><code>Object.preventExtensions(proxy)</code> ne renvoie <code>true</code> que si <code>Object.isExtensible(proxy)</code> vaut <code>false</code>.</li>
+</ul>
+
+<h2 id="Exemples">Exemples</h2>
+
+<p>On intercepte l'appel à {{jsxref("Object.preventExtensions()")}} dans l'exemple suivant :</p>
+
+<pre class="brush: js">var p = new Proxy({}, {
+  preventExtensions: function(cible) {
+    console.log("appelé");
+    Object.preventExtensions(cible);
+    return true;
+  }
+});
+
+console.log(Object.preventExtensions(p)); // "appelé"
+                                          // true
+</pre>
+
+<p>Le code suivant ne respecte pas l'invariant :</p>
+
+<pre class="brush: js">var p = new Proxy({}, {
+  preventExtensions: function(cible) {
+    return true;
+  }
+});
+
+Object.preventExtensions(p); // TypeError est levée
+</pre>
+
+<h2 id="Spécifications">Spécifications</h2>
+
+<table class="standard-table">
+ <tbody>
+  <tr>
+   <th scope="col">Spécification</th>
+   <th scope="col">État</th>
+   <th scope="col">Commentaires</th>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES2015', '#sec-proxy-object-internal-methods-and-internal-slots-preventextensions', '[[PreventExtensions]]')}}</td>
+   <td>{{Spec2('ES2015')}}</td>
+   <td>Définition initiale.</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-proxy-object-internal-methods-and-internal-slots-preventextensions', '[[PreventExtensions]]')}}</td>
+   <td>{{Spec2('ESDraft')}}</td>
+   <td> </td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
+
+<div class="hidden">Ce tableau de compatibilité a été généré à partir de données structurées. Si vous souhaitez contribuer à ces données, n'hésitez pas à envoyer une <em>pull request</em> sur <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a>.</div>
+
+<p>{{Compat("javascript.builtins.Proxy.handler.preventExtensions")}}</p>
+
+<h2 id="Voir_aussi">Voir aussi</h2>
+
+<ul>
+ <li>{{jsxref("Proxy")}}</li>
+ <li>{{jsxref("Proxy.handler", "handler")}}</li>
+ <li>{{jsxref("Object.preventExtensions()")}}</li>
+ <li>{{jsxref("Reflect.preventExtensions()")}}</li>
+</ul>
diff --git a/files/fr/web/javascript/reference/objets_globaux/proxy/handler/set/index.html b/files/fr/web/javascript/reference/objets_globaux/proxy/handler/set/index.html
new file mode 100644
index 0000000000..11270be519
--- /dev/null
+++ b/files/fr/web/javascript/reference/objets_globaux/proxy/handler/set/index.html
@@ -0,0 +1,125 @@
+---
+title: handler.set()
+slug: Web/JavaScript/Reference/Objets_globaux/Proxy/handler/set
+tags:
+  - ECMAScript 2015
+  - JavaScript
+  - Méthode
+  - Proxy
+  - Reference
+translation_of: Web/JavaScript/Reference/Global_Objects/Proxy/Proxy/set
+---
+<div>{{JSRef}}</div>
+
+<p>La méthode <code><strong>handler.set()</strong></code> est une trappe permettant d'intercepter les opérations visant à définir ou modifier la valeur d'une propriété.</p>
+
+<div>{{EmbedInteractiveExample("pages/js/proxyhandler-set.html", "taller")}}</div>
+
+<p class="hidden">Le code source de cet exemple interactif est disponible dans un dépôt GitHub. Si vous souhaitez contribuez à ces exemples, n'hésitez pas à cloner <a href="https://github.com/mdn/interactive-examples">https://github.com/mdn/interactive-examples</a> et à envoyer une <em>pull request</em> !</p>
+
+<h2 id="Syntaxe">Syntaxe</h2>
+
+<pre class="brush: js">var p = new Proxy(cible, {
+  set: function(cible, propriété, valeur, récepteur) {
+  }
+});
+</pre>
+
+<h3 id="Paramètres">Paramètres</h3>
+
+<p>Les paramètres suivants sont passés à la méthode <code>set</code>. <code>this</code> est lié au gestionnaire.</p>
+
+<dl>
+ <dt><code>cible</code></dt>
+ <dd>L'objet cible.</dd>
+ <dt><code>propriété</code></dt>
+ <dd>Le nom ou le symbole ({{jsxref("Symbol")}}) de la propriété à définir.</dd>
+ <dt><code>valeur</code></dt>
+ <dd>La nouvelle valeur à définir pour la propriété.</dd>
+ <dt><code>récepteur</code></dt>
+ <dd>L'objet intialement visé par l'affectation. Généralement ce sera le proxy lui-même. Le gestionnaire <code>set</code> peut également être appelé indirectement, via la chaîne de prototypes ou d'autres façons.</dd>
+ <dd>Par exemple, si on exécute l'instruction <code>obj.nom = "Jean"</code>, et qu'<code>obj</code> n'est pas un proxy ni ne possède de propriété <code>nom</code> mais s'il possède un proxy dans sa chaîne de prototypes, le gestionnaire <code>set</code> sera appelé et <code>obj</code> sera passé en tant que récepteur.</dd>
+</dl>
+
+<h3 id="Valeur_de_retour">Valeur de retour</h3>
+
+<p>La méthode <code>set</code> doit renvoyer une valeur booléenne. Elle renvoie <code>true</code> pour indiquer que l'affectation a réussi. Si la méthode <code>set</code> renvoie false et que l'affectation était exécutée dans du code en mode strict, une exception {{jsxref("TypeError")}} sera levée.</p>
+
+<h2 id="Description">Description</h2>
+
+<p>La méthode <code><strong>handler.set</strong></code> est une trappe qui permet d'intercepter les opérations qui sont utilisées pour définir ou modifier la valeur d'une propriété.</p>
+
+<h3 id="Interceptions">Interceptions</h3>
+
+<p>Cette trappe permet d'intercepter les opérations suivantes :</p>
+
+<ul>
+ <li>L'affectation à des propriétés : <code>proxy[toto] = truc</code> et <code>proxy.toto = truc</code></li>
+ <li>L'affectation de propriétés héritées : <code>Object.create(proxy)[toto] = truc</code></li>
+ <li>{{jsxref("Reflect.set()")}}</li>
+</ul>
+
+<h3 id="Invariants">Invariants</h3>
+
+<p>Si les invariants suivants ne sont pas respectés, le proxy renverra une exception {{jsxref("TypeError")}} :</p>
+
+<ul>
+ <li>Il est impossible de modifier la valeur d'une propriété pour qu'elle soit différente de la valeur de la propriété correspondante de l'objet cible si celle-ci n'est pas accessible en lecture seule et est non-configurable (pour les propriétés de données).</li>
+ <li>Il est impossible de modifier la valeur d'une propriété si la propriété correspondante de l'objet cible est une propriété d'accesseur/mutateur dont l'attribut [[Set]] vaut <code>undefined</code>.</li>
+ <li>En mode strict, si le gestionnaire <code>set</code> renvoie une valeur fausse (dans un contexte booléen), cela lèvera une exception {{jsxref("TypeError")}}.</li>
+</ul>
+
+<h2 id="Exemples">Exemples</h2>
+
+<p>Dans l'exemple qui suit, on intercepte la définition d'une nouvelle propriété.</p>
+
+<pre class="brush: js">var p = new Proxy({}, {
+  set: function(target, prop, value, receiver) {
+    target[prop] = value;
+    console.log('property set: ' + prop + ' = ' + value);
+    return true;
+  }
+});
+
+console.log('a' in p);  // false
+
+p.a = 10;               // "property set: a = 10"
+console.log('a' in p);  // true
+console.log(p.a);       // 10
+</pre>
+
+<h2 id="Spécifications">Spécifications</h2>
+
+<table class="standard-table">
+ <tbody>
+  <tr>
+   <th scope="col">Spécification</th>
+   <th scope="col">État</th>
+   <th scope="col">Commentaires</th>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES2015', '#sec-proxy-object-internal-methods-and-internal-slots-set-p-v-receiver', '[[Set]]')}}</td>
+   <td>{{Spec2('ES2015')}}</td>
+   <td>Définition initiale.</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-proxy-object-internal-methods-and-internal-slots-set-p-v-receiver', '[[Set]]')}}</td>
+   <td>{{Spec2('ESDraft')}}</td>
+   <td> </td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
+
+<div class="hidden">Ce tableau de compatibilité a été généré à partir de données structurées. Si vous souhaitez contribuer à ces données, n'hésitez pas à envoyer une <em>pull request</em> sur <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a>.</div>
+
+<p>{{Compat("javascript.builtins.Proxy.handler.set")}}</p>
+
+<h2 id="Voir_aussi">Voir aussi</h2>
+
+<ul>
+ <li>{{jsxref("Proxy")}}</li>
+ <li>{{jsxref("Proxy.handler", "handler")}}</li>
+ <li>{{jsxref("Reflect.set()")}}</li>
+</ul>
diff --git a/files/fr/web/javascript/reference/objets_globaux/proxy/handler/setprototypeof/index.html b/files/fr/web/javascript/reference/objets_globaux/proxy/handler/setprototypeof/index.html
new file mode 100644
index 0000000000..61c288637a
--- /dev/null
+++ b/files/fr/web/javascript/reference/objets_globaux/proxy/handler/setprototypeof/index.html
@@ -0,0 +1,136 @@
+---
+title: handler.setPrototypeOf()
+slug: Web/JavaScript/Reference/Objets_globaux/Proxy/handler/setPrototypeOf
+tags:
+  - ECMAScript 2015
+  - JavaScript
+  - Méthode
+  - Proxy
+  - Reference
+translation_of: Web/JavaScript/Reference/Global_Objects/Proxy/Proxy/setPrototypeOf
+---
+<div>{{JSRef}}</div>
+
+<p>La méthode <strong><code>handler.setPrototypeOf()</code></strong> est une trappe pour intercepter {{jsxref("Object.setPrototypeOf()")}}.</p>
+
+<div>{{EmbedInteractiveExample("pages/js/proxyhandler-setprototypeof.html", "taller", "taller")}}</div>
+
+<p class="hidden">Le code source de cet exemple interactif est disponible dans un dépôt GitHub. Si vous souhaitez contribuez à ces exemples, n'hésitez pas à cloner <a href="https://github.com/mdn/interactive-examples">https://github.com/mdn/interactive-examples</a> et à envoyer une <em>pull request</em> !</p>
+
+<h2 id="Syntaxe">Syntaxe</h2>
+
+<pre class="brush: js">var p = new Proxy(cible, {
+  setPrototypeOf: function(cible, prototype) {
+  }
+});
+</pre>
+
+<h3 id="Paramètres">Paramètres</h3>
+
+<p>Les paramètres suivants sont passés à la méthode <code>setPrototypeOf</code>. <code>this</code> est lié au gestionnaire.</p>
+
+<dl>
+ <dt><code>cible</code></dt>
+ <dd>L'objet cible.</dd>
+ <dt><code>prototype</code></dt>
+ <dd>Le nouveau prototype de l'objet ou <code>null</code>.</dd>
+</dl>
+
+<h3 id="Valeur_de_retour">Valeur de retour</h3>
+
+<p>La méthode <code>setPrototypeOf</code> renvoie <code>true</code> si la propriété interne <code>[[Prototype]]</code> a bien été modifiée et <code>false</code> sinon.</p>
+
+<h2 id="Description">Description</h2>
+
+<p>La méthode <code><strong>handler.setPrototypeOf</strong></code> est une trappe utilisée pour intercepter les opérations de {{jsxref("Object.setPrototypeOf()")}}.</p>
+
+<h3 id="Interceptions">Interceptions</h3>
+
+<p>Cette trappe permet d'intercepter :</p>
+
+<ul>
+ <li>{{jsxref("Object.setPrototypeOf()")}}</li>
+ <li>{{jsxref("Reflect.setPrototypeOf()")}}</li>
+</ul>
+
+<h3 id="Invariants">Invariants</h3>
+
+<p>Si les invariants suivants ne sont pas respectés, le proxy renverra une exception {{jsxref("TypeError")}} :</p>
+
+<ul>
+ <li>Si <code>cible</code> n'est pas extensible, le paramètre <code>prototype</code> doit être le même valeur que <code>Object.getPrototypeOf(cible)</code>.</li>
+</ul>
+
+<h2 id="Exemples">Exemples</h2>
+
+<p>Si on souhaite interdire la définition d'un nouveau prototype pour un objet, on peut utiliser une méthode <code>setPrototypeOf</code> qui renvoie <code>false</code> ou qui génère une exception.</p>
+
+<p>Avec cette première approche, toute opération qui voudra modifier le prototype génèrera une exception. On aura par exemple {{jsxref("Object.setPrototypeOf()")}} qui créera et lèvera l'exception <code>TypeError</code>. Si la modification est effectuée par une opération qui ne génère pas d'exception en cas d'échec (comme  {{jsxref("Reflect.setPrototypeOf()")}}), aucune exception ne sera générée.</p>
+
+<pre class="brush: 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
+</pre>
+
+<p>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.</p>
+
+<pre class="brush: 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")</pre>
+
+<h2 id="Spécifications">Spécifications</h2>
+
+<table class="standard-table">
+ <tbody>
+  <tr>
+   <th scope="col">Spécification</th>
+   <th scope="col">État</th>
+   <th scope="col">Commentaires</th>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES2015', '#sec-proxy-object-internal-methods-and-internal-slots-setprototypeof-v', '[[SetPrototypeOf]]')}}</td>
+   <td>{{Spec2('ES2015')}}</td>
+   <td>Définition initiale.</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-proxy-object-internal-methods-and-internal-slots-setprototypeof-v', '[[SetPrototypeOf]]')}}</td>
+   <td>{{Spec2('ESDraft')}}</td>
+   <td> </td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
+
+<div class="hidden">Ce tableau de compatibilité a été généré à partir de données structurées. Si vous souhaitez contribuer à ces données, n'hésitez pas à envoyer une <em>pull request</em> sur <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a>.</div>
+
+<p>{{Compat("javascript.builtins.Proxy.handler.setPrototypeOf")}}</p>
+
+<h2 id="Voir_aussi">Voir aussi</h2>
+
+<ul>
+ <li>{{jsxref("Proxy")}}</li>
+ <li>{{jsxref("Proxy.handler", "handler")}}</li>
+ <li>{{jsxref("Object.setPrototypeOf()")}}</li>
+ <li>{{jsxref("Reflect.setPrototypeOf()")}}</li>
+</ul>