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
Como sabemos, objetos podem armazenar propriedades.
5
5
6
-
Until now, a property was a simple "key-value" pair to us. But an object property is actually a more flexible and powerful thing.
6
+
Até agora, para nós, uma propriedade era um simples par "chave-valor". Mas uma propriedade de objeto é na verdade uma coisa mais flexível e poderosa.
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
+
Neste capítulo, nós vamos estudar opções de configuração adicional, e no próximo nós vamos ver como invisivelmente tornar elas em funções getter/setter.
9
9
10
-
## Property flags
10
+
## Sinalizadores de propriedade
11
11
12
-
Object properties, besides a**`value`**, have three special attributes (so-called "flags"):
12
+
Propriedades de objeto, além do**`valor`** tem três atributos especiais (também chamados "sinalizadores"):
13
13
14
-
-**`writable`** -- if`true`, the value 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
+
-**`gravável`** -- se`true`, o valor pode ser alterado, caso contrário, é apenas-leitura.
15
+
-**`enúmeravel`** -- se`true`, então pode ser listado em loops, caso contrário, não pode.
16
+
-**`configurável`** -- se`true`, a propriedade pode ser deletada e seus atributos modificados, caso contrário não.
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
+
Nós não vimos eles ainda, porque geralmente eles não aparecem. Quando criamos uma propriedade "do jeito comum", todos eles são `true`. Mas nós também podemos mudá-los a qualquer hora.
19
19
20
-
First, let's see how to get those flags.
20
+
Primeiro, vamos ver como obter esses sinalizadores.
21
21
22
-
The method[Object.getOwnPropertyDescriptor](mdn:js/Object/getOwnPropertyDescriptor)allows to query the *full* information about a property.
22
+
O método[Object.getOwnPropertyDescriptor](mdn:js/Object/getOwnPropertyDescriptor)nos permite consultar a informação *completa* sobre a propriedade.
23
23
24
-
The syntax is:
24
+
A sintaxe é:
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
+
: O objeto do qual vamos obter a informação.
31
31
32
32
`propertyName`
33
-
: The name of the property.
33
+
: O nome da propriedade.
34
34
35
-
The returned value is a so-called "property descriptor" object: it contains the value and all the flags.
35
+
O valor retornado é também chamado de objeto "descritor de propriedade": ele contém o valor e todos os sinalizadores.
36
36
37
-
For instance:
37
+
Por exemplo:
38
38
39
39
```js run
40
40
let user = {
@@ -44,7 +44,7 @@ let user = {
44
44
let descriptor =Object.getOwnPropertyDescriptor(user, 'name');
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
+
Se a proprieade existe, `defineProperty`atualiza seu sinalizador. Caso contrário, é criada uma propriedade com os sinalizadores setados; neste caso, se um sinalizador não é enviado, seu valor é assumido como`false`.
72
72
73
-
For instance, here a property`name`is created with all falsy flags:
73
+
Por exemplo, aqui a propriedade`name`é criada com todos os sinalizadores falsos:
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
+
Compare isso com o `user.name`"criado normalmente" acima: agora todos os sinalizadores são falsos. Se não é isso que queremos, então é melhor setá-los como `true`no`descriptor`.
100
100
101
-
Now let's see effects of the flags by example.
101
+
Agora vamos ver os efeitos dos sinalizadores, por exemplo:
102
102
103
-
## Non-writable
103
+
## Não-gravável
104
104
105
-
Let's make`user.name`non-writable (can't be reassigned) by changing `writable` flag:
105
+
Vamos deixar`user.name`não-gravável (não pode ser reatribuído) alterando o sinalizador `writable`:
106
106
107
107
```js run
108
108
let user = {
@@ -120,36 +120,35 @@ 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
+
Agora, ninguém pode alterar o nome do nosso usuário, a não ser que eles apliquem seus próprios `defineProperty`para sobrescrever o nosso.
124
124
125
-
```smart header="Errors appear only in strict mode"
126
-
In the non-strict mode, no errors occur when writing to non-writable properties and such. But the operation still won't succeed. Flag-violating actions are just silently ignored in non-strict.
125
+
```smart header="Erros aparecem apenas em strict mode"
126
+
No modo não-estrito, os erros não ocorrem quando gravando em propriedades não-graváveis, etc. Mas a operação ainda não terá sucesso. Ações que violam os sinalizadores são apenas ignoradas silenciosamentes em modo não-estrito.
127
127
```
128
128
129
-
Here's the same example, but the property is created from scratch:
129
+
Aqui está o mesmo exemplo, mas a propriedade é criada do zero.
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 we need to explicitly list what's true
137
+
//para novas proprieades, precisamos explicitamente listar o que é true
138
138
enumerable:true,
139
139
configurable:true
140
140
*/!*
141
141
});
142
142
143
-
alert(user.name); //Pete
144
-
user.name="Alice"; //Error
143
+
alert(user.name); //John
144
+
user.name="Alice"; //Erro
145
145
```
146
146
147
+
## Não-enumerável
147
148
148
-
## Non-enumerable
149
+
Agora, vamos adicionar um `toString` customizado ao `user`.
149
150
150
-
Now let's add a custom `toString` to `user`.
151
-
152
-
Normally, a built-in `toString` for objects is non-enumerable, it does not show up in `for..in`. But if we add a `toString` of our own, then by default it shows up in `for..in`, like this:
151
+
Normalmente, um `toString` embutido em objetos é não-enumerável, e não aparece em `for...in`. Mas se nós adicionarmos um `toString` por nós mesmos, então por padrão ele aparece em `for...in`, desta forma:
153
152
154
153
```js run
155
154
let user = {
@@ -159,11 +158,11 @@ let user = {
159
158
}
160
159
};
161
160
162
-
//By default, both our properties are listed:
161
+
//Por padrão, ambas as nossas propriedades são listadas:
163
162
for (let key in user) alert(key); // name, toString
164
163
```
165
164
166
-
If we don't like it, then we can set `enumerable:false`. Then it won't appear in a `for..in` loop, just like the built-in one:
165
+
Se nós não gostarmos disso, então podemos setar `enumerable:false`. Então ela não vai aparecer no loop `for...in`, assim como as propriedades embutidas:
Então, nós podemos setar várias propriedades de uma vez.
293
292
294
293
## Object.getOwnPropertyDescriptors
295
294
296
-
To get all property descriptors at once, we can use the method[Object.getOwnPropertyDescriptors(obj)](mdn:js/Object/getOwnPropertyDescriptors).
295
+
Para obter todos os sinalizadores de propriedade de uma vez, nós podemos usar o método[Object.getOwnPropertyDescriptors(obj)](mdn:js/Object/getOwnPropertyDescriptors).
297
296
298
-
Together with`Object.defineProperties`it can be used as a "flags-aware" way of cloning an object:
297
+
Juntamente com`Object.defineProperties`isso pode ser usado como um jeito "consciente-de-sinalizadores" de clonar objetos:
299
298
300
299
```js
301
300
let clone =Object.defineProperties({}, Object.getOwnPropertyDescriptors(obj));
302
301
```
303
302
304
-
Normally when we clone an object, we use an assignment to copy properties, like this:
303
+
Normalmente quando nós clonamos um objeto, nós usamos uma atribuição para copiar propriedades, desta forma:
305
304
306
305
```js
307
306
for (let key in user) {
308
307
clone[key] = user[key]
309
308
}
310
309
```
311
310
312
-
...But that does not copy flags. So if we want a "better" clone then `Object.defineProperties` is preferred.
311
+
...Mas isso não copia os sinalizadores. Então se nós quisermos um clone "melhor" então é preferível `Object.defineProperties`.
313
312
314
-
Another difference is that`for..in`ignores symbolic properties, but`Object.getOwnPropertyDescriptors`returns *all* property descriptors including symbolic ones.
313
+
Outra diferença é que`for..in`ignora propriedades simbólicas, mas`Object.getOwnPropertyDescriptors`returna *todas* as propriedades descritoras, incluindo as simbólicas.
315
314
316
-
## Sealing an object globally
315
+
## Selando um objeto globalmente
317
316
318
-
Property descriptors work at the level of individual properties.
317
+
Descritores de propriedade atuam no mesmo nível de propriedades individuais.
319
318
320
-
There are also methods that limit access to the *whole* object:
319
+
Também existem métodos que limitam o acesso ao objeto *inteiro*:
0 commit comments