diff options
Diffstat (limited to 'files/fr/web/javascript/reference/objets_globaux/reflect')
15 files changed, 1566 insertions, 0 deletions
diff --git a/files/fr/web/javascript/reference/objets_globaux/reflect/apply/index.html b/files/fr/web/javascript/reference/objets_globaux/reflect/apply/index.html new file mode 100644 index 0000000000..b6f27bc995 --- /dev/null +++ b/files/fr/web/javascript/reference/objets_globaux/reflect/apply/index.html @@ -0,0 +1,100 @@ +--- +title: Reflect.apply() +slug: Web/JavaScript/Reference/Objets_globaux/Reflect/apply +tags: + - ECMAScript 2015 + - JavaScript + - Méthode + - Reference + - Reflect +translation_of: Web/JavaScript/Reference/Global_Objects/Reflect/apply +--- +<div>{{JSRef}}</div> + +<p>La méthode statique <code><strong>Reflect</strong></code><strong><code>.apply()</code></strong> permet d'appeler une fonction cible avec des arguments donnés.</p> + +<div>{{EmbedInteractiveExample("pages/js/reflect-apply.html")}}</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="syntaxbox">Reflect.apply(cible, argumentThis, listeArguments) +</pre> + +<h3 id="Paramètres">Paramètres</h3> + +<dl> + <dt><code>cible</code></dt> + <dd>La fonction cible à appeler.</dd> + <dt><code>argumentThis</code></dt> + <dd>La valeur fournie pour <code>this</code> lors de l'appel à <em><code>cible</code></em>.</dd> + <dt><code>listeArguments</code></dt> + <dd>Un objet semblable à un tableau qui définit les arguments à passer à <em><code>cible</code></em>. S'il vaut {{jsxref("null")}} ou {{jsxref("undefined")}}, aucun argument ne sera passé.</dd> +</dl> + +<h3 id="Valeur_de_retour">Valeur de retour</h3> + +<p>Le résultat de l'appel de la fonction cible indiquée avec la valeur <code>this</code> et les arguments indiqués.</p> + +<h3 id="Exceptions_levées">Exceptions levées</h3> + +<p>Une exception {{jsxref("TypeError")}}, si <em>cible</em> ne peut pas être appelée.</p> + +<h2 id="Description">Description</h2> + +<p>Avec ES5, on utilise généralement {{jsxref("Function.prototype.apply()")}} pour appeler une fonction avec une valeur <code>this</code> donnée et des arguments donnés.</p> + +<pre class="brush: js">Function.prototype.apply.call(Math.floor, undefined, [1.75]);</pre> + +<p><code>Reflect.apply</code> permet de rendre cela plus concis et facile à comprendre.</p> + +<h2 id="Exemples">Exemples</h2> + +<pre class="brush: js">Reflect.apply(Math.floor, undefined, [1.75]); +// 1; + +Reflect.apply(String.fromCharCode, undefined, [104, 101, 108, 108, 111]); +// "hello" + +Reflect.apply(RegExp.prototype.exec, /ab/, ["confabulation"]).index; +// 4 + +Reflect.apply("".charAt, "poneys", [3]); +// "e" +</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-reflect.apply', 'Reflect.apply')}}</td> + <td>{{Spec2('ES2015')}}</td> + <td>Définition initiale.</td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-reflect.apply', 'Reflect.apply')}}</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.Reflect.apply")}}</p> + +<h2 id="Voir_aussi">Voir aussi</h2> + +<ul> + <li>{{jsxref("Reflect")}}</li> + <li>{{jsxref("Function.prototype.apply()")}}</li> +</ul> diff --git a/files/fr/web/javascript/reference/objets_globaux/reflect/comparaison_entre_reflect_et_les_méthodes_object/index.html b/files/fr/web/javascript/reference/objets_globaux/reflect/comparaison_entre_reflect_et_les_méthodes_object/index.html new file mode 100644 index 0000000000..2c8844e085 --- /dev/null +++ b/files/fr/web/javascript/reference/objets_globaux/reflect/comparaison_entre_reflect_et_les_méthodes_object/index.html @@ -0,0 +1,99 @@ +--- +title: Comparaison entre Reflect et les méthodes d'Object +slug: >- + Web/JavaScript/Reference/Objets_globaux/Reflect/Comparaison_entre_Reflect_et_les_méthodes_Object +tags: + - Aperçu + - Intermédiaire + - JavaScript + - Object + - Reflect +translation_of: >- + Web/JavaScript/Reference/Global_Objects/Reflect/Comparing_Reflect_and_Object_methods +--- +<div>{{jssidebar}}</div> + +<p>L'objet {{jsxref("Reflect")}}, introduit avec ES2015, est un objet natif fournissant des méthodes pour s'interfacer avec les objets JavaScript. Certaines fonctions statiques de <code>Reflect</code> ont une correspondance avec les méthodes fournies par {{jsxref("Object")}} et disponibles avant ES2015. Bien que ces méthodes aient un comportement similaire, il y a souvent de subtiles différences entre elles.</p> + +<p>Dans ce tableau, nous énumérons les différences entre les méthodes disponibles avec <code>Object</code> et <code>Reflect</code>. Si une méthode n'existe pas dans le cas indiqué, elle sera notée N/A.</p> + +<table class="standard-table"> + <thead> + <tr> + <th scope="col">Nom de la méthode</th> + <th scope="col"><code>Object</code></th> + <th scope="col"><code>Reflect</code></th> + </tr> + </thead> + <tbody> + <tr> + <td><code>defineProperty()</code></td> + <td>{{jsxref("Object.defineProperty()")}} renvoie l'objet qui a été passé à la fonction. Déclenche une exception <code>TypeError</code> si la propriété n'a pu être définie sur l'objet.</td> + <td>{{jsxref("Reflect.defineProperty()")}} renvoie <code>true</code> si la propriété a été définie sur l'objet et <code>false</code> sinon.</td> + </tr> + <tr> + <td><code>defineProperties()</code></td> + <td>{{jsxref("Object.defineProperties()")}} renvoie les objets passés à la fonction. Déclenche une exception <code>TypeError</code> si une des propriétés n'a pu être définie.</td> + <td>N/A</td> + </tr> + <tr> + <td><code>set()</code></td> + <td>N/A</td> + <td>{{jsxref("Reflect.set()")}} renvoie <code>true</code> si la propriété a été définie sur l'objet et <code>false</code> sinon. Déclenche une exception <code>TypeError</code> si la cible n'était pas un <code>Object</code>.</td> + </tr> + <tr> + <td><code>get()</code></td> + <td>N/A</td> + <td>{{jsxref("Reflect.get()")}} renvoie la valeur de la propriété. Déclenche une exception <code>TypeError</code> si la cible n'était pas un <code>Object</code>.</td> + </tr> + <tr> + <td><code>deleteProperty()</code></td> + <td>N/A</td> + <td>{{jsxref("Reflect.deleteProperty()")}} renvoie <code>true</code> si la propriété a été supprimée de l'objet et <code>false</code> sinon.</td> + </tr> + <tr> + <td><code>getOwnPropertyDescriptor()</code></td> + <td>{{jsxref("Object.getOwnPropertyDescriptor()")}} renvoie un descripteur de la propriété si elle existe sur l'objet passé en argument. Si la propriété n'existe pas, la méthode renvoie <code>undefined</code>. Si la valeur passée en premier argument n'est pas un objet, elle sera automatiquement convertie en un objet.</td> + <td>{{jsxref("Reflect.getOwnPropertyDescriptor()")}} renvoie un descripteur de la propriété si elle existe sur l'objet et <code>undefined</code> si elle n'existe pas. Déclenche une exception <code>TypeError</code> si la valeur passée en premier argument n'est pas un objet.</td> + </tr> + <tr> + <td><code>getOwnPropertyDescriptors()</code></td> + <td>{{jsxref("Object.getOwnPropertyDescriptors()")}} renvoie un objet contenant un descripteur de propriété pour chaque objet passé en argument. Renvoie un objet vide si l'objet passé en argument ne contient pas les descripteurs.</td> + <td>N/A</td> + </tr> + <tr> + <td><code>getPrototypeOf()</code></td> + <td>{{jsxref("Object.getPrototypeOf()")}} renvoie le prototype de l'objet fourni. Renvoie <code>null</code> s'il n'y a pas de propriétés héritées. En ES5, déclenche une exception <code>TypeError</code> pour les valeurs qui ne sont pas des objets (pour ES6 et ensuite, les valeurs sont converties en objet).</td> + <td>{{jsxref("Reflect.getPrototypeOf()")}} renvoie le prototype de l'objet fourni. Renvoie <code>null</code> s'il n'y a pas de propriétés héritées et déclenche une exception <code>TypeError</code> pour les valeurs qui ne sont pas des objets.</td> + </tr> + <tr> + <td><code>setPrototypeOf()</code></td> + <td>{{jsxref("Object.setPrototypeOf()")}} renvoie l'objet fourni si le prototype a pu être défini. Déclenche une exception <code>TypeError</code> si le prototype utilisé n'était pas un objet ou <code>null</code> ou si le prototype de l'objet à modifier n'est pas extensible.</td> + <td>{{jsxref("Reflect.setPrototypeOf()")}} renvoie <code>true</code> si le prototype a pu être défini sur l'objet et <code>false</code> sinon (y compris lorsque le prototype n'est pas extensible). Déclenche une exception <code>TypeError</code> si la cible passée n'est pas un objet ou si le prototype à appliquer n'est pas un objet ou n'est pas <code>null</code>.</td> + </tr> + <tr> + <td><code>isExtensible()</code></td> + <td>{{jsxref("Object.isExtensible()")}} renvoie <code>true</code> si l'objet est extensible et <code>false</code> sinon. En ES5, déclenche une exception <code>TypeError</code> si le premier argument fourni n'est pas un objet. Avec ES6 et ensuite, si l'argument fourni est une valeur primitive, il est converti en un objet non-extensible et la méthode renvoie donc <code>false</code>.</td> + <td> + <p>{{jsxref("Reflect.isExtensible()")}} renvoie <code>true</code> si l'objet est extensible et <code>false</code> sinon. Déclenche une exception <code>TypeError</code> si le premier argument n'est pas un objet.</p> + </td> + </tr> + <tr> + <td><code>preventExtensions()</code></td> + <td> + <p>{{jsxref("Object.preventExtensions()")}} renvoie l'objet qui a été rendu non-extensible. En ES5, déclenche une exception si l'argument n'est pas un objet. Avec ES6 et ensuite, si l'argument fourni est une valeur primitive, il est converti en un objet non-extensible et c'est cette valeur qui est renvoyée.</p> + </td> + <td>{{jsxref("Reflect.preventExtensions()")}} renvoie <code>true</code> si l'objet a été rendu non-extensible et <code>false</code> sinon. Déclenche une exception <code>TypeError</code> si l'argument n'est pas un objet.</td> + </tr> + <tr> + <td><code>keys()</code></td> + <td>{{jsxref("Object.keys()")}} renvoie un tableau de chaînes de caractères qui sont les noms des propriétés propres (et énumérables) de l'objet. En ES5, déclenche une exception <code>TypeError</code> si la cible n'est pas un objet. Avec ES6 et les versions suivantes, les valeurs primitives sont converties en objets.</td> + <td>N/A</td> + </tr> + <tr> + <td><code>ownKeys()</code></td> + <td>N/A</td> + <td>{{jsxref("Reflect.ownKeys()")}} renvoie un tableau des noms des propriétés pour les clés des propriétés propres de de l'objet. Déclenche une exception <code>TypeError</code> si la cible n'est pas un objet.</td> + </tr> + </tbody> +</table> diff --git a/files/fr/web/javascript/reference/objets_globaux/reflect/construct/index.html b/files/fr/web/javascript/reference/objets_globaux/reflect/construct/index.html new file mode 100644 index 0000000000..9f61844a66 --- /dev/null +++ b/files/fr/web/javascript/reference/objets_globaux/reflect/construct/index.html @@ -0,0 +1,163 @@ +--- +title: Reflect.construct() +slug: Web/JavaScript/Reference/Objets_globaux/Reflect/construct +tags: + - ECMAScript 2015 + - JavaScript + - Méthode + - Reference + - Reflect +translation_of: Web/JavaScript/Reference/Global_Objects/Reflect/construct +--- +<div>{{JSRef}}</div> + +<p>La méthode statique <code><strong>Reflect</strong></code><strong><code>.construct()</code></strong> agit comme l'opérateur <a href="/fr/docs/Web/JavaScript/Reference/Opérateurs/L_opérateur_new"><code>new</code></a> sous la forme d'une fonction. Elle est équivalente à <code>new cible(...args)</code> et permet d'indiquer un prototype différent.</p> + +<div>{{EmbedInteractiveExample("pages/js/reflect-construct.html")}}</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="syntaxbox">Reflect.construct(cible, listeArguments[, newCible]) +</pre> + +<h3 id="Paramètres">Paramètres</h3> + +<dl> + <dt><code>cible</code></dt> + <dd>La fonction cible à appeler.</dd> + <dt><code>listeArguments</code></dt> + <dd>Un objet semblable à un tableau définissant les arguments à passer à <code>cible</code> lors de l'appel. Utiliser {{jsxref("null")}} ou {{jsxref("undefined")}} si aucun argument ne doit être fourni à la fonction.</dd> + <dt><code>newCible</code> {{optional_inline}}</dt> + <dd>Le constructeur dont le prototype devrait être utilisé. Voir également l'opérateur <code><a href="/fr/docs/Web/JavaScript/Reference/Opérateurs/new.target">new.target</a></code>. Si <code>newCible</code> n'est pas présent, c'est <code>cible</code> qui sera utilisé.</dd> +</dl> + +<h3 id="Valeur_de_retour">Valeur de retour</h3> + +<p>Un nouvelle instance de la cible indiquée, créée en l'appelant comme un constructeur (ou en appelant <code>newCible</code> si elle est fournie) avec les arguments fournis.</p> + +<h3 id="Exceptions_levées">Exceptions levées</h3> + +<p>Une exception {{jsxref("TypeError")}} si <code>cible</code> ou <code>newCible</code> ne sont pas des constructeurs.</p> + +<h2 id="Description">Description</h2> + +<p><code>Reflect.construct()</code> permet d'appeler un constructeur avec un nombre d'arguments variable (ce qui peut également être fait avec <a href="/fr/docs/Web/JavaScript/Reference/Opérateurs/Opérateur_de_décomposition">l'opérateur de décomposition</a> et l'opérateur <code><a href="/fr/docs/Web/JavaScript/Reference/Opérateurs/L_opérateur_new">new</a></code>).</p> + +<pre class="brush: js">var obj = new Toto(...args); +var obj = Reflect.construct(Toto, args);</pre> + +<h2 id="Exemples">Exemples</h2> + +<h3 id="Utiliser_Reflect.construct()">Utiliser <code>Reflect.construct()</code></h3> + +<pre class="brush: js">var d = Reflect.construct(Date, [1776, 6, 4]); +d instanceof Date; // true +d.getFullYear(); // 1776 +</pre> + +<h3 id="Utiliser_le_paramètre_newCible">Utiliser le paramètre <code>newCible</code></h3> + +<p>Pour plus d'informations sur la création de sous-classes, voir les <a href="/fr/docs/Web/JavaScript/Reference/Classes">classes</a> et l'opérateur <code><a href="/fr/docs/Web/JavaScript/Reference/Opérateurs/new.target">new.target</a></code>.</p> + +<pre class="brush: js">function unConstructeur() {} +var résultat = Reflect.construct(Array, [], unConstructeur); + +Reflect.getPrototypeOf(résultat); // unConstructeur.prototype +Array.isArray(résultat); // true +</pre> + +<h3 id="Une_comparaison_entre_Reflect.construct()_et_Object.create()">Une comparaison entre <code>Reflect.construct()</code> et <code>Object.create()</code></h3> + +<p>Avant l'apparition de <code>Reflect</code>, on pouvait construire des objets avec une combinaison donnée de consttructeur et de prototype grâce à {{jsxref("Object.create()")}}.</p> + +<pre class="brush: js">function MaClasseA() { + this.name = 'A'; +} + +function MaClasseB() { + this.name = 'B'; +} + +// Avec cette instruction : +var obj1 = Reflect.construct(MaClasseA, args, MaClasseB); + +// on aura le même résultat qu'avec +var obj2 = Object.create(MaClasseB.prototype); +MaClasseA.apply(obj2, args); + +console.log(obj1.name); // 'A' +console.log(obj2.name); // 'A' + +console.log(obj1 instanceof MaClasseA); // false +console.log(obj2 instanceof MaClasseA); // false + +console.log(obj1 instanceof MaClasseB); // true +console.log(obj2 instanceof MaClasseB); // true +</pre> + +<p>Toutefois, si les résultats sont identiques, il y a une différence notable. Lorsqu'on utilise <code>Object.create()</code> et <code>Function.prototype.apply()</code>, l'opérateur <code>new.target</code> pointe vers <code>undefined</code> dans la fonction utilisée comme constructeur car le mot-clé <code>new</code> n'est pas utilisé à la création de l'objet.</p> + +<p>Mais quand on appelle <code>Reflect.construct()</code>, <code>new.target</code> pointe vers la valeur fournie par <code>newCible</code> si ce dernier est fourni ou vers <code>cible</code> sinon.</p> + +<pre class="brush: js">function MaClasseA() { + console.log('MaClasseA'); + console.log(new.target); +} +function MaClasseB() { + console.log('MaClasseB'); + console.log(new.target); +} + +var obj1 = Reflect.construct(MaClasseA, args); +// Résultat : +// MaClasseA +// function MaClasseA { ... } + +var obj2 = Reflect.construct(MaClasseA, args, MaClasseB); +// Résultat : +// MaClasseA +// function MaClasseB { ... } + +var obj3 = Object.create(MaClasseB.prototype); +MaClasseA.apply(obj3, args); +// Résultat : +// MaClasseA +// undefined</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-reflect.construct', 'Reflect.construct')}}</td> + <td>{{Spec2('ES2015')}}</td> + <td>Définition initiale.</td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-reflect.construct', 'Reflect.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.Reflect.construct")}}</p> + +<h2 id="Voir_aussi">Voir aussi</h2> + +<ul> + <li>{{jsxref("Reflect")}}</li> + <li><a href="/fr/docs/Web/JavaScript/Reference/Opérateurs/L_opérateur_new"><code>new</code></a></li> + <li><code><a href="/fr/docs/Web/JavaScript/Reference/Opérateurs/new.target">new.target</a></code></li> +</ul> diff --git a/files/fr/web/javascript/reference/objets_globaux/reflect/defineproperty/index.html b/files/fr/web/javascript/reference/objets_globaux/reflect/defineproperty/index.html new file mode 100644 index 0000000000..71d6e6b60f --- /dev/null +++ b/files/fr/web/javascript/reference/objets_globaux/reflect/defineproperty/index.html @@ -0,0 +1,100 @@ +--- +title: Reflect.defineProperty() +slug: Web/JavaScript/Reference/Objets_globaux/Reflect/defineProperty +tags: + - ECMAScript 2015 + - JavaScript + - Méthode + - Reference + - Reflect +translation_of: Web/JavaScript/Reference/Global_Objects/Reflect/defineProperty +--- +<div>{{JSRef}}</div> + +<p>La méthode statique <code><strong>Reflect</strong></code><strong><code>.defineProperty()</code></strong> est semblable à {{jsxref("Object.defineProperty()")}} mais renvoie un {{jsxref("Boolean")}}.</p> + +<div>{{EmbedInteractiveExample("pages/js/reflect-defineproperty.html")}}</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="syntaxbox">Reflect.defineProperty(<var>cible</var>, <var>cléPropriété</var>, <var>attributs</var>) +</pre> + +<h3 id="Paramètres">Paramètres</h3> + +<dl> + <dt><code>cible</code></dt> + <dd>L'objet cible sur lequel on veut définir la propriété.</dd> + <dt><code>cléPropriété</code></dt> + <dd>Le nom de la propriété qu'on souhaite définir ou modifier.</dd> + <dt><code>attributs</code></dt> + <dd>Les attributs de de la propriété qu'on ajoute ou qu'on modifie.</dd> +</dl> + +<h3 id="Valeur_de_retour">Valeur de retour</h3> + +<p>Un {{jsxref("Boolean","booléen","",1)}} qui indique si la propriété a bien été définie.</p> + +<h3 id="Exceptions">Exceptions</h3> + +<p>Une erreur {{jsxref("TypeError")}} si <code>cible</code> n'est pas un {{jsxref("Object")}}.</p> + +<h2 id="Description">Description</h2> + +<p>La méthode <code>Reflect.defineProperty</code> permet d'ajouter ou de modifier finement une propriété d'un objet. Pour plus de détails, voir la méthode {{jsxref("Object.defineProperty")}} qui est très similaire. <code>Object.defineProperty</code> renvoie l'objet et lève une {{jsxref("TypeError")}} si la propriété n'a pas correctement été définie. <code>Reflect.defineProperty</code> renvoie simplement un {{jsxref("Boolean")}} qui indique si la propriété a été définie avec succès ou non.</p> + +<h2 id="Exemples">Exemples</h2> + +<h3 id="Utiliser_Reflect.defineProperty()">Utiliser <code>Reflect.defineProperty()</code></h3> + +<pre class="brush: js">var obj = {}; +Reflect.defineProperty(obj, "x", {value: 7}); // true +obj.x; // 7 +</pre> + +<h3 id="Vérifier_si_la_définition_de_propriété_a_réussi">Vérifier si la définition de propriété a réussi</h3> + +<p>{{jsxref("Object.defineProperty")}} renvoie un objet si la définition a réussi ou lève une exception {{jsxref("TypeError")}} sinon, ce qui implique d'utiliser un bloc <code><a href="/fr/docs/Web/JavaScript/Reference/Instructions/try...catch">try...catch</a></code> pour attraper l'erreur. <code>Reflect.defineProperty</code> renvoie un booléen pour indiquer la réussite ou l'échec, un bloc <code><a href="/fr/docs/Web/JavaScript/Reference/Instructions/if...else">if...else</a></code> suffit :</p> + +<pre class="brush: js">if (Reflect.defineProperty(cible, propriété, attributs)) { + // succès +} else { + // échec +}</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-reflect.defineproperty', 'Reflect.defineProperty')}}</td> + <td>{{Spec2('ES2015')}}</td> + <td>Définition initiale.</td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-reflect.defineproperty', 'Reflect.defineProperty')}}</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.Reflect.defineProperty")}}</p> + +<h2 id="Voir_aussi">Voir aussi</h2> + +<ul> + <li>{{jsxref("Reflect")}}</li> + <li>{{jsxref("Object.defineProperty()")}}</li> +</ul> diff --git a/files/fr/web/javascript/reference/objets_globaux/reflect/deleteproperty/index.html b/files/fr/web/javascript/reference/objets_globaux/reflect/deleteproperty/index.html new file mode 100644 index 0000000000..f5ba3abedc --- /dev/null +++ b/files/fr/web/javascript/reference/objets_globaux/reflect/deleteproperty/index.html @@ -0,0 +1,96 @@ +--- +title: Reflect.deleteProperty() +slug: Web/JavaScript/Reference/Objets_globaux/Reflect/deleteProperty +tags: + - ECMAScript 2015 + - JavaScript + - Méthode + - Reference + - Reflect +translation_of: Web/JavaScript/Reference/Global_Objects/Reflect/deleteProperty +--- +<div>{{JSRef}}</div> + +<p>La méthode statique <code><strong>Reflect</strong></code><strong><code>.deleteProperty()</code></strong> permet de supprimer des propriétés. Il agit comme l'opérateur <a href="/fr/docs/Web/JavaScript/Reference/Opérateurs/L_opérateur_delete"><code>delete</code></a>.</p> + +<div>{{EmbedInteractiveExample("pages/js/reflect-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="syntaxbox">Reflect.deleteProperty(<var>cible</var>, <var>cléPropriété</var>) +</pre> + +<h3 id="Paramètres">Paramètres</h3> + +<dl> + <dt><code>cible</code></dt> + <dd>L'objet cible sur lequel on souhaite supprimer la propriété.</dd> + <dt><code>cléPropriété</code></dt> + <dd>Le nom de la propriété à supprimer.</dd> +</dl> + +<h3 id="Valeur_de_retour">Valeur de retour</h3> + +<p>Un {{jsxref("Boolean","booléen","",1)}} qui indique si la suppression de la propriété s'est bien passée.</p> + +<h3 id="Exceptions">Exceptions</h3> + +<p>Une erreur {{jsxref("TypeError")}} si <code>cible</code> n'est pas un {{jsxref("Object")}}.</p> + +<h2 id="Description">Description</h2> + +<p>La méthode <code>Reflect.deleteProperty</code> permet de supprimer une propriété d'un objet. Elle renvoie un {{jsxref("Boolean")}} qui indique si la propriété a été supprimée correctement. Cette méthode est très proche de l'opérateur <a href="/fr/docs/Web/JavaScript/Reference/Opérateurs/L_opérateur_delete"><code>delete</code></a>.</p> + +<h2 id="Exemples">Exemples</h2> + +<pre class="brush: js">var obj = { x: 1, y: 2 }; +Reflect.deleteProperty(obj, "x"); // true +obj; // { y: 2 } + +var arr = [1, 2, 3, 4, 5]; +Reflect.deleteProperty(arr, "3"); // true +arr; // [1, 2, 3, , 5] + +// Renvoie true si aucune propriété correspondante n'existe +Reflect.deleteProperty({}, "toto"); // true + +// Renvoie false si une propriété n'est pas configurable +Reflect.deleteProperty(Object.freeze({toto: 1}),"toto"); // false +</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-reflect.deleteproperty', 'Reflect.deleteProperty')}}</td> + <td>{{Spec2('ES2015')}}</td> + <td>Définition initiale.</td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-reflect.deleteproperty', 'Reflect.deleteProperty')}}</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.Reflect.deleteProperty")}}</p> + +<h2 id="Voir_aussi">Voir aussi</h2> + +<ul> + <li>{{jsxref("Reflect")}}</li> + <li><a href="/fr/docs/Web/JavaScript/Reference/Opérateurs/L_opérateur_delete">Opérateur <code>delete</code></a></li> +</ul> diff --git a/files/fr/web/javascript/reference/objets_globaux/reflect/get/index.html b/files/fr/web/javascript/reference/objets_globaux/reflect/get/index.html new file mode 100644 index 0000000000..8538b87538 --- /dev/null +++ b/files/fr/web/javascript/reference/objets_globaux/reflect/get/index.html @@ -0,0 +1,98 @@ +--- +title: Reflect.get() +slug: Web/JavaScript/Reference/Objets_globaux/Reflect/get +tags: + - ECMAScript 2015 + - JavaScript + - Méthode + - Reference + - Reflect +translation_of: Web/JavaScript/Reference/Global_Objects/Reflect/get +--- +<div>{{JSRef}}</div> + +<p>La méthode statique <code><strong>Reflect.get()</strong></code> est une fonction qui permet d'obtenir une propriété d'un objet cible. Elle fonctionne comme (<code>cible[cléPropriété]</code>) mais sous la forme d'une fonction.</p> + +<div>{{EmbedInteractiveExample("pages/js/reflect-get.html")}}</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="syntaxbox">Reflect.get(<var>cible</var>, <var>cléPropriété</var>[, <var>récepteur</var>]) +</pre> + +<h3 id="Paramètres">Paramètres</h3> + +<dl> + <dt><code>cible</code></dt> + <dd>L'objet cible dont on souhaite obtenir la propriété.</dd> + <dt><code>cléPropriété</code></dt> + <dd>Le nom de la propriété qu'on souhaite obtenir.</dd> + <dt><code>récepteur</code> {{optional_inline}}</dt> + <dd>La valeur de <code>this</code> à passer à <code>cible</code> si l'accesseur est utilisé. Lorsqu'on l'utilise avec {{jsxref("Proxy")}}, ce peut être un objet qui hérite de la cible.</dd> +</dl> + +<h3 id="Valeur_de_retour">Valeur de retour</h3> + +<p>La valeur de la propriété.</p> + +<h3 id="Exceptions">Exceptions</h3> + +<p>Une erreur {{jsxref("TypeError")}} si <code>cible</code> n'est pas un {{jsxref("Object")}}.</p> + +<h2 id="Description">Description</h2> + +<p>La méthode <code>Reflect.get</code> permet d'obtenir une propriété d'un objet. Elle est équivalent à <a href="/fr/docs/Web/JavaScript/Reference/Opérateurs/Opérateurs_de_membres">un accesseur de propriété</a> mais sous la forme d'une fonction.</p> + +<h2 id="Exemples">Exemples</h2> + +<pre class="brush: js">// Object +var obj = { x: 1, y: 2 }; +Reflect.get(obj, "x"); // 1 + +// Array +Reflect.get(["zero", "un"], 1); // "un" + +// Proxy qui intercepte get +var x = {p: 1}; +var obj = new Proxy(x, { + get(t, k, r) { return k + "truc"; } +}); +Reflect.get(obj, "toto"); // "tototruc" +</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-reflect.get', 'Reflect.get')}}</td> + <td>{{Spec2('ES2015')}}</td> + <td>Définition initiale</td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-reflect.get', 'Reflect.get')}}</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.Reflect.get")}}</p> + +<h2 id="Voir_aussi">Voir aussi</h2> + +<ul> + <li>{{jsxref("Reflect")}}</li> + <li><a href="/fr/docs/Web/JavaScript/Reference/Opérateurs/Opérateurs_de_membres">Accesseurs de propriété</a></li> +</ul> diff --git a/files/fr/web/javascript/reference/objets_globaux/reflect/getownpropertydescriptor/index.html b/files/fr/web/javascript/reference/objets_globaux/reflect/getownpropertydescriptor/index.html new file mode 100644 index 0000000000..77db7ad5e1 --- /dev/null +++ b/files/fr/web/javascript/reference/objets_globaux/reflect/getownpropertydescriptor/index.html @@ -0,0 +1,103 @@ +--- +title: Reflect.getOwnPropertyDescriptor() +slug: Web/JavaScript/Reference/Objets_globaux/Reflect/getOwnPropertyDescriptor +tags: + - ECMAScript 2015 + - JavaScript + - Méthode + - Reference + - Reflect +translation_of: Web/JavaScript/Reference/Global_Objects/Reflect/getOwnPropertyDescriptor +--- +<div>{{JSRef}}</div> + +<p>La méthode statique <code><strong>Reflect</strong></code><strong><code>.getOwnPropertyDescriptor()</code></strong> est similaire à {{jsxref("Object.getOwnPropertyDescriptor()")}}. Elle renvoie un descripteur de propriété pour la propriété visée si elle existe sur l'objet, sinon, elle renvoie {{jsxref("undefined")}}.</p> + +<div>{{EmbedInteractiveExample("pages/js/reflect-getownpropertydescriptor.html")}}</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="syntaxbox">Reflect.getOwnPropertyDescriptor(<var>cible</var>, <var>cléPropriété</var>) +</pre> + +<h3 id="Paramètres">Paramètres</h3> + +<dl> + <dt><code>cible</code></dt> + <dd>L'objet cible sur lequel on cherche la propriété.</dd> + <dt><code>cléPropriété</code></dt> + <dd>Le nom de la propriété dont on veut obtenir le descripteur.</dd> +</dl> + +<h3 id="Valeur_de_retour">Valeur de retour</h3> + +<p>Un objet qui est un descripteur de propriété si elle existe sur l'objet cible ou {{jsxref("undefined")}} dans le cas contraire.</p> + +<h3 id="Exceptions">Exceptions</h3> + +<p>Une erreur {{jsxref("TypeError")}} si <code>cible</code> n'est pas un {{jsxref("Object")}}.</p> + +<h2 id="Description">Description</h2> + +<p>La méthode <code>Reflect.getOwnPropertyDescriptor</code> renvoie un descripteur pour la propriété demandée si celle-ci existe sur l'objet, sinon, elle renvoie {{jsxref("undefined")}}. La seule différence avec {{jsxref("Object.getOwnPropertyDescriptor()")}} est la façon dont les cibles qui ne sont pas des objets sont gérées.</p> + +<h2 id="Exemples">Exemples</h2> + +<h3 id="Utiliser_Reflect.getOwnPropertyDescriptor()">Utiliser <code>Reflect.getOwnPropertyDescriptor()</code></h3> + +<pre class="brush: js">Reflect.getOwnPropertyDescriptor({x: "coucou"}, "x"); +// {value: "coucou", writable: true, enumerable: true, configurable: true} + +Reflect.getOwnPropertyDescriptor({x: "coucou"}, "y"); +// undefined + +Reflect.getOwnPropertyDescriptor([], "length"); +// {value: 0, writable: true, enumerable: false, configurable: false} +</pre> + +<h3 id="Différence_avec_Object.getOwnPropertyDescriptor()">Différence avec <code>Object.getOwnPropertyDescriptor()</code></h3> + +<p>Si le premier argument passé à la méthode n'est pas un objet (autrement dit si c'est une valeur de type primitif), cela causera une exception {{jsxref("TypeError")}}. Si on utilise {{jsxref("Object.getOwnPropertyDescriptor")}}, une valeur qui n'est pas un objet sera d'abord convertie en objet.</p> + +<pre class="brush: js">Reflect.getOwnPropertyDescriptor("toto", 0); +// TypeError: "toto" is not non-null object + +Object.getOwnPropertyDescriptor("toto", 0); +// { value: "toto", writable: false, enumerable: true, configurable: false }</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-reflect.getownpropertydescriptor', 'Reflect.getOwnPropertyDescriptor')}}</td> + <td>{{Spec2('ES2015')}}</td> + <td>Définition initiale.</td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-reflect.getownpropertydescriptor', 'Reflect.getOwnPropertyDescriptor')}}</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.Reflect.getOwnPropertyDescriptor")}}</p> + +<h2 id="Voir_aussi">Voir aussi</h2> + +<ul> + <li>{{jsxref("Reflect")}}</li> + <li>{{jsxref("Object.getOwnPropertyDescriptor()")}}</li> +</ul> diff --git a/files/fr/web/javascript/reference/objets_globaux/reflect/getprototypeof/index.html b/files/fr/web/javascript/reference/objets_globaux/reflect/getprototypeof/index.html new file mode 100644 index 0000000000..c59fff975a --- /dev/null +++ b/files/fr/web/javascript/reference/objets_globaux/reflect/getprototypeof/index.html @@ -0,0 +1,106 @@ +--- +title: Reflect.getPrototypeOf() +slug: Web/JavaScript/Reference/Objets_globaux/Reflect/getPrototypeOf +tags: + - ECMAScript 2015 + - JavaScript + - Méthode + - Reference + - Reflect +translation_of: Web/JavaScript/Reference/Global_Objects/Reflect/getPrototypeOf +--- +<div>{{JSRef}}</div> + +<p>La méthode statique <code><strong>Reflect</strong></code><strong><code>.getPrototypeOf()</code></strong> est semblable à la méthode {{jsxref("Object.getPrototypeOf()")}}. Elle renvoie le prototype (c'est-à-dire la valeur de la propriété interne <code>[[Prototype]]</code>) de l'objet donné.</p> + +<div>{{EmbedInteractiveExample("pages/js/reflect-getprototypeof.html")}}</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="syntaxbox">Reflect.getPrototypeOf(<var>cible</var>) +</pre> + +<h3 id="Paramètres">Paramètres</h3> + +<dl> + <dt><code>cible</code></dt> + <dd>L'objet cible dont on souhaite obtenir le prototype.</dd> +</dl> + +<h3 id="Valeur_de_retour">Valeur de retour</h3> + +<p>Le prototype de l'objet ou {{jsxref("null")}} s'il n'y a aucune propriété héritée.</p> + +<h3 id="Exceptions_levées">Exceptions levées</h3> + +<p>Une erreur {{jsxref("TypeError")}} si <code>cible</code> n'est pas un {{jsxref("Object")}}.</p> + +<h2 id="Description">Description</h2> + +<p>La méthode <code>Reflect.getPrototypeOf</code> renvoie le prototype (qui correspond en réalité à la valeur de la propriété interne <code>[[Prototype]]</code>) de l'objet passé en argument.</p> + +<h2 id="Exemples">Exemples</h2> + +<h3 id="Utiliser_Reflect.getPrototypeOf()">Utiliser <code>Reflect.getPrototypeOf()</code></h3> + +<pre class="brush: js">Reflect.getPrototypeOf({}); // Object.prototype +Reflect.getPrototypeOf(Object.prototype); // null +Reflect.getPrototypeOf(Object.create(null)); // null +</pre> + +<h3 id="Comparaison_avec_Object.getPrototypeOf()">Comparaison avec <code>Object.getPrototypeOf()</code></h3> + +<pre class="brush: js">// Résultat identiques pour les objets +Object.getPrototypeOf({}); // Object.prototype +Reflect.getPrototypeOf({}); // Object.prototype + +// Exception levée avec ES5 pour les valeurs qui ne sont pas des objets +Object.getPrototypeOf('toto'); // Throws TypeError +Reflect.getPrototypeOf('toto'); // Throws TypeError + +// Avec ES2015 (ES6), seul Reflect lève une exception +// Object convertit automatiquement les valeurs en objets +Object.getPrototypeOf('toto'); // String.prototype +Reflect.getPrototypeOf('toto'); // Throws TypeError + +// Pour obtenir le même effet qu'avec Object en ES2015, il +// faut ajouter une opération de conversion explicite +Reflect.getPrototypeOf(Object('toto')); // String.prototype +</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-reflect.getprototypeof', 'Reflect.getPrototypeOf')}}</td> + <td>{{Spec2('ES2015')}}</td> + <td>Définition initiale.</td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-reflect.getprototypeof', 'Reflect.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.Reflect.getPrototypeOf")}}</p> + +<h2 id="Voir_aussi">Voir aussi</h2> + +<ul> + <li>{{jsxref("Reflect")}}</li> + <li>{{jsxref("Object.getPrototypeOf()")}}</li> +</ul> diff --git a/files/fr/web/javascript/reference/objets_globaux/reflect/has/index.html b/files/fr/web/javascript/reference/objets_globaux/reflect/has/index.html new file mode 100644 index 0000000000..66b230f065 --- /dev/null +++ b/files/fr/web/javascript/reference/objets_globaux/reflect/has/index.html @@ -0,0 +1,96 @@ +--- +title: Reflect.has() +slug: Web/JavaScript/Reference/Objets_globaux/Reflect/has +tags: + - ECMAScript 2015 + - JavaScript + - Méthode + - Reference + - Reflect +translation_of: Web/JavaScript/Reference/Global_Objects/Reflect/has +--- +<div>{{JSRef}}</div> + +<p>La méthode statique <code><strong>Reflect</strong></code><strong><code>.has()</code></strong> fonctionne comme <a href="/fr/docs/Web/JavaScript/Reference/Opérateurs/L_opérateur_in">l'opérateur <code>in</code></a> mais sous forme d'une fonction.</p> + +<div>{{EmbedInteractiveExample("pages/js/reflect-has.html")}}</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="syntaxbox">Reflect.has(<var>cible</var>, <var>cléPropriété</var>) +</pre> + +<h3 id="Paramètres">Paramètres</h3> + +<dl> + <dt><code>cible</code></dt> + <dd>L'objet cible dont on souhaite savoir s'il contient la propriété donnée.</dd> + <dt><code>cléPropriété</code></dt> + <dd>Le nom de la propriété dont on souhaite vérifier la présence.</dd> +</dl> + +<h3 id="Valeur_de_retour">Valeur de retour</h3> + +<p>Un {{jsxref("Boolean","booléen","",1)}} qui indique si la propriété recherchée est présente sur l'objet cible.</p> + +<h3 id="Exceptions">Exceptions</h3> + +<p>Une erreur {{jsxref("TypeError")}} si <code>cible</code> n'est pas un {{jsxref("Object")}}.</p> + +<h2 id="Description">Description</h2> + +<p>La méthode <code>Reflect.has</code> vous permet de vérifier si une propriété est présente sur un objet. C'est une fonction qui agit comme l'opérateur <a href="/fr/docs/Web/JavaScript/Reference/Opérateurs/L_opérateur_in"><code>in</code></a>.</p> + +<h2 id="Exemples">Exemples</h2> + +<pre class="brush: js">Reflect.has({x: 0}, "x"); // true +Reflect.has({x: 0}, "y"); // false + +// renvoie true pour les propriétés présentes +// grâce à la chaîne de prototypes +Reflect.has({x: 0}, "toString"); + +// Proxy avec la méthode .has() +obj = new Proxy({}, { + has(t, k) { return k.startsWith("bou"); } +}); +Reflect.has(obj, "bouchon"); // true +Reflect.has(obj, "bonbon"); // false +</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-reflect.has', 'Reflect.has')}}</td> + <td>{{Spec2('ES2015')}}</td> + <td>Définition initiale.</td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-reflect.has', 'Reflect.has')}}</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.Reflect.has")}}</p> + +<h2 id="Voir_aussi">Voir aussi</h2> + +<ul> + <li>{{jsxref("Reflect")}}</li> + <li><a href="/fr/docs/Web/JavaScript/Reference/Opérateurs/L_opérateur_in">Opérateur <code>in</code></a></li> +</ul> diff --git a/files/fr/web/javascript/reference/objets_globaux/reflect/index.html b/files/fr/web/javascript/reference/objets_globaux/reflect/index.html new file mode 100644 index 0000000000..8a1383c7b5 --- /dev/null +++ b/files/fr/web/javascript/reference/objets_globaux/reflect/index.html @@ -0,0 +1,85 @@ +--- +title: Reflect +slug: Web/JavaScript/Reference/Objets_globaux/Reflect +tags: + - ECMAScript 2015 + - JavaScript + - Reference + - Reflect +translation_of: Web/JavaScript/Reference/Global_Objects/Reflect +--- +<div>{{JSRef}}</div> + +<p><code><strong>Reflect</strong></code> est un objet natif qui fournit des méthodes pour les opérations qui peuvent être interceptées en JavaScript (via les proxies). Les méthodes de cet objet sont les mêmes que celles des <a href="/fr/docs/Web/JavaScript/Reference/Objets_globaux/Proxy/handler">gestionnaires de proxy</a>. <code>Reflect</code> n'est pas une fonction (y compris pour construire un objet).</p> + +<h2 id="Description">Description</h2> + +<p>Contrairement à la plupart des objets globaux, <code>Reflect</code> n'est pas un constructeur. Il ne peut pas être utilisé avec l'opérateur {{jsxref("Opérateurs/L_opérateur_new","new")}} ou être invoqué comme une fonction. Les propriétés et méthodes de <code>Reflect</code> sont statiques (comme pour celles de l'objet {{jsxref("Math")}}).</p> + +<h2 id="Méthodes">Méthodes</h2> + +<p>L'objet <code>Reflect</code> fournit des fonctions statiques qui ont les mêmes noms que les méthodes des <a href="/fr/docs/Web/JavaScript/Reference/Objets_globaux/Proxy/handler">gestionnaires de proxy</a> et dont certaines correspondent, <a href="/fr/docs/Web/JavaScript/Reference/Objets_globaux/Reflect/Comparing_Reflect_and_Object_methods">avec quelques différences</a>, à celles d'{{jsxref("Object")}} :</p> + +<dl> + <dt>{{jsxref("Reflect.apply()")}}</dt> + <dd>Appelle une fonction cible avec les arguments définis par le paramètres <code>args</code>. Voir aussi {{jsxref("Function.prototype.apply()")}}.</dd> + <dt>{{jsxref("Reflect.construct()")}}</dt> + <dd> L'opérateur {{jsxref("Opérateurs/L_opérateur_new","new")}} comme fonction. C'est équivalent à <code>new cible(...args)</code>. Cette méthode permet également d'indiquer un prototype différent.</dd> + <dt>{{jsxref("Reflect.defineProperty()")}}</dt> + <dd>Semblable à {{jsxref("Object.defineProperty()")}}. Renvoie un {{jsxref("Boolean")}}.</dd> + <dt>{{jsxref("Reflect.deleteProperty()")}}</dt> + <dd>L'opérateur {{jsxref("Opérateurs/L_opérateur_delete","delete")}} comme fonction. C'est équivalent à <code>delete cible[nom]</code>.</dd> + <dt>{{jsxref("Reflect.get()")}}</dt> + <dd>Une fonction qui renvoie la valeur d'une propriété.</dd> + <dt>{{jsxref("Reflect.getOwnPropertyDescriptor()")}}</dt> + <dd>Semblable à {{jsxref("Object.getOwnPropertyDescriptor()")}}. Renvoie un descripteur de propriété si la propriété existe sur l'objet, {{jsxref("undefined")}} sinon.</dd> + <dt>{{jsxref("Reflect.getPrototypeOf()")}}</dt> + <dd>Identique à {{jsxref("Object.getPrototypeOf()")}}.</dd> + <dt>{{jsxref("Reflect.has()")}}</dt> + <dd>L'opérateur {{jsxref("Opérateurs/L_opérateur_in","in")}} comme fonction. Renvoie un booléen qui indique si une telle propriété existe pour l'objet (qu'elle soit directement rattachée ou héritée).</dd> + <dt>{{jsxref("Reflect.isExtensible()")}}</dt> + <dd>La même fonction que {{jsxref("Object.isExtensible()")}}.</dd> + <dt>{{jsxref("Reflect.ownKeys()")}}</dt> + <dd>Renvoie un tableau de chaînes de caractères qui correspondent aux noms des propriétés propres (celles qui ne sont pas héritées) de l'objet.</dd> + <dt>{{jsxref("Reflect.preventExtensions()")}}</dt> + <dd>Semblable à {{jsxref("Object.preventExtensions()")}}. Renvoie un {{jsxref("Boolean")}}.</dd> + <dt>{{jsxref("Reflect.set()")}}</dt> + <dd>Une fonction qui affecte des valeurs à des propriétés. Renvoie un {{jsxref("Boolean")}} qui vaut <code>true</code> si la mise à jour a bien été effectuée.</dd> + <dt>{{jsxref("Reflect.setPrototypeOf()")}}</dt> + <dd>Une fonction qui permet de définir le prototype d'un objet.</dd> +</dl> + +<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-reflect-object', 'Reflect')}}</td> + <td>{{Spec2('ES2015')}}</td> + <td>Définition initiale.</td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-reflect-object', 'Reflect')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td>Retrait de <code>Reflect.enumerate</code></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.Reflect")}}</p> + +<h2 id="Voir_aussi">Voir aussi</h2> + +<ul> + <li>L'objet global {{jsxref("Proxy")}}.</li> + <li>L'objet {{jsxref("Proxy.handler", "handler")}}.</li> +</ul> diff --git a/files/fr/web/javascript/reference/objets_globaux/reflect/isextensible/index.html b/files/fr/web/javascript/reference/objets_globaux/reflect/isextensible/index.html new file mode 100644 index 0000000000..bdb266575c --- /dev/null +++ b/files/fr/web/javascript/reference/objets_globaux/reflect/isextensible/index.html @@ -0,0 +1,113 @@ +--- +title: Reflect.isExtensible() +slug: Web/JavaScript/Reference/Objets_globaux/Reflect/isExtensible +tags: + - ECMAScript 2015 + - JavaScript + - Méthode + - Reference + - Reflect +translation_of: Web/JavaScript/Reference/Global_Objects/Reflect/isExtensible +--- +<div>{{JSRef}}</div> + +<p>La méthode statique <code><strong>Reflect.isExtensible()</strong></code> permet de déterminer si un objet est extensible (i.e. si on peut lui ajouter de nouvelles propriétés). Elle est semblable à la méthode {{jsxref("Object.isExtensible()")}} (modulo <a href="#diffs">quelques différences</a>).</p> + +<div>{{EmbedInteractiveExample("pages/js/reflect-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="syntaxbox">Reflect.isExtensible(<var>cible</var>) +</pre> + +<h3 id="Paramètres">Paramètres</h3> + +<dl> + <dt><code>cible</code></dt> + <dd>L'objet cible dont on souhaite savoir s'il est extensible.</dd> +</dl> + +<h3 id="Valeur_de_retour">Valeur de retour</h3> + +<p>Un {{jsxref("Boolean","booléen", "",1)}} qui indique si la cible est extensible ou non.</p> + +<h3 id="Exceptions">Exceptions</h3> + +<p>Une erreur {{jsxref("TypeError")}} si <code>cible</code> n'est pas un {{jsxref("Object")}}.</p> + +<h2 id="Description">Description</h2> + +<p>La méthode <code>Reflect.isExtensible</code> permet de déterminer si un objet est extensible (autrement dit si on peut lui ajouter de nouvelles propriétés). Cette méthode est semblable à la méthode {{jsxref("Object.isExtensible()")}}.</p> + +<h2 id="Exemples">Exemples</h2> + +<h3 id="Utiliser_Reflect.isExtensible()">Utiliser <code>Reflect.isExtensible()</code></h3> + +<p>Voir aussi {{jsxref("Object.isExtensible()")}}.</p> + +<pre class="brush: js">// Les nouveaux objets sont extensibles. +var vide = {}; +Reflect.isExtensible(vide); // true + +// ...mais ça peut être changé. +Reflect.preventExtensions(vide); +Reflect.isExtensible(vide); // false + +// Par définition, les objets scellés +// ne sont pas extensibles. +var scellé = Object.seal({}); +Reflect.isExtensible(scellé); // false + +// Par définition, les objets gelés sont +// également non-extensibles. +var gelé = Object.freeze({}); +Reflect.isExtensible(gelé); // false +</pre> + +<h3 id="Différence_avec_Object.isExtensible()">Différence avec <code>Object.isExtensible()</code></h3> + +<p>Si le premier argument passé à la méthode n'est pas un objet (autrement dit si la valeur est une valeur primitive), cela provoquera une exception {{jsxref("TypeError")}}. La méthode {{jsxref("Object.isExtensible()")}} aurait commencé par convertir l'argument en un objet.</p> + +<pre class="brush: js">Reflect.isExtensible(1); +// TypeError: 1 is not an object + +Object.isExtensible(1); +// false +</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-reflect.isextensible', 'Reflect.isExtensible')}}</td> + <td>{{Spec2('ES2015')}}</td> + <td>Définition initiale.</td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-reflect.isextensible', 'Reflect.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.Reflect.isExtensible")}}</p> + +<h2 id="Voir_aussi">Voir aussi</h2> + +<ul> + <li>{{jsxref("Reflect")}}</li> + <li>{{jsxref("Object.isExtensible()")}}</li> +</ul> diff --git a/files/fr/web/javascript/reference/objets_globaux/reflect/ownkeys/index.html b/files/fr/web/javascript/reference/objets_globaux/reflect/ownkeys/index.html new file mode 100644 index 0000000000..9372830b80 --- /dev/null +++ b/files/fr/web/javascript/reference/objets_globaux/reflect/ownkeys/index.html @@ -0,0 +1,95 @@ +--- +title: Reflect.ownKeys() +slug: Web/JavaScript/Reference/Objets_globaux/Reflect/ownKeys +tags: + - ECMAScript 2015 + - JavaScript + - Méthode + - Reference + - Reflect +translation_of: Web/JavaScript/Reference/Global_Objects/Reflect/ownKeys +--- +<p>{{JSRef}}</p> + +<p>La méthode statique <strong><code>Reflect.ownKeys()</code></strong> renvoie un tableau qui contient les clés des propriétés propres (non héritées) de l'objet <code>cible</code>.</p> + +<div>{{EmbedInteractiveExample("pages/js/reflect-ownkeys.html")}}</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="syntaxbox">Reflect.ownKeys(<var>cible</var>) +</pre> + +<h3 id="Paramètres">Paramètres</h3> + +<dl> + <dt><code>cible</code></dt> + <dd>L'objet cible dont on souhaite obtenir les noms et symboles des propriétés propres.</dd> +</dl> + +<h3 id="Valeur_de_retour">Valeur de retour</h3> + +<p>Un objet {{jsxref("Array")}} qui contient les clés des propriétés propres de <code>cible</code>.</p> + +<h3 id="Exceptions">Exceptions</h3> + +<p>Une erreur {{jsxref("TypeError")}} si <code>cible</code> n'est pas un {{jsxref("Object")}}.</p> + +<h2 id="Description">Description</h2> + +<p>La méthode <code>Reflect.ownKeys</code> renvoie un tableau dont les éléments sont les clés des propriétés propres de l'objet <code>cible</code>. Sa valeur de retour est équivalente à <code>{{jsxref("Object.getOwnPropertyNames", "Object.getOwnPropertyNames(target)", "", 1)}}.concat({{jsxref("Object.getOwnPropertySymbols", "Object.getOwnPropertySymbols(target)", "", 1)}})</code>.</p> + +<h2 id="Exemples">Exemples</h2> + +<pre>Reflect.ownKeys({z: 3, y: 2, x: 1}); // [ "z", "y", "x" ] +Reflect.ownKeys([]); // ["length"] + +var sym = Symbol.for("comète"); +var sym2 = Symbol.for("météore"); +var obj = {[sym]: 0, "str1": 0, "773": 0, "0": 0, + [sym2]: 0, "-1": 0, "8": 0, "seconde str": 0}; +Reflect.ownKeys(obj); +// [ "0", "8", "773", "str1", "-1", "seconde str", Symbol(comète), Symbol(météore) ] +// Indices dans l'ordre numérique +// Chaînes de caractères dans l'ordre d'insertion +// Symboles dans l'ordre d'insertion +</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-reflect.ownkeys', 'Reflect.ownKeys')}}</td> + <td>{{Spec2('ES2015')}}</td> + <td>Définition initiale.</td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-reflect.ownkeys', 'Reflect.ownKeys')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2> + +<div class="hidden"> +<p>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>.</p> +</div> + +<p>{{Compat("javascript.builtins.Reflect.ownKeys")}}</p> + +<h2 id="Voir_aussi">Voir aussi</h2> + +<ul> + <li>{{jsxref("Reflect")}}</li> + <li>{{jsxref("Object.getOwnPropertyNames()")}}</li> +</ul> diff --git a/files/fr/web/javascript/reference/objets_globaux/reflect/preventextensions/index.html b/files/fr/web/javascript/reference/objets_globaux/reflect/preventextensions/index.html new file mode 100644 index 0000000000..c7f202f685 --- /dev/null +++ b/files/fr/web/javascript/reference/objets_globaux/reflect/preventextensions/index.html @@ -0,0 +1,103 @@ +--- +title: Reflect.preventExtensions() +slug: Web/JavaScript/Reference/Objets_globaux/Reflect/preventExtensions +tags: + - ECMAScript 2015 + - JavaScript + - Méthode + - Reference + - Reflect +translation_of: Web/JavaScript/Reference/Global_Objects/Reflect/preventExtensions +--- +<div>{{JSRef}}</div> + +<p>La méthode statique <code><strong>Reflect.preventExtensions()</strong></code> permet d'empêcher d'ajouter de nouvelles propriétés à un objet. Cette méthode est semblable à la méthode {{jsxref("Object.preventExtensions()")}} (modulo <a href="#diffs">quelques différences</a>).</p> + +<div>{{EmbedInteractiveExample("pages/js/reflect-preventextensions.html")}}</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="syntaxbox">Reflect.preventExtensions(<em>cible</em>) +</pre> + +<h3 id="Paramètres">Paramètres</h3> + +<dl> + <dt><code>cible</code></dt> + <dd>L'objet cible dont on veut empêcher l'ajout d'autres propriétés.</dd> +</dl> + +<h3 id="Valeur_de_retour">Valeur de retour</h3> + +<p>Un {{jsxref("Boolean","booléen","",1)}} qui indique si l'interdiction a bien été mise en place sur l'objet cible.</p> + +<h3 id="Exceptions">Exceptions</h3> + +<p>Une erreur {{jsxref("TypeError")}} si <code>cible</code> n'est pas un {{jsxref("Object")}}.</p> + +<h2 id="Description">Description</h2> + +<p>La méthode <code>Reflect.preventExtensions</code> permet d'empêcher l'ajout de nouvelles propriétés sur un objet. Cette méthode est semblable à {{jsxref("Object.preventExtensions()")}}.</p> + +<h2 id="Exemples">Exemples</h2> + +<h3 id="Utiliser_Reflect.preventExtensions()">Utiliser <code>Reflect.preventExtensions()</code></h3> + +<p>Voir aussi {{jsxref("Object.preventExtensions()")}}.</p> + +<pre class="brush: js">// Par défaut les objets sont extensibles +var vide = {}; +Reflect.isExtensible(vide); // === true + +// ...mais cela peut être modifié +Reflect.preventExtensions(vide); +Reflect.isExtensible(vide); // === false +</pre> + +<h3 id="Différences_avec_Object.preventExtensions()">Différences avec <code>Object.preventExtensions()</code></h3> + +<p>Si le premier argument de cette méthode n'est pas un objet (autrement dit c'est une valeur primitive), cela provoquera une {{jsxref("TypeError")}}. {{jsxref("Object.preventExtensions()")}}, quant à elle, convertira l'argument passé en un objet.</p> + +<pre class="brush: js">Reflect.preventExtensions(1); +// TypeError: 1 is not an object + +Object.preventExtensions(1); +// 1 +</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-reflect.preventextensions', 'Reflect.preventExtensions')}}</td> + <td>{{Spec2('ES2015')}}</td> + <td>Définition initiale.</td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-reflect.preventextensions', 'Reflect.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.Reflect.preventExtensions")}}</p> + +<h2 id="Voir_aussi">Voir aussi</h2> + +<ul> + <li>{{jsxref("Reflect")}}</li> + <li>{{jsxref("Object.isExtensible()")}}</li> +</ul> diff --git a/files/fr/web/javascript/reference/objets_globaux/reflect/set/index.html b/files/fr/web/javascript/reference/objets_globaux/reflect/set/index.html new file mode 100644 index 0000000000..8d37acc413 --- /dev/null +++ b/files/fr/web/javascript/reference/objets_globaux/reflect/set/index.html @@ -0,0 +1,109 @@ +--- +title: Reflect.set() +slug: Web/JavaScript/Reference/Objets_globaux/Reflect/set +tags: + - ECMAScript 2015 + - JavaScript + - Méthode + - Reference + - Reflect +translation_of: Web/JavaScript/Reference/Global_Objects/Reflect/set +--- +<div>{{JSRef}}</div> + +<p>La méthode statique <code><strong>Reflect.set()</strong></code> permet de définir ou de modifier une propriété sur un objet.</p> + +<div>{{EmbedInteractiveExample("pages/js/reflect-set.html")}}</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="syntaxbox">Reflect.set(<var>cible</var>, <var>cléPropriété</var>, <var>valeur</var>[, <var>récepteur</var>]) +</pre> + +<h3 id="Paramètres">Paramètres</h3> + +<dl> + <dt><code>cible</code></dt> + <dd>L'objet cible sur lequel on veut définir ou modifier la propriété.</dd> + <dt><code>cléPropriété</code></dt> + <dd>Le nom de la propriété à définir ou à modifier.</dd> + <dt><code>valeur</code></dt> + <dd>La valeur pour la propriété.</dd> + <dt><code>récepteur</code>{{optional_inline}}</dt> + <dd>La valeur de <code>this</code> pour l'appel à <code>cible</code> si un mutateur (<em>setter</em>) est utilisé.</dd> +</dl> + +<h3 id="Valeur_de_retour">Valeur de retour</h3> + +<p>Un {{jsxref("Boolean","booléen","",1)}} qui indique si la définition/modification de la propriété a réussi.</p> + +<h3 id="Exceptions">Exceptions</h3> + +<p>Une erreur {{jsxref("TypeError")}} si <code>cible</code> n'est pas un {{jsxref("Object")}}.</p> + +<h2 id="Description">Description</h2> + +<p>La méthode <code>Reflect.set</code> permet de définir une propriété sur un objet. Elle effectue une affectation de propriété et est semblable à la syntaxe pour <a href="/fr/docs/Web/JavaScript/Reference/Opérateurs/Opérateurs_de_membres">accéder à un propriété</a> mais sous la forme d'une fonction.</p> + +<h2 id="Exemples">Exemples</h2> + +<h3 id="Utiliser_Reflect.set()">Utiliser <code>Reflect.set()</code></h3> + +<pre class="brush: js">// Object +var obj = {}; +Reflect.set(obj, "prop", "value"); // true +obj.prop; // "value" + +// Array +var arr = ["canard", "canard", "canard"]; +Reflect.set(arr, 2, "oie"); // true +arr[2]; // "oie" + +// On peut l'utiliser pour tronquer un tableau +Reflect.set(arr, "length", 1); // true +arr; // ["canard"]; + +// Avec un seul argument +// cléPropriété et valeur valent "undefined". +var obj = {}; +Reflect.set(obj); // true +Reflect.getOwnPropertyDescriptor(obj, "undefined"); +// { value: undefined, writable: true, enumerable: true, configurable: true } +</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-reflect.set', 'Reflect.set')}}</td> + <td>{{Spec2('ES2015')}}</td> + <td>Définition initiale.</td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-reflect.set', 'Reflect.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.Reflect.set")}}</p> + +<h2 id="Voir_aussi">Voir aussi</h2> + +<ul> + <li>{{jsxref("Reflect")}}</li> + <li><a href="/fr/docs/Web/JavaScript/Reference/Opérateurs/Opérateurs_de_membres">Accesseurs de propriété</a></li> +</ul> diff --git a/files/fr/web/javascript/reference/objets_globaux/reflect/setprototypeof/index.html b/files/fr/web/javascript/reference/objets_globaux/reflect/setprototypeof/index.html new file mode 100644 index 0000000000..8d267952c0 --- /dev/null +++ b/files/fr/web/javascript/reference/objets_globaux/reflect/setprototypeof/index.html @@ -0,0 +1,100 @@ +--- +title: Reflect.setPrototypeOf() +slug: Web/JavaScript/Reference/Objets_globaux/Reflect/setPrototypeOf +tags: + - ECMAScript 2015 + - JavaScript + - Méthode + - Reference + - Reflect +translation_of: Web/JavaScript/Reference/Global_Objects/Reflect/setPrototypeOf +--- +<div>{{JSRef}}</div> + +<p>la méthode statique <code><strong>Reflect.setPrototypeOf()</strong></code> est semblable à la méthode {{jsxref("Object.setPrototypeOf()")}} (exception faite de la valeur de retour). Elle permet de définir le prototype (c'est-à-dire la propriété interne <code>[[Prototype]]</code>) d'un objet donné avec un autre objet ou {{jsxref("null")}}. Cette méthode renvoie <code>true</code> si l'opération a réussi et <code>false</code> sinon.</p> + +<div>{{EmbedInteractiveExample("pages/js/reflect-setprototypeof.html")}}</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="syntaxbox">Reflect.setPrototypeOf(<var>cible</var>, <var>prototype</var>) +</pre> + +<h3 id="Paramètres">Paramètres</h3> + +<dl> + <dt><code>cible</code></dt> + <dd>L'objet cible dont on souhaite modifier le prototype.</dd> + <dt><code>prototype</code></dt> + <dd>Le nouveau prototype à appliquer à l'objet cible (ça peut être un objet ou {{jsxref("null")}}).</dd> +</dl> + +<h3 id="Valeur_de_retour">Valeur de retour</h3> + +<p>Un {{jsxref("Boolean","booléen","",1)}} qui indique si le prototype a correctement été modifié.</p> + +<h3 id="Exceptions">Exceptions</h3> + +<p>Une erreur {{jsxref("TypeError")}} si <code>cible</code> n'est pas un {{jsxref("Object")}} ou si <code>prototype</code> n'est ni un objet ni {{jsxref("null")}}.</p> + +<h2 id="Description">Description</h2> + +<p>La méthode <code>Reflect.setPrototypeOf</code> permet de modifier le prototype (qui est la valeur de la propriété interne <code>[[Prototype]]</code>) d'un objet donné.</p> + +<h2 id="Exemples">Exemples</h2> + +<h3 id="Utiliser_Reflect.setPrototypeOf()">Utiliser <code>Reflect.setPrototypeOf()</code></h3> + +<pre class="brush: js">Reflect.setPrototypeOf({}, Object.prototype); // true + +// On peut modifier le [[Prototype]] d'un objet +// pour que celui-ci soit null. +Reflect.setPrototypeOf({}, null); // true + +// La méthode renvoie false si la cible +// n'est pas extensible. +Reflect.setPrototypeOf(Object.freeze({}), null); // false + +// La méthode renvoie false si l'affectation +// entraîne un cycle dans la chaîne de prototypes. +var target = {}; +var proto = Object.create(target); +Reflect.setPrototypeOf(target, proto); // false +</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-reflect.setprototypeof', 'Reflect.setPrototypeOf')}}</td> + <td>{{Spec2('ES2015')}}</td> + <td>Définition initiale.</td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-reflect.setprototypeof', 'Reflect.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.Reflect.setPrototypeOf")}}</p> + +<h2 id="Voir_aussi">Voir aussi</h2> + +<ul> + <li>{{jsxref("Reflect")}}</li> + <li>{{jsxref("Object.setPrototypeOf()")}}</li> +</ul> |