From 39f2114f9797eb51994966c6bb8ff1814c9a4da8 Mon Sep 17 00:00:00 2001 From: Florian Merz Date: Thu, 11 Feb 2021 12:36:08 +0100 Subject: unslug fr: move --- .../global_objects/reflect/apply/index.html | 100 +++++++++++++ .../index.html | 99 +++++++++++++ .../global_objects/reflect/construct/index.html | 163 +++++++++++++++++++++ .../reflect/defineproperty/index.html | 100 +++++++++++++ .../reflect/deleteproperty/index.html | 96 ++++++++++++ .../global_objects/reflect/get/index.html | 98 +++++++++++++ .../reflect/getownpropertydescriptor/index.html | 103 +++++++++++++ .../reflect/getprototypeof/index.html | 106 ++++++++++++++ .../global_objects/reflect/has/index.html | 96 ++++++++++++ .../reference/global_objects/reflect/index.html | 85 +++++++++++ .../global_objects/reflect/isextensible/index.html | 113 ++++++++++++++ .../global_objects/reflect/ownkeys/index.html | 95 ++++++++++++ .../reflect/preventextensions/index.html | 103 +++++++++++++ .../global_objects/reflect/set/index.html | 109 ++++++++++++++ .../reflect/setprototypeof/index.html | 100 +++++++++++++ 15 files changed, 1566 insertions(+) create mode 100644 files/fr/web/javascript/reference/global_objects/reflect/apply/index.html create mode 100644 files/fr/web/javascript/reference/global_objects/reflect/comparing_reflect_and_object_methods/index.html create mode 100644 files/fr/web/javascript/reference/global_objects/reflect/construct/index.html create mode 100644 files/fr/web/javascript/reference/global_objects/reflect/defineproperty/index.html create mode 100644 files/fr/web/javascript/reference/global_objects/reflect/deleteproperty/index.html create mode 100644 files/fr/web/javascript/reference/global_objects/reflect/get/index.html create mode 100644 files/fr/web/javascript/reference/global_objects/reflect/getownpropertydescriptor/index.html create mode 100644 files/fr/web/javascript/reference/global_objects/reflect/getprototypeof/index.html create mode 100644 files/fr/web/javascript/reference/global_objects/reflect/has/index.html create mode 100644 files/fr/web/javascript/reference/global_objects/reflect/index.html create mode 100644 files/fr/web/javascript/reference/global_objects/reflect/isextensible/index.html create mode 100644 files/fr/web/javascript/reference/global_objects/reflect/ownkeys/index.html create mode 100644 files/fr/web/javascript/reference/global_objects/reflect/preventextensions/index.html create mode 100644 files/fr/web/javascript/reference/global_objects/reflect/set/index.html create mode 100644 files/fr/web/javascript/reference/global_objects/reflect/setprototypeof/index.html (limited to 'files/fr/web/javascript/reference/global_objects/reflect') diff --git a/files/fr/web/javascript/reference/global_objects/reflect/apply/index.html b/files/fr/web/javascript/reference/global_objects/reflect/apply/index.html new file mode 100644 index 0000000000..b6f27bc995 --- /dev/null +++ b/files/fr/web/javascript/reference/global_objects/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 +--- +
{{JSRef}}
+ +

La méthode statique Reflect.apply() permet d'appeler une fonction cible avec des arguments donnés.

+ +
{{EmbedInteractiveExample("pages/js/reflect-apply.html")}}
+ + + +

Syntaxe

+ +
Reflect.apply(cible, argumentThis, listeArguments)
+
+ +

Paramètres

+ +
+
cible
+
La fonction cible à appeler.
+
argumentThis
+
La valeur fournie pour this lors de l'appel à cible.
+
listeArguments
+
Un objet semblable à un tableau qui définit les arguments à passer à cible. S'il vaut {{jsxref("null")}} ou {{jsxref("undefined")}}, aucun argument ne sera passé.
+
+ +

Valeur de retour

+ +

Le résultat de l'appel de la fonction cible indiquée avec la valeur this et les arguments indiqués.

+ +

Exceptions levées

+ +

Une exception {{jsxref("TypeError")}}, si cible ne peut pas être appelée.

+ +

Description

+ +

Avec ES5, on utilise généralement {{jsxref("Function.prototype.apply()")}} pour appeler une fonction avec une valeur this donnée et des arguments donnés.

+ +
Function.prototype.apply.call(Math.floor, undefined, [1.75]);
+ +

Reflect.apply permet de rendre cela plus concis et facile à comprendre.

+ +

Exemples

+ +
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"
+
+ +

Spécifications

+ + + + + + + + + + + + + + + + + + + +
SpécificationÉtatCommentaires
{{SpecName('ES2015', '#sec-reflect.apply', 'Reflect.apply')}}{{Spec2('ES2015')}}Définition initiale.
{{SpecName('ESDraft', '#sec-reflect.apply', 'Reflect.apply')}}{{Spec2('ESDraft')}} 
+ +

Compatibilité des navigateurs

+ + + +

{{Compat("javascript.builtins.Reflect.apply")}}

+ +

Voir aussi

+ + diff --git a/files/fr/web/javascript/reference/global_objects/reflect/comparing_reflect_and_object_methods/index.html b/files/fr/web/javascript/reference/global_objects/reflect/comparing_reflect_and_object_methods/index.html new file mode 100644 index 0000000000..2c8844e085 --- /dev/null +++ b/files/fr/web/javascript/reference/global_objects/reflect/comparing_reflect_and_object_methods/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 +--- +
{{jssidebar}}
+ +

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 Reflect 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.

+ +

Dans ce tableau, nous énumérons les différences entre les méthodes disponibles avec Object et Reflect. Si une méthode n'existe pas dans le cas indiqué, elle sera notée N/A.

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
Nom de la méthodeObjectReflect
defineProperty(){{jsxref("Object.defineProperty()")}} renvoie l'objet qui a été passé à la fonction. Déclenche une exception TypeError si la propriété n'a pu être définie sur l'objet.{{jsxref("Reflect.defineProperty()")}} renvoie true si la propriété a été définie sur l'objet et false sinon.
defineProperties(){{jsxref("Object.defineProperties()")}} renvoie les objets passés à la fonction. Déclenche une exception TypeError si une des propriétés n'a pu être définie.N/A
set()N/A{{jsxref("Reflect.set()")}} renvoie true si la propriété a été définie sur l'objet et false sinon. Déclenche une exception TypeError si la cible n'était pas un Object.
get()N/A{{jsxref("Reflect.get()")}} renvoie la valeur de la propriété. Déclenche une exception TypeError si la cible n'était pas un Object.
deleteProperty()N/A{{jsxref("Reflect.deleteProperty()")}} renvoie true si la propriété a été supprimée de l'objet et false sinon.
getOwnPropertyDescriptor(){{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 undefined. Si la valeur passée en premier argument n'est pas un objet, elle sera automatiquement convertie en un objet.{{jsxref("Reflect.getOwnPropertyDescriptor()")}} renvoie un descripteur de la propriété si elle existe sur l'objet et undefined si elle n'existe pas. Déclenche une exception TypeError si la valeur passée en premier argument n'est pas un objet.
getOwnPropertyDescriptors(){{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.N/A
getPrototypeOf(){{jsxref("Object.getPrototypeOf()")}} renvoie le prototype de l'objet fourni. Renvoie null s'il n'y a pas de propriétés héritées. En ES5, déclenche une exception TypeError pour les valeurs qui ne sont pas des objets (pour ES6 et ensuite, les valeurs sont converties en objet).{{jsxref("Reflect.getPrototypeOf()")}} renvoie le prototype de l'objet fourni. Renvoie null s'il n'y a pas de propriétés héritées et déclenche une exception TypeError pour les valeurs qui ne sont pas des objets.
setPrototypeOf(){{jsxref("Object.setPrototypeOf()")}} renvoie l'objet fourni si le prototype a pu être défini. Déclenche une exception TypeError si le prototype utilisé n'était pas un objet ou null ou si le prototype de l'objet à modifier n'est pas extensible.{{jsxref("Reflect.setPrototypeOf()")}} renvoie true si le prototype a pu être défini sur l'objet et false sinon (y compris lorsque le prototype n'est pas extensible). Déclenche une exception TypeError si la cible passée n'est pas un objet ou si le prototype à appliquer n'est pas un objet ou n'est pas null.
isExtensible(){{jsxref("Object.isExtensible()")}} renvoie true si l'objet est extensible et false sinon. En ES5, déclenche une exception TypeError 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 false. +

{{jsxref("Reflect.isExtensible()")}} renvoie true si l'objet est extensible et false sinon. Déclenche une exception TypeError si le premier argument n'est pas un objet.

+
preventExtensions() +

{{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.

+ 		{{jsxref("Reflect.preventExtensions()")}} renvoie true si l'objet a été rendu non-extensible et false sinon. Déclenche une exception TypeError si l'argument n'est pas un objet.
keys(){{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 TypeError si la cible n'est pas un objet. Avec ES6 et les versions suivantes, les valeurs primitives sont converties en objets.N/A
ownKeys()N/A{{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 TypeError si la cible n'est pas un objet.
diff --git a/files/fr/web/javascript/reference/global_objects/reflect/construct/index.html b/files/fr/web/javascript/reference/global_objects/reflect/construct/index.html new file mode 100644 index 0000000000..9f61844a66 --- /dev/null +++ b/files/fr/web/javascript/reference/global_objects/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 +--- +
{{JSRef}}
+ +

La méthode statique Reflect.construct() agit comme l'opérateur new sous la forme d'une fonction. Elle est équivalente à new cible(...args) et permet d'indiquer un prototype différent.

+ +
{{EmbedInteractiveExample("pages/js/reflect-construct.html")}}
+ + + +

Syntaxe

+ +
Reflect.construct(cible, listeArguments[, newCible])
+
+ +

Paramètres

+ +
+
cible
+
La fonction cible à appeler.
+
listeArguments
+
Un objet semblable à un tableau définissant les arguments à passer à cible lors de l'appel. Utiliser {{jsxref("null")}} ou {{jsxref("undefined")}} si aucun argument ne doit être fourni à la fonction.
+
newCible {{optional_inline}}
+
Le constructeur dont le prototype devrait être utilisé. Voir également l'opérateur new.target. Si newCible n'est pas présent, c'est cible qui sera utilisé.
+
+ +

Valeur de retour

+ +

Un nouvelle instance de la cible indiquée, créée en l'appelant comme un constructeur (ou en appelant newCible si elle est fournie) avec les arguments fournis.

+ +

Exceptions levées

+ +

Une exception {{jsxref("TypeError")}} si cible ou newCible ne sont pas des constructeurs.

+ +

Description

+ +

Reflect.construct() permet d'appeler un constructeur avec un nombre d'arguments variable (ce qui peut également être fait avec l'opérateur de décomposition et l'opérateur new).

+ +
var obj = new Toto(...args);
+var obj = Reflect.construct(Toto, args);
+ +

Exemples

+ +

Utiliser Reflect.construct()

+ +
var d = Reflect.construct(Date, [1776, 6, 4]);
+d instanceof Date; // true
+d.getFullYear(); // 1776
+
+ +

Utiliser le paramètre newCible

+ +

Pour plus d'informations sur la création de sous-classes, voir les classes et l'opérateur new.target.

+ +
function unConstructeur() {}
+var résultat = Reflect.construct(Array, [], unConstructeur);
+
+Reflect.getPrototypeOf(résultat); // unConstructeur.prototype
+Array.isArray(résultat); // true
+
+ +

Une comparaison entre Reflect.construct() et Object.create()

+ +

Avant l'apparition de Reflect, on pouvait construire des objets avec une combinaison donnée de consttructeur et de prototype grâce à {{jsxref("Object.create()")}}.

+ +
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
+
+ +

Toutefois, si les résultats sont identiques, il y a une différence notable. Lorsqu'on utilise Object.create() et Function.prototype.apply(), l'opérateur new.target pointe vers undefined dans la fonction utilisée comme constructeur car le mot-clé new n'est pas utilisé à la création de l'objet.

+ +

Mais quand on appelle Reflect.construct(), new.target pointe vers la valeur fournie par newCible si ce dernier est fourni ou vers cible sinon.

+ +
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
+ +

Spécifications

+ + + + + + + + + + + + + + + + + + + +
SpécificationÉtatCommentaires
{{SpecName('ES2015', '#sec-reflect.construct', 'Reflect.construct')}}{{Spec2('ES2015')}}Définition initiale.
{{SpecName('ESDraft', '#sec-reflect.construct', 'Reflect.construct')}}{{Spec2('ESDraft')}}
+ +

Compatibilité des navigateurs

+ + + +

{{Compat("javascript.builtins.Reflect.construct")}}

+ +

Voir aussi

+ + diff --git a/files/fr/web/javascript/reference/global_objects/reflect/defineproperty/index.html b/files/fr/web/javascript/reference/global_objects/reflect/defineproperty/index.html new file mode 100644 index 0000000000..71d6e6b60f --- /dev/null +++ b/files/fr/web/javascript/reference/global_objects/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 +--- +
{{JSRef}}
+ +

La méthode statique Reflect.defineProperty() est semblable à {{jsxref("Object.defineProperty()")}} mais renvoie un {{jsxref("Boolean")}}.

+ +
{{EmbedInteractiveExample("pages/js/reflect-defineproperty.html")}}
+ + + +

Syntaxe

+ +
Reflect.defineProperty(cible, cléPropriété, attributs)
+
+ +

Paramètres

+ +
+
cible
+
L'objet cible sur lequel on veut définir la propriété.
+
cléPropriété
+
Le nom de la propriété qu'on souhaite définir ou modifier.
+
attributs
+
Les attributs de de la propriété qu'on ajoute ou qu'on modifie.
+
+ +

Valeur de retour

+ +

Un {{jsxref("Boolean","booléen","",1)}} qui indique si la propriété a bien été définie.

+ +

Exceptions

+ +

Une erreur {{jsxref("TypeError")}} si cible n'est pas un {{jsxref("Object")}}.

+ +

Description

+ +

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

+ +

Exemples

+ +

Utiliser Reflect.defineProperty()

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

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

+ +

{{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 try...catch pour attraper l'erreur. Reflect.defineProperty renvoie un booléen pour indiquer la réussite ou l'échec, un bloc if...else suffit :

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

Spécifications

+ + + + + + + + + + + + + + + + + + + +
SpécificationÉtatCommentaires
{{SpecName('ES2015', '#sec-reflect.defineproperty', 'Reflect.defineProperty')}}{{Spec2('ES2015')}}Définition initiale.
{{SpecName('ESDraft', '#sec-reflect.defineproperty', 'Reflect.defineProperty')}}{{Spec2('ESDraft')}} 
+ +

Compatibilité des navigateurs

+ + + +

{{Compat("javascript.builtins.Reflect.defineProperty")}}

+ +

Voir aussi

+ + diff --git a/files/fr/web/javascript/reference/global_objects/reflect/deleteproperty/index.html b/files/fr/web/javascript/reference/global_objects/reflect/deleteproperty/index.html new file mode 100644 index 0000000000..f5ba3abedc --- /dev/null +++ b/files/fr/web/javascript/reference/global_objects/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 +--- +
{{JSRef}}
+ +

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

+ +
{{EmbedInteractiveExample("pages/js/reflect-deleteproperty.html", "taller")}}
+ + + +

Syntaxe

+ +
Reflect.deleteProperty(cible, cléPropriété)
+
+ +

Paramètres

+ +
+
cible
+
L'objet cible sur lequel on souhaite supprimer la propriété.
+
cléPropriété
+
Le nom de la propriété à supprimer.
+
+ +

Valeur de retour

+ +

Un {{jsxref("Boolean","booléen","",1)}} qui indique si la suppression de la propriété s'est bien passée.

+ +

Exceptions

+ +

Une erreur {{jsxref("TypeError")}} si cible n'est pas un {{jsxref("Object")}}.

+ +

Description

+ +

La méthode Reflect.deleteProperty 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 delete.

+ +

Exemples

+ +
var obj = { x: 1, y: 2 };
+Reflect.deleteProperty(obj, "x"); // true
+obj; // { y: 2 }
+
+var arr = [1, 2, 3, 4, 5];
+Reflect.deleteProperty(arr, "3"); // true
+arr; // [1, 2, 3, , 5]
+
+// Renvoie true si aucune propriété correspondante n'existe
+Reflect.deleteProperty({}, "toto"); // true
+
+// Renvoie false si une propriété n'est pas configurable
+Reflect.deleteProperty(Object.freeze({toto: 1}),"toto"); // false
+
+ +

Spécifications

+ + + + + + + + + + + + + + + + + + + +
SpécificationÉtatCommentaires
{{SpecName('ES2015', '#sec-reflect.deleteproperty', 'Reflect.deleteProperty')}}{{Spec2('ES2015')}}Définition initiale.
{{SpecName('ESDraft', '#sec-reflect.deleteproperty', 'Reflect.deleteProperty')}}{{Spec2('ESDraft')}} 
+ +

Compatibilité des navigateurs

+ + + +

{{Compat("javascript.builtins.Reflect.deleteProperty")}}

+ +

Voir aussi

+ + diff --git a/files/fr/web/javascript/reference/global_objects/reflect/get/index.html b/files/fr/web/javascript/reference/global_objects/reflect/get/index.html new file mode 100644 index 0000000000..8538b87538 --- /dev/null +++ b/files/fr/web/javascript/reference/global_objects/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 +--- +
{{JSRef}}
+ +

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

+ +
{{EmbedInteractiveExample("pages/js/reflect-get.html")}}
+ + + +

Syntaxe

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

Paramètres

+ +
+
cible
+
L'objet cible dont on souhaite obtenir la propriété.
+
cléPropriété
+
Le nom de la propriété qu'on souhaite obtenir.
+
récepteur {{optional_inline}}
+
La valeur de this à passer à cible si l'accesseur est utilisé. Lorsqu'on l'utilise avec {{jsxref("Proxy")}}, ce peut être un objet qui hérite de la cible.
+
+ +

Valeur de retour

+ +

La valeur de la propriété.

+ +

Exceptions

+ +

Une erreur {{jsxref("TypeError")}} si cible n'est pas un {{jsxref("Object")}}.

+ +

Description

+ +

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

+ +

Exemples

+ +
// Object
+var obj = { x: 1, y: 2 };
+Reflect.get(obj, "x"); // 1
+
+// Array
+Reflect.get(["zero", "un"], 1); // "un"
+
+// Proxy qui intercepte get
+var x = {p: 1};
+var obj = new Proxy(x, {
+  get(t, k, r) { return k + "truc"; }
+});
+Reflect.get(obj, "toto"); // "tototruc"
+
+ +

Spécifications

+ + + + + + + + + + + + + + + + + + + +
SpécificationÉtatCommentaires
{{SpecName('ES2015', '#sec-reflect.get', 'Reflect.get')}}{{Spec2('ES2015')}}Définition initiale
{{SpecName('ESDraft', '#sec-reflect.get', 'Reflect.get')}}{{Spec2('ESDraft')}} 
+ +

Compatibilité des navigateurs

+ + + +

{{Compat("javascript.builtins.Reflect.get")}}

+ +

Voir aussi

+ + diff --git a/files/fr/web/javascript/reference/global_objects/reflect/getownpropertydescriptor/index.html b/files/fr/web/javascript/reference/global_objects/reflect/getownpropertydescriptor/index.html new file mode 100644 index 0000000000..77db7ad5e1 --- /dev/null +++ b/files/fr/web/javascript/reference/global_objects/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 +--- +
{{JSRef}}
+ +

La méthode statique Reflect.getOwnPropertyDescriptor() 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")}}.

+ +
{{EmbedInteractiveExample("pages/js/reflect-getownpropertydescriptor.html")}}
+ + + +

Syntaxe

+ +
Reflect.getOwnPropertyDescriptor(cible, cléPropriété)
+
+ +

Paramètres

+ +
+
cible
+
L'objet cible sur lequel on cherche la propriété.
+
cléPropriété
+
Le nom de la propriété dont on veut obtenir le descripteur.
+
+ +

Valeur de retour

+ +

Un objet qui est un descripteur de propriété si elle existe sur l'objet cible ou {{jsxref("undefined")}} dans le cas contraire.

+ +

Exceptions

+ +

Une erreur {{jsxref("TypeError")}} si cible n'est pas un {{jsxref("Object")}}.

+ +

Description

+ +

La méthode Reflect.getOwnPropertyDescriptor renvoie un descripteur pour la propriété demandée si celle-ci existe sur l'objet, sinon, elle renvoie {{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.

+ +

Exemples

+ +

Utiliser Reflect.getOwnPropertyDescriptor()

+ +
Reflect.getOwnPropertyDescriptor({x: "coucou"}, "x");
+// {value: "coucou", writable: true, enumerable: true, configurable: true}
+
+Reflect.getOwnPropertyDescriptor({x: "coucou"}, "y");
+// undefined
+
+Reflect.getOwnPropertyDescriptor([], "length");
+// {value: 0, writable: true, enumerable: false, configurable: false}
+
+ +

Différence avec Object.getOwnPropertyDescriptor()

+ +

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

+ +
Reflect.getOwnPropertyDescriptor("toto", 0);
+// TypeError: "toto" is not non-null object
+
+Object.getOwnPropertyDescriptor("toto", 0);
+// { value: "toto", writable: false, enumerable: true, configurable: false }
+ +

Spécifications

+ + + + + + + + + + + + + + + + + + + +
SpécificationÉtatCommentaires
{{SpecName('ES2015', '#sec-reflect.getownpropertydescriptor', 'Reflect.getOwnPropertyDescriptor')}}{{Spec2('ES2015')}}Définition initiale.
{{SpecName('ESDraft', '#sec-reflect.getownpropertydescriptor', 'Reflect.getOwnPropertyDescriptor')}}{{Spec2('ESDraft')}} 
+ +

Compatibilité des navigateurs

+ + + +

{{Compat("javascript.builtins.Reflect.getOwnPropertyDescriptor")}}

+ +

Voir aussi

+ + diff --git a/files/fr/web/javascript/reference/global_objects/reflect/getprototypeof/index.html b/files/fr/web/javascript/reference/global_objects/reflect/getprototypeof/index.html new file mode 100644 index 0000000000..c59fff975a --- /dev/null +++ b/files/fr/web/javascript/reference/global_objects/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 +--- +
{{JSRef}}
+ +

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

+ +
{{EmbedInteractiveExample("pages/js/reflect-getprototypeof.html")}}
+ + + +

Syntaxe

+ +
Reflect.getPrototypeOf(cible)
+
+ +

Paramètres

+ +
+
cible
+
L'objet cible dont on souhaite obtenir le prototype.
+
+ +

Valeur de retour

+ +

Le prototype de l'objet ou {{jsxref("null")}} s'il n'y a aucune propriété héritée.

+ +

Exceptions levées

+ +

Une erreur {{jsxref("TypeError")}} si cible n'est pas un {{jsxref("Object")}}.

+ +

Description

+ +

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

+ +

Exemples

+ +

Utiliser Reflect.getPrototypeOf()

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

Comparaison avec Object.getPrototypeOf()

+ +
// Résultat identiques pour les objets
+Object.getPrototypeOf({});  // Object.prototype
+Reflect.getPrototypeOf({}); // Object.prototype
+
+// Exception levée avec ES5 pour les valeurs qui ne sont pas des objets
+Object.getPrototypeOf('toto');  // Throws TypeError
+Reflect.getPrototypeOf('toto'); // Throws TypeError
+
+// Avec ES2015 (ES6), seul Reflect lève une exception
+// Object convertit automatiquement les valeurs en objets
+Object.getPrototypeOf('toto');  // String.prototype
+Reflect.getPrototypeOf('toto'); // Throws TypeError
+
+// Pour obtenir le même effet qu'avec Object en ES2015, il
+// faut ajouter une opération de conversion explicite
+Reflect.getPrototypeOf(Object('toto')); // String.prototype
+
+ +

Spécifications

+ + + + + + + + + + + + + + + + + + + +
SpécificationÉtatCommentaires
{{SpecName('ES2015', '#sec-reflect.getprototypeof', 'Reflect.getPrototypeOf')}}{{Spec2('ES2015')}}Définition initiale.
{{SpecName('ESDraft', '#sec-reflect.getprototypeof', 'Reflect.getPrototypeOf')}}{{Spec2('ESDraft')}} 
+ +

Compatibilité des navigateurs

+ + + +

{{Compat("javascript.builtins.Reflect.getPrototypeOf")}}

+ +

Voir aussi

+ + diff --git a/files/fr/web/javascript/reference/global_objects/reflect/has/index.html b/files/fr/web/javascript/reference/global_objects/reflect/has/index.html new file mode 100644 index 0000000000..66b230f065 --- /dev/null +++ b/files/fr/web/javascript/reference/global_objects/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 +--- +
{{JSRef}}
+ +

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

+ +
{{EmbedInteractiveExample("pages/js/reflect-has.html")}}
+ + + +

Syntaxe

+ +
Reflect.has(cible, cléPropriété)
+
+ +

Paramètres

+ +
+
cible
+
L'objet cible dont on souhaite savoir s'il contient la propriété donnée.
+
cléPropriété
+
Le nom de la propriété dont on souhaite vérifier la présence.
+
+ +

Valeur de retour

+ +

Un {{jsxref("Boolean","booléen","",1)}} qui indique si la propriété recherchée est présente sur l'objet cible.

+ +

Exceptions

+ +

Une erreur {{jsxref("TypeError")}} si cible n'est pas un {{jsxref("Object")}}.

+ +

Description

+ +

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

+ +

Exemples

+ +
Reflect.has({x: 0}, "x"); // true
+Reflect.has({x: 0}, "y"); // false
+
+// renvoie true pour les propriétés présentes
+// grâce à la chaîne de prototypes
+Reflect.has({x: 0}, "toString");
+
+// Proxy avec la méthode .has()
+obj = new Proxy({}, {
+  has(t, k) { return k.startsWith("bou"); }
+});
+Reflect.has(obj, "bouchon"); // true
+Reflect.has(obj, "bonbon");  // false
+
+ +

Spécifications

+ + + + + + + + + + + + + + + + + + + +
SpécificationÉtatCommentaires
{{SpecName('ES2015', '#sec-reflect.has', 'Reflect.has')}}{{Spec2('ES2015')}}Définition initiale.
{{SpecName('ESDraft', '#sec-reflect.has', 'Reflect.has')}}{{Spec2('ESDraft')}} 
+ +

Compatibilité des navigateurs

+ + + +

{{Compat("javascript.builtins.Reflect.has")}}

+ +

Voir aussi

+ + diff --git a/files/fr/web/javascript/reference/global_objects/reflect/index.html b/files/fr/web/javascript/reference/global_objects/reflect/index.html new file mode 100644 index 0000000000..8a1383c7b5 --- /dev/null +++ b/files/fr/web/javascript/reference/global_objects/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 +--- +
{{JSRef}}
+ +

Reflect 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 gestionnaires de proxy. Reflect n'est pas une fonction (y compris pour construire un objet).

+ +

Description

+ +

Contrairement à la plupart des objets globaux, Reflect 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 Reflect sont statiques (comme pour celles de l'objet {{jsxref("Math")}}).

+ +

Méthodes

+ +

L'objet Reflect fournit des fonctions statiques qui ont les mêmes noms que les méthodes des gestionnaires de proxy et dont certaines correspondent, avec quelques différences, à celles d'{{jsxref("Object")}} :

+ +
+
{{jsxref("Reflect.apply()")}}
+
Appelle une fonction cible avec les arguments définis par le paramètres args. Voir aussi {{jsxref("Function.prototype.apply()")}}.
+
{{jsxref("Reflect.construct()")}}
+
 L'opérateur {{jsxref("Opérateurs/L_opérateur_new","new")}} comme fonction. C'est équivalent à new cible(...args). Cette méthode permet également d'indiquer un prototype différent.
+
{{jsxref("Reflect.defineProperty()")}}
+
Semblable à {{jsxref("Object.defineProperty()")}}. Renvoie un {{jsxref("Boolean")}}.
+
{{jsxref("Reflect.deleteProperty()")}}
+
L'opérateur {{jsxref("Opérateurs/L_opérateur_delete","delete")}} comme fonction. C'est équivalent à delete cible[nom].
+
{{jsxref("Reflect.get()")}}
+
Une fonction qui renvoie la valeur d'une propriété.
+
{{jsxref("Reflect.getOwnPropertyDescriptor()")}}
+
Semblable à {{jsxref("Object.getOwnPropertyDescriptor()")}}. Renvoie un descripteur de propriété si la propriété existe sur l'objet, {{jsxref("undefined")}} sinon.
+
{{jsxref("Reflect.getPrototypeOf()")}}
+
Identique à {{jsxref("Object.getPrototypeOf()")}}.
+
{{jsxref("Reflect.has()")}}
+
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).
+
{{jsxref("Reflect.isExtensible()")}}
+
La même fonction que {{jsxref("Object.isExtensible()")}}.
+
{{jsxref("Reflect.ownKeys()")}}
+
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.
+
{{jsxref("Reflect.preventExtensions()")}}
+
Semblable à {{jsxref("Object.preventExtensions()")}}. Renvoie un {{jsxref("Boolean")}}.
+
{{jsxref("Reflect.set()")}}
+
Une fonction qui affecte des valeurs à des propriétés. Renvoie un {{jsxref("Boolean")}} qui vaut true si la mise à jour a bien été effectuée.
+
{{jsxref("Reflect.setPrototypeOf()")}}
+
Une fonction qui permet de définir le prototype d'un objet.
+
+ +

Spécifications

+ + + + + + + + + + + + + + + + + + + +
SpécificationÉtatCommentaires
{{SpecName('ES2015', '#sec-reflect-object', 'Reflect')}}{{Spec2('ES2015')}}Définition initiale.
{{SpecName('ESDraft', '#sec-reflect-object', 'Reflect')}}{{Spec2('ESDraft')}}Retrait de Reflect.enumerate
+ +

Compatibilité des navigateurs

+ + + +

{{Compat("javascript.builtins.Reflect")}}

+ +

Voir aussi

+ + diff --git a/files/fr/web/javascript/reference/global_objects/reflect/isextensible/index.html b/files/fr/web/javascript/reference/global_objects/reflect/isextensible/index.html new file mode 100644 index 0000000000..bdb266575c --- /dev/null +++ b/files/fr/web/javascript/reference/global_objects/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 +--- +
{{JSRef}}
+ +

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

+ +
{{EmbedInteractiveExample("pages/js/reflect-isextensible.html", "taller")}}
+ + + +

Syntaxe

+ +
Reflect.isExtensible(cible)
+
+ +

Paramètres

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

Valeur de retour

+ +

Un {{jsxref("Boolean","booléen", "",1)}} qui indique si la cible est extensible ou non.

+ +

Exceptions

+ +

Une erreur {{jsxref("TypeError")}} si cible n'est pas un {{jsxref("Object")}}.

+ +

Description

+ +

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

+ +

Exemples

+ +

Utiliser Reflect.isExtensible()

+ +

Voir aussi {{jsxref("Object.isExtensible()")}}.

+ +
// Les nouveaux objets sont extensibles.
+var vide = {};
+Reflect.isExtensible(vide); // true
+
+// ...mais ça peut être changé.
+Reflect.preventExtensions(vide);
+Reflect.isExtensible(vide); // false
+
+// Par définition, les objets scellés
+// ne sont pas extensibles.
+var scellé = Object.seal({});
+Reflect.isExtensible(scellé); // false
+
+// Par définition, les objets gelés sont
+// également non-extensibles.
+var gelé = Object.freeze({});
+Reflect.isExtensible(gelé); // false
+
+ +

Différence avec Object.isExtensible()

+ +

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

+ +
Reflect.isExtensible(1);
+// TypeError: 1 is not an object
+
+Object.isExtensible(1);
+// false
+
+ +

Spécifications

+ + + + + + + + + + + + + + + + + + + +
SpécificationÉtatCommentaires
{{SpecName('ES2015', '#sec-reflect.isextensible', 'Reflect.isExtensible')}}{{Spec2('ES2015')}}Définition initiale.
{{SpecName('ESDraft', '#sec-reflect.isextensible', 'Reflect.isExtensible')}}{{Spec2('ESDraft')}} 
+ +

Compatibilité des navigateurs

+ + + +

{{Compat("javascript.builtins.Reflect.isExtensible")}}

+ +

Voir aussi

+ + diff --git a/files/fr/web/javascript/reference/global_objects/reflect/ownkeys/index.html b/files/fr/web/javascript/reference/global_objects/reflect/ownkeys/index.html new file mode 100644 index 0000000000..9372830b80 --- /dev/null +++ b/files/fr/web/javascript/reference/global_objects/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 +--- +

{{JSRef}}

+ +

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

+ +
{{EmbedInteractiveExample("pages/js/reflect-ownkeys.html")}}
+ + + +

Syntaxe

+ +
Reflect.ownKeys(cible)
+
+ +

Paramètres

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

Valeur de retour

+ +

Un objet {{jsxref("Array")}} qui contient les clés des propriétés propres de cible.

+ +

Exceptions

+ +

Une erreur {{jsxref("TypeError")}} si cible n'est pas un {{jsxref("Object")}}.

+ +

Description

+ +

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

+ +

Exemples

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

Spécifications

+ + + + + + + + + + + + + + + + + + + +
SpécificationÉtatCommentaires
{{SpecName('ES2015', '#sec-reflect.ownkeys', 'Reflect.ownKeys')}}{{Spec2('ES2015')}}Définition initiale.
{{SpecName('ESDraft', '#sec-reflect.ownkeys', 'Reflect.ownKeys')}}{{Spec2('ESDraft')}} 
+ +

Compatibilité des navigateurs

+ + + +

{{Compat("javascript.builtins.Reflect.ownKeys")}}

+ +

Voir aussi

+ + diff --git a/files/fr/web/javascript/reference/global_objects/reflect/preventextensions/index.html b/files/fr/web/javascript/reference/global_objects/reflect/preventextensions/index.html new file mode 100644 index 0000000000..c7f202f685 --- /dev/null +++ b/files/fr/web/javascript/reference/global_objects/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 +--- +
{{JSRef}}
+ +

La méthode statique Reflect.preventExtensions() 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 quelques différences).

+ +
{{EmbedInteractiveExample("pages/js/reflect-preventextensions.html")}}
+ + + +

Syntaxe

+ +
Reflect.preventExtensions(cible)
+
+ +

Paramètres

+ +
+
cible
+
L'objet cible dont on veut empêcher l'ajout d'autres propriétés.
+
+ +

Valeur de retour

+ +

Un {{jsxref("Boolean","booléen","",1)}} qui indique si l'interdiction a bien été mise en place sur l'objet cible.

+ +

Exceptions

+ +

Une erreur {{jsxref("TypeError")}} si cible n'est pas un {{jsxref("Object")}}.

+ +

Description

+ +

La méthode Reflect.preventExtensions permet d'empêcher l'ajout de nouvelles propriétés sur un objet. Cette méthode est semblable à {{jsxref("Object.preventExtensions()")}}.

+ +

Exemples

+ +

Utiliser Reflect.preventExtensions()

+ +

Voir aussi {{jsxref("Object.preventExtensions()")}}.

+ +
// 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
+
+ +

Différences avec Object.preventExtensions()

+ +

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.

+ +
Reflect.preventExtensions(1);
+// TypeError: 1 is not an object
+
+Object.preventExtensions(1);
+// 1
+
+ +

Spécifications

+ + + + + + + + + + + + + + + + + + + +
SpécificationÉtatCommentaires
{{SpecName('ES2015', '#sec-reflect.preventextensions', 'Reflect.preventExtensions')}}{{Spec2('ES2015')}}Définition initiale.
{{SpecName('ESDraft', '#sec-reflect.preventextensions', 'Reflect.preventExtensions')}}{{Spec2('ESDraft')}}
+ +

Compatibilité des navigateurs

+ + + +

{{Compat("javascript.builtins.Reflect.preventExtensions")}}

+ +

Voir aussi

+ + diff --git a/files/fr/web/javascript/reference/global_objects/reflect/set/index.html b/files/fr/web/javascript/reference/global_objects/reflect/set/index.html new file mode 100644 index 0000000000..8d37acc413 --- /dev/null +++ b/files/fr/web/javascript/reference/global_objects/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 +--- +
{{JSRef}}
+ +

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

+ +
{{EmbedInteractiveExample("pages/js/reflect-set.html")}}
+ + + +

Syntaxe

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

Paramètres

+ +
+
cible
+
L'objet cible sur lequel on veut définir ou modifier la propriété.
+
cléPropriété
+
Le nom de la propriété à définir ou à modifier.
+
valeur
+
La valeur pour la propriété.
+
récepteur{{optional_inline}}
+
La valeur de this pour l'appel à cible si un mutateur (setter) est utilisé.
+
+ +

Valeur de retour

+ +

Un {{jsxref("Boolean","booléen","",1)}} qui indique si la définition/modification de la propriété a réussi.

+ +

Exceptions

+ +

Une erreur {{jsxref("TypeError")}} si cible n'est pas un {{jsxref("Object")}}.

+ +

Description

+ +

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

+ +

Exemples

+ +

Utiliser Reflect.set()

+ +
// Object
+var obj = {};
+Reflect.set(obj, "prop", "value"); // true
+obj.prop; // "value"
+
+// Array
+var arr = ["canard", "canard", "canard"];
+Reflect.set(arr, 2, "oie"); // true
+arr[2]; // "oie"
+
+// On peut l'utiliser pour tronquer un tableau
+Reflect.set(arr, "length", 1); // true
+arr; // ["canard"];
+
+// Avec un seul argument
+// cléPropriété et valeur valent "undefined".
+var obj = {};
+Reflect.set(obj); // true
+Reflect.getOwnPropertyDescriptor(obj, "undefined");
+// { value: undefined, writable: true, enumerable: true, configurable: true }
+
+ +

Spécifications

+ + + + + + + + + + + + + + + + + + + +
SpécificationÉtatCommentaires
{{SpecName('ES2015', '#sec-reflect.set', 'Reflect.set')}}{{Spec2('ES2015')}}Définition initiale.
{{SpecName('ESDraft', '#sec-reflect.set', 'Reflect.set')}}{{Spec2('ESDraft')}} 
+ +

Compatibilité des navigateurs

+ + + +

{{Compat("javascript.builtins.Reflect.set")}}

+ +

Voir aussi

+ + diff --git a/files/fr/web/javascript/reference/global_objects/reflect/setprototypeof/index.html b/files/fr/web/javascript/reference/global_objects/reflect/setprototypeof/index.html new file mode 100644 index 0000000000..8d267952c0 --- /dev/null +++ b/files/fr/web/javascript/reference/global_objects/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 +--- +
{{JSRef}}
+ +

la méthode statique Reflect.setPrototypeOf() 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 [[Prototype]]) d'un objet donné avec un autre objet ou {{jsxref("null")}}. Cette méthode renvoie true si l'opération a réussi et false sinon.

+ +
{{EmbedInteractiveExample("pages/js/reflect-setprototypeof.html")}}
+ + + +

Syntaxe

+ +
Reflect.setPrototypeOf(cible, prototype)
+
+ +

Paramètres

+ +
+
cible
+
L'objet cible dont on souhaite modifier le prototype.
+
prototype
+
Le nouveau prototype à appliquer à l'objet cible (ça peut être un objet ou {{jsxref("null")}}).
+
+ +

Valeur de retour

+ +

Un {{jsxref("Boolean","booléen","",1)}} qui indique si le prototype a correctement été modifié.

+ +

Exceptions

+ +

Une erreur {{jsxref("TypeError")}} si cible n'est pas un {{jsxref("Object")}} ou si prototype n'est ni un objet ni {{jsxref("null")}}.

+ +

Description

+ +

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

+ +

Exemples

+ +

Utiliser Reflect.setPrototypeOf()

+ +
Reflect.setPrototypeOf({}, Object.prototype); // true
+
+// On peut modifier le [[Prototype]] d'un objet
+// pour que celui-ci soit null.
+Reflect.setPrototypeOf({}, null); // true
+
+// La méthode renvoie false si la cible
+// n'est pas extensible.
+Reflect.setPrototypeOf(Object.freeze({}), null); // false
+
+// La méthode renvoie false si l'affectation
+// entraîne un cycle dans la chaîne de prototypes.
+var target = {};
+var proto = Object.create(target);
+Reflect.setPrototypeOf(target, proto); // false
+
+ +

Spécifications

+ + + + + + + + + + + + + + + + + + + +
SpécificationÉtatCommentaires
{{SpecName('ES2015', '#sec-reflect.setprototypeof', 'Reflect.setPrototypeOf')}}{{Spec2('ES2015')}}Définition initiale.
{{SpecName('ESDraft', '#sec-reflect.setprototypeof', 'Reflect.setPrototypeOf')}}{{Spec2('ESDraft')}}
+ +

Compatibilité des navigateurs

+ + + +

{{Compat("javascript.builtins.Reflect.setPrototypeOf")}}

+ +

Voir aussi

+ + -- cgit v1.2.3-54-g00ecf