From 0f761e893d58c086ab31ebcd46268703a6d6701a Mon Sep 17 00:00:00 2001
From: Flavio Lima <flavio.hblima@gmail.com>
Date: Mon, 1 Nov 2021 14:26:55 -0300
Subject: [PATCH 01/20] FEAT: Translate native-prototypes (article,tasks &
 solutions).

---
 .../1-defer-to-prototype/solution.md          |   4 +-
 .../1-defer-to-prototype/task.md              |  10 +-
 .../2-defer-to-prototype-extended/solution.md |   8 +-
 .../2-defer-to-prototype-extended/task.md     |  10 +-
 .../03-native-prototypes/article.md           | 135 +++++++++---------
 5 files changed, 83 insertions(+), 84 deletions(-)

diff --git a/1-js/08-prototypes/03-native-prototypes/1-defer-to-prototype/solution.md b/1-js/08-prototypes/03-native-prototypes/1-defer-to-prototype/solution.md
index ebd2f44e9..98127a64b 100644
--- a/1-js/08-prototypes/03-native-prototypes/1-defer-to-prototype/solution.md
+++ b/1-js/08-prototypes/03-native-prototypes/1-defer-to-prototype/solution.md
@@ -6,8 +6,8 @@ Function.prototype.defer = function(ms) {
 };
 
 function f() {
-  alert("Hello!");
+  alert("Olá!");
 }
 
-f.defer(1000); // shows "Hello!" after 1 sec
+f.defer(1000); // mostra "Olá!" depois de 1 segundo
 ```
diff --git a/1-js/08-prototypes/03-native-prototypes/1-defer-to-prototype/task.md b/1-js/08-prototypes/03-native-prototypes/1-defer-to-prototype/task.md
index d3b3a51c2..25677bc28 100644
--- a/1-js/08-prototypes/03-native-prototypes/1-defer-to-prototype/task.md
+++ b/1-js/08-prototypes/03-native-prototypes/1-defer-to-prototype/task.md
@@ -2,16 +2,16 @@ importance: 5
 
 ---
 
-# Add method "f.defer(ms)" to functions
+# Adicione o método "f.defer(ms)" às funções
 
-Add to the prototype of all functions the method `defer(ms)`, that runs the function after `ms` milliseconds.
+Adicione ao protótipo de todas as funções o método `defer(ms)`, que executa a função depois de `ms` milisegundos.
 
-After you do it, such code should work:
+Depois de fazer isso, este código deveria funcionar:
 
 ```js
 function f() {
-  alert("Hello!");
+  alert("Olá!");
 }
 
-f.defer(1000); // shows "Hello!" after 1 second
+f.defer(1000); // mostra "Olá!" depois de 1 segundo
 ```
diff --git a/1-js/08-prototypes/03-native-prototypes/2-defer-to-prototype-extended/solution.md b/1-js/08-prototypes/03-native-prototypes/2-defer-to-prototype-extended/solution.md
index 99c358c9b..3995c4fbf 100644
--- a/1-js/08-prototypes/03-native-prototypes/2-defer-to-prototype-extended/solution.md
+++ b/1-js/08-prototypes/03-native-prototypes/2-defer-to-prototype-extended/solution.md
@@ -8,17 +8,17 @@ Function.prototype.defer = function(ms) {
   }
 };
 
-// check it
+// confira
 function f(a, b) {
   alert( a + b );
 }
 
-f.defer(1000)(1, 2); // shows 3 after 1 sec
+f.defer(1000)(1, 2); // mostra 3 depois de 1 segundo
 ```
 
-Please note: we use `this` in `f.apply` to make our decoration work for object methods.
+Note que: nós usamos `this` no `f.apply` para nossa decoração funcionar para métodos de objetos.
 
-So if the wrapper function is called as an object method, then `this` is passed to the original method `f`.
+Então, se a função *wrapper* é chamada como um método de um objeto, então o this é passado para o método `f` original.
 
 ```js run
 Function.prototype.defer = function(ms) {
diff --git a/1-js/08-prototypes/03-native-prototypes/2-defer-to-prototype-extended/task.md b/1-js/08-prototypes/03-native-prototypes/2-defer-to-prototype-extended/task.md
index 4d3823bb8..37d95e3a3 100644
--- a/1-js/08-prototypes/03-native-prototypes/2-defer-to-prototype-extended/task.md
+++ b/1-js/08-prototypes/03-native-prototypes/2-defer-to-prototype-extended/task.md
@@ -2,18 +2,18 @@ importance: 4
 
 ---
 
-# Add the decorating "defer()" to functions
+# Adicione o decorador "defer()" às funções
 
-Add to the prototype of all functions the method `defer(ms)`, that returns a wrapper, delaying the call by `ms` milliseconds.
+Adicione ao protótipo de todas as funções o método `defer(ms)` que retorne um *wrapper* (invólucro), atrasando a chamada em `ms` milisegundos.
 
-Here's an example of how it should work:
+Aqui está um exemplo de como deveria funcionar:
 
 ```js
 function f(a, b) {
   alert( a + b );
 }
 
-f.defer(1000)(1, 2); // shows 3 after 1 second
+f.defer(1000)(1, 2); // mostra 3 depois de 1 segundo
 ```
 
-Please note that the arguments should be passed to the original function.
+Note que os argumentos devem ser passados para a função original.
diff --git a/1-js/08-prototypes/03-native-prototypes/article.md b/1-js/08-prototypes/03-native-prototypes/article.md
index 9cf9897b2..6f6e63855 100644
--- a/1-js/08-prototypes/03-native-prototypes/article.md
+++ b/1-js/08-prototypes/03-native-prototypes/article.md
@@ -1,33 +1,33 @@
-# Native prototypes
+# Protótipos Nativos
 
-The `"prototype"` property is widely used by the core of JavaScript itself. All built-in constructor functions use it.
+A propriedade `"prototype"` é comumente utilizada pelo núcleo do próprio JavaScript. Toda função construtora embutida a usa.
 
-We'll see how it is for plain objects first, and then for more complex ones.
+Vamos ver como é para objetos vazios primeiro, e depois para objetos mais complexos.
 
 ## Object.prototype
 
-Let's say we output an empty object:
+Digamos que a gente imprima um objeto vazio:
 
 ```js run
 let obj = {};
 alert( obj ); // "[object Object]" ?
 ```
 
-Where's the code that generates the string `"[object Object]"`? That's a built-in `toString` method, but where is it? The `obj` is empty!
+Onde está o código que gera a string `"[object Object]"`? Isso é um método embutido `toString`, mas onde ele está? O `obj` está vazio!
 
-...But the short notation `obj = {}` is the same as `obj = new Object()`, where `Object` is a built-in object constructor function, with its own `prototype` referencing a huge object with `toString` and other methods.
+... Mas a notação abreviada `obj = {}` é o mesmo que `obj = new Object()`, onde `Object` é uma função construtora embutida, com seu próprio `prototype` referenciando um objeto enorme com `toString` e outros métodos.
 
-Here's what's going on:
+Veja o que está acontecendo:
 
 ![](object-prototype.svg)
 
-When `new Object()` is called (or a literal object `{...}` is created), the `[[Prototype]]` of it is set to `Object.prototype` according to the rule that we discussed in the previous chapter:
+Quando `new Object()` é chamado (ou um objeto literal `{...}` é criado), o seu `[[Prototype]]` é configurado para o `Object.prototype` de acordo com a regra que nós discutimos no capítulo anterior:
 
 ![](object-prototype-1.svg)
 
-So then when `obj.toString()` is called the method is taken from `Object.prototype`.
+Assim, quando `obj.toString()` é chamado, o método é obtido de `Object.prototype`.
 
-We can check it like this:
+Nós podemos conferir isso assim:
 
 ```js run
 let obj = {};
@@ -38,115 +38,114 @@ alert(obj.toString === obj.__proto__.toString); //true
 alert(obj.toString === Object.prototype.toString); //true
 ```
 
-Please note that there is no additional `[[Prototype]]` in the chain above `Object.prototype`:
+Note que não há um `[[Prototype]]` adicional na cadeia acima de `Object.prototype`:
 
 ```js run
 alert(Object.prototype.__proto__); // null
 ```
 
-## Other built-in prototypes
+## Outros protótipos embutidos
 
-Other built-in objects such as `Array`, `Date`, `Function` and others also keep methods in prototypes.
+Outros objetos embutidos, como `Array`, `Date`, `Function`, entre outros, também mantém métodos nos seus protótipos.
 
-For instance, when we create an array `[1, 2, 3]`, the default `new Array()` constructor is  used internally. So the array data is written into the new object, and `Array.prototype` becomes its prototype and provides methods. That's very memory-efficient.
+Por exemplo, quando nós criamos um array `[1, 2, 3]`, a função construtura padrão `new Array()` é usada internamente. Dessa forma, os dados são escritos dentro do novo objeto, e `Array.prototype` se torna o seu protótipo e provê métodos. Isso é bem eficiente em termos de memória.
 
-By specification, all of the built-in prototypes have `Object.prototype` on the top. Sometimes people say that "everything inherits from objects".
+Pela especificação, todos os protótipos embutidos tem `Object.prototype` no topo. Algumas pessoas dizem que "tudo herda os objetos".
 
-Here's the overall picture (for 3 built-ins to fit):
+Aqui temos uma visão geral (para 3 protótipos embutidos):
 
 ![](native-prototypes-classes.svg)
 
-Let's check the prototypes manually:
+Vamos conferir os protótipos manualmente:
 
 ```js run
 let arr = [1, 2, 3];
 
-// it inherits from Array.prototype?
+// herda de Array.prototype?
 alert( arr.__proto__ === Array.prototype ); // true
 
-// then from Object.prototype?
+// e depois herda de Object.prototype?
 alert( arr.__proto__.__proto__ === Object.prototype ); // true
 
-// and null on the top.
+// e null no topo.
 alert( arr.__proto__.__proto__.__proto__ ); // null
 ```
 
-Some methods in prototypes may overlap, for instance, `Array.prototype` has its own `toString` that lists comma-delimited elements:
+Alguns métodos nos protótipos podem se sobrepor. Por exemplo, `Array.prototype` tem o seu próprio `toString` que lista os elementos separados por vírgula:
 
 ```js run
 let arr = [1, 2, 3]
-alert(arr); // 1,2,3 <-- the result of Array.prototype.toString
+alert(arr); // 1,2,3 <-- O resultado de Array.prototype.toString
 ```
 
-As we've seen before, `Object.prototype` has `toString` as well, but `Array.prototype` is closer in the chain, so the array variant is used.
+Como vimos antes, `Object.prototype` também tem o método `toString`, mas `Array.prototype` está mais perto na cadeia, então a variante da array é utilizada.
 
 
 ![](native-prototypes-array-tostring.svg)
 
-
-In-browser tools like Chrome developer console also show inheritance (`console.dir` may need to be used for built-in objects):
+Ferramentas embutidas em navegadores, como o console do desenvolvedor no Chrome, também mostram herança (objetos embutidos podem precisar usar o `console.dir`):
 
 ![](console_dir_array.png)
 
-Other built-in objects also work the same way. Even functions -- they are objects of a built-in `Function` constructor, and their methods (`call`/`apply` and others) are taken from `Function.prototype`. Functions have their own `toString` too.
+Outros objetos embutidos também trabalham da mesma forma. Até mesmo funções -- elas são objetos de um construtor `Function` embutido, e seus métodos (`call`/`apply` e outros) são obtidos de `Function.prototype`. Funções também têm seu próprio `toString`.
 
 ```js run
 function f() {}
 
 alert(f.__proto__ == Function.prototype); // true
-alert(f.__proto__.__proto__ == Object.prototype); // true, inherit from objects
+alert(f.__proto__.__proto__ == Object.prototype); // true, herdado de object
 ```
 
-## Primitives
+## Primitivos
 
-The most intricate thing happens with strings, numbers and booleans.
+As coisas mais complicadas acontecem com strings, números e boleanos.
 
-As we remember, they are not objects. But if we try to access their properties, temporary wrapper objects are created using built-in constructors `String`, `Number` and `Boolean`. They provide the methods and disappear.
+Como sabemos, eles não são objetos. Mas se nós tentarmos acessar as propriedades deles, temporariamente são criados objetos que contém os construtores embutidos `String`, `Number` and `Boolean`. Eles fornecem os métodos e disaparecem.
 
-These objects are created invisibly to us and most engines optimize them out, but the specification describes it exactly this way. Methods of these objects also reside in prototypes, available as `String.prototype`, `Number.prototype` and `Boolean.prototype`.
+Esses objetos são criados invisivelmente para nós e a maioria das engines otimizam esse processo, apesar da especificação descrevê-lo exatamente dessa forma. Os métodos desses objetos também residem nos protótipos, disponíveis como `String.prototype`, `Number.prototype` e `Boolean.prototype`.
 
-```warn header="Values `null` and `undefined` have no object wrappers"
-Special values `null` and `undefined` stand apart. They have no object wrappers, so methods and properties are not available for them. And there are no corresponding prototypes either.
+```warn header="Os valores `null` e `undefined` não têm objetos que os envolvam"
+O valores especiais `null` e `undefined` se destacam dos outros. Eles não tem objetos que os envolem, então métodos e propriedades não estão disponíveis para eles. Também não existem protótipos correspondentes.
 ```
 
-## Changing native prototypes [#native-prototype-change]
+## Mudando protótipos nativos [#native-prototype-change]
 
-Native prototypes can be modified. For instance, if we add a method to `String.prototype`,  it becomes available to all strings:
+Protótipos nativos podem ser modificados. Por exemplo, se nós adicionarmos um método a `String.prototype`, ele vai ficar disponível a todas as strings:
 
 ```js run
 String.prototype.show = function() {
   alert(this);
 };
 
-"BOOM!".show(); // BOOM!
+"BUM!".show(); // BUM!
 ```
 
-During the process of development, we may have ideas for new built-in methods we'd like to have, and we may be tempted to add them to native prototypes. But that is generally a bad idea.
+Durante o processo do desenvolvimento, nós podemos ter novas ideias de métodos embutidos que nós gostaríamos de ter, e podemos ficar tentados a adicioná-los nos protótipos nativos. Mas isso é geralmente uma má ideia.
 
 ```warn
-Prototypes are global, so it's easy to get a conflict. If two libraries add a method `String.prototype.show`, then one of them will be overwriting the other.
+Protótipos são globais, então é fácil gerar um conflito. Se duas bibliotecas adicionam um método `String.prototype.show`, uma delas estará sobrescrevendo a outra.
 
-So, generally, modifying a native prototype is considered a bad idea.
+Por isso, geralmente, modificar um protótipo nativo é considerado uma má ideia.
 ```
 
-**In modern programming, there is only one case where modifying native prototypes is approved. That's polyfilling.**
+**Na programação moderna, existe apenas um caso quando modificar protótipos nativos é aprovado: fazer polyfill (polyfilling).**
 
-Polyfilling is a term for making a substitute for a method that exists in the JavaScript specification, but is not yet supported by a particular JavaScript engine.
+*Polyfill* é um termpo para criar um substituto para um método que existe na especificação do JavaScript, mas ainda não tem suporte em alguma engine particular de JavaScript.
 
-We may then implement it manually and populate the built-in prototype with it.
+Nesse caso nós podemos implementar e popular o protótipo embutido com ele.
 
-For instance:
+Por exemplo:
 
 ```js run
-if (!String.prototype.repeat) { // if there's no such method
-  // add it to the prototype
+if (!String.prototype.repeat) { // Se não existe esse método
+  // adiciona no protótipo
 
   String.prototype.repeat = function(n) {
-    // repeat the string n times
+    // repete a string n vezes
 
-    // actually, the code should be a little bit more complex than that
-    // (the full algorithm is in the specification)
-    // but even an imperfect polyfill is often considered good enough
+    // na realidade, o código deveria ser um pouco mais complexo do que isso
+    // (o algoritmo completo está na especificação)
+    // mas mesmo imperfeito, o polyfill é geralmente considerado bom o suficiente
     return new Array(n + 1).join(this);
   };
 }
@@ -155,22 +154,22 @@ alert( "La".repeat(3) ); // LaLaLa
 ```
 
 
-## Borrowing from prototypes
+## Pegando emprestado dos protótipos
 
-In the chapter <info:call-apply-decorators#method-borrowing> we talked about method borrowing.
+No capítulo <info:call-apply-decorators#method-borrowing>, nós falamos sobre pegar métodos emprestado.
 
-That's when we take a method from one object and copy it into another.
+Isso é quando nós pegamos um método de um objeto e o copiamos para outro.
 
-Some methods of native prototypes are often borrowed.
+Alguns métodos de protótipos nativos são emprestados com muita frequência.
 
-For instance, if we're making an array-like object, we may want to copy some array methods to it.
+Por exemplo, se nós estamos fazendo um objeto parecido com um array, nós podemos querer copiar alguns métodos para ele.
 
-E.g.
+Veja um exemplo:
 
 ```js run
 let obj = {
-  0: "Hello",
-  1: "world!",
+  0: "Olá",
+  1: "mundo!",
   length: 2,
 };
 
@@ -178,21 +177,21 @@ let obj = {
 obj.join = Array.prototype.join;
 */!*
 
-alert( obj.join(',') ); // Hello,world!
+alert( obj.join(',') ); // Olá,mundo!
 ```
 
-It works because the internal algorithm of the built-in `join` method only cares about the correct indexes and the `length` property. It doesn't check if the object is indeed an array. Many built-in methods are like that.
+Ele funciona porque o algoritmo interno do método `join` embutido só precisa dos índices corretos e da propriedade `length`. Ele não confere se o objeto é de fato uma array. Muitos métodos enbutidos são assim.
 
-Another possibility is to inherit by setting `obj.__proto__` to `Array.prototype`, so all `Array` methods are automatically available in `obj`.
+Outra possibilidade é herdar configurando `obj.__proto__` para o `Array.prototype`, de forma que todos os métodos de `Array` fiquem automaticamente disponíveis em `obj`.
 
-But that's impossible if `obj` already inherits from another object. Remember, we only can inherit from one object at a time.
+Mas isso é impossível se `obj` já herda de outro objeto. Lembre-se, nós só podemos herdar de um objeto por vez.
 
-Borrowing methods is flexible, it allows to mix functionalities from different objects if needed.
+Pegar métodos emprestado é mais flexível, isso permite misturar as funcionalidades de diferentes objetos caso necessário.
 
-## Summary
+## Resumo
 
-- All built-in objects follow the same pattern:
-    - The methods are stored in the prototype (`Array.prototype`, `Object.prototype`, `Date.prototype`, etc.)
-    - The object itself stores only the data (array items, object properties, the date)
-- Primitives also store methods in prototypes of wrapper objects: `Number.prototype`, `String.prototype` and `Boolean.prototype`. Only `undefined` and `null` do not have wrapper objects
-- Built-in prototypes can be modified or populated with new methods. But it's not recommended to change them. The only allowable case is probably when we add-in a new standard, but it's not yet supported by the JavaScript engine
+- Todos os objetos enbutidos seguem o mesmo padrão:
+    - Os métodos são guardados no protótipo (`Array.prototype`, `Object.prototype`, `Date.prototype`, etc.)
+    - O objeto só guarda os dados nele mesmo (itens de array, propriedades de objetos, a data)
+- Tipos primitivos também guardam métodos em protótipos de objetos que os envolvem (como um invólucro): `Number.prototype`, `String.prototype` e `Boolean.prototype`. Apenas `undefined` e `null` que não tem objetos invólucros.
+- Protótipos embutidos podem ser modificados ou populados com novos métodos. Mas modificá-los não é recomendado. O único caso aceitável é provavelmente quando nós adicionamos um novo comportamento e ele ainda não tem suporte em alguma engine JavaScript.

From e994eaf9484816b136a786adec6830e6545a7d96 Mon Sep 17 00:00:00 2001
From: Osvaldo Dias dos Santos <vadodsantos@yahoo.com>
Date: Wed, 17 Nov 2021 22:11:51 +0100
Subject: [PATCH 02/20] Match line numbers to original.

---
 1-js/08-prototypes/03-native-prototypes/article.md | 1 +
 1 file changed, 1 insertion(+)

diff --git a/1-js/08-prototypes/03-native-prototypes/article.md b/1-js/08-prototypes/03-native-prototypes/article.md
index 6f6e63855..5faf00035 100644
--- a/1-js/08-prototypes/03-native-prototypes/article.md
+++ b/1-js/08-prototypes/03-native-prototypes/article.md
@@ -83,6 +83,7 @@ Como vimos antes, `Object.prototype` também tem o método `toString`, mas `Arra
 
 ![](native-prototypes-array-tostring.svg)
 
+
 Ferramentas embutidas em navegadores, como o console do desenvolvedor no Chrome, também mostram herança (objetos embutidos podem precisar usar o `console.dir`):
 
 ![](console_dir_array.png)

From 52dcc1607cbb7d595f7aae8f6441bb449b0b2819 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Fl=C3=A1vio=20Lima?= <flavio.hblima@gmail.com>
Date: Sat, 26 Feb 2022 20:31:42 -0300
Subject: [PATCH 03/20] Update
 1-js/08-prototypes/03-native-prototypes/article.md

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

diff --git a/1-js/08-prototypes/03-native-prototypes/article.md b/1-js/08-prototypes/03-native-prototypes/article.md
index 5faf00035..943de4200 100644
--- a/1-js/08-prototypes/03-native-prototypes/article.md
+++ b/1-js/08-prototypes/03-native-prototypes/article.md
@@ -2,7 +2,7 @@
 
 A propriedade `"prototype"` é comumente utilizada pelo núcleo do próprio JavaScript. Toda função construtora embutida a usa.
 
-Vamos ver como é para objetos vazios primeiro, e depois para objetos mais complexos.
+Vamos ver como é para objetos simples primeiro, e depois para objetos mais complexos.
 
 ## Object.prototype
 

From cfa5101874a45d225ae18dbdfcec17dff69cf5aa Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Fl=C3=A1vio=20Lima?= <flavio.hblima@gmail.com>
Date: Sat, 26 Feb 2022 20:32:03 -0300
Subject: [PATCH 04/20] Update
 1-js/08-prototypes/03-native-prototypes/article.md

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

diff --git a/1-js/08-prototypes/03-native-prototypes/article.md b/1-js/08-prototypes/03-native-prototypes/article.md
index 943de4200..60b9d0875 100644
--- a/1-js/08-prototypes/03-native-prototypes/article.md
+++ b/1-js/08-prototypes/03-native-prototypes/article.md
@@ -195,4 +195,4 @@ Pegar métodos emprestado é mais flexível, isso permite misturar as funcionali
     - Os métodos são guardados no protótipo (`Array.prototype`, `Object.prototype`, `Date.prototype`, etc.)
     - O objeto só guarda os dados nele mesmo (itens de array, propriedades de objetos, a data)
 - Tipos primitivos também guardam métodos em protótipos de objetos que os envolvem (como um invólucro): `Number.prototype`, `String.prototype` e `Boolean.prototype`. Apenas `undefined` e `null` que não tem objetos invólucros.
-- Protótipos embutidos podem ser modificados ou populados com novos métodos. Mas modificá-los não é recomendado. O único caso aceitável é provavelmente quando nós adicionamos um novo comportamento e ele ainda não tem suporte em alguma engine JavaScript.
+- Protótipos embutidos podem ser modificados ou populados com novos métodos. Mas modificá-los não é recomendado. O único caso aceitável é provavelmente quando nós adicionamos um novo comportamento e ele ainda não tem suporte em algum interpretador (*engine*) de JavaScript.

From c836a268658198fb5935d04e532a3e588adb1c3b Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Fl=C3=A1vio=20Lima?= <flavio.hblima@gmail.com>
Date: Sat, 26 Feb 2022 20:32:26 -0300
Subject: [PATCH 05/20] Update
 1-js/08-prototypes/03-native-prototypes/article.md

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

diff --git a/1-js/08-prototypes/03-native-prototypes/article.md b/1-js/08-prototypes/03-native-prototypes/article.md
index 60b9d0875..7deffeac5 100644
--- a/1-js/08-prototypes/03-native-prototypes/article.md
+++ b/1-js/08-prototypes/03-native-prototypes/article.md
@@ -194,5 +194,5 @@ Pegar métodos emprestado é mais flexível, isso permite misturar as funcionali
 - Todos os objetos enbutidos seguem o mesmo padrão:
     - Os métodos são guardados no protótipo (`Array.prototype`, `Object.prototype`, `Date.prototype`, etc.)
     - O objeto só guarda os dados nele mesmo (itens de array, propriedades de objetos, a data)
-- Tipos primitivos também guardam métodos em protótipos de objetos que os envolvem (como um invólucro): `Number.prototype`, `String.prototype` e `Boolean.prototype`. Apenas `undefined` e `null` que não tem objetos invólucros.
+- Tipos primitivos também guardam métodos em protótipos de objetos que os envolvem: `Number.prototype`, `String.prototype` e `Boolean.prototype`. Apenas `undefined` e `null` não tem objetos invólucros.
 - Protótipos embutidos podem ser modificados ou populados com novos métodos. Mas modificá-los não é recomendado. O único caso aceitável é provavelmente quando nós adicionamos um novo comportamento e ele ainda não tem suporte em algum interpretador (*engine*) de JavaScript.

From 4770f5f3e141da006a113b09c5a655c6d9a2b4b5 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Fl=C3=A1vio=20Lima?= <flavio.hblima@gmail.com>
Date: Sat, 26 Feb 2022 20:32:44 -0300
Subject: [PATCH 06/20] Update
 1-js/08-prototypes/03-native-prototypes/article.md

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

diff --git a/1-js/08-prototypes/03-native-prototypes/article.md b/1-js/08-prototypes/03-native-prototypes/article.md
index 7deffeac5..24b56909b 100644
--- a/1-js/08-prototypes/03-native-prototypes/article.md
+++ b/1-js/08-prototypes/03-native-prototypes/article.md
@@ -183,7 +183,7 @@ alert( obj.join(',') ); // Olá,mundo!
 
 Ele funciona porque o algoritmo interno do método `join` embutido só precisa dos índices corretos e da propriedade `length`. Ele não confere se o objeto é de fato uma array. Muitos métodos enbutidos são assim.
 
-Outra possibilidade é herdar configurando `obj.__proto__` para o `Array.prototype`, de forma que todos os métodos de `Array` fiquem automaticamente disponíveis em `obj`.
+Outra possibilidade é herdar configurando `obj.__proto__` para `Array.prototype`, de forma que todos os métodos de `Array` fiquem automaticamente disponíveis em `obj`.
 
 Mas isso é impossível se `obj` já herda de outro objeto. Lembre-se, nós só podemos herdar de um objeto por vez.
 

From 86e78a123a9846d4c4970030f7480d81b8aa4720 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Fl=C3=A1vio=20Lima?= <flavio.hblima@gmail.com>
Date: Sat, 26 Feb 2022 20:33:12 -0300
Subject: [PATCH 07/20] Update
 1-js/08-prototypes/03-native-prototypes/article.md

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

diff --git a/1-js/08-prototypes/03-native-prototypes/article.md b/1-js/08-prototypes/03-native-prototypes/article.md
index 24b56909b..462e24469 100644
--- a/1-js/08-prototypes/03-native-prototypes/article.md
+++ b/1-js/08-prototypes/03-native-prototypes/article.md
@@ -48,7 +48,7 @@ alert(Object.prototype.__proto__); // null
 
 Outros objetos embutidos, como `Array`, `Date`, `Function`, entre outros, também mantém métodos nos seus protótipos.
 
-Por exemplo, quando nós criamos um array `[1, 2, 3]`, a função construtura padrão `new Array()` é usada internamente. Dessa forma, os dados são escritos dentro do novo objeto, e `Array.prototype` se torna o seu protótipo e provê métodos. Isso é bem eficiente em termos de memória.
+Por exemplo, quando nós criamos um array `[1, 2, 3]`, a função construtura padrão `new Array()` é usada internamente. Dessa forma, os dados são escritos dentro do novo objeto, e `Array.prototype` se torna no seu protótipo e provê métodos. Isso é bem eficiente em termos de memória.
 
 Pela especificação, todos os protótipos embutidos tem `Object.prototype` no topo. Algumas pessoas dizem que "tudo herda os objetos".
 

From 1fdbd844433089c928d363624b1f7a000c16b2d6 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Fl=C3=A1vio=20Lima?= <flavio.hblima@gmail.com>
Date: Sat, 26 Feb 2022 20:33:22 -0300
Subject: [PATCH 08/20] Update
 1-js/08-prototypes/03-native-prototypes/article.md

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

diff --git a/1-js/08-prototypes/03-native-prototypes/article.md b/1-js/08-prototypes/03-native-prototypes/article.md
index 462e24469..edb7dd910 100644
--- a/1-js/08-prototypes/03-native-prototypes/article.md
+++ b/1-js/08-prototypes/03-native-prototypes/article.md
@@ -50,7 +50,7 @@ Outros objetos embutidos, como `Array`, `Date`, `Function`, entre outros, també
 
 Por exemplo, quando nós criamos um array `[1, 2, 3]`, a função construtura padrão `new Array()` é usada internamente. Dessa forma, os dados são escritos dentro do novo objeto, e `Array.prototype` se torna no seu protótipo e provê métodos. Isso é bem eficiente em termos de memória.
 
-Pela especificação, todos os protótipos embutidos tem `Object.prototype` no topo. Algumas pessoas dizem que "tudo herda os objetos".
+Pela especificação, todos os protótipos embutidos têm `Object.prototype` no topo. Algumas pessoas dizem que "tudo herda de objetos".
 
 Aqui temos uma visão geral (para 3 protótipos embutidos):
 

From c1fc6cf6bc535fe911b27b0dcd6feac05b4cdf0c Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Fl=C3=A1vio=20Lima?= <flavio.hblima@gmail.com>
Date: Sat, 26 Feb 2022 20:33:31 -0300
Subject: [PATCH 09/20] Update
 1-js/08-prototypes/03-native-prototypes/article.md

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

diff --git a/1-js/08-prototypes/03-native-prototypes/article.md b/1-js/08-prototypes/03-native-prototypes/article.md
index edb7dd910..566648717 100644
--- a/1-js/08-prototypes/03-native-prototypes/article.md
+++ b/1-js/08-prototypes/03-native-prototypes/article.md
@@ -78,7 +78,7 @@ let arr = [1, 2, 3]
 alert(arr); // 1,2,3 <-- O resultado de Array.prototype.toString
 ```
 
-Como vimos antes, `Object.prototype` também tem o método `toString`, mas `Array.prototype` está mais perto na cadeia, então a variante da array é utilizada.
+Como vimos antes, `Object.prototype` também tem o método `toString`, mas `Array.prototype` está mais perto na cadeia, então a variante do array é utilizada.
 
 
 ![](native-prototypes-array-tostring.svg)

From 209f35c2d7148c5595e4769e963cc5f0c45dbfb9 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Fl=C3=A1vio=20Lima?= <flavio.hblima@gmail.com>
Date: Sat, 26 Feb 2022 20:33:48 -0300
Subject: [PATCH 10/20] Update
 1-js/08-prototypes/03-native-prototypes/article.md

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

diff --git a/1-js/08-prototypes/03-native-prototypes/article.md b/1-js/08-prototypes/03-native-prototypes/article.md
index 566648717..52ec14c0d 100644
--- a/1-js/08-prototypes/03-native-prototypes/article.md
+++ b/1-js/08-prototypes/03-native-prototypes/article.md
@@ -84,7 +84,7 @@ Como vimos antes, `Object.prototype` também tem o método `toString`, mas `Arra
 ![](native-prototypes-array-tostring.svg)
 
 
-Ferramentas embutidas em navegadores, como o console do desenvolvedor no Chrome, também mostram herança (objetos embutidos podem precisar usar o `console.dir`):
+Ferramentas embutidas em navegadores, como o console do desenvolvedor no Chrome, também mostram herança (objetos embutidos podem precisar de usar o `console.dir`):
 
 ![](console_dir_array.png)
 

From 7961a937c4f755ad5234c3358c657089d97e0109 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Fl=C3=A1vio=20Lima?= <flavio.hblima@gmail.com>
Date: Sat, 26 Feb 2022 20:34:10 -0300
Subject: [PATCH 11/20] Update
 1-js/08-prototypes/03-native-prototypes/article.md

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

diff --git a/1-js/08-prototypes/03-native-prototypes/article.md b/1-js/08-prototypes/03-native-prototypes/article.md
index 52ec14c0d..2f82320a3 100644
--- a/1-js/08-prototypes/03-native-prototypes/article.md
+++ b/1-js/08-prototypes/03-native-prototypes/article.md
@@ -146,7 +146,7 @@ if (!String.prototype.repeat) { // Se não existe esse método
 
     // na realidade, o código deveria ser um pouco mais complexo do que isso
     // (o algoritmo completo está na especificação)
-    // mas mesmo imperfeito, o polyfill é geralmente considerado bom o suficiente
+    // mas mesmo um polyfill imperfeito, é geralmente considerado bom o suficiente
     return new Array(n + 1).join(this);
   };
 }

From 1a0745cce2ed5cf90dbf2bd5756d757ec85f6a32 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Fl=C3=A1vio=20Lima?= <flavio.hblima@gmail.com>
Date: Sat, 26 Feb 2022 20:34:29 -0300
Subject: [PATCH 12/20] Update
 1-js/08-prototypes/03-native-prototypes/article.md

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

diff --git a/1-js/08-prototypes/03-native-prototypes/article.md b/1-js/08-prototypes/03-native-prototypes/article.md
index 2f82320a3..4effe6af1 100644
--- a/1-js/08-prototypes/03-native-prototypes/article.md
+++ b/1-js/08-prototypes/03-native-prototypes/article.md
@@ -163,7 +163,7 @@ Isso é quando nós pegamos um método de um objeto e o copiamos para outro.
 
 Alguns métodos de protótipos nativos são emprestados com muita frequência.
 
-Por exemplo, se nós estamos fazendo um objeto parecido com um array, nós podemos querer copiar alguns métodos para ele.
+Por exemplo, se nós estamos fazendo um objeto parecido com um array, nós podemos querer copiar alguns métodos de array para ele.
 
 Veja um exemplo:
 

From 197c4f294226e41866ec286564f2a90dc73f86c1 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Fl=C3=A1vio=20Lima?= <flavio.hblima@gmail.com>
Date: Sat, 26 Feb 2022 20:34:48 -0300
Subject: [PATCH 13/20] Update
 1-js/08-prototypes/03-native-prototypes/article.md

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

diff --git a/1-js/08-prototypes/03-native-prototypes/article.md b/1-js/08-prototypes/03-native-prototypes/article.md
index 4effe6af1..f1986aa69 100644
--- a/1-js/08-prototypes/03-native-prototypes/article.md
+++ b/1-js/08-prototypes/03-native-prototypes/article.md
@@ -103,7 +103,7 @@ As coisas mais complicadas acontecem com strings, números e boleanos.
 
 Como sabemos, eles não são objetos. Mas se nós tentarmos acessar as propriedades deles, temporariamente são criados objetos que contém os construtores embutidos `String`, `Number` and `Boolean`. Eles fornecem os métodos e disaparecem.
 
-Esses objetos são criados invisivelmente para nós e a maioria das engines otimizam esse processo, apesar da especificação descrevê-lo exatamente dessa forma. Os métodos desses objetos também residem nos protótipos, disponíveis como `String.prototype`, `Number.prototype` e `Boolean.prototype`.
+Esses objetos são criados invisivelmente para nós e a maioria dos interpretadores (*engines*) otimizam esse processo, apesar da especificação descrevê-lo exatamente dessa forma. Os métodos desses objetos também residem nos protótipos, disponíveis como `String.prototype`, `Number.prototype` e `Boolean.prototype`.
 
 ```warn header="Os valores `null` e `undefined` não têm objetos que os envolvam"
 O valores especiais `null` e `undefined` se destacam dos outros. Eles não tem objetos que os envolem, então métodos e propriedades não estão disponíveis para eles. Também não existem protótipos correspondentes.

From 926a671036b636169b470af7161cb4781ee31420 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Fl=C3=A1vio=20Lima?= <flavio.hblima@gmail.com>
Date: Sat, 26 Feb 2022 20:35:05 -0300
Subject: [PATCH 14/20] Update
 1-js/08-prototypes/03-native-prototypes/article.md

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

diff --git a/1-js/08-prototypes/03-native-prototypes/article.md b/1-js/08-prototypes/03-native-prototypes/article.md
index f1986aa69..dcd85ca7c 100644
--- a/1-js/08-prototypes/03-native-prototypes/article.md
+++ b/1-js/08-prototypes/03-native-prototypes/article.md
@@ -106,7 +106,7 @@ Como sabemos, eles não são objetos. Mas se nós tentarmos acessar as proprieda
 Esses objetos são criados invisivelmente para nós e a maioria dos interpretadores (*engines*) otimizam esse processo, apesar da especificação descrevê-lo exatamente dessa forma. Os métodos desses objetos também residem nos protótipos, disponíveis como `String.prototype`, `Number.prototype` e `Boolean.prototype`.
 
 ```warn header="Os valores `null` e `undefined` não têm objetos que os envolvam"
-O valores especiais `null` e `undefined` se destacam dos outros. Eles não tem objetos que os envolem, então métodos e propriedades não estão disponíveis para eles. Também não existem protótipos correspondentes.
+O valores especiais `null` e `undefined` se destacam dos outros. Eles não têm objetos que os envolem, então métodos e propriedades não estão disponíveis para eles. Também não existem protótipos correspondentes.
 ```
 
 ## Mudando protótipos nativos [#native-prototype-change]

From aa5ca52a52784711095c5b1495ea0e7c3d0f9f6c Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Fl=C3=A1vio=20Lima?= <flavio.hblima@gmail.com>
Date: Sat, 26 Feb 2022 20:35:17 -0300
Subject: [PATCH 15/20] Update
 1-js/08-prototypes/03-native-prototypes/article.md

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

diff --git a/1-js/08-prototypes/03-native-prototypes/article.md b/1-js/08-prototypes/03-native-prototypes/article.md
index dcd85ca7c..c5f11c290 100644
--- a/1-js/08-prototypes/03-native-prototypes/article.md
+++ b/1-js/08-prototypes/03-native-prototypes/article.md
@@ -121,7 +121,7 @@ String.prototype.show = function() {
 "BUM!".show(); // BUM!
 ```
 
-Durante o processo do desenvolvimento, nós podemos ter novas ideias de métodos embutidos que nós gostaríamos de ter, e podemos ficar tentados a adicioná-los nos protótipos nativos. Mas isso é geralmente uma má ideia.
+Durante o processo do desenvolvimento, nós podemos ter novas ideias de métodos embutidos que nós gostaríamos de ter, e podemos ficar tentados a adicioná-los aos protótipos nativos. Mas isso é geralmente uma má ideia.
 
 ```warn
 Protótipos são globais, então é fácil gerar um conflito. Se duas bibliotecas adicionam um método `String.prototype.show`, uma delas estará sobrescrevendo a outra.

From 54b79a75d3e7570c875546b1a12817fc258f39ab Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Fl=C3=A1vio=20Lima?= <flavio.hblima@gmail.com>
Date: Sat, 26 Feb 2022 20:35:32 -0300
Subject: [PATCH 16/20] Update
 1-js/08-prototypes/03-native-prototypes/article.md

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

diff --git a/1-js/08-prototypes/03-native-prototypes/article.md b/1-js/08-prototypes/03-native-prototypes/article.md
index c5f11c290..c68149028 100644
--- a/1-js/08-prototypes/03-native-prototypes/article.md
+++ b/1-js/08-prototypes/03-native-prototypes/article.md
@@ -129,7 +129,7 @@ Protótipos são globais, então é fácil gerar um conflito. Se duas biblioteca
 Por isso, geralmente, modificar um protótipo nativo é considerado uma má ideia.
 ```
 
-**Na programação moderna, existe apenas um caso quando modificar protótipos nativos é aprovado: fazer polyfill (polyfilling).**
+**Na programação moderna, existe apenas um caso erm que modificar protótipos nativos é aprovado: fazer polyfill (polyfilling).**
 
 *Polyfill* é um termpo para criar um substituto para um método que existe na especificação do JavaScript, mas ainda não tem suporte em alguma engine particular de JavaScript.
 

From 2b3585786444d62e67cc995cedd5a68c3e9c0af0 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Fl=C3=A1vio=20Lima?= <flavio.hblima@gmail.com>
Date: Sat, 26 Feb 2022 20:36:40 -0300
Subject: [PATCH 17/20] Update
 1-js/08-prototypes/03-native-prototypes/article.md

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

diff --git a/1-js/08-prototypes/03-native-prototypes/article.md b/1-js/08-prototypes/03-native-prototypes/article.md
index c68149028..2f35c784f 100644
--- a/1-js/08-prototypes/03-native-prototypes/article.md
+++ b/1-js/08-prototypes/03-native-prototypes/article.md
@@ -131,7 +131,7 @@ Por isso, geralmente, modificar um protótipo nativo é considerado uma má idei
 
 **Na programação moderna, existe apenas um caso erm que modificar protótipos nativos é aprovado: fazer polyfill (polyfilling).**
 
-*Polyfill* é um termpo para criar um substituto para um método que existe na especificação do JavaScript, mas ainda não tem suporte em alguma engine particular de JavaScript.
+*Polyfill* é um termpo para criar um substituto para um método que existe na especificação do JavaScript, mas ainda não tem suporte em algum interpretador particular de JavaScript.
 
 Nesse caso nós podemos implementar e popular o protótipo embutido com ele.
 

From fa8bf24fb5028f939b28ae820ac138bc890fec5e Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Fl=C3=A1vio=20Lima?= <flavio.hblima@gmail.com>
Date: Sat, 26 Feb 2022 20:36:53 -0300
Subject: [PATCH 18/20] Update
 1-js/08-prototypes/03-native-prototypes/article.md

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

diff --git a/1-js/08-prototypes/03-native-prototypes/article.md b/1-js/08-prototypes/03-native-prototypes/article.md
index 2f35c784f..816ede7ab 100644
--- a/1-js/08-prototypes/03-native-prototypes/article.md
+++ b/1-js/08-prototypes/03-native-prototypes/article.md
@@ -133,7 +133,7 @@ Por isso, geralmente, modificar um protótipo nativo é considerado uma má idei
 
 *Polyfill* é um termpo para criar um substituto para um método que existe na especificação do JavaScript, mas ainda não tem suporte em algum interpretador particular de JavaScript.
 
-Nesse caso nós podemos implementar e popular o protótipo embutido com ele.
+Nesse caso nós podemos implementar e preencher o protótipo embutido com ele.
 
 Por exemplo:
 

From 8842a5987793d0b335ecec463a2656deb2f33550 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Fl=C3=A1vio=20Lima?= <flavio.hblima@gmail.com>
Date: Sat, 26 Feb 2022 20:37:03 -0300
Subject: [PATCH 19/20] Update
 1-js/08-prototypes/03-native-prototypes/article.md

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

diff --git a/1-js/08-prototypes/03-native-prototypes/article.md b/1-js/08-prototypes/03-native-prototypes/article.md
index 816ede7ab..c7dfd938d 100644
--- a/1-js/08-prototypes/03-native-prototypes/article.md
+++ b/1-js/08-prototypes/03-native-prototypes/article.md
@@ -139,7 +139,7 @@ Por exemplo:
 
 ```js run
 if (!String.prototype.repeat) { // Se não existe esse método
-  // adiciona no protótipo
+  // adiciona ao protótipo
 
   String.prototype.repeat = function(n) {
     // repete a string n vezes

From 06ba0db301e6439fb8b738912792453a58d96c3f Mon Sep 17 00:00:00 2001
From: Jonnathan Santos <jonnathan.lacerda.santos@gmail.com>
Date: Sat, 1 Jun 2024 12:18:47 -0300
Subject: [PATCH 20/20] refactor: fixes merge conflict, notes according to PR
 review and adds pending translations

---
 .../1-defer-to-prototype/task.md              |  2 +-
 .../2-defer-to-prototype-extended/solution.md |  2 +-
 .../03-native-prototypes/article.md           | 52 +++++++++----------
 3 files changed, 28 insertions(+), 28 deletions(-)

diff --git a/1-js/08-prototypes/03-native-prototypes/1-defer-to-prototype/task.md b/1-js/08-prototypes/03-native-prototypes/1-defer-to-prototype/task.md
index 25677bc28..a7196ce38 100644
--- a/1-js/08-prototypes/03-native-prototypes/1-defer-to-prototype/task.md
+++ b/1-js/08-prototypes/03-native-prototypes/1-defer-to-prototype/task.md
@@ -6,7 +6,7 @@ importance: 5
 
 Adicione ao protótipo de todas as funções o método `defer(ms)`, que executa a função depois de `ms` milisegundos.
 
-Depois de fazer isso, este código deveria funcionar:
+Depois de fazer isso, esse código deve funcionar:
 
 ```js
 function f() {
diff --git a/1-js/08-prototypes/03-native-prototypes/2-defer-to-prototype-extended/solution.md b/1-js/08-prototypes/03-native-prototypes/2-defer-to-prototype-extended/solution.md
index 3995c4fbf..1da096de6 100644
--- a/1-js/08-prototypes/03-native-prototypes/2-defer-to-prototype-extended/solution.md
+++ b/1-js/08-prototypes/03-native-prototypes/2-defer-to-prototype-extended/solution.md
@@ -18,7 +18,7 @@ f.defer(1000)(1, 2); // mostra 3 depois de 1 segundo
 
 Note que: nós usamos `this` no `f.apply` para nossa decoração funcionar para métodos de objetos.
 
-Então, se a função *wrapper* é chamada como um método de um objeto, então o this é passado para o método `f` original.
+Então, se a função *wrapper* for chamada como um método de objeto, o `this` é passado para o método `f` original.
 
 ```js run
 Function.prototype.defer = function(ms) {
diff --git a/1-js/08-prototypes/03-native-prototypes/article.md b/1-js/08-prototypes/03-native-prototypes/article.md
index 43a26ee83..77138fdf7 100644
--- a/1-js/08-prototypes/03-native-prototypes/article.md
+++ b/1-js/08-prototypes/03-native-prototypes/article.md
@@ -1,27 +1,27 @@
 # Protótipos Nativos
 
-A propriedade `"prototype"` é comumente utilizada pelo núcleo do próprio JavaScript. Toda função construtora embutida a usa.
+A propriedade `"prototype"` é amplamente utilizada pelo próprio núcleo do JavaScript. Todas as funções construtoras integradas o utilizam.
 
-First we'll look at the details, and then how to use it for adding new capabilities to built-in objects.
+Primeiro veremos os detalhes e depois como usá-lo para adicionar novos recursos a objetos integrados.
 
 ## Object.prototype
 
-Digamos que a gente imprima um objeto vazio:
+Digamos que produzimos um objeto vazio:
 
 ```js run
 let obj = {};
 alert( obj ); // "[object Object]" ?
 ```
 
-Onde está o código que gera a string `"[object Object]"`? Isso é um método embutido `toString`, mas onde ele está? O `obj` está vazio!
+Onde está o código que gera a string `"[object Object]"`? Isto vem de um método embutido `toString`, mas onde ele está? O `obj` está vazio!
 
-... Mas a notação abreviada `obj = {}` é o mesmo que `obj = new Object()`, onde `Object` é uma função construtora embutida, com seu próprio `prototype` referenciando um objeto enorme com `toString` e outros métodos.
+... A notação abreviada `obj = {}` é o mesmo que `obj = new Object()`. Onde `Object` é uma função construtora embutida, com o seu próprio `prototype` referenciando um objeto enorme, possuindo `toString` e outros métodos.
 
 Veja o que está acontecendo:
 
 ![](object-prototype.svg)
 
-Quando `new Object()` é chamado (ou um objeto literal `{...}` é criado), o seu `[[Prototype]]` é configurado para o `Object.prototype` de acordo com a regra que nós discutimos no capítulo anterior:
+Quando `new Object()` é invocado (ou um objeto literal `{...}` é criado), o seu `[[Prototype]]` é configurado para o `Object.prototype`, de acordo com a regra que nós discutimos no capítulo anterior:
 
 ![](object-prototype-1.svg)
 
@@ -38,7 +38,7 @@ alert(obj.toString === obj.__proto__.toString); //true
 alert(obj.toString === Object.prototype.toString); //true
 ```
 
-Please note that there is no more `[[Prototype]]` in the chain above `Object.prototype`:
+Observe que não há mais `[[Prototype]]` na cadeia acima de `Object.prototype`:
 
 ```js run
 alert(Object.prototype.__proto__); // null
@@ -46,11 +46,11 @@ alert(Object.prototype.__proto__); // null
 
 ## Outros protótipos embutidos
 
-Outros objetos embutidos, como `Array`, `Date`, `Function`, entre outros, também mantém métodos nos seus protótipos.
+Outros objetos embutidos, como `Array`, `Date`, `Function`, etc., também têm métodos nos seus protótipos.
 
-For instance, when we create an array `[1, 2, 3]`, the default `new Array()` constructor is used internally. So `Array.prototype` becomes its prototype and provides methods. That's very memory-efficient.
+Por exemplo, quando criamos um array `[1, 2, 3]`, o construtor padrão `new Array()` é usado internamente. Então `Array.prototype` se torna seu protótipo e fornece métodos. Isso é muito eficiente em termos de memória.
 
-By specification, all of the built-in prototypes have `Object.prototype` on the top. That's why some people say that "everything inherits from objects".
+Por especificação, todos os protótipos integrados têm `Object.prototype` no topo. É por isso que algumas pessoas dizem que “tudo herda dos objetos”.
 
 Aqui temos uma visão geral (para 3 protótipos embutidos):
 
@@ -64,7 +64,7 @@ let arr = [1, 2, 3];
 // herda de Array.prototype?
 alert( arr.__proto__ === Array.prototype ); // true
 
-// e depois herda de Object.prototype?
+// a seguir herda de Object.prototype?
 alert( arr.__proto__.__proto__ === Object.prototype ); // true
 
 // e null no topo.
@@ -84,11 +84,11 @@ Como vimos antes, `Object.prototype` também tem o método `toString`, mas `Arra
 ![](native-prototypes-array-tostring.svg)
 
 
-Ferramentas embutidas em navegadores, como o console do desenvolvedor no Chrome, também mostram herança (objetos embutidos podem precisar de usar o `console.dir`):
+Ferramentas embutidas em navegadores, como o console do desenvolvedor no Chrome, também mostram herança (para objetos embutidos pode ser preciso usar `console.dir`):
 
 ![](console_dir_array.png)
 
-Outros objetos embutidos também trabalham da mesma forma. Até mesmo funções -- elas são objetos de um construtor `Function` embutido, e seus métodos (`call`/`apply` e outros) são obtidos de `Function.prototype`. Funções também têm seu próprio `toString`.
+Outros objetos embutidos também trabalham da mesma forma. Até mesmo funções -- elas são objetos de um construtor `Function` embutido, e os seus métodos (`call`/`apply`, e outros) são obtidos de `Function.prototype`. Funções também têm o seu próprio `toString`.
 
 ```js run
 function f() {}
@@ -101,9 +101,9 @@ alert(f.__proto__.__proto__ == Object.prototype); // true, herdado de object
 
 As coisas mais complicadas acontecem com strings, números e boleanos.
 
-Como sabemos, eles não são objetos. Mas se nós tentarmos acessar as propriedades deles, temporariamente são criados objetos que contém os construtores embutidos `String`, `Number` and `Boolean`. Eles fornecem os métodos e disaparecem.
+Como sabemos, eles não são objetos. Mas se nós tentarmos acessar as propriedades deles, temporariamente são criados objetos usando os construtores embutidos `String`, `Number` and `Boolean`. Esses objetos fornecem os métodos e desaparecem.
 
-Esses objetos são criados invisivelmente para nós e a maioria dos interpretadores (*engines*) otimizam esse processo, apesar da especificação descrevê-lo exatamente dessa forma. Os métodos desses objetos também residem nos protótipos, disponíveis como `String.prototype`, `Number.prototype` e `Boolean.prototype`.
+Esses objetos são criados invisivelmente para nós e a maioria dos interpretadores (*engines*) otimizam esse processo, apesar da especificação descrevê-lo exatamente desta forma. Os métodos desses objetos também residem nos protótipos, disponíveis como `String.prototype`, `Number.prototype` e `Boolean.prototype`.
 
 ```warn header="Os valores `null` e `undefined` não têm objetos que os envolvam"
 O valores especiais `null` e `undefined` se destacam dos outros. Eles não têm objetos que os envolem, então métodos e propriedades não estão disponíveis para eles. Também não existem protótipos correspondentes.
@@ -121,19 +121,19 @@ String.prototype.show = function() {
 "BUM!".show(); // BUM!
 ```
 
-Durante o processo do desenvolvimento, nós podemos ter novas ideias de métodos embutidos que nós gostaríamos de ter, e podemos ficar tentados a adicioná-los aos protótipos nativos. Mas isso é geralmente uma má ideia.
+Durante o processo de desenvolvimento, nós podemos ter novas ideias de métodos embutidos que gostaríamos de ter, e podemos ficar tentados a adicioná-los aos protótipos nativos. Mas isso é geralmente uma má ideia.
 
 ```warn
-Prototypes are global, so it's easy to get a conflict. If two libraries add a method `String.prototype.show`, then one of them will be overwriting the method of the other.
+Os protótipos são globais, por isso é fácil criar conflitos. Se duas bibliotecas adicionarem um método `String.prototype.show`, então uma delas substituirá o método da outra.
 
 Por isso, geralmente, modificar um protótipo nativo é considerado uma má ideia.
 ```
 
 **Na programação moderna, existe apenas um caso erm que modificar protótipos nativos é aprovado: fazer polyfill (polyfilling).**
 
-*Polyfill* é um termpo para criar um substituto para um método que existe na especificação do JavaScript, mas ainda não tem suporte em algum interpretador particular de JavaScript.
+*Polyfill* é um termo para criar um substituto para um método que existe na especificação, mas que ainda não tem suporte em um particular interpretador de JavaScript.
 
-Nesse caso nós podemos implementar e preencher o protótipo embutido com ele.
+Nesse caso nós o podemos implementar e preencher o protótipo embutido com ele.
 
 Por exemplo:
 
@@ -157,13 +157,13 @@ alert( "La".repeat(3) ); // LaLaLa
 
 ## Pegando emprestado dos protótipos
 
-No capítulo <info:call-apply-decorators#method-borrowing>, nós falamos sobre pegar métodos emprestado.
+No capítulo <info:call-apply-decorators#method-borrowing>, nós falamos sobre pegar métodos emprestados.
 
 Isso é quando nós pegamos um método de um objeto e o copiamos para outro.
 
 Alguns métodos de protótipos nativos são emprestados com muita frequência.
 
-For instance, if we're making an array-like object, we may want to copy some `Array` methods to it.
+Por exemplo, se estivermos criando um objeto semelhante a um array, podemos querer copiar alguns métodos `Array` para ele.
 
 Veja um exemplo:
 
@@ -183,16 +183,16 @@ alert( obj.join(',') ); // Olá,mundo!
 
 Ele funciona porque o algoritmo interno do método `join` embutido só precisa dos índices corretos e da propriedade `length`. Ele não confere se o objeto é de fato uma array. Muitos métodos enbutidos são assim.
 
-Outra possibilidade é herdar configurando `obj.__proto__` para `Array.prototype`, de forma que todos os métodos de `Array` fiquem automaticamente disponíveis em `obj`.
+Outra possibilidade é herdando, configurando `obj.__proto__` para `Array.prototype`, de forma que todos os métodos de `Array` fiquem automaticamente disponíveis em `obj`.
 
 Mas isso é impossível se `obj` já herda de outro objeto. Lembre-se, nós só podemos herdar de um objeto por vez.
 
-Pegar métodos emprestado é mais flexível, isso permite misturar as funcionalidades de diferentes objetos caso necessário.
+Pegar métodos emprestados é mais flexível, isso permite misturar as funcionalidades de diferentes objetos caso necessário.
 
 ## Resumo
 
-- Todos os objetos enbutidos seguem o mesmo padrão:
+- Todos os objetos embutidos seguem o mesmo padrão:
     - Os métodos são guardados no protótipo (`Array.prototype`, `Object.prototype`, `Date.prototype`, etc.)
-    - O objeto só guarda os dados nele mesmo (itens de array, propriedades de objetos, a data)
+    - O objeto só guarda os dados nele mesmo (itens de array, propriedades de objetos, uma data)
 - Tipos primitivos também guardam métodos em protótipos de objetos que os envolvem: `Number.prototype`, `String.prototype` e `Boolean.prototype`. Apenas `undefined` e `null` não tem objetos invólucros.
-- Protótipos embutidos podem ser modificados ou populados com novos métodos. Mas modificá-los não é recomendado. O único caso aceitável é provavelmente quando nós adicionamos um novo comportamento e ele ainda não tem suporte em algum interpretador (*engine*) de JavaScript.
+- Protótipos embutidos podem ser modificados ou populados com novos métodos. Mas modificá-los não é recomendado. O único caso aceitável, é provavelmente quando nós adicionamos um novo comportamento que ainda não tem suporte em algum interpretador (*engine*) de JavaScript.