You signed in with another tab or window. Reload to refresh your session.You signed out in another tab or window. Reload to refresh your session.You switched accounts on another tab or window. Reload to refresh your session.Dismiss alert
Comme nous le savons, les objets peuvent stocker des propriétés.
5
5
6
-
Till now, a property was a simple "key-value" pair to us. But an object property is actually a more flexible and powerful thing.
6
+
Jusqu'à présent, une propriété était pour nous une simple paire "clé-valeur". Mais une propriété d'objet est en réalité une chose plus flexible et plus puissante.
7
7
8
-
In this chapter we'll study additional configuration options, and in the next we'll see how to invisibly turn them into getter/setter functions.
8
+
Dans ce chapitre, nous étudierons des options de configuration supplémentaires et, dans le prochain, nous verrons comment les transformer de manière invisible en fonctions de accesseur / mutateur.
9
9
10
-
## Property flags
10
+
## Attributs de propriétés
11
11
12
-
Object properties, besides a**`value`**, have three special attributes (so-called "flags"):
12
+
Les propriétés des objets, outre que**`valeur`**, ont trois attributs spéciaux (appelés drapeaux, ou "flags" en anglais):
13
13
14
-
-**`writable`** -- if`true`, can be changed, otherwise it's read-only.
15
-
-**`enumerable`** -- if`true`, then listed in loops, otherwise not listed.
16
-
-**`configurable`** -- if`true`, the property can be deleted and these attributes can be modified, otherwise not.
14
+
-**`writable`** -- si`true`, peut être modifié, sinon c'est lecture seule.
15
+
-**`enumerable`** -- si`true`, alors listé dans les boucles, sinon non listé.
16
+
-**`configurable`** -- si`true`, la propriété peut être supprimée et ces attributs peuvent être modifiés, sinon non.
17
17
18
-
We didn't see them yet, because generally they do not show up. When we create a property "the usual way", all of them are `true`. But we also can change them anytime.
18
+
Nous ne les avons pas encore vues, car généralement elles ne se présentent pas. Lorsque nous créons une propriété "de la manière habituelle", ils sont tous `true`. Mais nous pouvons aussi les changer à tout moment.
19
19
20
-
First, let's see how to get those flags.
20
+
Voyons d’abord comment obtenir ces "flags".
21
21
22
-
The method[Object.getOwnPropertyDescriptor](mdn:js/Object/getOwnPropertyDescriptor)allows to query the *full* information about a property.
22
+
La methode[Object.getOwnPropertyDescriptor](https://developer.mozilla.org/fr/docs/Web/JavaScript/Reference/Objets_globaux/Object/getOwnPropertyDescriptor)permet d'interroger les informations *complètes* sur une propriété.
23
23
24
-
The syntax is:
24
+
La syntaxe est la suivante:
25
25
```js
26
26
let descriptor =Object.getOwnPropertyDescriptor(obj, propertyName);
27
27
```
28
28
29
29
`obj`
30
-
: The object to get information from.
30
+
: L'objet à partir duquel obtenir des informations.
31
31
32
32
`propertyName`
33
-
: The name of the property.
33
+
: Le nom de la propriété.
34
34
35
-
The returned value is a so-called "property descriptor" object: it contains the value and all the flags.
35
+
La valeur renvoyée est un objet dit "descripteur de propriété": il contient la valeur et tous les descripteurs.
To change the flags, we can use[Object.defineProperty](mdn:js/Object/defineProperty).
57
+
Pour changer les attributs, on peut utiliser[Object.defineProperty](https://developer.mozilla.org/fr/docs/Web/JavaScript/Reference/Objets_globaux/Object/defineProperty).
: The object and its property to apply the descriptor.
66
+
: L'objet et sa propriété pour appliquer le descripteur.
67
67
68
68
`descriptor`
69
-
: Property descriptor to apply.
69
+
: Descripteur de propriété à appliquer.
70
70
71
-
If the property exists, `defineProperty`updates its flags. Otherwise, it creates the property with the given value and flags; in that case, if a flag is not supplied, it is assumed`false`.
71
+
Si la propriété existe, `defineProperty`met à jour ses attributs. Sinon, il crée la propriété avec la valeur et les descripteurs donnés. Dans ce cas, si aucun drapeau n'est fourni, il est supposé`false`.
72
72
73
-
For instance, here a property`name`is created with all falsy flags:
73
+
Par exemple, ici, une propriété`name`est créée avec tous les attributs falsy:
Compare it with "normally created" `user.name`above: now all flags are falsy. If that's not what we want then we'd better set them to `true`in`descriptor`.
99
+
Comparez-le avec `user.name`"normalement créé" ci-dessus: maintenant tous les attributs sont falsy. Si ce n'est pas ce que nous voulons, nous ferions mieux de leur attribuer la valeur `true`dans`descriptor`.
100
100
101
-
Now let's see effects of the flags by example.
101
+
Voyons maintenant les effets des attributs par exemple.
102
102
103
-
## Read-only
103
+
## Lecture seule
104
104
105
-
Let's make `user.name`read-only by changing `writable` flag:
105
+
Rendons `user.name`en lecture seule en modifiant le desripteur `writeable`:
106
106
107
107
```js run
108
108
let user = {
@@ -120,21 +120,21 @@ user.name = "Pete"; // Error: Cannot assign to read only property 'name'
120
120
*/!*
121
121
```
122
122
123
-
Now no one can change the name of our user, unless they apply their own `defineProperty`to override ours.
123
+
Maintenant, personne ne peut changer le nom de notre utilisateur, à moins qu’ils appliquent leur propre `defineProperty`pour remplacer le nôtre.
124
124
125
-
```smart header="Errors appear only in strict mode"
126
-
In the non-strict mode, no errors occur when writing to read-only properties and such. But the operation still won't succeed. Flag-violating actions are just silently ignored in non-strict.
125
+
```smart header="Les erreurs apparaissent uniquement en mode strict"
126
+
En mode non strict, aucune erreur ne se produit lors de l'écriture dans les propriétés en lecture seule, etc. Mais l'opération ne réussira toujours pas. Les actions qui violent les dexcripteurs sont simplement ignorées en mode nonstrict.
127
127
```
128
128
129
-
Here's the same example, but the property is created from scratch:
129
+
Voici le même exemple, mais la propriété est créée à partir de zéro:
130
130
131
131
```js run
132
132
let user = { };
133
133
134
134
Object.defineProperty(user, "name", {
135
135
*!*
136
136
value:"John",
137
-
//for new properties need to explicitly list what's true
137
+
//besoin de lister explicitement ce qui est true pour les nouvelles propriétés
138
138
enumerable:true,
139
139
configurable:true
140
140
*/!*
@@ -144,11 +144,11 @@ alert(user.name); // John
144
144
user.name="Pete"; // Error
145
145
```
146
146
147
-
## Non-enumerable
147
+
## Non énumérable
148
148
149
-
Now let's add a custom `toString`to`user`.
149
+
Ajoutons maintenant un `toString`personnalisé à`user`.
150
150
151
-
Normally, a built-in `toString`for objects is non-enumerable, it does not show up in `for..in`. But if we add `toString` of our own, then by default it shows up in `for..in`, like this:
151
+
Normalement, un `toString`intégré pour les objets n'est pas énumérable, il n'apparaît pas dans `for..in`. Mais si nous ajoutons notre propre `toString`, alors, par défaut, il apparaît dans `for..in`, comme ceci:
152
152
153
153
```js run
154
154
let user = {
@@ -158,11 +158,11 @@ let user = {
158
158
}
159
159
};
160
160
161
-
//By default, both our properties are listed:
161
+
//Par défaut, nos deux propriétés sont répertoriées:
162
162
for (let key in user) alert(key); // name, toString
163
163
```
164
164
165
-
If we don't like it, then we can set`enumerable:false`. Then it won't appear in `for..in` loop, just like the built-in one:
165
+
Si nous n'aimons pas cela, alors nous pouvons définir`enumerable:false`. Ensuite, il n'apparaîtra pas dans la boucle `for..in`, comme dans la boucle intégrée:
So, a programmer is unable to change the value of`Math.PI`or overwrite it.
214
+
Ainsi, un programmeur est incapable de changer la valeur de`Math.PI`ou de le remplacer.
215
215
216
216
```js run
217
217
Math.PI=3; // Error
218
218
219
-
//delete Math.PI won't work either
219
+
//supprimer Math.PI ne fonctionnera pas non plus
220
220
```
221
221
222
-
Making a property non-configurable is a one-way road. We cannot change it back, because`defineProperty`doesn't work on non-configurable properties.
222
+
Rendre une propriété nonconfigurable est une route à sens unique. Nous ne pouvons pas le rétablir, car`defineProperty`ne fonctionne pas avec des propriétés non configurables.
223
223
224
-
Here we are making`user.name`a "forever sealed" constant:
224
+
Ici, nous faisons de`user.name`une constante "scellée pour toujours":
There's a method [Object.defineProperties(obj, descriptors)](mdn:js/Object/defineProperties)that allows to define many properties at once.
247
+
Il y a une méthode [Object.defineProperties(obj, descriptors)](https://developer.mozilla.org/fr/docs/Web/JavaScript/Reference/Objets_globaux/Object/defineProperties)qui permet de définir plusieurs propriétés à la fois.
Nous pouvons donc définir plusieurs propriétés à la fois.
270
270
271
271
## Object.getOwnPropertyDescriptors
272
272
273
-
To get all property descriptors at once, we can use the method[Object.getOwnPropertyDescriptors(obj)](mdn:js/Object/getOwnPropertyDescriptors).
273
+
Pour obtenir tous les descripteurs de propriété à la fois, nous pouvons utiliser la méthode[Object.getOwnPropertyDescriptors(obj)](https://developer.mozilla.org/fr/docs/Web/JavaScript/Reference/Objets_globaux/Object/getOwnPropertyDescriptors).
274
274
275
-
Together with `Object.defineProperties` it can be used as a "flags-aware" way of cloning an object:
275
+
Avec `Object.defineProperties`, elle peut être utilisé comme moyen de cloner un objet conscient des attributs:
276
276
277
277
```js
278
278
let clone =Object.defineProperties({}, Object.getOwnPropertyDescriptors(obj));
279
279
```
280
280
281
-
Normally when we clone an object, we use an assignment to copy properties, like this:
281
+
Normalement, lorsque nous clonons un objet, nous utilisons une affectation pour copier les propriétés, comme ceci:
282
282
283
283
```js
284
284
for (let key in user) {
285
285
clone[key] = user[key]
286
286
}
287
287
```
288
288
289
-
...But that does not copy flags. So if we want a "better" clone then`Object.defineProperties`is preferred.
289
+
...Mais cela ne copie pas les attributs. Donc, si nous voulons un "meilleur" clone, alors`Object.defineProperties`est préféré.
290
290
291
-
Another difference is that `for..in`ignores symbolic properties, but `Object.getOwnPropertyDescriptors`returns *all* property descriptors including symbolic ones.
291
+
Une autre différence est que `for..in`ignore les propriétés symboliques, mais que `Object.getOwnPropertyDescriptors`renvoie *tous* les descripteurs de propriété, y compris les descripteurs symboliques.
292
292
293
-
## Sealing an object globally
293
+
## Sceller un objet globalement
294
294
295
-
Property descriptors work at the level of individual properties.
295
+
Les descripteurs de propriété fonctionnent au niveau des propriétés individuelles.
296
296
297
-
There are also methods that limit access to the *whole* object:
297
+
Il existe également des méthodes qui limitent l'accès à l'objet *entier*:
: Retourne`true`si l'ajout/la suppression/la modification de propriétés est interdite et si toutes les propriétés actuelles sont`configurable: false, writable: false`.
317
317
318
-
These methods are rarely used in practice.
318
+
Ces méthodes sont rarement utilisées dans la pratique.
0 commit comments