docs: fix translation mistakes

Author: danilolmc

1-js/99-js-misc/01-proxy/01-error-nonexisting/task.md

@@ -2,9 +2,9 @@
 
 Normalmente, uma tentativa de ler uma propriedade inexistente retorna `undefined`.
 
-Crie um proxy que lança um erro ao tentar ler uma propriedade inexistente
+Crie um proxy que lança um erro numa tentativa de ler uma propriedade inexistente.
 
-Isso pode ajudar a detectar problemas de programação antecipadamente.
+Isso pode ajudar a detectar erros de programação antecipadamente.
 
 Escreva uma função `wrap(target)` que recebe um objeto `target` e retorna um proxy que adiciona esse aspecto funcional
 

1-js/99-js-misc/01-proxy/02-array-negative/solution.md

@@ -5,8 +5,8 @@ let array = [1, 2, 3];
 array = new Proxy(array, {
   get(target, prop, receiver) {
     if (prop < 0) {
-      // messmo se acessarmos como arr[1]
-      // prop é uma string, então é necessário convertê-la para número.
+      // mesmo se acessarmos como arr[1]
+      // prop é uma string, então é necessário convertê-la para um número.
       prop = +prop + target.length;
     }
     return Reflect.get(target, prop, receiver);

1-js/99-js-misc/01-proxy/02-array-negative/task.md

@@ -3,14 +3,14 @@
 
 Em algumas linguagens de programação, podemos acessar elementos de um array usando índices negativos, contados a partir do final.
 
-Dessa forma :
+Assim:
 
 ```js
 let array = [1, 2, 3];
 
 array[-1]; // 3, o último elemento
-array[-2]; // 2, uma posição a partir do final
-array[-3]; // 1, duas posições a partir do final
+array[-2]; // 2, uma posição a partir da última
+array[-3]; // 1, duas posições a partir da última
 ```
 
 Em outras palavras, `array[-N]` é o mesmo que `array[array.length - N]`.

1-js/99-js-misc/01-proxy/03-observable/solution.md

@@ -1,17 +1,16 @@
 A solução consiste em duas partes:
 
-
-1. Sempre que `.observe(handler)` for chamado, precisamos lembrar do manipulador em algum lugar, para ser capaz de chamá-lo depois. Podemos armazenar os manipuladores no próprio objeto, usando nosso symbol como chave da propriedade.
-2. Precisamos de um proxy com um `set` para chamar todos os manipuladores caso de aconteça qualquer alteração.
+1. Sempre que `.observe(handler)` for chamado, precisamos lembrar handler em algum lugar, para ser possível chamá-lo mais tarde. Podemos armazenar os handlers diretamente no objeto, usando nosso symbol como chave da propriedade.
+2. Precisamos de um proxy com uma armadilha (trap) `set` para chamar os handlers no caso de alguma mudança.
 
 ```js run
 let handlers = Symbol('handlers');
 
 function makeObservable(target) {
-  // 1. inicializa o armazenamento de manipuladores
+  // 1. Inicializa o armazenamento de manipuladores
   target[handlers] = [];
 
-  // Armazena a função manipuladora no array para futuras chamadas
+  // Armazena a função handler no array para futuras chamadas
   target.observe = function(handler) {
     this[handlers].push(handler);
   };
@@ -20,8 +19,8 @@ function makeObservable(target) {
   return new Proxy(target, {
     set(target, property, value, receiver) {
       let success = Reflect.set(...arguments); // Encaminha a operação para o objeto
-      if (success) { // Se não houver erro ao definir a propriedade
-        // chama rodos os manipuladores
+      if (success) { // Se não houve erro ao definir a propriedade
+        // chama rodos os handlers
         target[handlers].forEach(handler => handler(property, value));
       }
       return success;

1-js/99-js-misc/01-proxy/03-observable/task.md

@@ -3,7 +3,7 @@
 
 Crie uma função makeObservable(target) que "torna o objeto observável" ao retornar um proxy.
 
-Veja como deveria funcionar:
+Aqui está como deveria funcionar:
 
 ```js run
 function makeObservable(target) {
@@ -17,11 +17,11 @@ user.observe((key, value) => {
   alert(`SET ${key}=${value}`);
 });
 
-user.name = "John"; // alerts: SET name=John
+user.name = "John"; // alerta: SET name=John
 ```
 
-Em outras palavras, um objeto retornado por makeObservable é como o original, mas também tem o método `observe(handler)` que define a função `handler` a ser chamada em qualquer alteração de propriedade.
+Em outras palavras, um objeto retornado por `makeObservable` é exatamente como o original, mas também possui o método `observe(handler)` que define a função `handler` para ser chamada em qualquer alteração de propriedade.
 
 Sempre que uma propriedade muda, `handler(key, value)` é chamado com o nome e o valor da propriedade.
 
-P.S. Nessa tarefa, preocupe-se apenas com a escrita em uma propriedade. Outras operações podem ser implementadas de maneira semelhante.
+P.S. Nesta tarefa, preocupe-se apenas com a escrita em uma propriedade. Outras operações podem ser implementadas de maneira semelhante.