1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
|
---
title: Object
slug: Web/JavaScript/Reference/Global_Objects/Object
tags:
- Constructeur
- JavaScript
- Object
- Reference
translation_of: Web/JavaScript/Reference/Global_Objects/Object
original_slug: Web/JavaScript/Reference/Objets_globaux/Object
---
{{JSRef}}
Le constructeur **`Object`** crée un wrapper d'objet.
## Syntaxe
// Initialisateur d'objet ou littéral { [ paireNomValeur1[, paireNomValeur2[,
...paireNomValeurN] ] ] }
// Appelé comme un constructeur
new Object([valeur])
### Paramètres
- `paireNomValeur1, paireNomValeur2, ... paireNomValeurN`
- : Paires de noms (chaînes) et de valeurs (toutes valeurs) où le nom est séparé de la valeur par deux points (:).
- `valeur`
- : Toute valeur.
## Description
Le constructeur `Object` crée un wrapper d'objet pour la valeur donnée. Si la valeur est {{jsxref("null")}} ou {{jsxref("undefined")}}, il créera et retournera un objet vide, sinon, il retournera un objet du Type qui correspond à la valeur donnée. Si la valeur est déjà un objet, le constructeur retournera cette valeur.
Lorsqu'il n'est pas appelé dans un contexte constructeur, `Object` se comporte de façon identique à `new Object()`.
Voir aussi [initialisateur d'objet / syntaxe de littéral](https://developer.mozilla.org/fr/docs/Web/JavaScript/Reference/Op%C3%A9rateurs/Initialisateur_objet).
## Propriétés du constructeur `Object`
- `Object.length`
- : A une valeur de 1.
- {{jsxref("Object.prototype")}}
- : Permet l'ajout de propriétés à tous les objets de type Object.
## Méthodes du constructeur `Object`
- {{jsxref("Object.assign()")}}
- : Copie les valeurs de toutes propriétés propres énumérables depuis un ou plusieurs objets source dans un objet cible.
- {{jsxref("Object.create()")}}
- : Crée un nouvel objet avec le prototype d'objet et les propriétés indiqués.
- {{jsxref("Object.defineProperty()")}}
- : Ajoute à un objet la propriété nommée décrite par le descripteur donné.
- {{jsxref("Object.defineProperties()")}}
- : Ajoute à un objet les propriétés nommées décrites par les descripteurs donnés.
- {{jsxref("Object.entries()")}}
- : Retourne un tableau contenant les paires `[clé, valeur]` des propriétés énumérables propres (c'est-à-dire directement rattachées à l'objet) de l'objet donné et dont les clés sont des chaînes de caractères.
- {{jsxref("Object.freeze()")}}
- : Gèle un objet : un autre code ne peut ni détruire ni changer aucune propriété.
- {{jsxref("Object.fromEntries()")}}
- : Renvoie un nouvel objet à partir d'un itérable contenant des paires de clés-valeurs (l'opération duale de {{jsxref("Object.entries")}}).
- {{jsxref("Object.getOwnPropertyDescriptor()")}}
- : Retourne un descripteur de propriété pour une propriété nommée d'un objet.
- {{jsxref("Object.getOwnPropertyDescriptors()")}}
- : Retourne un objet contenant tous les descripteurs des propriétés propres d'un objet.
- {{jsxref("Object.getOwnPropertyNames()")}}
- : Retourne un tableau contenant les noms de toutes les propriétés énumérables et non énumérables **propres** de l'objet donné.
- {{jsxref("Object.getOwnPropertySymbols()")}}
- : Retourne un tableau de toutes les propriétés symboles trouvées directement dans un objet donné.
- {{jsxref("Object.getPrototypeOf()")}}
- : Retourne le prototype de l'objet indiqué.
- {{jsxref("Object.is()")}}
- : Détermine si deux valeurs sont la même valeur. Considère comme égales toutes les valeurs NaN (ce qui diffère à la fois de la Comparaison d'Égalité Abstraite et de la Comparaison d'Égalité Stricte).
- {{jsxref("Object.isExtensible()")}}
- : Détermine si l'extension d'un objet est permise.
- {{jsxref("Object.isFrozen()")}}
- : Détermine si un objet a été gelé.
- {{jsxref("Object.isSealed()")}}
- : Détermine si un objet est scellé.
- {{jsxref("Object.keys()")}}
- : Retourne un tableau contenant les noms de toutes les propriétés énumérables **propres** de l'objet donné.
- {{jsxref("Object.preventExtensions()")}}
- : Empêche toute extension de l'objet.
- {{jsxref("Object.seal()")}}
- : Empêche un autre code de détruire les propriétés d'un objet.
- {{jsxref("Object.setPrototypeOf()")}}
- : Définit le prototype d'un objet (c-à-d, la propriété interne `[[Prototype]]`).
- {{jsxref("Object.values()")}}
- : Retourne le tableau des valeurs énumérables propres de l'objet donné dont les clés sont des chaînes de caractères.
## Instances d'`Object` et objet de prototype `Object`
Tous les objets en JavaScript descendent d'`Object` ; tous les objets héritent des méthodes et des propriétés de {{jsxref("Object.prototype")}}, même si elles peuvent être surchargées. Par exemple, d'autres prototypes de constructeurs surchargent la propriété du `constructor` et fournissent leurs propres méthodes `toString()`. Les changements apportés à l'objet de prototype `Object` sont propagées à tous les objets, à moins que les propriétés et méthodes auxquelles s'appliquent ces changements ne soient surchargées plus loin dans la chaîne de prototypes.
### Propriétés
{{page('/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/prototype', 'Properties') }}
### Méthodes
{{page('/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/prototype', 'Methods') }}
## Suppression d'une propriété dans un objet
Il n'y a aucune méthode dans un Object lui-même pour supprimer ses propres propriétés (par exemple, comme [Map.prototype.delete()](/fr-Fr/docs/Web/JavaScript/Reference/Global_Objects/Map/delete)). Pour ce faire, il faut utiliser l'[opérateur delete](/fr-Fr/docs/Web/JavaScript/Reference/Operators/delete).
## Exemples
### Utilisation d'`Object` avec les types `undefined` et `null`
Les exemples suivants stockent un `Object` vide dans `o` :
```js
var o = new Object();
```
```js
var o = new Object(undefined);
```
```js
var o = new Object(null);
```
### Utilisation d'`Object` pour créer des objets `Boolean`
Les exemples suivants stockent des objets {{jsxref("Boolean")}} dans `o` :
```js
// Équivalent à : o = new Boolean(true);
var o = new Object(true);
```
```js
// Équivalent à : o = new Boolean(false);
var o = new Object(Boolean());
```
## Spécifications
| Spécification | Statut | Commentaire |
| ---------------------------------------------------------------------------- | ---------------------------- | -------------------------------------------------------------------------------------- |
| {{SpecName('ES1')}} | {{Spec2('ES1')}} | Définition initiale. Implémentée par JavaScript 1.0. |
| {{SpecName('ES5.1', '#sec-15.2', 'Object')}} | {{Spec2('ES5.1')}} | |
| {{SpecName('ES6', '#sec-object-objects', 'Object')}} | {{Spec2('ES6')}} | Ajout de Object.assign, Object.getOwnPropertySymbols, Object.setPrototypeOf, Object.is |
| {{SpecName('ESDraft', '#sec-object-objects', 'Object')}} | {{Spec2('ESDraft')}} | Ajout de Object.entries, de Object.values et de Object.getOwnPropertyDescriptors. |
## Compatibilité des navigateurs
{{Compat("javascript.builtins.Object")}}
## Voir aussi
- [Initialisateur d'objet](/fr/docs/Web/JavaScript/Reference/Op%C3%A9rateurs/Initialisateur_objet)
|
