Translate missing Object pages (#3172)

2 files changed, 219 insertions, 0 deletions

diff --git a/files/fr/web/javascript/reference/global_objects/object/hasown/index.md b/files/fr/web/javascript/reference/global_objects/object/hasown/index.md
new file mode 100644
index 0000000000..1bcbcc99bf
--- /dev/null
+++ b/files/fr/web/javascript/reference/global_objects/object/hasown/index.md
@@ -0,0 +1,152 @@
+---
+title: Object.hasOwn()
+slug: Web/JavaScript/Reference/Global_Objects/Object/hasOwn
+translation_of: Web/JavaScript/Reference/Global_Objects/Object/hasOwn
+browser-compat: javascript.builtins.Object.hasOwn
+---
+{{JSRef}}{{SeeCompatTable}}
+
+La méthode statique **`Object.hasOwn()`** renvoie `true` si l'objet indiqué possède la propriété indiquée comme propriété _propre_. Si la propriété est héritée ou qu'elle n'existe pas, la méthode renverra `false`.
+
+> **Note :** `Object.hasOwn()` est conçu comme une méthode de remplacement pour [`Object.hasOwnProperty()`](/fr/docs/Web/JavaScript/Reference/Global_Objects/Object/hasOwnProperty).
+
+{{EmbedInteractiveExample("pages/js/object-hasown.html")}}
+
+## Syntaxe
+
+```js
+Object.hasOwn(instance,prop)
+```
+
+### Paramètres
+
+- _instance_
+  - : L'objet JavaScript pour lequel on souhaite tester la présence d'une propriété.
+- _prop_
+  - : Une chaîne de caractères ([`String`](/fr/docs/Web/JavaScript/Reference/Global_Objects/String)) indiquant le nom de la propriété recherchée ou un symbole ([`Symbol`](/fr/docs/Web/JavaScript/Reference/Global_Objects/Symbol)) désignant la propriété.
+
+### Valeur de retour
+
+`true` si l'objet indiqué possède, directement, la propriété indiquée, `false` sinon.
+
+## Description
+
+La méthode **`Object.hasOwn()`** renvoie `true` si la propriété indiquée est une propriété directe de l'objet (et même si celle-ci vaut `null` ou `undefined`). La méthode renvoie `false` si la propriété est héritée ou si elle n'a pas été déclarée. À la différence de l'opérateur [`in`](/fr/docs/Web/JavaScript/Reference/Operators/in), cette méthode ne consulte pas la chaîne de prototypes de l'objet pour détecter la propriété.
+
+`Object.hasOwn()` pourra être recommandée en lieu et place de [`Object.hasOwnProperty()`](/fr/docs/Web/JavaScript/Reference/Global_Objects/Object/hasOwnProperty) car elle fonctionne sur les objets créés avec `Object.create(null)` et pour les objets qui ont surchargé la méthode héritée `hasOwnProperty()`. Bien qu'il soit possible de contourner ces deux problèmes en invoquant `Object.prototype.hasOwnProperty()` sur un objet externe, `Object.hasOwn()` semble plus intuitif.
+
+## Exemples
+
+### Utiliser Object.hasOwn() pour tester l'existence d'une propriété
+
+Le code suivant illustre comment déterminer si l'objet `exemple` contient une propriété intitulée `prop`.
+ 
+```js
+let exemple = {};
+Object.hasOwn(exemple, 'prop');   // false : 'prop' n'a pas été définie
+
+exemple.prop = 'existe';
+Object.hasOwn(exemple, 'prop');   // true : 'prop' a été définie
+
+exemple.prop = null;
+Object.hasOwn(exemple, 'prop');   // true : la propriété existe malgré sa valeur null
+
+exemple.prop = undefined;
+Object.hasOwn(exemple, 'prop');   // true : la propriété existe malgré sa valeur undefined
+```
+
+### Propriétés propres et propriétés héritées
+
+Dans l'exemple suivant, on distingue les propriétés propres/directes et celles qui sont héritées via la chaîne de prototypes :
+
+```js
+let exemple = {}
+exemple.prop = 'existe';
+
+// `Objet.hasOwn()` renverra true seulement pour les propriétés propres
+Object.hasOwn(exemple, 'prop');             // renvoie true
+Object.hasOwn(exemple, 'toString');         // renvoie false
+Object.hasOwn(exemple, 'hasOwnProperty');   // renvoie false
+
+// L'opérateur `in` renverra true pour les propriétés propres et héritées
+'prop' in exemple;                          // renvoie true
+'toString' in exemple;                      // renvoie true
+'hasOwnProperty' in exemple;                // renvoie true
+```
+
+### Parcourir les propriétés d'un objet=
+
+Pour parcourir les propriétés énumérables d'un objet, on privilégiera cette forme :
+
+```js
+let exemple = { toto: true, truc: true };
+for (let nom of Object.keys(exemple)) {
+  // …
+}
+```
+
+S'il est nécessaire d'utiliser `for..in`, on pourra utiliser `Object.hasOwn()` afin de filtrer les propriétés héritées :
+
+```js
+let exemple = { toto: true, truc: true };
+for (let nom in exemple) {
+  if (Object.hasOwn(exemple, nom)) {
+    // …
+  }
+}
+```
+
+### Vérifier l'existence d'un indice dans un tableau
+
+Les éléments d'un tableau ([`Array`](/fr/docs/Web/JavaScript/Reference/Global_Objects/Array)) sont définis comme propriétés propres. Ainsi, `Object.hasOwn()` pourra être utilisé pour vérifier si un indice donné existe :
+
+```js
+let fruits = ['Pomme', 'Banane', 'Melon', 'Orange'];
+Object.hasOwn(fruits, 3);   // true ('Orange')
+Object.hasOwn(fruits, 4);   // false, non défini
+```
+
+### Cas problématiques pour hasOwnProperty()
+
+Cette section illustre l'immunité de `Object.hasOwn()` concernant des problèmes qui se posent pour `Object.prototype.hasOwnProperty()`. Tout d'abord, on peut utiliser cette première avec des objets qui ont réimplémenté `hasOwnProperty()` :
+
+```js
+let toto = {
+  hasOwnProperty: function() {
+    return false;
+  },
+  truc: 'Ga bu zo meu'
+};
+
+if (Object.hasOwn(toto, 'truc')) {
+  console.log(toto.truc); //true - la surcharge de hasOwnProperty() n'a pas d'impact
+}
+```
+
+On peut également l'utiliser pour tester des objets créés avec [`Object.create(null)`](/fr/docs/Web/JavaScript/Reference/Global_Objects/Object/create) qui n'héritent pas de `Object.prototype` et pour qui `hasOwnProperty()` est donc inaccessible.
+
+```js
+let toto = Object.create(null);
+toto.prop = 'existe';
+if (Object.hasOwn(toto, 'prop')) {
+  console.log(toto.prop); // true.
+}
+```
+
+## Spécifications
+
+{{Specifications}}
+
+## Compatibilité des navigateurs
+
+{{Compat}}
+
+## Voir aussi
+
+- [Caractère énumérable et rattachement des propriétés](/fr/docs/Web/JavaScript/Enumerability_and_ownership_of_properties)
+- [Héritage et chaîne de prototypes dans le guide JavaScript](/fr/docs/Web/JavaScript/Inheritance_and_the_prototype_chain)
+- [`Object.hasOwnProperty()`](/fr/docs/Web/JavaScript/Reference/Global_Objects/Object/hasOwnProperty)
+- [`Object.getOwnPropertyNames()`](/fr/docs/Web/JavaScript/Reference/Global_Objects/Object/getOwnPropertyNames)
+- [`for...in`](/fr/docs/Web/JavaScript/Reference/Statements/for...in)
+- [`in`](/fr/docs/Web/JavaScript/Reference/Operators/in)
+- Une prothèse d'émulation pour `Object.hasOwn()` disponible avec [`core-js`](https://github.com/zloirock/core-js#ecmascript-object)
diff --git a/files/fr/web/javascript/reference/global_objects/object/object/index.md b/files/fr/web/javascript/reference/global_objects/object/object/index.md
new file mode 100644
index 0000000000..d92802d387
--- /dev/null
+++ b/files/fr/web/javascript/reference/global_objects/object/object/index.md
@@ -0,0 +1,67 @@
+---
+title: Constructeur Object()
+slug: Web/JavaScript/Reference/Global_Objects/Object/Object
+translation_of: Web/JavaScript/Reference/Global_Objects/Object/Object
+browser-compat: javascript.builtins.Object.Object
+---
+{{JSRef}}
+
+Le **constructeur `Object`** crée une enveloppe objet pour la valeur passée en argument.
+
+- Si la valeur est [`null`](/fr/docs/Web/JavaScript/Reference/Global_Objects/null) ou [`undefined`](/fr/docs/Web/JavaScript/Reference/Global_Objects/undefined), il crée et renvoie un nouvel objet vide.
+- Sinon, il renvoie un objet du type correspondant à la valeur passée en argument.
+- Si la valeur est déjà un objet, il renvoie la valeur.
+
+Lorsqu'il est appelé comme une fonction plutôt que comme un constructeur (c'est-à-dire sans être précédé de l'opérateur `new`), `Object` se comporte de façon identique à `new Object()`.
+
+## Syntaxe
+
+```js
+new Object()
+new Object(valeur)
+```
+
+### Paramètres
+
+- `valeur`
+  - : N'importe quelle valeur.
+
+## Exemples
+
+### Créer un nouvel objet
+
+```js
+let o = new Object();
+o.toto = 42;
+
+console.log(o);
+// Object { toto: 42 }
+```
+
+### Utiliser Object() avec undefined et null
+
+Dans l'exemple suivant, on crée un objet vide dans la variable `o` :
+
+```js
+let o = new Object();
+```
+
+```js
+let o = new Object(undefined);
+```
+
+```js
+let o = new Object(null);
+```
+
+## Spécifications
+
+{{Specifications}}
+
+## Compatibilité des navigateurs
+
+{{Compat}}
+
+## Voir aussi
+
+- [Initialisateur d'objet](/fr/docs/Web/JavaScript/Reference/Operators/Object_initializer)