FIX: article/tasks reviews resolved. Translate missing task.

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.
 

1-js/08-prototypes/02-function-prototype/1-changing-prototype/task.md

@@ -1,4 +1,4 @@
-importância: 5
+importance: 5
 
 ---
 

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).
+(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).

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.

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: