From 65377ed336dd7a6ee998a49b29acb4ed483e2a68 Mon Sep 17 00:00:00 2001
From: Gabriel Fernandes Silva <ga3riel.fernandess@gmail.com>
Date: Thu, 21 Sep 2023 17:16:46 -0300
Subject: [PATCH 01/14] translate introduction

---
 1-js/05-data-types/07-map-set/article.md | 12 ++++++------
 1 file changed, 6 insertions(+), 6 deletions(-)

diff --git a/1-js/05-data-types/07-map-set/article.md b/1-js/05-data-types/07-map-set/article.md
index 37f5e48c2..e7d7e1a82 100644
--- a/1-js/05-data-types/07-map-set/article.md
+++ b/1-js/05-data-types/07-map-set/article.md
@@ -1,12 +1,12 @@
 
-# Map and Set
+# Map e Set
 
-Till now, we've learned about the following complex data structures:
+Até agora, aprendemos sobre as seguintes estruturas de dados complexas:
 
-- Objects are used for storing keyed collections.
-- Arrays are used for storing ordered collections.
+- Objetos são usados para armazenar coleções indexadas.
+- Arrays são usados para armazenar coleções ordenadas.
 
-But that's not enough for real life. That's why `Map` and `Set` also exist.
+Mas isso não é suficiente para a vida real. É por isso que `Map` e `Set` também existem.
 
 ## Map
 
@@ -78,7 +78,7 @@ visitsCountObj[john] = 123; // try to use john object as the key, ben object wil
 
 *!*
 // That's what got written!
-alert( visitsCountObj["[object Object]"] ); // 123 
+alert( visitsCountObj["[object Object]"] ); // 123
 */!*
 ```
 

From 9e0410b897707367c42ccd6154e3584a26b3a108 Mon Sep 17 00:00:00 2001
From: Gabriel Fernandes Silva <ga3riel.fernandess@gmail.com>
Date: Thu, 21 Sep 2023 22:49:22 -0300
Subject: [PATCH 02/14] translate section map

---
 1-js/05-data-types/07-map-set/article.md | 70 ++++++++++++------------
 1 file changed, 35 insertions(+), 35 deletions(-)

diff --git a/1-js/05-data-types/07-map-set/article.md b/1-js/05-data-types/07-map-set/article.md
index e7d7e1a82..b23f67dae 100644
--- a/1-js/05-data-types/07-map-set/article.md
+++ b/1-js/05-data-types/07-map-set/article.md
@@ -10,88 +10,88 @@ Mas isso não é suficiente para a vida real. É por isso que `Map` e `Set` tamb
 
 ## Map
 
-[Map](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Map) is a collection of keyed data items, just like an `Object`. But the main difference is that `Map` allows keys of any type.
+[Map](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Map) é uma coleção de itens de dados indexados, assim como um `Object`. Mas a principal diferença é que `Map` permite chaves de qualquer tipo.
 
-Methods and properties are:
+Métodos e propriedades são:
 
-- [`new Map()`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Map/Map) -- creates the map.
-- [`map.set(key, value)`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Map/set) -- stores the value by the key.
-- [`map.get(key)`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Map/get) -- returns the value by the key, `undefined` if `key` doesn't exist in map.
-- [`map.has(key)`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Map/has) -- returns `true` if the `key` exists, `false` otherwise.
-- [`map.delete(key)`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Map/delete) -- removes the element (the key/value pair) by the key.
-- [`map.clear()`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Map/clear) -- removes everything from the map.
-- [`map.size`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Map/size) -- returns the current element count.
+- [`new Map()`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Map/Map) -- cria o mapa.
+- [`map.set(chave, valor)`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Map/set) -- armazena o valor pela chave.
+- [`map.get(chave)`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Map/get) -- retorna o valor pela chave, `undefined` se a `chave` não existir no mapa.
+- [`map.has(chave)`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Map/has) -- retorna `true` se a `chave` existir, `false` caso contrário.
+- [`map.delete(chave)`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Map/delete) -- remove o elemento (o par chave/valor) pela chave.
+- [`map.clear()`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Map/clear) -- remove tudo do mapa.
+- [`map.size`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Map/size) -- retorna a contagem atual de elementos.
 
-For instance:
+Por exemplo:
 
 ```js run
 let map = new Map();
 
-map.set('1', 'str1');   // a string key
-map.set(1, 'num1');     // a numeric key
-map.set(true, 'bool1'); // a boolean key
+map.set('1', 'str1');   // uma chave de string
+map.set(1, 'num1');     // uma chave numérica
+map.set(true, 'bool1'); // uma chave booleana
 
-// remember the regular Object? it would convert keys to string
-// Map keeps the type, so these two are different:
+// lembra do objeto normal? Ele converteria as chaves para string
+// Map mantém o tipo, então esses dois são diferentes:
 alert( map.get(1)   ); // 'num1'
 alert( map.get('1') ); // 'str1'
 
 alert( map.size ); // 3
 ```
 
-As we can see, unlike objects, keys are not converted to strings. Any type of key is possible.
+Como podemos ver, ao contrário de objetos, as chaves não são convertidas em strings. Qualquer tipo de chave é possível.
 
-```smart header="`map[key]` isn't the right way to use a `Map`"
-Although `map[key]` also works, e.g. we can set `map[key] = 2`, this is treating `map` as a plain JavaScript object, so it implies all corresponding limitations (only string/symbol keys and so on).
+```smart header="`map[chave]` não é a maneira correta de usar um `Map`"
+Embora `map[chave]` também funcione, por exemplo, podemos definir `map[chave] = 2`, isso trata o `map` como um objeto JavaScript simples, o que implica todas as limitações correspondentes (apenas chaves de string/símbolo, entre outras).
 
-So we should use `map` methods: `set`, `get` and so on.
+Portanto, devemos usar os métodos do `map`: `set`, `get` e assim por diante.
 ```
 
-**Map can also use objects as keys.**
+**Map também pode usar objetos como chaves.**
 
-For instance:
+Por exemplo:
 
 ```js run
 let john = { name: "John" };
 
-// for every user, let's store their visits count
+// para cada usuário, vamos armazenar a contagem de suas visitas.
 let visitsCountMap = new Map();
 
-// john is the key for the map
+// john é a chave para o mapa
 visitsCountMap.set(john, 123);
 
 alert( visitsCountMap.get(john) ); // 123
 ```
 
-Using objects as keys is one of the most notable and important `Map` features. The same does not count for `Object`. String as a key in `Object` is fine, but we can't use another `Object` as a key in `Object`.
+Usar objetos como chaves é uma das características mais notáveis e importantes do `Map`. O mesmo não se aplica ao `Object`. Usar uma string como chave em um `Object` é aceitável, mas não podemos usar outro `Object` como chave em um `Object`.
 
-Let's try:
+Vamos tentar:
 
 ```js run
 let john = { name: "John" };
 let ben = { name: "Ben" };
 
-let visitsCountObj = {}; // try to use an object
+let visitsCountObj = {}; // tente usar um objeto
 
-visitsCountObj[ben] = 234; // try to use ben object as the key
-visitsCountObj[john] = 123; // try to use john object as the key, ben object will get replaced
+visitsCountObj[ben] = 234; // tente usar o objeto ben como chave
+visitsCountObj[john] = 123; // tente usar o objeto john como chave, o objeto ben será substituído
 
 *!*
-// That's what got written!
+// Isso é o que foi escrito!
 alert( visitsCountObj["[object Object]"] ); // 123
 */!*
 ```
 
-As `visitsCountObj` is an object, it converts all `Object` keys, such as `john` and `ben` above, to same string `"[object Object]"`. Definitely not what we want.
+"Como `visitsCountObj` é um objeto, ele converte todas as chaves de `Object`, como `john` e `ben` acima, para a mesma string `"[object Object]"`. Definitivamente, não é o que queremos."
 
-```smart header="How `Map` compares keys"
-To test keys for equivalence, `Map` uses the algorithm [SameValueZero](https://tc39.github.io/ecma262/#sec-samevaluezero). It is roughly the same as strict equality `===`, but the difference is that `NaN` is considered equal to `NaN`. So `NaN` can be used as the key as well.
+```smart header="Como o `Map` compara chaves"
+Para testar as chaves quanto à equivalência, o `Map` utiliza o algoritmo [SameValueZero](https://tc39.github.io/ecma262/#sec-samevaluezero). Ele é essencialmente o mesmo que a igualdade estrita `===`, mas a diferença é que `NaN` é considerado igual a `NaN`. Portanto, `NaN` pode ser usado como chave também.
 
-This algorithm can't be changed or customized.
+Este algoritmo não pode ser alterado ou personalizado.
 ```
 
-````smart header="Chaining"
-Every `map.set` call returns the map itself, so we can "chain" the calls:
+````smart header="Encadeamento"
+Cada chamada de `map.set` retorna o próprio mapa, então podemos "encadear" as chamadas:
 
 ```js
 map.set('1', 'str1')

From 02664c53323236a0633ca205cd91852351fe09cc Mon Sep 17 00:00:00 2001
From: Gabriel Fernandes Silva <ga3riel.fernandess@gmail.com>
Date: Thu, 21 Sep 2023 23:13:23 -0300
Subject: [PATCH 03/14] translate section iteration over map

---
 1-js/05-data-types/07-map-set/article.md | 32 ++++++++++++------------
 1 file changed, 16 insertions(+), 16 deletions(-)

diff --git a/1-js/05-data-types/07-map-set/article.md b/1-js/05-data-types/07-map-set/article.md
index b23f67dae..965c33690 100644
--- a/1-js/05-data-types/07-map-set/article.md
+++ b/1-js/05-data-types/07-map-set/article.md
@@ -82,7 +82,7 @@ alert( visitsCountObj["[object Object]"] ); // 123
 */!*
 ```
 
-"Como `visitsCountObj` é um objeto, ele converte todas as chaves de `Object`, como `john` e `ben` acima, para a mesma string `"[object Object]"`. Definitivamente, não é o que queremos."
+Como `visitsCountObj` é um objeto, ele converte todas as chaves de `Object`, como `john` e `ben` acima, para a mesma string `"[object Object]"`. Definitivamente, não é o que queremos.
 
 ```smart header="Como o `Map` compara chaves"
 Para testar as chaves quanto à equivalência, o `Map` utiliza o algoritmo [SameValueZero](https://tc39.github.io/ecma262/#sec-samevaluezero). Ele é essencialmente o mesmo que a igualdade estrita `===`, mas a diferença é que `NaN` é considerado igual a `NaN`. Portanto, `NaN` pode ser usado como chave também.
@@ -100,15 +100,15 @@ map.set('1', 'str1')
 ```
 ````
 
-## Iteration over Map
+## Iteração sobre o Mapa
 
-For looping over a `map`, there are 3 methods:
+Para fazer um loop em um `map`, existem 3 métodos:
 
-- [`map.keys()`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Map/keys) -- returns an iterable for keys,
-- [`map.values()`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Map/values) -- returns an iterable for values,
-- [`map.entries()`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Map/entries) -- returns an iterable for entries `[key, value]`, it's used by default in `for..of`.
+- [`map.keys()`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Map/keys) -- retorna um iterável para chaves,
+- [`map.values()`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Map/values) -- retorna um iterável para valores,
+- [`map.entries()`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Map/entries) -- retorna um iterável para entradas `[chave, valor]`, é usado por padrão em `for..of`.
 
-For instance:
+Por exemplo:
 
 ```js run
 let recipeMap = new Map([
@@ -117,30 +117,30 @@ let recipeMap = new Map([
   ['onion',    50]
 ]);
 
-// iterate over keys (vegetables)
+// itera sobre as chaves (vegetais)
 for (let vegetable of recipeMap.keys()) {
   alert(vegetable); // cucumber, tomatoes, onion
 }
 
-// iterate over values (amounts)
+// itera sobre os valores (quantidades)
 for (let amount of recipeMap.values()) {
   alert(amount); // 500, 350, 50
 }
 
-// iterate over [key, value] entries
-for (let entry of recipeMap) { // the same as of recipeMap.entries()
-  alert(entry); // cucumber,500 (and so on)
+// itera sobre as entradas [chave, valor]
+for (let entry of recipeMap) { // o mesmo que recipeMap.entries()
+  alert(entry); // cucumber,500 (e assim por diante)
 }
 ```
 
-```smart header="The insertion order is used"
-The iteration goes in the same order as the values were inserted. `Map` preserves this order, unlike a regular `Object`.
+```smart header="A ordem de inserção é usada."
+A iteração segue a mesma ordem em que os valores foram inseridos. O `Map` preserva essa ordem, ao contrário de um objeto normal.
 ```
 
-Besides that, `Map` has a built-in `forEach` method, similar to `Array`:
+Além disso, o `Map` possui um método embutido chamado `forEach`, semelhante ao `Array`:
 
 ```js
-// runs the function for each (key, value) pair
+// executa a função para cada par (chave, valor)
 recipeMap.forEach( (value, key, map) => {
   alert(`${key}: ${value}`); // cucumber: 500 etc
 });

From 3f36862abd80314db6756d7e55beadb9ccee5d60 Mon Sep 17 00:00:00 2001
From: Gabriel Fernandes Silva <ga3riel.fernandess@gmail.com>
Date: Fri, 22 Sep 2023 13:37:00 -0300
Subject: [PATCH 04/14] translate section Object.entries: Map from Object

---
 1-js/05-data-types/07-map-set/article.md | 15 +++++++--------
 1 file changed, 7 insertions(+), 8 deletions(-)

diff --git a/1-js/05-data-types/07-map-set/article.md b/1-js/05-data-types/07-map-set/article.md
index 965c33690..c9b6e0e18 100644
--- a/1-js/05-data-types/07-map-set/article.md
+++ b/1-js/05-data-types/07-map-set/article.md
@@ -100,7 +100,7 @@ map.set('1', 'str1')
 ```
 ````
 
-## Iteração sobre o Mapa
+## Iteração sobre o Map
 
 Para fazer um loop em um `map`, existem 3 métodos:
 
@@ -146,12 +146,12 @@ recipeMap.forEach( (value, key, map) => {
 });
 ```
 
-## Object.entries: Map from Object
+## Object.entries: Map a partir de Objeto
 
-When a `Map` is created, we can pass an array (or another iterable) with key/value pairs for initialization, like this:
+Quando um `Map` é criado, podemos passar um array (ou outro iterável) com pares chave/valor para inicialização, como este:
 
 ```js run
-// array of [key, value] pairs
+// array de pares [chave, valor]
 let map = new Map([
   ['1',  'str1'],
   [1,    'num1'],
@@ -161,9 +161,9 @@ let map = new Map([
 alert( map.get('1') ); // str1
 ```
 
-If we have a plain object, and we'd like to create a `Map` from it, then we can use built-in method [Object.entries(obj)](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/entries) that returns an array of key/value pairs for an object exactly in that format.
+Se tivermos um objeto simples e gostaríamos de criar um `Map` a partir dele, podemos usar o método embutido [Object.entries(obj)](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/entries), que retorna um array de pares chave/valor para um objeto exatamente nesse formato.
 
-So we can create a map from an object like this:
+Portanto, podemos criar um mapa a partir de um objeto da seguinte forma:
 
 ```js run
 let obj = {
@@ -178,8 +178,7 @@ let map = new Map(Object.entries(obj));
 alert( map.get('name') ); // John
 ```
 
-Here, `Object.entries` returns the array of key/value pairs: `[ ["name","John"], ["age", 30] ]`. That's what `Map` needs.
-
+Aqui, `Object.entries` retorna o array de pares chave/valor: `[ ["name","John"], ["age", 30] ]`. Isso é o que o `Map` precisa.
 
 ## Object.fromEntries: Object from Map
 

From bce43a983494c2ace676930c2b037ae545ded0a7 Mon Sep 17 00:00:00 2001
From: Gabriel Fernandes Silva <ga3riel.fernandess@gmail.com>
Date: Sat, 23 Sep 2023 15:08:35 -0300
Subject: [PATCH 05/14] translate section Object from Map

---
 1-js/05-data-types/07-map-set/article.md | 26 ++++++++++++------------
 1 file changed, 13 insertions(+), 13 deletions(-)

diff --git a/1-js/05-data-types/07-map-set/article.md b/1-js/05-data-types/07-map-set/article.md
index c9b6e0e18..e2777d0d1 100644
--- a/1-js/05-data-types/07-map-set/article.md
+++ b/1-js/05-data-types/07-map-set/article.md
@@ -180,11 +180,11 @@ alert( map.get('name') ); // John
 
 Aqui, `Object.entries` retorna o array de pares chave/valor: `[ ["name","John"], ["age", 30] ]`. Isso é o que o `Map` precisa.
 
-## Object.fromEntries: Object from Map
+## Object.fromEntries: Objeto a partir de Map
 
-We've just seen how to create `Map` from a plain object with `Object.entries(obj)`.
+Acabamos de ver como criar um `Map` a partir de um objeto simples usando `Object.entries(obj)`.
 
-There's `Object.fromEntries` method that does the reverse: given an array of `[key, value]` pairs, it creates an object from them:
+Existe o método `Object.fromEntries` que faz o inverso: dado um array de pares `[chave, valor]`, ele cria um objeto a partir deles:
 
 ```js run
 let prices = Object.fromEntries([
@@ -193,16 +193,16 @@ let prices = Object.fromEntries([
   ['meat', 4]
 ]);
 
-// now prices = { banana: 1, orange: 2, meat: 4 }
+// agora prices = { banana: 1, orange: 2, meat: 4 }
 
 alert(prices.orange); // 2
 ```
 
-We can use `Object.fromEntries` to get a plain object from `Map`.
+Podemos usar `Object.fromEntries` para obter um objeto simples a partir de um `Map`.
 
-E.g. we store the data in a `Map`, but we need to pass it to a 3rd-party code that expects a plain object.
+Por exemplo, armazenamos os dados em um `Map`, mas precisamos passá-los para um código de terceiros que espera um objeto simples.
 
-Here we go:
+Aqui está:
 
 ```js run
 let map = new Map();
@@ -211,23 +211,23 @@ map.set('orange', 2);
 map.set('meat', 4);
 
 *!*
-let obj = Object.fromEntries(map.entries()); // make a plain object (*)
+let obj = Object.fromEntries(map.entries()); // cria um objeto simples (*)
 */!*
 
-// done!
+// feito!
 // obj = { banana: 1, orange: 2, meat: 4 }
 
 alert(obj.orange); // 2
 ```
 
-A call to `map.entries()` returns an iterable of key/value pairs, exactly in the right format for `Object.fromEntries`.
+Uma chamada para `map.entries()` retorna um iterável de pares chave/valor, exatamente no formato correto para `Object.fromEntries`.
 
-We could also make line `(*)` shorter:
+Também podemos tornar a linha `(*)` mais curta:
 ```js
-let obj = Object.fromEntries(map); // omit .entries()
+let obj = Object.fromEntries(map); // omite .entries()
 ```
 
-That's the same, because `Object.fromEntries` expects an iterable object as the argument. Not necessarily an array. And the standard iteration for `map` returns same key/value pairs as `map.entries()`. So we get a plain object with same key/values as the `map`.
+Isso é o mesmo, porque `Object.fromEntries` espera um objeto iterável como argumento. Não necessariamente um array. E a iteração padrão para o `map` retorna os mesmos pares chave/valor que o `map.entries()`. Portanto, obtemos um objeto simples com as mesmas chaves/valores do `map`.
 
 ## Set
 

From bc80b4198a92dddef977cbe4e906f36ce272f096 Mon Sep 17 00:00:00 2001
From: Gabriel Fernandes Silva <ga3riel.fernandess@gmail.com>
Date: Sat, 23 Sep 2023 15:19:38 -0300
Subject: [PATCH 06/14] translate section Set

---
 1-js/05-data-types/07-map-set/article.md | 30 ++++++++++++------------
 1 file changed, 15 insertions(+), 15 deletions(-)

diff --git a/1-js/05-data-types/07-map-set/article.md b/1-js/05-data-types/07-map-set/article.md
index e2777d0d1..582e4af9b 100644
--- a/1-js/05-data-types/07-map-set/article.md
+++ b/1-js/05-data-types/07-map-set/article.md
@@ -231,22 +231,22 @@ Isso é o mesmo, porque `Object.fromEntries` espera um objeto iterável como arg
 
 ## Set
 
-A [`Set`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Set) is a special type collection - "set of values" (without keys), where each value may occur only once.
+Um [`Set`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Set) é um tipo especial de coleção - "conjunto de valores" (sem chaves), onde cada valor pode ocorrer apenas uma vez.
 
-Its main methods are:
+Seus principais métodos são:
 
-- [`new Set([iterable])`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Set/Set) -- creates the set, and if an `iterable` object is provided (usually an array), copies values from it into the set.
-- [`set.add(value)`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Set/add) -- adds a value, returns the set itself.
-- [`set.delete(value)`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Set/delete) -- removes the value, returns `true` if `value` existed at the moment of the call, otherwise `false`.
-- [`set.has(value)`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Set/has) -- returns `true` if the value exists in the set, otherwise `false`.
-- [`set.clear()`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Set/clear) -- removes everything from the set.
-- [`set.size`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Set/size) -- is the elements count.
+- [`new Set([iterable])`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Set/Set) -- cria o conjunto e, se um objeto `iterable` (geralmente um array) for fornecido, copia os valores dele para o conjunto.
+- [`set.add(value)`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Set/add) -- adiciona um valor e retorna o próprio conjunto.
+- [`set.delete(value)`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Set/delete) -- remove o valor e retorna `true` se o `value` existir no momento da chamada, caso contrário, retorna `false`.
+- [`set.has(value)`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Set/has) -- retorna `true` se o valor existir no conjunto, caso contrário, retorna `false`.
+- [`set.clear()`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Set/clear) -- remove tudo do conjunto.
+- [`set.size`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Set/size) -- representa a contagem de elementos.
 
-The main feature is that repeated calls of `set.add(value)` with the same value don't do anything. That's the reason why each value appears in a `Set` only once.
+A principal característica é que chamadas repetidas de `set.add(value)` com o mesmo valor não fazem nada. Essa é a razão pela qual cada valor aparece em um `Set` apenas uma vez.
 
-For example, we have visitors coming, and we'd like to remember everyone. But repeated visits should not lead to duplicates. A visitor must be "counted" only once.
+Por exemplo, temos visitantes chegando, e gostaríamos de lembrar de todos. Mas visitas repetidas não devem levar a duplicatas. Um visitante deve ser "contado" apenas uma vez.
 
-`Set` is just the right thing for that:
+`Set` é exatamente o que você precisa para isso:
 
 ```js run
 let set = new Set();
@@ -255,22 +255,22 @@ let john = { name: "John" };
 let pete = { name: "Pete" };
 let mary = { name: "Mary" };
 
-// visits, some users come multiple times
+// visitas, alguns usuários vêm várias vezes
 set.add(john);
 set.add(pete);
 set.add(mary);
 set.add(john);
 set.add(mary);
 
-// set keeps only unique values
+// set mantém apenas valores únicos
 alert( set.size ); // 3
 
 for (let user of set) {
-  alert(user.name); // John (then Pete and Mary)
+  alert(user.name); // John (depois Pete e Mary)
 }
 ```
 
-The alternative to `Set` could be an array of users, and the code to check for duplicates on every insertion using [arr.find](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/find). But the performance would be much worse, because this method walks through the whole array checking every element. `Set` is much better optimized internally for uniqueness checks.
+A alternativa ao `Set` poderia ser um array de usuários e o código para verificar duplicatas em cada inserção usando [arr.find](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/find). No entanto, o desempenho seria muito pior, porque esse método percorre todo o array verificando cada elemento. O `Set` é muito mais otimizado internamente para verificações de unicidade.
 
 ## Iteration over Set
 

From 20e00787a6d03d56de9988071a070f285f357e95 Mon Sep 17 00:00:00 2001
From: Gabriel Fernandes Silva <ga3riel.fernandess@gmail.com>
Date: Sat, 23 Sep 2023 15:30:25 -0300
Subject: [PATCH 07/14] translate section Iteration over Set

---
 1-js/05-data-types/07-map-set/article.md | 18 +++++++++---------
 1 file changed, 9 insertions(+), 9 deletions(-)

diff --git a/1-js/05-data-types/07-map-set/article.md b/1-js/05-data-types/07-map-set/article.md
index 582e4af9b..5372e1680 100644
--- a/1-js/05-data-types/07-map-set/article.md
+++ b/1-js/05-data-types/07-map-set/article.md
@@ -272,30 +272,30 @@ for (let user of set) {
 
 A alternativa ao `Set` poderia ser um array de usuários e o código para verificar duplicatas em cada inserção usando [arr.find](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/find). No entanto, o desempenho seria muito pior, porque esse método percorre todo o array verificando cada elemento. O `Set` é muito mais otimizado internamente para verificações de unicidade.
 
-## Iteration over Set
+## Iteração sobre o Set
 
-We can loop over a set either with `for..of` or using `forEach`:
+Podemos fazer um loop sobre um conjunto tanto com `for..of` quanto usando `forEach`:
 
 ```js run
 let set = new Set(["oranges", "apples", "bananas"]);
 
 for (let value of set) alert(value);
 
-// the same with forEach:
+// o mesmo com forEach:
 set.forEach((value, valueAgain, set) => {
   alert(value);
 });
 ```
 
-Note the funny thing. The callback function passed in `forEach` has 3 arguments: a `value`, then *the same value* `valueAgain`, and then the target object. Indeed, the same value appears in the arguments twice.
+Observe a coisa curiosa. A função de retorno de chamada passada no `forEach` tem 3 argumentos: um `value`, em seguida, *o mesmo valor* `valueAgain`, e depois o objeto de destino. Na verdade, o mesmo valor aparece nos argumentos duas vezes.
 
-That's for compatibility with `Map` where the callback passed `forEach` has three arguments. Looks a bit strange, for sure. But this may help to replace `Map` with `Set` in certain cases with ease, and vice versa.
+Isso é para compatibilidade com o `Map`, onde a função de retorno de chamada passada no `forEach` tem três argumentos. Parece um pouco estranho, com certeza. Mas isso pode ajudar a substituir `Map` por `Set` em determinados casos com facilidade, e vice-versa.
 
-The same methods `Map` has for iterators are also supported:
+Os mesmos métodos que o `Map` tem para iteradores também são suportados:
 
-- [`set.keys()`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Set/keys) -- returns an iterable object for values,
-- [`set.values()`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Set/values) -- same as `set.keys()`, for compatibility with `Map`,
-- [`set.entries()`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Set/entries) -- returns an iterable object for entries `[value, value]`, exists for compatibility with `Map`.
+- [`set.keys()`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Set/keys) -- retorna um objeto iterável para valores,
+- [`set.values()`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Set/values) -- o mesmo que `set.keys()`, para compatibilidade com `Map`,
+- [`set.entries()`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Set/entries) -- retorna um objeto iterável para entradas `[valor, valor]`, existe para compatibilidade com `Map`.
 
 ## Summary
 

From 144368da06feff16c2aae118249a2e58fe17de2d Mon Sep 17 00:00:00 2001
From: Gabriel Fernandes Silva <ga3riel.fernandess@gmail.com>
Date: Sat, 23 Sep 2023 15:37:48 -0300
Subject: [PATCH 08/14] translate section summary

---
 1-js/05-data-types/07-map-set/article.md | 44 ++++++++++++------------
 1 file changed, 22 insertions(+), 22 deletions(-)

diff --git a/1-js/05-data-types/07-map-set/article.md b/1-js/05-data-types/07-map-set/article.md
index 5372e1680..8672bac66 100644
--- a/1-js/05-data-types/07-map-set/article.md
+++ b/1-js/05-data-types/07-map-set/article.md
@@ -297,34 +297,34 @@ Os mesmos métodos que o `Map` tem para iteradores também são suportados:
 - [`set.values()`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Set/values) -- o mesmo que `set.keys()`, para compatibilidade com `Map`,
 - [`set.entries()`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Set/entries) -- retorna um objeto iterável para entradas `[valor, valor]`, existe para compatibilidade com `Map`.
 
-## Summary
+## Resumo
 
-[`Map`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Map) -- is a collection of keyed values.
+[`Map`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Map) -- é uma coleção de valores indexados.
 
-Methods and properties:
+Métodos e propriedades:
 
-- [`new Map([iterable])`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Map/Map) -- creates the map, with optional `iterable` (e.g. array) of `[key,value]` pairs for initialization.
-- [`map.set(key, value)`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Map/set) -- stores the value by the key, returns the map itself.
-- [`map.get(key)`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Map/get) -- returns the value by the key, `undefined` if `key` doesn't exist in map.
-- [`map.has(key)`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Map/has) -- returns `true` if the `key` exists, `false` otherwise.
-- [`map.delete(key)`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Map/delete) -- removes the element by the key, returns `true` if `key` existed at the moment of the call, otherwise `false`.
-- [`map.clear()`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Map/clear) -- removes everything from the map.
-- [`map.size`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Map/size) -- returns the current element count.
+- [`new Map([iterable])`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Map/Map) -- cria o mapa, com um `iterable` opcional (por exemplo, array) de pares `[chave, valor]` para inicialização.
+- [`map.set(chave, valor)`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Map/set) -- armazena o valor pela chave e retorna o próprio mapa.
+- [`map.get(chave)`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Map/get) -- retorna o valor pela chave, `undefined` se a `chave` não existir no mapa.
+- [`map.has(chave)`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Map/has) -- retorna `true` se a `chave` existir, `false` caso contrário.
+- [`map.delete(chave)`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Map/delete) -- remove o elemento pela chave e retorna `true` se a `chave` existir no momento da chamada, caso contrário, `false`.
+- [`map.clear()`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Map/clear) -- remove tudo do mapa.
+- [`map.size`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Map/size) -- retorna a contagem atual de elementos.
 
-The differences from a regular `Object`:
+As diferenças em relação a um objeto normal (`Object`):
 
-- Any keys, objects can be keys.
-- Additional convenient methods, the `size` property.
+- Qualquer chave, objetos também podem ser chaves.
+- Métodos adicionais convenientes e a propriedade `size`.
 
-[`Set`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Set) -- is a collection of unique values.
+[`Set`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Set) -- é uma coleção de valores únicos.
 
-Methods and properties:
+Métodos e propriedades:
 
-- [`new Set([iterable])`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Set/Set) -- creates the set, with optional `iterable` (e.g. array) of values for initialization.
-- [`set.add(value)`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Set/add) -- adds a value (does nothing if `value` exists), returns the set itself.
-- [`set.delete(value)`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Set/delete) -- removes the value, returns `true` if `value` existed at the moment of the call, otherwise `false`.
-- [`set.has(value)`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Set/has) -- returns `true` if the value exists in the set, otherwise `false`.
-- [`set.clear()`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Set/clear) -- removes everything from the set.
-- [`set.size`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Set/size) -- is the elements count.
+- [`new Set([iterable])`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Set/Set) -- cria o conjunto, com um `iterable` opcional (por exemplo, array) de valores para inicialização.
+- [`set.add(valor)`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Set/add) -- adiciona um valor (não faz nada se o `valor` já existir) e retorna o próprio conjunto.
+- [`set.delete(valor)`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Set/delete) -- remove o valor e retorna `true` se o `valor` existir no momento da chamada, caso contrário, `false`.
+- [`set.has(valor)`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Set/has) -- retorna `true` se o valor existir no conjunto, caso contrário, `false`.
+- [`set.clear()`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Set/clear) -- remove tudo do conjunto.
+- [`set.size`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Set/size) -- representa a contagem de elementos.
 
-Iteration over `Map` and `Set` is always in the insertion order, so we can't say that these collections are unordered, but we can't reorder elements or directly get an element by its number.
+A iteração sobre `Map` e `Set` sempre segue a ordem de inserção, então não podemos dizer que essas coleções são desordenadas. No entanto, não podemos reordenar os elementos ou obter um elemento diretamente pelo seu número.

From 3aa8890a82ac7331e64a008163e976679bc2d3ef Mon Sep 17 00:00:00 2001
From: Gabriel Fernandes Silva <ga3riel.fernandess@gmail.com>
Date: Sat, 23 Sep 2023 15:44:46 -0300
Subject: [PATCH 09/14] translate task 1

---
 .../07-map-set/01-array-unique-map/task.md         | 14 +++++++-------
 1 file changed, 7 insertions(+), 7 deletions(-)

diff --git a/1-js/05-data-types/07-map-set/01-array-unique-map/task.md b/1-js/05-data-types/07-map-set/01-array-unique-map/task.md
index d68030032..ff44582d0 100644
--- a/1-js/05-data-types/07-map-set/01-array-unique-map/task.md
+++ b/1-js/05-data-types/07-map-set/01-array-unique-map/task.md
@@ -1,14 +1,14 @@
-importance: 5
+importancia: 5
 
 ---
 
-# Filter unique array members
+# Filtrar elementos únicos de um array
 
-Let `arr` be an array.
+Seja `arr` um array.
 
-Create a function `unique(arr)` that should return an array with unique items of `arr`.
+Crie uma função `unique(arr)` que deve retornar um array com itens únicos de `arr`.
 
-For instance:
+Por exemplo:
 
 ```js
 function unique(arr) {
@@ -22,6 +22,6 @@ let values = ["Hare", "Krishna", "Hare", "Krishna",
 alert( unique(values) ); // Hare, Krishna, :-O
 ```
 
-P.S. Here strings are used, but can be values of any type.
+Observação: Aqui estão sendo usadas strings, mas os valores podem ser de qualquer tipo.
 
-P.P.S. Use `Set` to store unique values.
+Observação adicional: Use `Set` para armazenar valores únicos.

From 32aecc499c33668008237b3775ef8c8fc7f0a827 Mon Sep 17 00:00:00 2001
From: Gabriel Fernandes Silva <ga3riel.fernandess@gmail.com>
Date: Sun, 24 Sep 2023 21:37:42 -0300
Subject: [PATCH 10/14] translate task 2

---
 .../07-map-set/02-filter-anagrams/solution.md | 24 +++++++++----------
 .../07-map-set/02-filter-anagrams/task.md     | 17 +++++++------
 2 files changed, 20 insertions(+), 21 deletions(-)

diff --git a/1-js/05-data-types/07-map-set/02-filter-anagrams/solution.md b/1-js/05-data-types/07-map-set/02-filter-anagrams/solution.md
index 160675185..6c4b34b84 100644
--- a/1-js/05-data-types/07-map-set/02-filter-anagrams/solution.md
+++ b/1-js/05-data-types/07-map-set/02-filter-anagrams/solution.md
@@ -1,6 +1,6 @@
-To find all anagrams, let's split every word to letters and sort them. When letter-sorted, all anagrams are same.
+Para encontrar todos os anagramas, vamos dividir cada palavra em letras e ordená-las. Quando ordenadas por letras, todos os anagramas são iguais.
 
-For instance:
+Por exemplo:
 
 ```
 nap, pan -> anp
@@ -9,14 +9,14 @@ cheaters, hectares, teachers -> aceehrst
 ...
 ```
 
-We'll use the letter-sorted variants as map keys to store only one value per each key:
+Vamos usar as variantes ordenadas por letras como chaves de mapa para armazenar apenas um valor para cada chave:
 
 ```js run
 function aclean(arr) {
   let map = new Map();
 
   for (let word of arr) {
-    // split the word by letters, sort them and join back
+    // Divida a palavra em letras, ordene-as e junte novamente.
 *!*
     let sorted = word.toLowerCase().split('').sort().join(''); // (*)
 */!*
@@ -31,9 +31,9 @@ let arr = ["nap", "teachers", "cheaters", "PAN", "ear", "era", "hectares"];
 alert( aclean(arr) );
 ```
 
-Letter-sorting is done by the chain of calls in the line `(*)`.
+A ordenação por letras é feita pela cadeia de chamadas na linha `(*)`.
 
-For convenience let's split it into multiple lines:
+Para maior clareza, vamos dividi-la em várias linhas:
 
 ```js
 let sorted = word // PAN
@@ -43,21 +43,21 @@ let sorted = word // PAN
   .join(''); // anp
 ```
 
-Two different words `'PAN'` and `'nap'` receive the same letter-sorted form `'anp'`.
+Duas palavras diferentes, `'PAN'` e `'nap'`, recebem a mesma forma ordenada por letras, `'anp'`.
 
-The next line put the word into the map:
+A próxima linha coloca a palavra no mapa:
 
 ```js
 map.set(sorted, word);
 ```
 
-If we ever meet a word the same letter-sorted form again, then it would overwrite the previous value with the same key in the map. So we'll always have at maximum one word per letter-form.
+Se encontrarmos novamente uma palavra com a mesma forma ordenada por letras, ela irá sobrescrever o valor anterior com a mesma chave no mapa. Portanto, sempre teremos no máximo uma palavra por forma de letras.
 
-At the end `Array.from(map.values())` takes an iterable over map values (we don't need keys in the result) and returns an array of them.
+No final, `Array.from(map.values())` cria um iterável sobre os valores do mapa (não precisamos das chaves no resultado) e retorna um array com eles.
 
-Here we could also use a plain object instead of the `Map`, because keys are strings.
+Aqui também poderíamos usar um objeto simples em vez do `Map`, porque as chaves são strings.
 
-That's how the solution can look:
+É assim que a solução pode ser implementada:
 
 ```js run demo
 function aclean(arr) {
diff --git a/1-js/05-data-types/07-map-set/02-filter-anagrams/task.md b/1-js/05-data-types/07-map-set/02-filter-anagrams/task.md
index 731fd2c25..02a9d8de6 100644
--- a/1-js/05-data-types/07-map-set/02-filter-anagrams/task.md
+++ b/1-js/05-data-types/07-map-set/02-filter-anagrams/task.md
@@ -1,12 +1,12 @@
-importance: 4
+importancia: 4
 
 ---
 
-# Filter anagrams
+# Filtrar anagramas
 
-[Anagrams](https://en.wikipedia.org/wiki/Anagram) are words that have the same number of same letters, but in different order.
+[Anagramas](https://en.wikipedia.org/wiki/Anagram) são palavras que têm o mesmo número das mesmas letras, mas em ordem diferente.
 
-For instance:
+Por exemplo:
 
 ```
 nap - pan
@@ -14,15 +14,14 @@ ear - are - era
 cheaters - hectares - teachers
 ```
 
-Write a function `aclean(arr)` that returns an array cleaned from anagrams.
+Escreva uma função `aclean(arr)` que retorne um array limpo de anagramas.
 
-For instance:
+Por exemplo:
 
 ```js
 let arr = ["nap", "teachers", "cheaters", "PAN", "ear", "era", "hectares"];
 
-alert( aclean(arr) ); // "nap,teachers,ear" or "PAN,cheaters,era"
+alert( aclean(arr) ); // "nap,teachers,ear" ou "PAN,cheaters,era"
 ```
 
-From every anagram group should remain only one word, no matter which one.
-
+De cada grupo de anagramas, deve permanecer apenas uma palavra, não importa qual.

From 10b1fb03cf951ee49109481976932a335230a58c Mon Sep 17 00:00:00 2001
From: Gabriel Fernandes Silva <ga3riel.fernandess@gmail.com>
Date: Sun, 24 Sep 2023 21:41:18 -0300
Subject: [PATCH 11/14] translate task 3

---
 .../05-data-types/07-map-set/03-iterable-keys/solution.md | 5 ++---
 1-js/05-data-types/07-map-set/03-iterable-keys/task.md    | 8 ++++----
 2 files changed, 6 insertions(+), 7 deletions(-)

diff --git a/1-js/05-data-types/07-map-set/03-iterable-keys/solution.md b/1-js/05-data-types/07-map-set/03-iterable-keys/solution.md
index 7310d1d36..83c3b0ed9 100644
--- a/1-js/05-data-types/07-map-set/03-iterable-keys/solution.md
+++ b/1-js/05-data-types/07-map-set/03-iterable-keys/solution.md
@@ -1,8 +1,7 @@
 
-That's because `map.keys()` returns an iterable, but not an array.
-
-We can convert it into an array using `Array.from`:
+Isso ocorre porque `map.keys()` retorna um objeto iterável, mas não um array.
 
+Podemos convertê-lo em um array usando `Array.from`:
 
 ```js run
 let map = new Map();
diff --git a/1-js/05-data-types/07-map-set/03-iterable-keys/task.md b/1-js/05-data-types/07-map-set/03-iterable-keys/task.md
index 81507647f..39689565f 100644
--- a/1-js/05-data-types/07-map-set/03-iterable-keys/task.md
+++ b/1-js/05-data-types/07-map-set/03-iterable-keys/task.md
@@ -1,12 +1,12 @@
-importance: 5
+importancia: 5
 
 ---
 
 # Iterable keys
 
-We'd like to get an array of `map.keys()` in a variable and then apply array-specific methods to it, e.g. `.push`.
+Gostaríamos de obter um array de `map.keys()` em uma variável e, em seguida, aplicar métodos específicos de array a ele, como `.push`.
 
-But that doesn't work:
+Mas isso não funciona:
 
 ```js run
 let map = new Map();
@@ -21,4 +21,4 @@ keys.push("more");
 */!*
 ```
 
-Why? How can we fix the code to make `keys.push` work?
+Por quê? Como podemos corrigir o código para fazer com que `keys.push` funcione?

From 7c9ca051e6ed3c4dde530bf2d026c4ece69072e2 Mon Sep 17 00:00:00 2001
From: Gabriel Fernandes Silva <ga3riel.fernandess@gmail.com>
Date: Sun, 24 Sep 2023 21:49:41 -0300
Subject: [PATCH 12/14] translate test 1

---
 .../07-map-set/01-array-unique-map/_js.view/test.js           | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/1-js/05-data-types/07-map-set/01-array-unique-map/_js.view/test.js b/1-js/05-data-types/07-map-set/01-array-unique-map/_js.view/test.js
index cfc7b1fc3..14cc708ca 100644
--- a/1-js/05-data-types/07-map-set/01-array-unique-map/_js.view/test.js
+++ b/1-js/05-data-types/07-map-set/01-array-unique-map/_js.view/test.js
@@ -1,5 +1,5 @@
 describe("unique", function() {
-  it("removes non-unique elements", function() {
+  it("remove elementos não únicos", function () {
     let strings = ["Hare", "Krishna", "Hare", "Krishna",
       "Krishna", "Krishna", "Hare", "Hare", ":-O"
     ];
@@ -7,7 +7,7 @@ describe("unique", function() {
     assert.deepEqual(unique(strings), ["Hare", "Krishna", ":-O"]);
   });
 
-  it("does not change the source array", function() {
+  it("não altera o array de origem", function () {
     let strings = ["Krishna", "Krishna", "Hare", "Hare"];
     unique(strings);
     assert.deepEqual(strings, ["Krishna", "Krishna", "Hare", "Hare"]);

From c095eb41d0d5fa5febb1be182e0fbc22a4d76c04 Mon Sep 17 00:00:00 2001
From: Gabriel Fernandes Silva <ga3riel.fernandess@gmail.com>
Date: Sun, 24 Sep 2023 21:56:58 -0300
Subject: [PATCH 13/14] translate test 2

---
 .../07-map-set/02-filter-anagrams/_js.view/test.js         | 7 +++----
 1 file changed, 3 insertions(+), 4 deletions(-)

diff --git a/1-js/05-data-types/07-map-set/02-filter-anagrams/_js.view/test.js b/1-js/05-data-types/07-map-set/02-filter-anagrams/_js.view/test.js
index 75acb36b7..2576bc171 100644
--- a/1-js/05-data-types/07-map-set/02-filter-anagrams/_js.view/test.js
+++ b/1-js/05-data-types/07-map-set/02-filter-anagrams/_js.view/test.js
@@ -3,8 +3,7 @@ function intersection(arr1, arr2) {
 }
 
 describe("aclean", function() {
-
-  it("returns exactly 1 word from each anagram set", function() {
+  it("retorna exatamente 1 palavra de cada conjunto de anagramas", function () {
     let arr = ["nap", "teachers", "cheaters", "PAN", "ear", "era", "hectares"];
 
     let result = aclean(arr);
@@ -16,9 +15,9 @@ describe("aclean", function() {
 
   });
 
-  it("is case-insensitive", function() {
+  it("é insensível a maiúsculas e minúsculas", function () {
     let arr = ["era", "EAR"];
     assert.equal(aclean(arr).length, 1);
   });
 
-});
\ No newline at end of file
+});

From 4b8cb195baa40e9beee5b6e265f1376a7661e369 Mon Sep 17 00:00:00 2001
From: Jonnathan Santos <jonnathan.lacerda.santos@gmail.com>
Date: Sun, 8 Oct 2023 15:08:57 -0300
Subject: [PATCH 14/14] =?UTF-8?q?refactor:=20desfaz=20altera=C3=A7=C3=B5es?=
 =?UTF-8?q?=20de=20tradu=C3=A7=C3=A3o=20respectivos=20aos=20metadados?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 1-js/05-data-types/07-map-set/01-array-unique-map/task.md | 2 +-
 1-js/05-data-types/07-map-set/02-filter-anagrams/task.md  | 2 +-
 1-js/05-data-types/07-map-set/03-iterable-keys/task.md    | 2 +-
 3 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/1-js/05-data-types/07-map-set/01-array-unique-map/task.md b/1-js/05-data-types/07-map-set/01-array-unique-map/task.md
index ff44582d0..58d28de78 100644
--- a/1-js/05-data-types/07-map-set/01-array-unique-map/task.md
+++ b/1-js/05-data-types/07-map-set/01-array-unique-map/task.md
@@ -1,4 +1,4 @@
-importancia: 5
+importance: 5
 
 ---
 
diff --git a/1-js/05-data-types/07-map-set/02-filter-anagrams/task.md b/1-js/05-data-types/07-map-set/02-filter-anagrams/task.md
index 02a9d8de6..6a243bfe9 100644
--- a/1-js/05-data-types/07-map-set/02-filter-anagrams/task.md
+++ b/1-js/05-data-types/07-map-set/02-filter-anagrams/task.md
@@ -1,4 +1,4 @@
-importancia: 4
+importance: 4
 
 ---
 
diff --git a/1-js/05-data-types/07-map-set/03-iterable-keys/task.md b/1-js/05-data-types/07-map-set/03-iterable-keys/task.md
index 39689565f..fc6039852 100644
--- a/1-js/05-data-types/07-map-set/03-iterable-keys/task.md
+++ b/1-js/05-data-types/07-map-set/03-iterable-keys/task.md
@@ -1,4 +1,4 @@
-importancia: 5
+importance: 5
 
 ---