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
The assignment to`Rabbit.prototype`sets up`[[Prototype]]`for new objects, but it does not affect the existing ones.
6
+
A atribuição a`Rabbit.prototype`configura o`[[Prototype]]`para novos objetos, mas não afeta os objetos que já existem.
7
7
8
8
2.`false`.
9
9
10
-
Objects are assigned by reference. The object from`Rabbit.prototype`is not duplicated, it's still a single object referenced both by`Rabbit.prototype`and by the `[[Prototype]]`of`rabbit`.
10
+
Objetos são atribuídos por referência. O objeto do`Rabbit.prototype`não é duplicado, ele continua sendo um único objeto referenciado por`Rabbit.prototype`e pelo `[[Prototype]]`do`rabbit`.
11
11
12
-
So when we change its content through one reference, it is visible through the other one.
12
+
Portanto, quando nós mudamos o seu conteúdo através de uma referência, ele fica visível para as outras.
13
13
14
14
3.`true`.
15
15
16
-
All `delete`operations are applied directly to the object. Here `delete rabbit.eats`tries to remove `eats`property from `rabbit`, but it doesn't have it. So the operation won't have any effect.
16
+
Todas as operações de `delete`são aplicadas diretamente ao objeto. Neste caso, `delete rabbit.eats`tenta remover a propriedade `eats`do `rabbit`, mas ele não a tem. Assim, essa operação não tem nenhum efeito.
17
17
18
18
4.`undefined`.
19
19
20
-
The property`eats`is deleted from the prototype, it doesn't exist any more.
20
+
A propriedade`eats`é deletada do protótipo, então ela realmente não existe mais.
..But if someone, so to speak, overwrites`User.prototype`and forgets to recreate `constructor`to reference `User`, then it would fail.
18
+
...Mas se alguém, por acaso, sobrescrever`User.prototype`e se esquecer de recriar o `constructor`referenciando `User`, então o código irá falhar.
19
19
20
-
For instance:
20
+
Por exemplo:
21
21
22
22
```js run
23
23
functionUser(name) {
@@ -33,17 +33,17 @@ let user2 = new user.constructor('Pete');
33
33
alert( user2.name ); // undefined
34
34
```
35
35
36
-
Why `user2.name`is`undefined`?
36
+
Por que `user2.name`está`undefined`?
37
37
38
-
Here's how `new user.constructor('Pete')`works:
38
+
Abaixo está como o `new user.constructor('Pete')`funciona:
39
39
40
-
1.First, it looks for`constructor`in`user`. Nothing.
41
-
2.Then it follows the prototype chain. The prototype of`user`is`User.prototype`, and it also has no `constructor` (because we "forgot" to set it right!).
42
-
3.Going further up the chain, `User.prototype`is a plain object, its prototype is the built-in `Object.prototype`.
43
-
4.Finally, for the built-in `Object.prototype`, there's a built-in`Object.prototype.constructor == Object`. So it is used.
40
+
1.Primeiro, ele procura o`constructor`do`user`. Não o encontra.
41
+
2.Depois, ele segue a cadeia de protótipos. O protótipo de`user`é`User.prototype`, e ele também não tem um `constructor` (porque nós nos "esquecemos" de configurá-lo!).
42
+
3.Indo adiante na cadeia, `User.prototype`é um objeto vazio, cujo protótipo é o `Object.prototype` padrão.
43
+
4.Por último, para o `Object.prototype` padrão existe um`Object.prototype.constructor == Object` padrão. Então, ele é usado.
44
44
45
-
Finally, at the end, we have`let user2 = new Object('Pete')`.
45
+
No fim, nós temos`let user2 = new Object('Pete')`.
46
46
47
-
Probably, that's not what we want. We'd like to create `new User`, not `new Object`. That's the outcome of the missing`constructor`.
47
+
Provavelmente não é isso que nós queremos. Nós gostaríamos de criar um `new User`, não um `new Object`. Essa é a consequência da falta de um`constructor`.
48
48
49
-
(Just in case you're curious, the `new Object(...)`call converts its argument to an object. That's a theoretical thing, in practice no one calls `new Object`with a value, and generally we don't use`new Object`to make objects at all).
49
+
(Caso você esteja curioso, a chamada `new Object(...)`converte o seu argumento para um objeto. Isso é algo teórico, mas, na prática, ninguém faz a chamada `new Object`com um valor, e geralmente nós não usamos`new Object`para criar objetos).
Copy file name to clipboardExpand all lines: 1-js/08-prototypes/02-function-prototype/4-new-object-same-constructor/task.md
+4-4Lines changed: 4 additions & 4 deletions
Original file line number
Diff line number
Diff line change
@@ -2,14 +2,14 @@ importance: 5
2
2
3
3
---
4
4
5
-
# Create an object with the same constructor
5
+
# Criando um objeto com o mesmo construtor
6
6
7
-
Imagine, we have an arbitrary object`obj`, created by a constructor function -- we don't know which one, but we'd like to create a new object using it.
7
+
Imagine que nós temos um objeto`obj` arbitrário, criado por uma função construtura -- nós não sabemos qual é, mas nós gostaríamos de criar um objeto novo usando ela.
8
8
9
-
Can we do it like that?
9
+
Nós podemos fazer isso dessa forma?
10
10
11
11
```js
12
12
let obj2 =newobj.constructor();
13
13
```
14
14
15
-
Give an example of a constructor function for `obj`which lets such code work right. And an example that makes it work wrong.
15
+
Dê um exemplo de uma função construtora para o `obj`que faça esse código funcionar corretamente, e outro exemplo que faça ele não funcionar.
Remember, new objects can be created with a constructor function, like`new F()`.
3
+
Lembre-se, novos objetos podem ser criados com uma função construtora, usando`new F()`.
4
4
5
-
If`F.prototype`is an object, then the `new`operator uses it to set`[[Prototype]]`for the new object.
5
+
Se`F.prototype`for um objeto, então o operador `new`usa ela para configurar o`[[Prototype]]`do novo objeto.
6
6
7
7
```smart
8
-
JavaScript had prototypal inheritance from the beginning. It was one of the core features of the language.
8
+
JavaScript tem herança prototipada desde o começo. Isso era uma das funcionalidades centrais da linguagem.
9
9
10
-
But in the old times, there was no direct access to it. The only thing that worked reliably was a `"prototype"` property of the constructor function, described in this chapter. So there are many scripts that still use it.
10
+
Mas antigamente não havia um acesso direto a ela. A única coisa que funcionava de forma confiável era uma propriedade `"prototype"` da função construtora, descrita nesse capítulo. Então, existem muitos scripts que ainda a utilizam.
11
11
```
12
12
13
-
Please note that`F.prototype`here means a regular property named `"prototype"`on `F`. It sounds something similar to the term "prototype", but here we really mean a regular property with this name.
13
+
Note que o`F.prototype`aqui significa uma propriedade regular chamada `"prototype"`dentro de `F`. Isso soa um pouco similar ao termo "prototype" (protótipo), mas aqui nós estamos falando realmente de uma propriedade regular com esse nome.
14
14
15
-
Here's the example:
15
+
Aqui temos um exemplo:
16
16
17
17
```js run
18
18
let animal = {
@@ -27,32 +27,32 @@ function Rabbit(name) {
27
27
Rabbit.prototype= animal;
28
28
*/!*
29
29
30
-
let rabbit =newRabbit("White Rabbit"); // rabbit.__proto__ == animal
30
+
let rabbit =newRabbit("Coelho Branco"); // rabbit.__proto__ == animal
31
31
32
32
alert( rabbit.eats ); // true
33
33
```
34
34
35
-
Setting`Rabbit.prototype = animal`literally states the following: "When a`new Rabbit`is created, assign its`[[Prototype]]`to`animal`".
35
+
Configurando`Rabbit.prototype = animal`literalmente significa o seguinte: "Quando o`new Rabbit`for criado, atribua seu`[[Prototype]]`para`animal`".
36
36
37
-
That's the resulting picture:
37
+
Essa é a imagem do resultado:
38
38
39
39
40
40
41
-
On the picture, `"prototype"`is a horizontal arrow, meaning a regular property, and`[[Prototype]]`is vertical, meaning the inheritance of`rabbit`from`animal`.
41
+
Na imagem, `"prototype"`é a seta na horizontal, indicando uma propriedade regular, e`[[Prototype]]`está na vertical, indicando a herança de`rabbit`vinda de`animal`.
42
42
43
-
```smart header="`F.prototype`only used at `new F` time"
44
-
`F.prototype`property is only used when `new F`is called, it assigns `[[Prototype]]`of the new object.
43
+
```smart header="`F.prototype`é usada apenas na chamada `new F`"
44
+
A propriedade `F.prototype`é usada apenas quando `new F`é chamado, e ela atribui um valor para o `[[Prototype]]`do novo objeto.
45
45
46
-
If, after the creation, `F.prototype`property changes (`F.prototype = <another object>`), then new objects created by`new F`will have another object as`[[Prototype]]`, but already existing objects keep the old one.
46
+
Se, depois da criação, a propriedade `F.prototype`mudar (`F.prototype = <another object>`), então novos objetos criados com`new F`vão ter outro objeto como`[[Prototype]]`, enquanto os objetos que já existirem vão manter o antigo.
47
47
```
48
48
49
-
## Default F.prototype, constructor property
49
+
## F.prototype padrão, propriedade do construtor
50
50
51
-
Every function has the `"prototype"` property even if we don't supply it.
51
+
Toda função tem a propriedade `"prototype"`, mesmo quando nós não a provermos.
52
52
53
-
The default `"prototype"` is an object with the only property `constructor` that points back to the function itself.
53
+
O `"prototype"` padrão é um objeto com apenas uma propriedade `constructor` que aponta para a própria função a que pertence.
alert(rabbit.constructor== Rabbit); // true (vindo do protótipo)
87
87
```
88
88
89
89
90
90
91
-
We can use `constructor`property to create a new object using the same constructor as the existing one.
91
+
Nós podemos usar a propriedade `constructor`para criar um objeto novo usando o próprio construtor de um objeto que já exista.
92
92
93
-
Like here:
93
+
Como abaixo:
94
94
95
95
```js run
96
96
functionRabbit(name) {
97
97
this.name= name;
98
98
alert(name);
99
99
}
100
100
101
-
let rabbit =newRabbit("White Rabbit");
101
+
let rabbit =newRabbit("Coelho Branco");
102
102
103
103
*!*
104
-
let rabbit2 =newrabbit.constructor("Black Rabbit");
104
+
let rabbit2 =newrabbit.constructor("Coelho Preto");
105
105
*/!*
106
106
```
107
107
108
-
That's handy when we have an object, don't know which constructor was used for it (e.g. it comes from a 3rd party library), and we need to create another one of the same kind.
108
+
Isso é prático quando nós temos um objeto, não sabemos que construtor foi usado para ele (de uma biblioteca de terceiros, por exemplo), e nós precisamos de criar outro objeto do mesmo tipo.
109
109
110
-
But probably the most important thing about `"constructor"`is that...
110
+
Mas provavelmente a coisa mais importante sobre o `"constructor"`é que...
111
111
112
-
**...JavaScript itself does not ensure the right `"constructor"` value.**
112
+
**...O próprio JavaScript não garante qual é o valor correto do `"constructor"`.**
113
113
114
-
Yes, it exists in the default `"prototype"`for functions, but that's all. What happens with it later -- is totally on us.
114
+
Sim, existe um `"prototype"`padrão para funções, mas é só isso. O que acontece com ele depois -- está totalmente por nossa conta.
115
115
116
-
In particular, if we replace the default prototype as a whole, then there will be no `"constructor"`in it.
116
+
Em particular, se nós substituirmos o `prototype` padrão, não vai haver um `"constructor"`nele.
So, to keep the right `"constructor"`we can choose to add/remove properties to the default `"prototype"`instead of overwriting it as a whole:
132
+
Portanto, para manter o `"constructor"`certo, nós podemos escolher adicionar/remover propriedades do `"prototype"`ao invés de sobrescrevê-lo completamente:
133
133
134
134
```js
135
135
functionRabbit() {}
136
136
137
-
//Not overwrite Rabbit.prototype totally
138
-
//just add to it
137
+
//não sobrescreva Rabbit.prototype completamente
138
+
//apenas adicione
139
139
Rabbit.prototype.jumps=true
140
-
//the default Rabbit.prototype.constructor is preserved
140
+
//o Rabbit.prototype.constructor padrão fica preservado
141
141
```
142
142
143
-
Or, alternatively, recreate the `constructor`property manually:
143
+
Outra alternativa é recriar a propriedade `constructor`manualmente:
144
144
145
145
```js
146
146
Rabbit.prototype= {
@@ -150,26 +150,26 @@ Rabbit.prototype = {
150
150
*/!*
151
151
};
152
152
153
-
//now constructor is also correct, because we added it
153
+
//agora o constructor também está correto, porque nós o adicionamos
154
154
```
155
155
156
+
## Resumo
156
157
157
-
## Summary
158
+
Neste capítulo, nós descrevemos brevemente a forma de configurar um `[[Prototype]]` para os objetos criados via função construtura. Mais tarde nós vamos ver padrões (*patterns*) mais avançados de programação que dependem disso.
158
159
159
-
In this chapter we briefly described the way of setting a `[[Prototype]]` for objects created via a constructor function. Later we'll see more advanced programming patterns that rely on it.
160
+
É tudo bem simples, mas aqui estão algumas notas para deixar as coisas claras:
160
161
161
-
Everything is quite simple, just a few notes to make things clear:
162
+
- A propriedade `F.prototype` (não confunda com o `[[Prototype]]`) configura o `[[Prototype]]` de novos objetos quando `new F()` é chamado.
163
+
- O valor de `F.prototype` deveria ser um objeto ou `null`: outros valores não vão funcionar.
164
+
- A propriedade `"prototype"` só tem o efeito especial quando configurada em uma função construtora, e invocada com `new`.
162
165
163
-
- The `F.prototype` property (don't mistake it for `[[Prototype]]`) sets `[[Prototype]]` of new objects when `new F()` is called.
164
-
- The value of `F.prototype` should be either an object or `null`: other values won'twork.
165
-
-The`"prototype"`propertyonlyhassuchaspecialeffectwhensetonaconstructor function, and invoked with `new`.
166
+
Em objetos regulares, o `prototype` não tem nada de especial:
166
167
167
-
On regular objects the `prototype` is nothing special:
168
168
```js
169
169
let user = {
170
170
name:"John",
171
-
prototype: "Bla-bla" //no magic at all
171
+
prototype:"Bla-bla"//nenhuma mágica aqui
172
172
};
173
173
```
174
174
175
-
By default all functions have `F.prototype = { constructor: F }`, so we can get the constructor of an object by accessing its `"constructor"` property.
175
+
Por padrão, todas as funções possuem `F.prototype= { constructor: F }`, então nós podemos obter o construtor de um objeto acessando sua propriedade `"constructor"`.
0 commit comments