diff options
Diffstat (limited to 'files/fr/web/javascript/reference/global_objects/proxy')
16 files changed, 2306 insertions, 0 deletions
diff --git a/files/fr/web/javascript/reference/global_objects/proxy/index.html b/files/fr/web/javascript/reference/global_objects/proxy/index.html new file mode 100644 index 0000000000..f01249796e --- /dev/null +++ b/files/fr/web/javascript/reference/global_objects/proxy/index.html @@ -0,0 +1,408 @@ +--- +title: Proxy +slug: Web/JavaScript/Reference/Global_Objects/Proxy +tags: + - ECMAScript 2015 + - JavaScript + - Proxy + - Reference +translation_of: Web/JavaScript/Reference/Global_Objects/Proxy +original_slug: Web/JavaScript/Reference/Objets_globaux/Proxy +--- +<div>{{JSRef}}</div> + +<p>L'objet <strong>Proxy</strong> est utilisé afin de définir un comportement sur mesure pour certaines opérations fondamentales (par exemple, l'accès aux propriétés, les affectations, les énumérations, les appels de fonctions, etc.).</p> + +<h2 id="Terminologie">Terminologie</h2> + +<dl> + <dt><a href="/fr/docs/Web/JavaScript/Reference/Objets_globaux/Proxy/handler">gestionnaire</a> (<em>handler</em>)</dt> + <dd>Un objet qui contient les trappes qui intercepteront les opérations.</dd> + <dt>trappes</dt> + <dd>Les méthodes qui fournissent l'accès aux propriétés. Ce concept est analogue aux <a href="https://en.wikipedia.org/wiki/Trap_%28computing%29">trappes</a> utilisées dans les systèmes d'exploitations.</dd> + <dt>cible</dt> + <dd>L'objet virtualisé par le proxy. Il est souvent utilisé comme objet de stockage. Les invariants (c'est-à-dire les éléments de sémantique qui restent inchangés) relatifs à la non-extensibilité et au caractère non-configurable des propriétés sont vérifiés par rapport à la cible.</dd> +</dl> + +<h2 id="Syntaxe">Syntaxe</h2> + +<pre class="syntaxbox">var p = new Proxy(cible, gestionnaire); +</pre> + +<h3 id="Paramètres">Paramètres</h3> + +<dl> + <dt><code>cible</code></dt> + <dd>Une cible (qui peut être n'importe quel objet, un tableau, une fonction, ou même un autre proxy) qu'on souhaite envelopper dans un <code>Proxy</code>.</dd> + <dt><code>gestionnaire</code></dt> + <dd>Un objet dont les propriétés sont des fonctions qui définissent le comportement du proxy lorsqu'on utilise une opération sur celui-ci.</dd> +</dl> + +<h2 id="Méthodes">Méthodes</h2> + +<dl> + <dt>{{jsxref("Proxy.revocable()")}}</dt> + <dd>Permet de créer un objet <code>Proxy</code> révocable.</dd> +</dl> + +<h2 id="Méthodes_pour_le_gestionnaire">Méthodes pour le gestionnaire</h2> + +<p>L'objet utilisé comme gestionnaire regroupe les différentes fonctions « trappes » pour le <code>Proxy</code>.</p> + +<div>{{page('/fr/docs/Web/JavaScript/Reference/Objets_globaux/Proxy/handler', 'Méthodes') }}</div> + +<h2 id="Exemples">Exemples</h2> + +<h3 id="Exemple_simple">Exemple simple</h3> + +<p>Dans ce court exemple, on renvoie le nombre <code>37</code> comme valeur par défaut lorsque la propriété nommée n'est pas présente dans l'objet. Pour cela, on utilise le gestionnaire correspondant à {{jsxref("Objets_globaux/Proxy/handler/get","get")}}.</p> + +<pre class="brush: js">var handler = { + get: function(obj, prop){ + return prop in obj? + obj[prop] : + 37; + } +}; + +var p = new Proxy({}, handler); +p.a = 1; +p.b = undefined; + +console.log(p.a, p.b); // 1, undefined +console.log('c' in p, p.c); // false, 37 +</pre> + +<h3 id="Proxy_«_invisible_»">Proxy « invisible »</h3> + +<p>Dans cet exemple, le proxy transfère toutes les opérations qui sont appliquées à l'objet cible.</p> + +<pre class="brush: js">var cible = {}; +var p = new Proxy(cible, {}); + +p.a = 37; // L'opération est transmise à la cible par le proxy + +console.log(cible.a); // 37. L'opération a bien été transmise +</pre> + +<h3 id="Validation">Validation</h3> + +<p>En utilisant un <code>Proxy</code>, il devient simple de valider les valeurs passées à un objet. Dans cet exemple, on utilise le gestionnaire correspondant à {{jsxref("Objets_globaux/Proxy/handler/set","set")}}.</p> + +<pre class="brush: js">let validateur = { + set: function(obj, prop, valeur) { + if (prop === 'âge') { + if (!Number.isInteger(valeur)) { + throw new TypeError('Cet âge n\'est pas un entier.'); + } + if (valeur > 200) { + throw new RangeError('Cet âge semble invalide.'); + } + } + + // Le comportement par défaut : enregistrer la valeur + obj[prop] = valeur; + + // On indique le succès de l'opération + return true; + } +}; + +let personne = new Proxy({}, validateur); + +personne.âge = 100; +console.log(personne.âge); // 100 +personne.âge = 'jeune'; // lève une exception +personne.âge = 300; // lève une exception +</pre> + +<h3 id="Étendre_un_constructeur">Étendre un constructeur</h3> + +<p>En utilisant une fonction proxy, on peut étendre un constructeur avec un nouveau constructeur. Dans cet exemple, on utilise les gestionnaires correspondants à {{jsxref("Objets_globaux/Proxy/handler/construct","construct")}} et {{jsxref("Objets_globaux/Proxy/handler/apply","apply")}}.</p> + +<pre class="brush: js">function étendre(sup,base) { + var descripteur = Object.getOwnPropertyDescriptor( + base.prototype, "constructor" + ); + base.prototype = Object.create(sup.prototype); + var gestionnaire = { + construct: function(cible, args) { + var obj = Object.create(base.prototype); + this.apply(cible,obj,args); + return obj; + }, + apply: function(cible, that, args) { + sup.apply(that,args); + base.apply(that,args); + } + }; + var proxy = new Proxy(base,gestionnaire); + descripteur.value = proxy; + Object.defineProperty(base.prototype, "constructor", descripteur); + return proxy; +} + +var Personne = function(nom){ + this.nom = nom; +}; + +var Garçon = étendre(Personne, function(nom, âge) { + this.âge = âge; +}); + +Garçon.prototype.genre = "M"; + +var Pierre = new Garçon("Pierre", 13); +console.log(Pierre.genre); // "M" +console.log(Pierre.nom); // "Pierre" +console.log(Pierre.âge); // 13</pre> + +<h3 id="Manipuler_les_nœuds_DOM">Manipuler les nœuds DOM</h3> + +<p>Parfois, on veut passer un attribut ou un nom de classe entre deux éléments différents. Dans cet exemple, on utilise le gestionnaire lié à {{jsxref("Objets_globaux/Proxy/handler/set","set")}}.</p> + +<pre class="brush: js">let vue = new Proxy({ + selected: null +}, +{ + set: function(obj, prop, nouvelleValeur) { + let ancienneValeur = obj[prop]; + + if (prop === 'selected') { + if (ancienneValeur) { + ancienneValeur.setAttribute('aria-selected', 'false'); + } + if (nouvelleValeur) { + nouvelleValeur.setAttribute('aria-selected', 'true'); + } + } + + // Le comportement par défaut : enregistrer la valeur + obj[prop] = nouvelleValeur; + + // On indique le succès de l'opération + return true; + } +}); + +let i1 = vue.selected = document.getElementById('item-1'); +console.log(i1.getAttribute('aria-selected')); // 'true' + +let i2 = vue.selected = document.getElementById('item-2'); +console.log(i1.getAttribute('aria-selected')); // 'false' +console.log(i2.getAttribute('aria-selected')); // 'true' +</pre> + +<h3 id="Corriger_une_valeur_et_ajouter_une_propriété_supplémentaire">Corriger une valeur et ajouter une propriété supplémentaire</h3> + +<p>Dans l'exemple qui suit, le proxy <code>produits</code> évalue la valeur passée et la convertit en tableau si besoin. L'objet supporte également la propriété supplémentaire <code>dernierNavigateur</code> à la fois comme accesseur et mutateur.</p> + +<pre class="brush: js">let produits = new Proxy({ + navigateurs: ['Internet Explorer', 'Netscape'] +}, +{ + get: function(obj, prop) { + // Une propriété supplémentaire + if (prop === 'dernierNavigateur') { + return obj.navigateurs[obj.navigateurs.length - 1]; + } + + // Le comportement par défaut : renvoyer la valeur + return obj[prop]; + }, + set: function(obj, prop, valeur) { + // Une propriété supplémentaire + if (prop === 'dernierNavigateur') { + obj.navigateurs.push(valeur); + return true; + } + + // on convertit la valeur si ce n'est pas un tableau + if (typeof valeur === 'string') { + valeur = [valeur]; + } + + // Le comportement par défaut : enregistrer la valeur + obj[prop] = valeur; + + // On indique le succès de l'opération + return true; + } +}); + +console.log(produits.navigateurs); // ['Internet Explorer', 'Netscape'] +produits.navigateurs = 'Firefox'; // on passe une chaîne +console.log(produits.navigateurs); // ['Firefox'] <- pas de problème, elle est convertie en tableau + +produits.dernierNavigateur = 'Chrome'; +console.log(produits.navigateurs); // ['Firefox', 'Chrome'] +console.log(produits.dernierNavigateur); // 'Chrome' +</pre> + +<h3 id="Trouver_un_élément_dans_un_tableau_grâce_à_sa_propriété">Trouver un élément dans un tableau grâce à sa propriété</h3> + +<p>Dans cet exemple, ce proxy étend le tableau avec des fonctionnalités supplémentaires. Ici, on définit des propriétés sans utiliser {{jsxref("Objets_globaux/Object/defineProperties","Object.defineProperties")}}. Cet exemple pourrait être adapté pour trouver la ligne d'un tableau à partir d'une de ces cellules (la cible serait alors <a href="/fr/docs/Web/API/HTMLTableElement.rows"><code>table.rows</code></a>).</p> + +<pre class="brush: js">let produits = new Proxy([ + { nom: 'Firefox', type: 'navigateur' }, + { nom: 'SeaMonkey', type: 'navigateur' }, + { nom: 'Thunderbird', type: 'client mail' } +], +{ + get: function(obj, prop) { + // Le comportement par défaut : on renvoie la valeur + // prop est généralement un entier + if (prop in obj) { + return obj[prop]; + } + + // On obtient le nombre de produits + // un alias pour products.length + if (prop === 'nombre') { + return obj.length; + } + + let résultat, types = {}; + + for (let produit of obj) { + if (produit.nom === prop) { + résultat = produit; + } + if (types[produit.type]) { + types[produit.type].push(produit); + } else { + types[produit.type] = [produit]; + } + } + + // Obtenir un produit grâce à un nom + if (résultat) { + return résultat; + } + + // Obtenir un produit par type + if (prop in types) { + return types[prop]; + } + + // Obtenir les types de produits + if (prop === 'types') { + return Object.keys(types); + } + + return undefined; + } +}); + +console.log(produits[0]); // { nom: 'Firefox', type: 'navigateur' } +console.log(produits['Firefox']); // { nom: 'Firefox', type: 'navigateur' } +console.log(produits['Chrome']); // undefined +console.log(produits.navigateur); // [{ nom: 'Firefox', type: 'navigateur' }, { nom: 'SeaMonkey', type: 'navigateur' }] +console.log(produits.types); // ['navigateur', 'client mail'] +console.log(produits.nombre); // 3 +</pre> + +<h3 id="Un_exemple_avec_toutes_les_trappes">Un exemple avec toutes les trappes</h3> + +<p>Pour illustrer l'ensemble des trappes, on tente de « proxifier » un objet non natif : l'objet global <code>docCookies</code> créé grâce à <a href="/fr/docs/Web/API/Document/cookie/Simple_document.cookie_framework">cet exemple</a>.</p> + +<pre class="brush: js">/* + var docCookies = ... définir l'objet "docCookies" grâce à + https://developer.mozilla.org/en-US/docs/DOM/document.cookie#A_little_framework.3A_a_complete_cookies_reader.2Fwriter_with_full_unicode_support +*/ + +var docCookies = new Proxy(docCookies, { + "get": function (oTarget, sKey) { + return oTarget[sKey] || oTarget.getItem(sKey) || undefined; + }, + "set": function (oTarget, sKey, vValue) { + if (sKey in oTarget) { return false; } + return oTarget.setItem(sKey, vValue); + }, + "deleteProperty": function (oTarget, sKey) { + if (sKey in oTarget) { return false; } + return oTarget.removeItem(sKey); + }, + "enumerate": function (oTarget, sKey) { + return oTarget.keys(); + }, + "ownKeys": function (oTarget, sKey) { + return oTarget.keys(); + }, + "has": function (oTarget, sKey) { + return sKey in oTarget || oTarget.hasItem(sKey); + }, + "defineProperty": function (oTarget, sKey, oDesc) { + if (oDesc && "value" in oDesc) { oTarget.setItem(sKey, oDesc.value); } + return oTarget; + }, + "getOwnPropertyDescriptor": function (oTarget, sKey) { + var vValue = oTarget.getItem(sKey); + return vValue ? { + "value": vValue, + "writable": true, + "enumerable": true, + "configurable": false + } : undefined; + }, +}); + +/* Cookies test */ + +console.log(docCookies.mon_cookie1 = "Première valeur"); +console.log(docCookies.getItem("mon_cookie1")); + +docCookies.setItem("mon_cookie1", "Valeur modifiée"); +console.log(docCookies.mon_cookie1);</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-objects', 'Proxy')}}</td> + <td>{{Spec2('ES2015')}}</td> + <td>Définition initiale.</td> + </tr> + <tr> + <td>{{SpecName('ES2016', '#sec-proxy-objects', 'Proxy')}}</td> + <td>{{Spec2('ES2016')}}</td> + <td></td> + </tr> + <tr> + <td>{{SpecName('ES2017', '#sec-proxy-objects', 'Proxy')}}</td> + <td>{{Spec2('ES2017')}}</td> + <td></td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-proxy-objects', 'Proxy')}}</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", 2)}}</p> + +<h2 id="Voir_aussi">Voir aussi</h2> + +<ul> + <li><a href="https://www.youtube.com/watch?v=sClk6aB_CPk">“Proxies are awesome”, une présentation de Brendan Eich à JSConf</a> (en anglais) (<a href="https://www.slideshare.net/BrendanEich/metaprog-5303821">présentation</a>)</li> + <li><a href="https://wiki.ecmascript.org/doku.php?id=harmony:proxies">La page pour la proposition ECMAScript Harmony sur Proxy</a> et <a href="https://wiki.ecmascript.org/doku.php?id=harmony:proxies_semantics">la page sur la sémantique des proxies ECMAScript Harmony</a></li> + <li><a href="http://web.archive.org/web/20171007221059/http://soft.vub.ac.be/~tvcutsem/proxies/">Un tutoriel sur les proxies</a> (en anglais)</li> + <li><a href="/fr/docs/JavaScript/Old_Proxy_API">L'ancienne API pour les Proxy SpiderMonkey</a></li> + <li>{{jsxref("Object.watch()")}}, une fonctionnalité non-standard présente dans Gecko.</li> +</ul> + +<h2 id="Notes_de_licence">Notes de licence</h2> + +<p>Certains composants de cette page (texte, exemples) ont été copiés ou adaptés du <a href="https://wiki.ecmascript.org/doku.php">Wiki ECMAScript</a> dont le contenu est sous licence <a href="https://creativecommons.org/licenses/by-nc-sa/2.0/">CC 2.0 BY-NC-SA</a>.</p> diff --git a/files/fr/web/javascript/reference/global_objects/proxy/proxy/apply/index.html b/files/fr/web/javascript/reference/global_objects/proxy/proxy/apply/index.html new file mode 100644 index 0000000000..1b3075413d --- /dev/null +++ b/files/fr/web/javascript/reference/global_objects/proxy/proxy/apply/index.html @@ -0,0 +1,119 @@ +--- +title: handler.apply() +slug: Web/JavaScript/Reference/Global_Objects/Proxy/Proxy/apply +tags: + - ECMAScript 2015 + - JavaScript + - Méthode + - Proxy + - Reference +translation_of: Web/JavaScript/Reference/Global_Objects/Proxy/Proxy/apply +original_slug: Web/JavaScript/Reference/Objets_globaux/Proxy/handler/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/global_objects/proxy/proxy/construct/index.html b/files/fr/web/javascript/reference/global_objects/proxy/proxy/construct/index.html new file mode 100644 index 0000000000..52b8b09b43 --- /dev/null +++ b/files/fr/web/javascript/reference/global_objects/proxy/proxy/construct/index.html @@ -0,0 +1,138 @@ +--- +title: handler.construct() +slug: Web/JavaScript/Reference/Global_Objects/Proxy/Proxy/construct +tags: + - ECMAScript 2015 + - JavaScript + - Méthode + - Proxy + - Reference +translation_of: Web/JavaScript/Reference/Global_Objects/Proxy/Proxy/construct +original_slug: Web/JavaScript/Reference/Objets_globaux/Proxy/handler/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/global_objects/proxy/proxy/defineproperty/index.html b/files/fr/web/javascript/reference/global_objects/proxy/proxy/defineproperty/index.html new file mode 100644 index 0000000000..1eafe8b18d --- /dev/null +++ b/files/fr/web/javascript/reference/global_objects/proxy/proxy/defineproperty/index.html @@ -0,0 +1,145 @@ +--- +title: handler.defineProperty() +slug: Web/JavaScript/Reference/Global_Objects/Proxy/Proxy/defineProperty +tags: + - ECMAScript 2015 + - JavaScript + - Méthode + - Proxy + - Reference +translation_of: Web/JavaScript/Reference/Global_Objects/Proxy/Proxy/defineProperty +original_slug: Web/JavaScript/Reference/Objets_globaux/Proxy/handler/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/global_objects/proxy/proxy/deleteproperty/index.html b/files/fr/web/javascript/reference/global_objects/proxy/proxy/deleteproperty/index.html new file mode 100644 index 0000000000..4604dd6d31 --- /dev/null +++ b/files/fr/web/javascript/reference/global_objects/proxy/proxy/deleteproperty/index.html @@ -0,0 +1,114 @@ +--- +title: handler.deleteProperty() +slug: Web/JavaScript/Reference/Global_Objects/Proxy/Proxy/deleteProperty +tags: + - ECMAScript 2015 + - JavaScript + - Méthode + - Proxy + - Reference +translation_of: Web/JavaScript/Reference/Global_Objects/Proxy/Proxy/deleteProperty +original_slug: Web/JavaScript/Reference/Objets_globaux/Proxy/handler/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/global_objects/proxy/proxy/get/index.html b/files/fr/web/javascript/reference/global_objects/proxy/proxy/get/index.html new file mode 100644 index 0000000000..a0ed1496f6 --- /dev/null +++ b/files/fr/web/javascript/reference/global_objects/proxy/proxy/get/index.html @@ -0,0 +1,137 @@ +--- +title: handler.get() +slug: Web/JavaScript/Reference/Global_Objects/Proxy/Proxy/get +tags: + - ECMAScript 2015 + - JavaScript + - Méthode + - Proxy + - Reference +translation_of: Web/JavaScript/Reference/Global_Objects/Proxy/Proxy/get +original_slug: Web/JavaScript/Reference/Objets_globaux/Proxy/handler/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/global_objects/proxy/proxy/getownpropertydescriptor/index.html b/files/fr/web/javascript/reference/global_objects/proxy/proxy/getownpropertydescriptor/index.html new file mode 100644 index 0000000000..a208d4a6a6 --- /dev/null +++ b/files/fr/web/javascript/reference/global_objects/proxy/proxy/getownpropertydescriptor/index.html @@ -0,0 +1,133 @@ +--- +title: handler.getOwnPropertyDescriptor() +slug: Web/JavaScript/Reference/Global_Objects/Proxy/Proxy/getOwnPropertyDescriptor +tags: + - ECMAScript 2015 + - JavaScript + - Méthode + - Proxy + - Reference +translation_of: Web/JavaScript/Reference/Global_Objects/Proxy/Proxy/getOwnPropertyDescriptor +original_slug: Web/JavaScript/Reference/Objets_globaux/Proxy/handler/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/global_objects/proxy/proxy/getprototypeof/index.html b/files/fr/web/javascript/reference/global_objects/proxy/proxy/getprototypeof/index.html new file mode 100644 index 0000000000..2c4fececdc --- /dev/null +++ b/files/fr/web/javascript/reference/global_objects/proxy/proxy/getprototypeof/index.html @@ -0,0 +1,155 @@ +--- +title: handler.getPrototypeOf() +slug: Web/JavaScript/Reference/Global_Objects/Proxy/Proxy/getPrototypeOf +tags: + - ECMAScript 2015 + - JavaScript + - Méthode + - Proxy + - Reference +translation_of: Web/JavaScript/Reference/Global_Objects/Proxy/Proxy/getPrototypeOf +original_slug: Web/JavaScript/Reference/Objets_globaux/Proxy/handler/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/global_objects/proxy/proxy/has/index.html b/files/fr/web/javascript/reference/global_objects/proxy/proxy/has/index.html new file mode 100644 index 0000000000..bc20c1445f --- /dev/null +++ b/files/fr/web/javascript/reference/global_objects/proxy/proxy/has/index.html @@ -0,0 +1,131 @@ +--- +title: handler.has() +slug: Web/JavaScript/Reference/Global_Objects/Proxy/Proxy/has +tags: + - ECMAScript 2015 + - JavaScript + - Méthode + - Proxy + - Reference +translation_of: Web/JavaScript/Reference/Global_Objects/Proxy/Proxy/has +original_slug: Web/JavaScript/Reference/Objets_globaux/Proxy/handler/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/global_objects/proxy/proxy/index.html b/files/fr/web/javascript/reference/global_objects/proxy/proxy/index.html new file mode 100644 index 0000000000..3253966fe6 --- /dev/null +++ b/files/fr/web/javascript/reference/global_objects/proxy/proxy/index.html @@ -0,0 +1,84 @@ +--- +title: Gestionnaire de Proxy (handler) +slug: Web/JavaScript/Reference/Global_Objects/Proxy/Proxy +tags: + - ECMAScript 2015 + - JavaScript + - Proxy + - Reference +translation_of: Web/JavaScript/Reference/Global_Objects/Proxy/Proxy +translation_of_original: Web/JavaScript/Reference/Global_Objects/Proxy/handler +original_slug: Web/JavaScript/Reference/Objets_globaux/Proxy/handler +--- +<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/global_objects/proxy/proxy/isextensible/index.html b/files/fr/web/javascript/reference/global_objects/proxy/proxy/isextensible/index.html new file mode 100644 index 0000000000..e8724916e4 --- /dev/null +++ b/files/fr/web/javascript/reference/global_objects/proxy/proxy/isextensible/index.html @@ -0,0 +1,124 @@ +--- +title: handler.isExtensible() +slug: Web/JavaScript/Reference/Global_Objects/Proxy/Proxy/isExtensible +tags: + - ECMAScript 2015 + - JavaScript + - Méthode + - Proxy + - Reference +translation_of: Web/JavaScript/Reference/Global_Objects/Proxy/Proxy/isExtensible +original_slug: Web/JavaScript/Reference/Objets_globaux/Proxy/handler/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/global_objects/proxy/proxy/ownkeys/index.html b/files/fr/web/javascript/reference/global_objects/proxy/proxy/ownkeys/index.html new file mode 100644 index 0000000000..4df08454e0 --- /dev/null +++ b/files/fr/web/javascript/reference/global_objects/proxy/proxy/ownkeys/index.html @@ -0,0 +1,137 @@ +--- +title: handler.ownKeys() +slug: Web/JavaScript/Reference/Global_Objects/Proxy/Proxy/ownKeys +tags: + - ECMAScript 2015 + - JavaScript + - Méthode + - Proxy + - Reference +translation_of: Web/JavaScript/Reference/Global_Objects/Proxy/Proxy/ownKeys +original_slug: Web/JavaScript/Reference/Objets_globaux/Proxy/handler/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/global_objects/proxy/proxy/preventextensions/index.html b/files/fr/web/javascript/reference/global_objects/proxy/proxy/preventextensions/index.html new file mode 100644 index 0000000000..4c5da8e67c --- /dev/null +++ b/files/fr/web/javascript/reference/global_objects/proxy/proxy/preventextensions/index.html @@ -0,0 +1,125 @@ +--- +title: handler.preventExtensions() +slug: Web/JavaScript/Reference/Global_Objects/Proxy/Proxy/preventExtensions +tags: + - ECMAScript 2015 + - JavaScript + - Méthode + - Proxy + - Reference +translation_of: Web/JavaScript/Reference/Global_Objects/Proxy/Proxy/preventExtensions +original_slug: Web/JavaScript/Reference/Objets_globaux/Proxy/handler/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/global_objects/proxy/proxy/set/index.html b/files/fr/web/javascript/reference/global_objects/proxy/proxy/set/index.html new file mode 100644 index 0000000000..65d2bc564d --- /dev/null +++ b/files/fr/web/javascript/reference/global_objects/proxy/proxy/set/index.html @@ -0,0 +1,126 @@ +--- +title: handler.set() +slug: Web/JavaScript/Reference/Global_Objects/Proxy/Proxy/set +tags: + - ECMAScript 2015 + - JavaScript + - Méthode + - Proxy + - Reference +translation_of: Web/JavaScript/Reference/Global_Objects/Proxy/Proxy/set +original_slug: Web/JavaScript/Reference/Objets_globaux/Proxy/handler/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/global_objects/proxy/proxy/setprototypeof/index.html b/files/fr/web/javascript/reference/global_objects/proxy/proxy/setprototypeof/index.html new file mode 100644 index 0000000000..13885e15f4 --- /dev/null +++ b/files/fr/web/javascript/reference/global_objects/proxy/proxy/setprototypeof/index.html @@ -0,0 +1,137 @@ +--- +title: handler.setPrototypeOf() +slug: Web/JavaScript/Reference/Global_Objects/Proxy/Proxy/setPrototypeOf +tags: + - ECMAScript 2015 + - JavaScript + - Méthode + - Proxy + - Reference +translation_of: Web/JavaScript/Reference/Global_Objects/Proxy/Proxy/setPrototypeOf +original_slug: Web/JavaScript/Reference/Objets_globaux/Proxy/handler/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> diff --git a/files/fr/web/javascript/reference/global_objects/proxy/revocable/index.html b/files/fr/web/javascript/reference/global_objects/proxy/revocable/index.html new file mode 100644 index 0000000000..927006ecd2 --- /dev/null +++ b/files/fr/web/javascript/reference/global_objects/proxy/revocable/index.html @@ -0,0 +1,93 @@ +--- +title: Proxy.revocable() +slug: Web/JavaScript/Reference/Global_Objects/Proxy/revocable +tags: + - ECMAScript 2015 + - JavaScript + - Méthode + - Proxy + - Reference +translation_of: Web/JavaScript/Reference/Global_Objects/Proxy/revocable +original_slug: Web/JavaScript/Reference/Objets_globaux/Proxy/revocable +--- +<div>{{JSRef}}</div> + +<p>La méthode <code><strong>Proxy.revocable()</strong></code> est utilisée afin de créer un objet {{jsxref("Proxy")}} révocable.</p> + +<h2 id="Syntaxe">Syntaxe</h2> + +<pre class="syntaxbox">Proxy.revocable(cible, gestionnaire); +</pre> + +<h3 id="Paramètres">Paramètres</h3> + +<div>{{Page("/fr/docs/Web/JavaScript/Reference/Objets_globaux/Proxy", "Paramètres")}}</div> + +<h3 id="Valeur_de_retour">Valeur de retour</h3> + +<p>Un nouvel objet <code>Proxy</code> révocable est renvoyé par la méthode.</p> + +<h2 id="Description">Description</h2> + +<p>Un <code>Proxy</code> révocable est un objet qui possède les propriétés suivantes : <code>{proxy: proxy, revoke: revoke}</code>.</p> + +<dl> + <dt><code>proxy</code></dt> + <dd>Un proxy crée avec un appel à <code>new Proxy(cible, gestionnaire)</code>.</dd> + <dt><code>revoke</code></dt> + <dd>Une fonction sans argument qui permet de désactiver le proxy.</dd> +</dl> + +<p>Si la fonction <code>revoke()</code> est appelée, le proxy devient inutilisable et toutes les trappes définies via un gestionnaire lèveront une exception {{jsxref("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 à <code>revoke()</code> n'auront aucun effet.</p> + +<h2 id="Exemples">Exemples</h2> + +<pre class="brush: js">var révocable = Proxy.revocable({}, { + get: function(cible, nom) { + return "[[" + nom + "]]"; + } +}); +var proxy = révocable.proxy; +console.log(proxy.toto); // "[[toto]]" + +révocable.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 +</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.revocable', 'Proxy Revocation Functions')}}</td> + <td>{{Spec2('ES2015')}}</td> + <td>Définition initiale.</td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-proxy.revocable', 'Proxy Revocation Functions')}}</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.revocable")}}</p> + +<h2 id="Voir_aussi">Voir aussi</h2> + +<ul> + <li>{{jsxref("Proxy")}}</li> +</ul> |