From 2f6340c3ea61da822dd927411a671542efb0a0a5 Mon Sep 17 00:00:00 2001
From: Flavio Lima <flavio.hblima@gmail.com>
Date: Sun, 24 Oct 2021 23:52:50 -0300
Subject: [PATCH 01/11] FEAT: Translate F.prototype article, task and solution
 to pt.

---
 .../1-changing-prototype/solution.md          | 12 +--
 .../1-changing-prototype/task.md              | 17 ++--
 .../02-function-prototype/article.md          | 91 ++++++++++---------
 3 files changed, 60 insertions(+), 60 deletions(-)

diff --git a/1-js/08-prototypes/02-function-prototype/1-changing-prototype/solution.md b/1-js/08-prototypes/02-function-prototype/1-changing-prototype/solution.md
index ebbdf3a7c..cda1e2867 100644
--- a/1-js/08-prototypes/02-function-prototype/1-changing-prototype/solution.md
+++ b/1-js/08-prototypes/02-function-prototype/1-changing-prototype/solution.md
@@ -1,20 +1,20 @@
 
-Answers:
+Respostas:
 
 1. `true`. 
 
-    The assignment to `Rabbit.prototype` sets up `[[Prototype]]` for new objects, but it does not affect the existing ones. 
+    A atribuição do `Rabbit.prototype` seta o `[[Prototype]]` para novos objetos, mas não afeta os objetos que já existem.
 
 2. `false`. 
 
-    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`. 
+    Objetos são atrbuídos por referência. O objeto do `Rabbit.prototype` não é duplicado, ele continua sendo um único objeto refereciado por `Rabbit.prototype` e pelo `[[Prototype]]` do `rabbit`. 
 
-    So when we change its content through one reference, it is visible through the other one.
+    Portanto, quando nós mudamos o seu conteúdo através de uma referência, ele fica visível para as outras.
 
 3. `true`.
 
-    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.
+    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.
 
 4. `undefined`.
 
-    The property `eats` is deleted from the prototype, it doesn't exist any more.
+    A propriedade `eats` é deletada do protótipo, então ela realmente não existe mais.
diff --git a/1-js/08-prototypes/02-function-prototype/1-changing-prototype/task.md b/1-js/08-prototypes/02-function-prototype/1-changing-prototype/task.md
index 2838c125a..6c67aeeeb 100644
--- a/1-js/08-prototypes/02-function-prototype/1-changing-prototype/task.md
+++ b/1-js/08-prototypes/02-function-prototype/1-changing-prototype/task.md
@@ -1,12 +1,12 @@
-importance: 5
+importância: 5
 
 ---
 
-# Changing "prototype"
+# Mudando o "prototype"
 
-In the code below we create `new Rabbit`, and then try to modify its prototype.
+No código abaixo, nós criamos um `new Rabbit`, depois tentamos modificar seu protótipo.
 
-In the start, we have this code:
+No começo, nós temos esse código:
 
 ```js run
 function Rabbit() {}
@@ -19,8 +19,7 @@ let rabbit = new Rabbit();
 alert( rabbit.eats ); // true
 ```
 
-
-1. We added one more string (emphasized). What will `alert` show now?
+1. Nós adicionamos uma linha (realçada). O que o `alert` vai mostrar agora?
 
     ```js
     function Rabbit() {}
@@ -37,7 +36,7 @@ alert( rabbit.eats ); // true
     alert( rabbit.eats ); // ?
     ```
 
-2. ...And if the code is like this (replaced one line)?
+2. ...E se o código for assim (a linha foi substituída)?
 
     ```js
     function Rabbit() {}
@@ -54,7 +53,7 @@ alert( rabbit.eats ); // true
     alert( rabbit.eats ); // ?
     ```
 
-3. And like this (replaced one line)?
+3. E se for assim (a linha foi substituída)?
 
     ```js
     function Rabbit() {}
@@ -71,7 +70,7 @@ alert( rabbit.eats ); // true
     alert( rabbit.eats ); // ?
     ```
 
-4. The last variant:
+4. A última variação:
 
     ```js
     function Rabbit() {}
diff --git a/1-js/08-prototypes/02-function-prototype/article.md b/1-js/08-prototypes/02-function-prototype/article.md
index b1ef51826..486ae189c 100644
--- a/1-js/08-prototypes/02-function-prototype/article.md
+++ b/1-js/08-prototypes/02-function-prototype/article.md
@@ -1,18 +1,18 @@
 # F.prototype
 
-Remember, new objects can be created with a constructor function, like `new F()`.
+Lembre-se, novos objetos podem ser criados com uma função construtora, usando `new F()`.
 
-If `F.prototype` is an object, then the `new` operator uses it to set `[[Prototype]]` for the new object.
+Se `F.prototype` é um objeto, então o operador `new` usa ela para setar `[[Prototype]]` no novo objeto.
 
 ```smart
-JavaScript had prototypal inheritance from the beginning. It was one of the core features of the language.
+JavaScript tem herança prototipada desde o começo. Isso era uma das funcionalidades centrais da linguagem.
 
-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.
+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.
 ```
 
-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.
+Note que o `F.prototype` aqui significa uma propriedade regular de nome `"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.
 
-Here's the example:
+Aqui temos um exemplo:
 
 ```js run
 let animal = {
@@ -32,27 +32,27 @@ let rabbit = new Rabbit("White Rabbit"); //  rabbit.__proto__ == animal
 alert( rabbit.eats ); // true
 ```
 
-Setting `Rabbit.prototype = animal` literally states the following: "When a `new Rabbit` is created, assign its `[[Prototype]]` to `animal`".
+Setando `Rabbit.prototype = animal` literalmente significa o seguinte: "Quando o `new Rabbit` for criado, atribua seu `[[Prototype]]` para `animal`".
 
-That's the resulting picture:
+Essa é a imagem do resultado:
 
 ![](proto-constructor-animal-rabbit.svg)
 
-On the picture, `"prototype"` is a horizontal arrow, meaning a regular property, and `[[Prototype]]` is vertical, meaning the inheritance of `rabbit` from `animal`.
+Na imagem, `"prototype"` é a seta na horizontal, indicando uma propriedade regular, e `[[Prototype]]` está na vertical, indicando a herança de `rabbit` vinda do `animal`.
 
-```smart header="`F.prototype` only used at `new F` time"
-`F.prototype` property is only used when `new F` is called, it assigns `[[Prototype]]` of the new object.
+```smart header="`F.prototype` é usado apenas na chamada `new F`"
+A propriedade `F.prototype` é usada apenas quando `new F` é chamado, e ela atribui um valor para o `[[Prototype]]` do novo objeto.
 
-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.
+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.
 ```
 
-## Default F.prototype, constructor property
+## F.prototype default, propriedade do construtor
 
-Every function has the `"prototype"` property even if we don't supply it.
+Toda função tem a propriedade `"prototype"`, mesmo que não a use.
 
-The default `"prototype"` is an object with the only property `constructor` that points back to the function itself.
+O `"prototype"` default é um objeto com apenas uma propriedade `constructor` que aponta para a própria função a que pertence.
 
-Like this:
+Assim:
 
 ```js
 function Rabbit() {}
@@ -64,33 +64,33 @@ Rabbit.prototype = { constructor: Rabbit };
 
 ![](function-prototype-constructor.svg)
 
-We can check it:
+Nós podemos conferir isso:
 
 ```js run
 function Rabbit() {}
-// by default:
+// Por definição:
 // Rabbit.prototype = { constructor: Rabbit }
 
 alert( Rabbit.prototype.constructor == Rabbit ); // true
 ```
 
-Naturally, if we do nothing, the `constructor` property is available to all rabbits through  `[[Prototype]]`:
+Naturalmente, se nós não fizermos nada, a propriedade `constructor` está disponível para todos os coelhos (*rabbits*) através do `[[Prototype]]`:
 
 ```js run
 function Rabbit() {}
-// by default:
+// Por definição:
 // Rabbit.prototype = { constructor: Rabbit }
 
-let rabbit = new Rabbit(); // inherits from {constructor: Rabbit}
+let rabbit = new Rabbit(); // herda de {constructor: Rabbit}
 
-alert(rabbit.constructor == Rabbit); // true (from prototype)
+alert(rabbit.constructor == Rabbit); // true (vindo do protótipo)
 ```
 
 ![](rabbit-prototype-constructor.svg)
 
-We can use `constructor` property to create a new object using the same constructor as the existing one.
+Nós podemos usar a propriedade `constructor` para criar um novo objeto usando o próprio construtor de um objeto que já exista.
 
-Like here:
+Como abaixo:
 
 ```js run
 function Rabbit(name) {
@@ -105,17 +105,17 @@ let rabbit2 = new rabbit.constructor("Black Rabbit");
 */!*
 ```
 
-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.
+Isso é prático quando nós temos um objeto, não sabemos qual construtor foi usado para ele (de uma biblioteca de terceiros, por exemplo), e nós precisamos criar outro objeto do mesmo tipo.
 
-But probably the most important thing about `"constructor"` is that...
+Mas provavelmente a coisa mais importante sobre o `"constructor"` é que...
 
-**...JavaScript itself does not ensure the right `"constructor"` value.**
+**...O próprio JavaScript não garante qual é o valor correto do `"constructor"`.**
 
-Yes, it exists in the default `"prototype"` for functions, but that's all. What happens with it later -- is totally on us.
+Sim, existe um `"prototype"` default para funções, mas é só isso. O que acontece com ele depois -- está totalmente por nossa conta.
 
-In particular, if we replace the default prototype as a whole, then there will be no `"constructor"` in it.
+Em particular, se nós substituirmos o `prototype` default como um todo, não vai haver um `"constructor"` nele.
 
-For instance:
+Por exemplo:
 
 ```js run
 function Rabbit() {}
@@ -129,18 +129,18 @@ alert(rabbit.constructor === Rabbit); // false
 */!*
 ```
 
-So, to keep the right `"constructor"` we can choose to add/remove properties to the default `"prototype"` instead of overwriting it as a whole:
+Portanto, para manter o `"constructor"` certo, nós podemos escolher adicionar/remover propriedades do `"prototype"` ao invés de sobrescrevê-lo completamente:
 
 ```js
 function Rabbit() {}
 
-// Not overwrite Rabbit.prototype totally
-// just add to it
+// não sobrescreva Rabbit.prototype completamente
+// apenas adicione
 Rabbit.prototype.jumps = true
-// the default Rabbit.prototype.constructor is preserved
+// o Rabbit.prototype.constructor default fica preservado
 ```
 
-Or, alternatively, recreate the `constructor` property manually:
+Outra alternativa é recriar a propriedade `constructor` manualmente:
 
 ```js
 Rabbit.prototype = {
@@ -150,26 +150,27 @@ Rabbit.prototype = {
 */!*
 };
 
-// now constructor is also correct, because we added it
+// agora o constructor também está correto, porque nós o adicionamos
 ```
 
 
-## Summary
+## Resumo
 
-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.
+Neste capítulo, nós descrevemos brevemente a forma de setar um `[[Prototype]]` para os objetos via função construtura. Mais tarde nós vamos ver padrões (*patterns*) mais avançados de programação que dependem disso.
 
-Everything is quite simple, just a few notes to make things clear:
+É tudo bem simples, mas aqui estão algumas notas para deixar as coisas claras:
 
-- The `F.prototype` property (don't mistake it for `[[Prototype]]`) sets `[[Prototype]]` of new objects when `new F()` is called.
-- The value of `F.prototype` should be either an object or `null`: other values won't work.
--  The `"prototype"` property only has such a special effect when set on a constructor function, and invoked with `new`.
+- A propriedade `F.prototype` (não confunda com o `[[Prototype]]`) seta o `[[Prototype]]` de novos objetos quando `new F()` é chamado.
+- O valor de `F.prototype` deveria ser ou um objeto ou `null`: outros valores não vão funcionar.
+- A propriedade `"prototype"` só tem o efeito especial quando setada em uma função construtora, e invocada com `new`.
+
+Em objetos regulares, o `prototype` não tem nada de especial:
 
-On regular objects the `prototype` is nothing special:
 ```js
 let user = {
   name: "John",
-  prototype: "Bla-bla" // no magic at all
+  prototype: "Bla-bla" // nenhuma mágica aqui
 };
 ```
 
-By default all functions have `F.prototype = { constructor: F }`, so we can get the constructor of an object by accessing its `"constructor"` property.
+Por definiçã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"`.

From 6ed95760f8c3620d07d029f9eaec02f389b2f4d3 Mon Sep 17 00:00:00 2001
From: Flavio Lima <flavio.hblima@gmail.com>
Date: Thu, 28 Oct 2021 13:39:04 -0300
Subject: [PATCH 02/11] FIX: article/tasks reviews resolved. Translate missing
 task.

---
 .../1-changing-prototype/solution.md          |  4 +--
 .../1-changing-prototype/task.md              |  2 +-
 .../4-new-object-same-constructor/solution.md | 30 +++++++++----------
 .../4-new-object-same-constructor/task.md     |  8 ++---
 .../02-function-prototype/article.md          | 14 ++++-----
 5 files changed, 29 insertions(+), 29 deletions(-)

diff --git a/1-js/08-prototypes/02-function-prototype/1-changing-prototype/solution.md b/1-js/08-prototypes/02-function-prototype/1-changing-prototype/solution.md
index cda1e2867..b571648be 100644
--- a/1-js/08-prototypes/02-function-prototype/1-changing-prototype/solution.md
+++ b/1-js/08-prototypes/02-function-prototype/1-changing-prototype/solution.md
@@ -3,11 +3,11 @@ Respostas:
 
 1. `true`. 
 
-    A atribuição do `Rabbit.prototype` seta o `[[Prototype]]` para novos objetos, mas não afeta os objetos que já existem.
+    A atribuição a `Rabbit.prototype` configura o `[[Prototype]]` para novos objetos, mas não afeta os objetos que já existem.
 
 2. `false`. 
 
-    Objetos são atrbuídos por referência. O objeto do `Rabbit.prototype` não é duplicado, ele continua sendo um único objeto refereciado por `Rabbit.prototype` e pelo `[[Prototype]]` do `rabbit`. 
+    Objetos são atrbuí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`. 
 
     Portanto, quando nós mudamos o seu conteúdo através de uma referência, ele fica visível para as outras.
 
diff --git a/1-js/08-prototypes/02-function-prototype/1-changing-prototype/task.md b/1-js/08-prototypes/02-function-prototype/1-changing-prototype/task.md
index 6c67aeeeb..83557de90 100644
--- a/1-js/08-prototypes/02-function-prototype/1-changing-prototype/task.md
+++ b/1-js/08-prototypes/02-function-prototype/1-changing-prototype/task.md
@@ -1,4 +1,4 @@
-importância: 5
+importance: 5
 
 ---
 
diff --git a/1-js/08-prototypes/02-function-prototype/4-new-object-same-constructor/solution.md b/1-js/08-prototypes/02-function-prototype/4-new-object-same-constructor/solution.md
index 372d50dd6..f6a9d916e 100644
--- a/1-js/08-prototypes/02-function-prototype/4-new-object-same-constructor/solution.md
+++ b/1-js/08-prototypes/02-function-prototype/4-new-object-same-constructor/solution.md
@@ -1,6 +1,6 @@
-We can use such approach if we are sure that `"constructor"` property has the correct value.
+Nós podemos usar essa abordagem se nós temos certeza que a propriedade `"constructor"` tem o valor correto.
 
-For instance, if we don't touch the default `"prototype"`, then this code works for sure:
+Por exemplo, se nós não tocarmos o `"prototype"` padrão, então esse código funciona com certeza:
 
 ```js run
 function User(name) {
@@ -10,14 +10,14 @@ function User(name) {
 let user = new User('John');
 let user2 = new user.constructor('Pete');
 
-alert( user2.name ); // Pete (worked!)
+alert( user2.name ); // Pete (funcionou!)
 ```
 
-It worked, because `User.prototype.constructor == User`.
+Funcionou, porque `User.prototype.constructor == User`.
 
-..But if someone, so to speak, overwrites `User.prototype` and forgets to recreate `constructor` to reference `User`, then it would fail.
+...Mas se alguém, por acaso, sobrescrever `User.prototype` e esquecer de recriar o `constructor` com referência ao próprio `User`, então o código iria falhar.
 
-For instance:
+Por exemplo:
 
 ```js run
 function User(name) {
@@ -33,17 +33,17 @@ let user2 = new user.constructor('Pete');
 alert( user2.name ); // undefined
 ```
 
-Why `user2.name` is `undefined`?
+Por que `user2.name` está `undefined`?
 
-Here's how `new user.constructor('Pete')` works:
+Abaixo está como o `new user.constructor('Pete')` funciona:
 
-1. First, it looks for `constructor` in `user`. Nothing.
-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!).
-3. Going further up the chain, `User.prototype` is a plain object, its prototype is the built-in `Object.prototype`. 
-4. Finally, for the built-in `Object.prototype`, there's a built-in `Object.prototype.constructor == Object`. So it is used.
+1. Primeiro, ele procura o `constructor` do `user`. Não o encontra.
+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 "esquecemos" de configurá-lo!).
+3. Indo adiante na cadeia, `User.prototype` é um objeto vazio, cujo protótipo é o `Object.prototype` padrão.
+4. Por último, para o `Object.prototype` padrão existe um `Object.prototype.constructor == Object` padrão. Então, ele é usado.
 
-Finally, at the end, we have `let user2 = new Object('Pete')`. 
+No fim, nós temos `let user2 = new Object('Pete')`.
 
-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`.
+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`.
 
-(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).
\ No newline at end of file
+(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).
diff --git a/1-js/08-prototypes/02-function-prototype/4-new-object-same-constructor/task.md b/1-js/08-prototypes/02-function-prototype/4-new-object-same-constructor/task.md
index 934f3470b..bde53e6be 100644
--- a/1-js/08-prototypes/02-function-prototype/4-new-object-same-constructor/task.md
+++ b/1-js/08-prototypes/02-function-prototype/4-new-object-same-constructor/task.md
@@ -2,14 +2,14 @@ importance: 5
 
 ---
 
-# Create an object with the same constructor
+# Criando um objeto com o mesmo construtor
 
-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.
+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 novo objeto usando ela.
 
-Can we do it like that?
+Nós podemos fazer isso dessa forma?
 
 ```js
 let obj2 = new obj.constructor();
 ```
 
-Give an example of a constructor function for `obj` which lets such code work right. And an example that makes it work wrong.
+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.
diff --git a/1-js/08-prototypes/02-function-prototype/article.md b/1-js/08-prototypes/02-function-prototype/article.md
index 486ae189c..63932c263 100644
--- a/1-js/08-prototypes/02-function-prototype/article.md
+++ b/1-js/08-prototypes/02-function-prototype/article.md
@@ -2,7 +2,7 @@
 
 Lembre-se, novos objetos podem ser criados com uma função construtora, usando `new F()`.
 
-Se `F.prototype` é um objeto, então o operador `new` usa ela para setar `[[Prototype]]` no novo objeto.
+Se `F.prototype` for um objeto, então o operador `new` usa ela para configurar o `[[Prototype]]` do novo objeto.
 
 ```smart
 JavaScript tem herança prototipada desde o começo. Isso era uma das funcionalidades centrais da linguagem.
@@ -27,7 +27,7 @@ function Rabbit(name) {
 Rabbit.prototype = animal;
 */!*
 
-let rabbit = new Rabbit("White Rabbit"); //  rabbit.__proto__ == animal
+let rabbit = new Rabbit("Coelho Branco"); //  rabbit.__proto__ == animal
 
 alert( rabbit.eats ); // true
 ```
@@ -137,7 +137,7 @@ function Rabbit() {}
 // não sobrescreva Rabbit.prototype completamente
 // apenas adicione
 Rabbit.prototype.jumps = true
-// o Rabbit.prototype.constructor default fica preservado
+// o Rabbit.prototype.constructor padrão fica preservado
 ```
 
 Outra alternativa é recriar a propriedade `constructor` manualmente:
@@ -156,13 +156,13 @@ Rabbit.prototype = {
 
 ## Resumo
 
-Neste capítulo, nós descrevemos brevemente a forma de setar um `[[Prototype]]` para os objetos via função construtura. Mais tarde nós vamos ver padrões (*patterns*) mais avançados de programação que dependem disso.
+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.
 
 É tudo bem simples, mas aqui estão algumas notas para deixar as coisas claras:
 
-- A propriedade `F.prototype` (não confunda com o `[[Prototype]]`) seta o `[[Prototype]]` de novos objetos quando `new F()` é chamado.
-- O valor de `F.prototype` deveria ser ou um objeto ou `null`: outros valores não vão funcionar.
-- A propriedade `"prototype"` só tem o efeito especial quando setada em uma função construtora, e invocada com `new`.
+- A propriedade `F.prototype` (não confunda com o `[[Prototype]]`) configura o `[[Prototype]]` de novos objetos quando `new F()` é chamado.
+- O valor de `F.prototype` deveria ser um objeto ou `null`: outros valores não vão funcionar.
+- A propriedade `"prototype"` só tem o efeito especial quando configurada em uma função construtora, e invocada com `new`.
 
 Em objetos regulares, o `prototype` não tem nada de especial:
 

From 75ce566c938a6415a4999b3553dcbc1d03215164 Mon Sep 17 00:00:00 2001
From: Flavio Lima <flavio.hblima@gmail.com>
Date: Fri, 29 Oct 2021 17:07:27 -0300
Subject: [PATCH 03/11] FIX: Resolving reviews.

---
 .../02-function-prototype/article.md          | 20 +++++++++----------
 1 file changed, 10 insertions(+), 10 deletions(-)

diff --git a/1-js/08-prototypes/02-function-prototype/article.md b/1-js/08-prototypes/02-function-prototype/article.md
index 63932c263..e259b54d0 100644
--- a/1-js/08-prototypes/02-function-prototype/article.md
+++ b/1-js/08-prototypes/02-function-prototype/article.md
@@ -32,25 +32,25 @@ let rabbit = new Rabbit("Coelho Branco"); //  rabbit.__proto__ == animal
 alert( rabbit.eats ); // true
 ```
 
-Setando `Rabbit.prototype = animal` literalmente significa o seguinte: "Quando o `new Rabbit` for criado, atribua seu `[[Prototype]]` para `animal`".
+Configurando `Rabbit.prototype = animal` literalmente significa o seguinte: "Quando o `new Rabbit` for criado, atribua seu `[[Prototype]]` para `animal`".
 
 Essa é a imagem do resultado:
 
 ![](proto-constructor-animal-rabbit.svg)
 
-Na imagem, `"prototype"` é a seta na horizontal, indicando uma propriedade regular, e `[[Prototype]]` está na vertical, indicando a herança de `rabbit` vinda do `animal`.
+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`.
 
-```smart header="`F.prototype` é usado apenas na chamada `new F`"
+```smart header="`F.prototype` é usada apenas na chamada `new F`"
 A propriedade `F.prototype` é usada apenas quando `new F` é chamado, e ela atribui um valor para o `[[Prototype]]` do novo objeto.
 
 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.
 ```
 
-## F.prototype default, propriedade do construtor
+## F.prototype padrão, propriedade do construtor
 
-Toda função tem a propriedade `"prototype"`, mesmo que não a use.
+Toda função tem a propriedade `"prototype"`, mesmo quando nós não a provermos.
 
-O `"prototype"` default é um objeto com apenas uma propriedade `constructor` que aponta para a própria função a que pertence.
+O `"prototype"` padrão é um objeto com apenas uma propriedade `constructor` que aponta para a própria função a que pertence.
 
 Assim:
 
@@ -98,10 +98,10 @@ function Rabbit(name) {
   alert(name);
 }
 
-let rabbit = new Rabbit("White Rabbit");
+let rabbit = new Rabbit("Coelho Branco");
 
 *!*
-let rabbit2 = new rabbit.constructor("Black Rabbit");
+let rabbit2 = new rabbit.constructor("Coelho Preto");
 */!*
 ```
 
@@ -111,9 +111,9 @@ Mas provavelmente a coisa mais importante sobre o `"constructor"` é que...
 
 **...O próprio JavaScript não garante qual é o valor correto do `"constructor"`.**
 
-Sim, existe um `"prototype"` default para funções, mas é só isso. O que acontece com ele depois -- está totalmente por nossa conta.
+Sim, existe um `"prototype"` padrão para funções, mas é só isso. O que acontece com ele depois -- está totalmente por nossa conta.
 
-Em particular, se nós substituirmos o `prototype` default como um todo, não vai haver um `"constructor"` nele.
+Em particular, se nós substituirmos o `prototype` padrão como um todo, não vai haver um `"constructor"` nele.
 
 Por exemplo:
 

From 74f456dc42a25f5f8c609d05fc01b536afa170f3 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Fl=C3=A1vio=20Lima?= <flavio.hblima@gmail.com>
Date: Mon, 1 Nov 2021 13:40:05 -0300
Subject: [PATCH 04/11] Update
 1-js/08-prototypes/02-function-prototype/4-new-object-same-constructor/solution.md

Co-authored-by: Osvaldo Dias dos Santos <vadodsantos@yahoo.com>
---
 .../4-new-object-same-constructor/solution.md                   | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/1-js/08-prototypes/02-function-prototype/4-new-object-same-constructor/solution.md b/1-js/08-prototypes/02-function-prototype/4-new-object-same-constructor/solution.md
index f6a9d916e..a7d2e46e5 100644
--- a/1-js/08-prototypes/02-function-prototype/4-new-object-same-constructor/solution.md
+++ b/1-js/08-prototypes/02-function-prototype/4-new-object-same-constructor/solution.md
@@ -1,4 +1,4 @@
-Nós podemos usar essa abordagem se nós temos certeza que a propriedade `"constructor"` tem o valor correto.
+Nós podemos usar essa abordagem se nós tivermos a certeza de que a propriedade `"constructor"` tem o valor correto.
 
 Por exemplo, se nós não tocarmos o `"prototype"` padrão, então esse código funciona com certeza:
 

From fa0c64e31ef6065c071392cfc6d109d7f5b69351 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Fl=C3=A1vio=20Lima?= <flavio.hblima@gmail.com>
Date: Mon, 1 Nov 2021 13:40:18 -0300
Subject: [PATCH 05/11] Update
 1-js/08-prototypes/02-function-prototype/4-new-object-same-constructor/solution.md

Co-authored-by: Osvaldo Dias dos Santos <vadodsantos@yahoo.com>
---
 .../4-new-object-same-constructor/solution.md                   | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/1-js/08-prototypes/02-function-prototype/4-new-object-same-constructor/solution.md b/1-js/08-prototypes/02-function-prototype/4-new-object-same-constructor/solution.md
index a7d2e46e5..b8bc5be1e 100644
--- a/1-js/08-prototypes/02-function-prototype/4-new-object-same-constructor/solution.md
+++ b/1-js/08-prototypes/02-function-prototype/4-new-object-same-constructor/solution.md
@@ -1,6 +1,6 @@
 Nós podemos usar essa abordagem se nós tivermos a certeza de que a propriedade `"constructor"` tem o valor correto.
 
-Por exemplo, se nós não tocarmos o `"prototype"` padrão, então esse código funciona com certeza:
+Por exemplo, se nós não tocarmos no `"prototype"` padrão, então esse código funciona com certeza:
 
 ```js run
 function User(name) {

From 4d86e7c4c21fe50c4fbbafbcb824bf299241f2b1 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Fl=C3=A1vio=20Lima?= <flavio.hblima@gmail.com>
Date: Mon, 1 Nov 2021 13:41:37 -0300
Subject: [PATCH 06/11] Update
 1-js/08-prototypes/02-function-prototype/4-new-object-same-constructor/solution.md

Co-authored-by: Osvaldo Dias dos Santos <vadodsantos@yahoo.com>
---
 .../4-new-object-same-constructor/solution.md                   | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/1-js/08-prototypes/02-function-prototype/4-new-object-same-constructor/solution.md b/1-js/08-prototypes/02-function-prototype/4-new-object-same-constructor/solution.md
index b8bc5be1e..4bd583a78 100644
--- a/1-js/08-prototypes/02-function-prototype/4-new-object-same-constructor/solution.md
+++ b/1-js/08-prototypes/02-function-prototype/4-new-object-same-constructor/solution.md
@@ -15,7 +15,7 @@ alert( user2.name ); // Pete (funcionou!)
 
 Funcionou, porque `User.prototype.constructor == User`.
 
-...Mas se alguém, por acaso, sobrescrever `User.prototype` e esquecer de recriar o `constructor` com referência ao próprio `User`, então o código iria falhar.
+...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.
 
 Por exemplo:
 

From 525cc2e51dcfe7d36e24ba1b8c297a347dbb9b95 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Fl=C3=A1vio=20Lima?= <flavio.hblima@gmail.com>
Date: Mon, 1 Nov 2021 13:42:04 -0300
Subject: [PATCH 07/11] Update
 1-js/08-prototypes/02-function-prototype/4-new-object-same-constructor/solution.md

Co-authored-by: Osvaldo Dias dos Santos <vadodsantos@yahoo.com>
---
 .../4-new-object-same-constructor/solution.md                   | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/1-js/08-prototypes/02-function-prototype/4-new-object-same-constructor/solution.md b/1-js/08-prototypes/02-function-prototype/4-new-object-same-constructor/solution.md
index 4bd583a78..80f23a471 100644
--- a/1-js/08-prototypes/02-function-prototype/4-new-object-same-constructor/solution.md
+++ b/1-js/08-prototypes/02-function-prototype/4-new-object-same-constructor/solution.md
@@ -38,7 +38,7 @@ Por que `user2.name` está `undefined`?
 Abaixo está como o `new user.constructor('Pete')` funciona:
 
 1. Primeiro, ele procura o `constructor` do `user`. Não o encontra.
-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 "esquecemos" de configurá-lo!).
+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!).
 3. Indo adiante na cadeia, `User.prototype` é um objeto vazio, cujo protótipo é o `Object.prototype` padrão.
 4. Por último, para o `Object.prototype` padrão existe um `Object.prototype.constructor == Object` padrão. Então, ele é usado.
 

From 2157dd4fa818a11f2b712e4ae9611330b0cf994a Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Fl=C3=A1vio=20Lima?= <flavio.hblima@gmail.com>
Date: Mon, 1 Nov 2021 13:42:17 -0300
Subject: [PATCH 08/11] Update
 1-js/08-prototypes/02-function-prototype/article.md

Co-authored-by: Osvaldo Dias dos Santos <vadodsantos@yahoo.com>
---
 1-js/08-prototypes/02-function-prototype/article.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/1-js/08-prototypes/02-function-prototype/article.md b/1-js/08-prototypes/02-function-prototype/article.md
index e259b54d0..f964aef04 100644
--- a/1-js/08-prototypes/02-function-prototype/article.md
+++ b/1-js/08-prototypes/02-function-prototype/article.md
@@ -10,7 +10,7 @@ JavaScript tem herança prototipada desde o começo. Isso era uma das funcionali
 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.
 ```
 
-Note que o `F.prototype` aqui significa uma propriedade regular de nome `"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.
+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.
 
 Aqui temos um exemplo:
 

From 70545353026ef85de3123c3110b567fff2c18411 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Fl=C3=A1vio=20Lima?= <flavio.hblima@gmail.com>
Date: Wed, 24 Nov 2021 11:33:49 -0300
Subject: [PATCH 09/11] Update
 1-js/08-prototypes/02-function-prototype/article.md

Co-authored-by: Osvaldo Dias dos Santos <vadodsantos@yahoo.com>
---
 1-js/08-prototypes/02-function-prototype/article.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/1-js/08-prototypes/02-function-prototype/article.md b/1-js/08-prototypes/02-function-prototype/article.md
index f964aef04..e619245c2 100644
--- a/1-js/08-prototypes/02-function-prototype/article.md
+++ b/1-js/08-prototypes/02-function-prototype/article.md
@@ -105,7 +105,7 @@ let rabbit2 = new rabbit.constructor("Coelho Preto");
 */!*
 ```
 
-Isso é prático quando nós temos um objeto, não sabemos qual construtor foi usado para ele (de uma biblioteca de terceiros, por exemplo), e nós precisamos criar outro objeto do mesmo tipo.
+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.
 
 Mas provavelmente a coisa mais importante sobre o `"constructor"` é que...
 

From e15987319b7ec362e98e0720e4ef346cc8383b40 Mon Sep 17 00:00:00 2001
From: Jonnathan Santos <jonnathan.lacerda.santos@gmail.com>
Date: Sun, 17 Sep 2023 22:22:21 -0300
Subject: [PATCH 10/11] refactor: applies the corrections requested in the
 second review of the PR#231

Pull Request: https://github.com/javascript-tutorial/pt.javascript.info/pull/231
---
 .../02-function-prototype/1-changing-prototype/solution.md | 2 +-
 .../4-new-object-same-constructor/solution.md              | 2 +-
 .../4-new-object-same-constructor/task.md                  | 2 +-
 1-js/08-prototypes/02-function-prototype/article.md        | 7 +++----
 4 files changed, 6 insertions(+), 7 deletions(-)

diff --git a/1-js/08-prototypes/02-function-prototype/1-changing-prototype/solution.md b/1-js/08-prototypes/02-function-prototype/1-changing-prototype/solution.md
index b571648be..bc9998897 100644
--- a/1-js/08-prototypes/02-function-prototype/1-changing-prototype/solution.md
+++ b/1-js/08-prototypes/02-function-prototype/1-changing-prototype/solution.md
@@ -7,7 +7,7 @@ Respostas:
 
 2. `false`. 
 
-    Objetos são atrbuí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`. 
+    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`. 
 
     Portanto, quando nós mudamos o seu conteúdo através de uma referência, ele fica visível para as outras.
 
diff --git a/1-js/08-prototypes/02-function-prototype/4-new-object-same-constructor/solution.md b/1-js/08-prototypes/02-function-prototype/4-new-object-same-constructor/solution.md
index 80f23a471..d28bf9e12 100644
--- a/1-js/08-prototypes/02-function-prototype/4-new-object-same-constructor/solution.md
+++ b/1-js/08-prototypes/02-function-prototype/4-new-object-same-constructor/solution.md
@@ -46,4 +46,4 @@ No fim, nós temos `let user2 = new Object('Pete')`.
 
 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`.
 
-(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).
+(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).
diff --git a/1-js/08-prototypes/02-function-prototype/4-new-object-same-constructor/task.md b/1-js/08-prototypes/02-function-prototype/4-new-object-same-constructor/task.md
index bde53e6be..61c18bf11 100644
--- a/1-js/08-prototypes/02-function-prototype/4-new-object-same-constructor/task.md
+++ b/1-js/08-prototypes/02-function-prototype/4-new-object-same-constructor/task.md
@@ -4,7 +4,7 @@ importance: 5
 
 # Criando um objeto com o mesmo construtor
 
-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 novo objeto usando ela.
+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.
 
 Nós podemos fazer isso dessa forma?
 
diff --git a/1-js/08-prototypes/02-function-prototype/article.md b/1-js/08-prototypes/02-function-prototype/article.md
index e619245c2..8ea06ec3d 100644
--- a/1-js/08-prototypes/02-function-prototype/article.md
+++ b/1-js/08-prototypes/02-function-prototype/article.md
@@ -88,7 +88,7 @@ alert(rabbit.constructor == Rabbit); // true (vindo do protótipo)
 
 ![](rabbit-prototype-constructor.svg)
 
-Nós podemos usar a propriedade `constructor` para criar um novo objeto usando o próprio construtor de um objeto que já exista.
+Nós podemos usar a propriedade `constructor` para criar um objeto novo usando o próprio construtor de um objeto que já exista.
 
 Como abaixo:
 
@@ -113,7 +113,7 @@ Mas provavelmente a coisa mais importante sobre o `"constructor"` é que...
 
 Sim, existe um `"prototype"` padrão para funções, mas é só isso. O que acontece com ele depois -- está totalmente por nossa conta.
 
-Em particular, se nós substituirmos o `prototype` padrão como um todo, não vai haver um `"constructor"` nele.
+Em particular, se nós substituirmos o `prototype` padrão, não vai haver um `"constructor"` nele.
 
 Por exemplo:
 
@@ -153,7 +153,6 @@ Rabbit.prototype = {
 // agora o constructor também está correto, porque nós o adicionamos
 ```
 
-
 ## Resumo
 
 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.
@@ -173,4 +172,4 @@ let user = {
 };
 ```
 
-Por definiçã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"`.
+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"`.

From 2e325491b7f7e403205a9adcea817a815ff7a6cc Mon Sep 17 00:00:00 2001
From: Jonnathan Santos <jonnathan.lacerda.santos@gmail.com>
Date: Sun, 17 Sep 2023 22:23:44 -0300
Subject: [PATCH 11/11] refactor: translates pending texts in svg files

---
 images.yml | 4 ++++
 1 file changed, 4 insertions(+)
 create mode 100644 images.yml

diff --git a/images.yml b/images.yml
new file mode 100644
index 000000000..84d9832b7
--- /dev/null
+++ b/images.yml
@@ -0,0 +1,4 @@
+proto-constructor-animal-rabbit.svg:
+  White Rabbit:
+    text: Coelho Branco
+    position: center