chore(i18n,curriculum): update translations (#43078)

curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/basic-javascript/understanding-case-sensitivity-in-variables.md

@@ -11,7 +11,7 @@ dashedName: understanding-case-sensitivity-in-variables
 
 在 JavaScript 中所有的變量和函數名都是大小寫敏感的。 要區別對待大寫字母和小寫字母。
 
-`MYVAR` 與 `MyVar` 和 `myvar` 是不同的變量。 這有可能導致出現多個相似名字的的變量。 所以強烈地建議你，爲了保持代碼清晰*不要*使用這一特性。
+`MYVAR` 與 `MyVar` 和 `myvar` 是不同的變量。 這有可能導致出現多個相似名字的變量。 所以強烈地建議你，爲了保持代碼清晰*不要*使用這一特性。
 
 **最佳實踐**
 

curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/basic-javascript/use-recursion-to-create-a-countdown.md

@@ -10,7 +10,7 @@ dashedName: use-recursion-to-create-a-countdown
 
 在上一個[挑戰](/learn/javascript-algorithms-and-data-structures/basic-javascript/replace-loops-using-recursion)，學習了怎樣用遞歸來代替 `for` 循環。 現在來學習一個更復雜的函數，函數返回一個從 `1` 到傳遞給函數的指定數字的連續數字數組。
 
-正如上一個挑戰提到的，會有一個 <dfn>base case</dfn>。 base case 告訴遞歸函數什麼時候不在需要調用其自身。 這是簡單 情況，返回得到的值。 還有 <dfn>recursive call</dfn>，繼續用不同的參數調用自身。 如果函數無誤，一直執行直到 base case 爲止。
+正如上一個挑戰提到的，會有一個 <dfn>base case</dfn>。 base case 告訴遞歸函數什麼時候不再需要調用其自身。 這是簡單 情況，返回得到的值。 還有 <dfn>recursive call</dfn>，繼續用不同的參數調用自身。 如果函數無誤，一直執行直到 base case 爲止。
 
 比如，如果想寫一個遞歸函數，返回一個數字 `1` 到 `n` 的連續數組。 這個函數需要接收一個參數 `n` 代表最終數字。 然後會持續的調用自身，傳入一個比 `n` 更小的值一直到傳入的值是 `1` 爲止。 函數如下：
 

curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/basic-javascript/understanding-case-sensitivity-in-variables.md

@@ -11,7 +11,7 @@ dashedName: understanding-case-sensitivity-in-variables
 
 在 JavaScript 中所有的变量和函数名都是大小写敏感的。 要区别对待大写字母和小写字母。
 
-`MYVAR` 与 `MyVar` 和 `myvar` 是不同的变量。 这有可能导致出现多个相似名字的的变量。 所以强烈地建议你，为了保持代码清晰*不要*使用这一特性。
+`MYVAR` 与 `MyVar` 和 `myvar` 是不同的变量。 这有可能导致出现多个相似名字的变量。 所以强烈地建议你，为了保持代码清晰*不要*使用这一特性。
 
 **最佳实践**
 

curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/basic-javascript/use-recursion-to-create-a-countdown.md

@@ -10,7 +10,7 @@ dashedName: use-recursion-to-create-a-countdown
 
 在上一个[挑战](/learn/javascript-algorithms-and-data-structures/basic-javascript/replace-loops-using-recursion)，学习了怎样用递归来代替 `for` 循环。 现在来学习一个更复杂的函数，函数返回一个从 `1` 到传递给函数的指定数字的连续数字数组。
 
-正如上一个挑战提到的，会有一个 <dfn>base case</dfn>。 base case 告诉递归函数什么时候不在需要调用其自身。 这是简单 情况，返回得到的值。 还有 <dfn>recursive call</dfn>，继续用不同的参数调用自身。 如果函数无误，一直执行直到 base case 为止。
+正如上一个挑战提到的，会有一个 <dfn>base case</dfn>。 base case 告诉递归函数什么时候不再需要调用其自身。 这是简单 情况，返回得到的值。 还有 <dfn>recursive call</dfn>，继续用不同的参数调用自身。 如果函数无误，一直执行直到 base case 为止。
 
 比如，如果想写一个递归函数，返回一个数字 `1` 到 `n` 的连续数组。 这个函数需要接收一个参数 `n` 代表最终数字。 然后会持续的调用自身，传入一个比 `n` 更小的值一直到传入的值是 `1` 为止。 函数如下：
 

curriculum/challenges/italian/01-responsive-web-design/applied-visual-design/learn-about-complementary-colors.md

@@ -17,7 +17,7 @@ Alcuni esempi di colori complementari con i loro codici esadecimali sono:
 
 <blockquote>rosso (#FF0000) e ciano (#00FFFF)<br>verde (#00FF00) e magenta (#FF00FF)<br>blu (#0000FF) e giallo (#FFFF00)</blockquote>
 
-Questo è diverso dal modello di colore superato RYB (Rosso Giallo Blu) che hanno insegnato a molti di noi a scuola, che ha diversi colori primari e complementari. La teoria dei colori moderna utilizza il modello RGB additivo (come su uno schermo del computer) e il modello CMY(K) sottrattivo (come nella stampa). Leggi [qui](https://en.wikipedia.org/wiki/Color_model) per maggiori informazioni su questo argomento complesso.
+Questo è diverso dal modello di colore superato RYB (Rosso Giallo Blu) che hanno insegnato a molti di noi a scuola, che ha diversi colori primari e complementari. La teoria dei colori moderna utilizza il modello RGB additivo (come su uno schermo del computer) e il modello CMY(K) sottrattivo (come nella stampa). Leggi [qui](https://it.wikipedia.org/wiki/Modello_di_colore) per maggiori informazioni su questo argomento complesso.
 
 Ci sono molti strumenti di selezione del colore disponibili online che hanno un'opzione per trovare il complementare di un colore.
 

curriculum/challenges/italian/01-responsive-web-design/basic-css/use-hex-code-for-specific-colors.md

@@ -11,9 +11,9 @@ dashedName: use-hex-code-for-specific-colors
 
 Lo sapevi che ci sono altri modi per rappresentare i colori in CSS? Uno di questi modi è chiamato codice esadecimale, o codice hex per brevità.
 
-Di solito usiamo <dfn>i numeri decimali</dfn> (o numeri in base 10), che usano i simboli da 0 a 9 per ogni cifra. <dfn>Gli esadecimali</dfn> (o <dfn>hex</dfn>) sono numeri in base 16. Ciò significa che utilizzano sedici simboli distinti. Come per i i decimali, i simboli 0-9 rappresentano i valori da zero a nove. I successivi simboli A,B,C,D,E,F rappresentano i valori da dieci a quindici. Complessivamente, una cifra esadecimale può andare da 0 a F, dandoci 16 valori totali possibili. Qui puoi trovare ulteriori informazioni sui [numeri esadecimali](https://en.wikipedia.org/wiki/Hexadecimal).
+Di solito usiamo <dfn>i numeri decimali</dfn> (o numeri in base 10), che usano i simboli da 0 a 9 per ogni cifra. <dfn>Gli esadecimali</dfn> (o <dfn>hex</dfn>) sono numeri in base 16. Ciò significa che utilizzano sedici simboli distinti. Come per i i decimali, i simboli 0-9 rappresentano i valori da zero a nove. I successivi simboli A,B,C,D,E,F rappresentano i valori da dieci a quindici. Complessivamente, una cifra esadecimale può andare da 0 a F, dandoci 16 valori totali possibili. Qui puoi trovare ulteriori informazioni sul [sistema numerico esadecimale](https://it.wikipedia.org/wiki/Sistema_numerico_esadecimale).
 
-In CSS, possiamo usare 6 cifre esadecimali per rappresentare i colori, due ciascuna per le componenti rossa (R), verde (G) e blu (B). Ad esempio, `#000000` è nero ed è anche il valore più basso possibile. Qui puoi trovare maggiori informazioni sul [sistema di colori RGB](https://en.wikipedia.org/wiki/RGB_color_model).
+In CSS, possiamo usare 6 cifre esadecimali per rappresentare i colori, due ciascuna per le componenti rossa (R), verde (G) e blu (B). Ad esempio, `#000000` è nero ed è anche il valore più basso possibile. Qui puoi trovare maggiori informazioni sul [sistema di colori RGB](https://it.wikipedia.org/wiki/RGB).
 
 ```css
 body {

curriculum/challenges/italian/02-javascript-algorithms-and-data-structures/basic-javascript/counting-cards.md

@@ -9,7 +9,7 @@ dashedName: counting-cards
 
 # --description--
 
-Nel gioco di casinò Blackjack, un giocatore può guadagnare un vantaggio rispetto alla casa tenendo traccia del numero relativo di carte alte e basse rimanenti nel mazzo. Questo si chiama [Conteggio delle carte](https://en.wikipedia.org/wiki/Card_counting).
+Nel gioco di casinò Blackjack, un giocatore può guadagnare un vantaggio rispetto alla casa tenendo traccia del numero relativo di carte alte e basse rimanenti nel mazzo. Questo si chiama [Conteggio delle carte](https://it.wikipedia.org/wiki/Conteggio_delle_carte).
 
 Avere più carte alte rimanenti nel mazzo favorisce il giocatore. Ad ogni carta è assegnato un valore secondo la tabella sottostante. Quando il conteggio è positivo, il giocatore dovrebbe puntare alto. Quando il conteggio è zero o negativo, il giocatore dovrebbe puntare basso.
 

curriculum/challenges/italian/02-javascript-algorithms-and-data-structures/javascript-algorithms-and-data-structures-projects/caesars-cipher.md

@@ -10,9 +10,9 @@ dashedName: caesars-cipher
 
 Uno dei più semplici e più conosciuti <dfn>cifrari</dfn> è il <dfn>cifrario di Cesare</dfn>, noto anche come <dfn>cifrario a scorrimento</dfn>. In un cifrario a scorrimento i significati delle lettere sono spostati di un certo numero di posizioni.
 
-Un uso moderno comune è il cifrario [ROT13](https://en.wikipedia.org/wiki/ROT13), dove i valori delle lettere sono spostati di 13 posti. Così `A ↔ N`, `B ↔ O` e così via.
+Un uso moderno comune è il cifrario [ROT13](https://it.wikipedia.org/wiki/ROT13), dove i valori delle lettere sono spostati di 13 posti. Così `A ↔ N`, `B ↔ O` e così via.
 
-Scrivi una funzione che prenda una stringa codificata [ROT13](https://en.wikipedia.org/wiki/ROT13) come input e restituisca una stringa decodificata.
+Scrivi una funzione che prenda una stringa codificata [ROT13](https://it.wikipedia.org/wiki/ROT13) come input e restituisca una stringa decodificata.
 
 Tutte le lettere saranno maiuscole. Non trasformare alcun carattere non alfabetico (cioè spazi, punteggiatura), ma passali come sono.
 

curriculum/challenges/italian/02-javascript-algorithms-and-data-structures/regular-expressions/reuse-patterns-using-capture-groups.md

@@ -8,24 +8,28 @@ dashedName: reuse-patterns-using-capture-groups
 
 # --description--
 
-Alcuni pattern che cerchi si verificheranno più volte in una stringa. È una perdita di tempo ripetere manualmente quell'espressione regolare. C'è un modo migliore per specificare quando si hanno più sottostringhe ripetute nella stringa.
+Per esempio vuoi trovare una parola che compare più di una volta come qui sotto.
-
-È possibile cercare sottostringhe ripetute utilizzando i <dfn>gruppi di cattura</dfn>. Le parentesi, `(` e `)`, sono usate per trovare sottostringhe ripetute. Metti tra le parentesi l'espressione regolare del pattern che si ripeterà.
-
-Per specificare dove apparirà quella stringa ripetuta, si utilizza una barra rovesciata (`\`) e quindi un numero. Questo numero inizia da 1 e aumenta con ogni gruppo di cattura aggiuntivo che utilizzi. Un esempio potrebbe essere `\1` per abbinare il primo gruppo.
-
-L'esempio sottostante riconosce qualsiasi parola che compare due volte separata da uno spazio:
 
 ```js
-let repeatStr = "regex regex";
+let repeatStr = "row row row your boat";
-let repeatRegex = /(\w+)\s\1/;
-repeatRegex.test(repeatStr);
-repeatStr.match(repeatRegex);
 ```
 
-La chiamata a `test` restituirà `true` e la chiamata a `match` restituirà `["regex regex", "regex"]`.
+Potresti usare `/row row row/`, ma se non conosci la specifica parola ripetuta? <dfn>Gruppi di cattura</dfn> possono essere usati per trovare sequenze di caratteri ripetute.
+
+I gruppi di cattura sono costruiti mettendo delle parentesi torne attorno allo schema regex che deve essere catturato. In questo caso, l'obbiettivo è catturare una parora contente caratteri alfanumerici quindi il gruppo di cattura sarà `\w+` circondato da parentesi tonde: `/(\w+)/`.
+
+La sottostringa corrispondente al gruppo è salvata in una "variabile" temporanea, a cui è possibile accedere all'interno della stessa regex utilizzando una barra rovesciata e il numero del gruppo di cattura (per esempio `\1`). I gruppi di cattura sono numerati automaticamente dalla posizione delle parentesi di apertura (da sinistra a destra), a partire da 1.
+
+L'esempio sottostante riconosce qualsiasi parola che compare tre volte separata da spazi:
+
+```js
+let repeatRegex = /(\w+) \1 \1/;
+repeatRegex.test(repeatStr); // Returns true
+repeatStr.match(repeatRegex); // Returns ["row row row", "row"]
+```
+
+Usando il metodo `.match()` su una stringa, esso restituirà un array con la stringa che corrisponde insieme al suo gruppo di cattura.
 
-Usando il metodo `.match()` su una stringa esso restituirà un array con la stringa che corrisponde, insieme al suo gruppo di cattura.
 
 # --instructions--
 

curriculum/challenges/portuguese/02-javascript-algorithms-and-data-structures/es6/compare-scopes-of-the-var-and-let-keywords.md

@@ -10,7 +10,7 @@ dashedName: compare-scopes-of-the-var-and-let-keywords
 
 Quando você declara uma variável com a palavra-chave `var`, ela é declarada globalmente, ou localmente se declarada dentro de uma função.
 
-A palvara-chave `let` se comporta de forma similar, mas com alguns recursos extras. Quando você declara a variável com a palavra-chave `let` dentro de um bloco, declaração, ou expressão, seu escopo é limitado ao bloco, declaração, ou expressão.
+A palavra-chave `let` se comporta de forma similar, mas com alguns recursos extras. Quando você declara a variável com a palavra-chave `let` dentro de um bloco, declaração, ou expressão, seu escopo é limitado ao bloco, declaração, ou expressão.
 
 Por exemplo:
 
@@ -70,15 +70,15 @@ console.log(printNumTwo());
 console.log(i);
 ```
 
-Aqui o console vai exibir o valor `2`, e um erro que `i is not defined` (i não foi definido).
+Aqui o console vai exibir o valor `2`, e um erro que `i is not defined` (i não foi definida).
 
-`i` não foi definido porque não foi declarado no escopo global. É declarado apenas dentro da declaração do laço `for`. `printNumTwo()` retornou o valor correto porque três variáveis `i` distintas com valores únicos (0, 1 e 2) foram criados com a palavra-chave `let` dentro da declaração do laço.
+`i` não foi definida porque não foi declarada no escopo global. Ela é declarada apenas dentro da declaração do laço `for`. `printNumTwo()` retornou o valor correto porque três variáveis `i` distintas com valores únicos (0, 1 e 2) foram criadas com a palavra-chave `let` dentro da declaração do laço.
 
 # --instructions--
 
-Corrija o código para que `i` declarado dentro do comando `if` seja uma variável diferente de `i` declarada na primeira linha da função. Tenha certeza de não usar a palavra-chave `var` em nenhum lugar do seu código.
+Corrija o código para que a variável `i` declarada dentro do comando `if` seja diferente da variável `i` declarada na primeira linha da função. Tenha certeza de não usar a palavra-chave `var` em nenhum lugar do seu código.
 
-Este exercício foi projetado para ilustrar a diferença ente como as palavras-chaves `var` e `let` definem o escopo para a variável declarada. Quando programamos uma função semelhar a aquelas utilizadas no exercício, geralmente é melhor utilizar variáveis distintas para evitar confusão.
+Este exercício foi projetado para ilustrar a diferença ente como as palavras-chaves `var` e `let` definem o escopo para a variável declarada. Quando programamos uma função semelhante a aquelas utilizadas no exercício, geralmente, é melhor utilizar variáveis distintas para evitar confusão.
 
 # --hints--
 

curriculum/challenges/portuguese/02-javascript-algorithms-and-data-structures/es6/complete-a-promise-with-resolve-and-reject.md

@@ -8,7 +8,7 @@ dashedName: complete-a-promise-with-resolve-and-reject
 
 # --description--
 
-Uma promessa possui três estados: pendente (`pending`), cumprida (`fulfilled`) e rejeitada (`rejected`). A promessa que você criou no desafio anterior está presa no estado `pending` para sempre porque você não adicionou uma forma de concluir a promessa. Os parâmetros `resolve` e `reject` passados para o argumento da promessa servem para este propósito. `resolve` é utilizado quando a promessa for bem sucedida, enquanto que `reject` é utilizado quando ela falhar. Ambos são métodos que recebem apenas um argumento, como no exemplo abaixo.
+Uma promessa possui três estados: pendente (`pending`), cumprida (`fulfilled`) e rejeitada (`rejected`). A promessa que você criou no desafio anterior está presa no estado `pending` para sempre porque você não adicionou uma forma de concluir a promessa. Os parâmetros `resolve` e `reject` passados para o argumento da promessa servem para este propósito. `resolve` é utilizado quando a promessa for bem-sucedida, enquanto `reject` é utilizado quando ela falhar. Ambos são métodos que recebem apenas um argumento, como no exemplo abaixo.
 
 ```js
 const myPromise = new Promise((resolve, reject) => {
@@ -20,7 +20,7 @@ const myPromise = new Promise((resolve, reject) => {
 });
 ```
 
-O exemplo acima usa strings como argumento desses métodos, mas você pode passar qualquer outro tipo de dado. Geralmente, é passado um objeto para esses métodos. Assim você pode acessar as propriedades deste objeto e usá-los em seu site ou em qualquer outro lugar.
+O exemplo acima usa strings como argumento desses métodos, mas você pode passar qualquer outro tipo de dado. Geralmente, é passado um objeto para esses métodos. Assim você pode acessar as propriedades deste objeto e usá-las em seu site ou em qualquer outro lugar.
 
 # --instructions--
 

curriculum/challenges/portuguese/02-javascript-algorithms-and-data-structures/es6/create-a-javascript-promise.md

@@ -8,7 +8,7 @@ dashedName: create-a-javascript-promise
 
 # --description--
 
-Uma promessa em JavaScript é exatamente o que parece - você faz a promessa de que vai fazer uma tarefa, geralmente de forma assíncrona. Quando a tarefa é finalizada, ou você cumpriu a promessa ou falhou ao tentar. Por ser uma função construtora, você precisa utilizar a palavra-chave `new` para criar uma `Promise`. Ele recebe uma função, como seu arguemento, com dois parâmetros - `resolve` e `reject`. Esses métodos são usados para determinar o resultado da promessa. A sintaxe se parecesse com isso:
+Uma promessa em JavaScript é exatamente o que parece - você faz a promessa de que vai fazer uma tarefa, geralmente de forma assíncrona. Quando a tarefa é finalizada, ou você cumpriu a promessa ou falhou ao tentar. Por ser uma função construtora, você precisa utilizar a palavra-chave `new` para criar uma `Promise`. Ela recebe uma função, como seu argumento, com dois parâmetros - `resolve` e `reject`. Esses métodos são usados para determinar o resultado da promessa. A sintaxe se assemelha a:
 
 ```js
 const myPromise = new Promise((resolve, reject) => {

curriculum/challenges/portuguese/02-javascript-algorithms-and-data-structures/es6/create-a-module-script.md

@@ -8,7 +8,7 @@ dashedName: create-a-module-script
 
 # --description--
 
-O JavaScript nasceu com com o objetivo de cumprir um pequeno papel em uma web onde tudo era, na maior parte, HTML. Hoje, o JavaScript é gigante. Para se ter noção, alguns websites são construídos quase que inteiramente em JavaScript. A fim de tornar o JavaScript mais modular, limpo e passível de manutenção, a versão ES6 introduziu uma forma mais simples de compartilhar códigos entre arquivos JavaScript. Dessa forma, você consegue exportar partes de um arquivo e usá-los em arquivos externos bem como importar as partes que você precisa. Para tirar proveito dessa funcionalidade, você precisa crair uma tag script com o atributo `type` de valor `module` no seu documento HTML. Exemplo:
+O JavaScript nasceu com com o objetivo de cumprir um pequeno papel em uma web onde tudo era, na maior parte, HTML. Hoje, o JavaScript é gigante. Para se ter noção, alguns websites são construídos quase que inteiramente em JavaScript. A fim de tornar o JavaScript mais modular, limpo e passível de manutenção, a versão ES6 introduziu uma forma mais simples de compartilhar códigos entre arquivos JavaScript. Dessa forma, você consegue exportar partes de um arquivo e usá-los em arquivos externos bem como importar as partes de que você precisa. Para tirar proveito dessa funcionalidade, você precisa criar uma tag script com o atributo `type` de valor `module` no seu documento HTML. Exemplo:
 
 ```html
 <script type="module" src="filename.js"></script>

curriculum/challenges/portuguese/02-javascript-algorithms-and-data-structures/es6/create-strings-using-template-literals.md

@@ -10,7 +10,7 @@ dashedName: create-strings-using-template-literals
 
 Um novo recurso introduzido na versão ES6 é o <dfn>template literal</dfn>. Esse é um tipo especial de string que torna mais fácil a criação de strings complexas.
 
-Template literals nos permite criar strings de mais de uma linha e usar os recursos de interpolação de strings.
+Template literals nos permitem criar strings de mais de uma linha e usar os recursos de interpolação de strings.
 
 Considere o código abaixo:
 
@@ -28,7 +28,7 @@ console.log(greeting);
 
 O console vai exibir as strings `Hello, my name is Zodiac Hasbro!` e `I am 56 years old.`.
 
-Muitas coisas aconteceram aqui. Primeiro, o exemplo utiliza crases, ou backticks em Inglês, (`` ` ``), ao invés de aspas (`'` ou `"`), ao redor da string. Segundo, note que a string tem mais de uma linha, tanto no código quanto na saída. Isso torna desnecessário inserir `\n` dentro das strings. A sintaxe `${variable}` usada acima é um espaço reservado (placeholder). Basicamente, você não terá mais que usar concatenação com o operador `+`. Para adicionar o valor de uma variável à string, você a envolve com `${` e `}`. Além de poder usar variáveis, você pode incluir outras expressões. Como por exemplo `${a + b}`. Essa nova maneira de criar strings te dá mais flexibilidade na hora de criar string complexas.
+Muitas coisas aconteceram aqui. Primeiro, o exemplo utiliza crases (ou backticks, em inglês, `` ` ``), ao invés de aspas (`'` ou `"`), ao redor da string. Segundo, note que a string tem mais de uma linha, tanto no código quanto na saída. Isso torna desnecessário inserir `\n` dentro das strings. A sintaxe `${variable}` usada acima é um espaço reservado (placeholder). Basicamente, você não terá mais que usar concatenação com o operador `+`. Para adicionar o valor de uma variável à string, você a envolve com `${` e `}`. Além de poder usar variáveis, você pode incluir outras expressões. Como por exemplo `${a + b}`. Essa nova maneira de criar strings te dá mais flexibilidade na hora de criar string complexas.
 
 # --instructions--
 

curriculum/challenges/portuguese/02-javascript-algorithms-and-data-structures/es6/declare-a-read-only-variable-with-the-const-keyword.md

@@ -10,16 +10,16 @@ dashedName: declare-a-read-only-variable-with-the-const-keyword
 
 A palavra-chave `let` não é a única nova forma de declarar variáveis. Na versão ES6, você também pode declarar variáveis usando a palavra-chave `const`.
 
-`const` possui todos os recursos maravilhosos que `let` tem, com o bônus adicional que variáveis declaradas usando `const` são somente de leitura. Eles são um valor constante, o que significa que uma vez que a variável é atribuída com `const`, não pode ser atribuída novamente.
+`const` possui todos os recursos maravilhosos que `let` tem, com o bônus adicional que variáveis declaradas usando `const` são somente de leitura. Elas têm um valor constante, o que significa que a variável atribuída com `const` não pode ser atribuída novamente.
 
 ```js
 const FAV_PET = "Cats";
 FAV_PET = "Dogs";
 ```
 
-O console irá exibir um erro devido à reatribuição do valor de `FAV_PET`.
+O console vai exibir um erro devido à reatribuição do valor de `FAV_PET`.
 
-Como você pode ver, tentar reatribuir uma variável declarada com `const` lançará um erro. Você sempre deve nomear variáveis que você não quer reatribuir, usando a palavra-chave `const`. Isso ajuda quando você acidentalmente tenta reatribuir uma variável que deveria ser constante. Uma prática comum ao nomear constantes é colocar todas as letras em maiúsculas, com palavras separadas por sublinhado (underscore ou underline).
+Como você pode ver, tentar reatribuir uma variável declarada com `const` lançará um erro. Você sempre deve nomear variáveis que você não quer reatribuir, usando a palavra-chave `const`. Isso ajuda quando você acidentalmente tenta reatribuir uma variável que deveria ser constante. Uma prática comum ao nomear constantes é colocar todas as letras em maiúsculas, com palavras separadas por sublinhado (underscore).
 
 **Observação:** é comum que os desenvolvedores usem nomes de variáveis maiúsculas para valores imutáveis e minúsculas ou camelCase para valores mutáveis (objetos e arrays). Em um desafio posterior, você verá um exemplo de um nome de variável em minúsculo usado para um array.
 

curriculum/challenges/portuguese/02-javascript-algorithms-and-data-structures/es6/explore-differences-between-the-var-and-let-keywords.md

@@ -18,7 +18,7 @@ console.log(camper);
 
 Aqui o console vai exibir a string `David`.
 
-Como você pode ver no código acima, a variável `camper` é originalmente declarada com o valor `James` e então substituída pelo valor `David`. Em uma aplicação pequena, você pode não encontrar esse tipo de problema, mas quando seu código se tornar maior, você pode acidentalmente sobrescrever uma variável que você não tinha a intenção. Como esse comportamente não lança nenhum erro, procurar e corrigir bugs se torna mais difícil.  
+Como você pode ver no código acima, a variável `camper` é originalmente declarada com o valor `James` e então substituída pelo valor `David`. Em uma aplicação pequena, você pode não encontrar esse tipo de problema, mas quando seu código se tornar maior, você pode acidentalmente sobrescrever uma variável que você não tinha a intenção. Como esse comportamento não lança nenhum erro, procurar e corrigir bugs se torna mais difícil.  
 Para resolver esse potencial problema com a palavra-chave `var`, uma nova palavra-chave chamada `let` foi introduzida no ES6. Se você tentar substituir `var` por `let` nas declarações de variável do código acima, o resultado será um erro.
 
 ```js
@@ -33,7 +33,7 @@ Esse erro pode ser visto no console do seu navegador. Então, diferente de `var`
 x = 3.14;
 ```
 
-O codigo acima vai exibir o erro: `x is not defined`.
+O código acima vai exibir o erro: `x is not defined`.
 
 # --instructions--
 

curriculum/challenges/portuguese/02-javascript-algorithms-and-data-structures/es6/handle-a-rejected-promise-with-catch.md

@@ -8,7 +8,7 @@ dashedName: handle-a-rejected-promise-with-catch
 
 # --description--
 
-`catch` é o método usado quando a promessa é rejeitada. Ele é executada imediatamente após o método `reject` da promessa ser chamado. Aqui está a sintaxe:
+`catch` é o método usado quando a promessa é rejeitada. Ele é executado imediatamente após o método `reject` da promessa ser chamado. Aqui está a sintaxe:
 
 ```js
 myPromise.catch(error => {

curriculum/challenges/portuguese/02-javascript-algorithms-and-data-structures/es6/import-a-default-export.md

@@ -8,13 +8,13 @@ dashedName: import-a-default-export
 
 # --description--
 
-No último desafio, você aprendeu sobre `export default` e seus usos. Para importar uma exportação padrão, você precisa usar uma sintaxe diferente de `import`. No exemplo a seguir, `add` é a exportação padrão do arquivo `math_functions.js`. Veja como importá-lo:
+No último desafio, você aprendeu sobre `export default` e seus usos. Para importar uma exportação padrão, você precisa usar uma sintaxe diferente de `import`. No exemplo a seguir, `add` é a exportação padrão do arquivo `math_functions.js`. Veja como importá-la:
 
 ```js
 import add from "./math_functions.js";
 ```
 
-A sintaxe é diferente em apenas um ponto. O valor importado, `add`, não está rodeado por chaves (`{}`). Aqui, `add` é simplesmente uma palavra qualquer que irá ser usada para identificar a variável sendo exportada do arquivo `math_functions.js`. Você pode usar qualquer nome ao importar algo que foi exportado como padrão.
+A sintaxe é diferente em apenas um ponto. O valor importado, `add`, não está rodeado por chaves (`{}`). Aqui, `add` é simplesmente uma palavra qualquer que vai ser usada para identificar a variável sendo exportada do arquivo `math_functions.js`. Você pode usar qualquer nome ao importar algo que foi exportado como padrão.
 
 # --instructions--
 

curriculum/challenges/portuguese/02-javascript-algorithms-and-data-structures/es6/prevent-object-mutation.md

@@ -10,7 +10,7 @@ dashedName: prevent-object-mutation
 
 Como visto no desafio anterior, a declaração `const` sozinha, na verdade, não protege a mutação de seus dados. Para garantir que seus dados não mudem, o JavaScript fornece a função `Object.freeze` que previne os dados de serem modificados.
 
-Uma vez congelado, você não pode mais adicionar, atualizar ou deletar as propriedades deste objeto. Qualquer tentativa de mudar o objeto será rejeitada. Observe que nenhum erro é lançado.
+Ao congelar o objeto, você não pode mais adicionar, atualizar ou deletar as propriedades dele. Qualquer tentativa de mudar o objeto será rejeitada. Observe que nenhum erro é lançado.
 
 ```js
 let obj = {

curriculum/challenges/portuguese/02-javascript-algorithms-and-data-structures/es6/use-arrow-functions-to-write-concise-anonymous-functions.md

@@ -8,7 +8,7 @@ dashedName: use-arrow-functions-to-write-concise-anonymous-functions
 
 # --description--
 
-No JavaScript, muitas vezes não precisamos nomear nossas funções, especialmente quando passamos uma função como argumento para outra função. Em vez disso, criamos funções anônimas. Como não iremos reutilizar essas funções posteriormente, não precisamos nomeá-las.
+No JavaScript, muitas vezes não precisamos nomear nossas funções, especialmente quando passamos uma função como argumento para outra função. Em vez disso, criamos funções anônimas. Como não vamos reutilizar essas funções posteriormente, não precisamos nomeá-las.
 
 Para fazer isso, geralmente usamos a seguinte sintaxe:
 
@@ -48,7 +48,7 @@ Você deve substituir a palavra-chave `var`.
 (getUserInput) => assert(!getUserInput('index').match(/var/g));
 ```
 
-A variável `magic` deve ser uma variável constante (use `const`).
+A variável `magic` deve ser uma constante (use `const`).
 
 ```js
 (getUserInput) => assert(getUserInput('index').match(/const\s+magic/g));

curriculum/challenges/portuguese/02-javascript-algorithms-and-data-structures/es6/use-class-syntax-to-define-a-constructor-function.md

@@ -1,6 +1,6 @@
 ---
 id: 587d7b8b367417b2b2512b53
-title: Use a sintaxe de classe para criar uma função construtora
+title: Usar a sintaxe de classe para criar uma função construtora
 challengeType: 1
 forumTopicId: 301212
 dashedName: use-class-syntax-to-define-a-constructor-function

curriculum/challenges/portuguese/02-javascript-algorithms-and-data-structures/es6/use-destructuring-assignment-to-extract-values-from-objects.md

@@ -1,6 +1,6 @@
 ---
 id: 5cfa550e84205a357704ccb6
-title: Use Atribuição de Desestruturação para Extrair Valores de Objetos
+title: Usar atribuição de desestruturação para extrair valores de objetos
 challengeType: 1
 forumTopicId: 301216
 dashedName: use-destructuring-assignment-to-extract-values-from-objects
@@ -8,7 +8,7 @@ dashedName: use-destructuring-assignment-to-extract-values-from-objects
 
 # --description--
 
-<dfn>Atribuição de Desestruturação</dfn> é uma sintaxe especial introduzida na ES6, para atribuir nitidamente valores retirados diretamente de um objeto.
+<dfn>Atribuição de desestruturação</dfn> é uma sintaxe especial introduzida na ES6, para atribuir nitidamente valores retirados diretamente de um objeto.
 
 Considere o seguinte código ES5:
 
@@ -29,7 +29,7 @@ const { name, age } = user;
 
 Novamente, `name` teria o valor da string `John Doe` e `age` teria o número `34`.
 
-Aqui, as variáveis `name` e `age` serão criadas e atribuídas a elas os valores de seus respectivos valores do objeto `user`. Você pode ver quão mais limpo é.
+Aqui, as variáveis `name` e `age` serão criadas e atribuídas a elas os valores de seus respectivos valores do objeto `user`. Você pode ver que fica muito mais limpo.
 
 Você pode extrair quantos valores do objeto quanto você quer.
 

curriculum/challenges/portuguese/02-javascript-algorithms-and-data-structures/es6/use-destructuring-assignment-to-pass-an-object-as-a-functions-parameters.md

@@ -53,7 +53,7 @@ Desestruturação deve ser usado.
 assert(__helpers.removeWhiteSpace(code).match(/half=\({\w+,\w+}\)/));
 ```
 
-Parâmetro desestruturado deve ser usado.
+O parâmetro desestruturado deve ser usado.
 
 ```js
 assert(!code.match(/stats\.max|stats\.min/));

curriculum/challenges/portuguese/02-javascript-algorithms-and-data-structures/es6/use-destructuring-assignment-with-the-rest-parameter-to-reassign-array-elements.md

@@ -22,7 +22,7 @@ console.log(arr);
 
 O console exibiria os valores `1, 2` e `[3, 4, 5, 7]`.
 
-As variáveis `a` e `b` pegam o primeiro e o segundo valores do array. Após isso, por causa da presença do parâmetro rest, `arr` pega o resto dos valores na forma de um array. O elemento rest só funciona corretamente como a última variável na lista. Como em, você não pode usar o parâmetro rest para capturar um subarray que deixa de fora o último elemento do array original.
+As variáveis `a` e `b` pegam o primeiro e o segundo valores do array. Depois disso, por causa da presença do parâmetro rest, `arr` pega o resto dos valores na forma de um array. O elemento rest só funciona corretamente como a última variável na lista. De momento, você não pode usar o parâmetro rest para capturar um sub-array que deixa de fora o último elemento do array original.
 
 # --instructions--
 

curriculum/challenges/portuguese/02-javascript-algorithms-and-data-structures/es6/use-getters-and-setters-to-control-access-to-an-object.md

@@ -48,7 +48,7 @@ Use a palavra-chave `class` para criar a classe `Thermostat`. O `constructor` ac
 
 Na classe, crie um `getter` para obter a temperatura em Celsius e um `setter` para definir a temperatura em Celsius.
 
-Lembre-se que `C = 5/9 * (F - 32)` e `F = C * 9.0 / 5 + 32`, aonde `F` é o valor da temperatura em Fahrenheit e `C` é o valor da mesma temperatura em Celsius.
+Lembre-se de que `C = 5/9 * (F - 32)` e `F = C * 9.0 / 5 + 32`, aonde `F` é o valor da temperatura em Fahrenheit e `C` é o valor da mesma temperatura em Celsius.
 
 **Observação:** quando você implementa isso, você vai rastrear a temperatura dentro da classe em uma escala, ou Fahrenheit ou Celsius.
 

curriculum/challenges/portuguese/02-javascript-algorithms-and-data-structures/es6/use-the-spread-operator-to-evaluate-arrays-in-place.md

@@ -1,6 +1,6 @@
 ---
 id: 587d7b89367417b2b2512b48
-title: Use o operador spread para avaliar arrays na hora
+title: Usar o operador spread para avaliar arrays na hora
 challengeType: 1
 forumTopicId: 301222
 dashedName: use-the-spread-operator-to-evaluate-arrays-in-place
@@ -8,7 +8,7 @@ dashedName: use-the-spread-operator-to-evaluate-arrays-in-place
 
 # --description--
 
-ES6 introduz o <dfn>operador spread</dfn>, o qual nos permite expandir arrays e outras expresões no lugar aonde é esperado diversos parâmetros ou elementos.
+ES6 introduz o <dfn>operador spread</dfn>, o qual nos permite expandir arrays e outras expressões no lugar aonde é esperado diversos parâmetros ou elementos.
 
 O código em ES5 abaixo usa `apply()` para calcular o valor máximo de um array:
 

curriculum/challenges/portuguese/02-javascript-algorithms-and-data-structures/es6/write-concise-object-literal-declarations-using-object-property-shorthand.md

@@ -40,7 +40,7 @@ assert.deepEqual(
 );
 ```
 
-Seu código deve usar `key:value`.
+O código deve usar `key:value`.
 
 ```js
 (getUserInput) => assert(!getUserInput('index').match(/:/g));

curriculum/challenges/portuguese/02-javascript-algorithms-and-data-structures/functional-programming/add-elements-to-the-end-of-an-array-using-concat-instead-of-push.md

@@ -27,13 +27,13 @@ Modifique a função `nonMutatingPush` de forma que ela use `concat` para adicio
 
 # --hints--
 
-O seu código deve usar o método `concat`.
+O código deve usar o método `concat`.
 
 ```js
 assert(code.match(/\.concat/g));
 ```
 
-O seu código não deve usar o método `push`.
+O código não deve usar o método `push`.
 
 ```js
 assert(!code.match(/\.?[\s\S]*?push/g));

curriculum/challenges/portuguese/02-javascript-algorithms-and-data-structures/functional-programming/apply-functional-programming-to-convert-strings-to-url-slugs.md

@@ -8,11 +8,11 @@ dashedName: apply-functional-programming-to-convert-strings-to-url-slugs
 
 # --description--
 
-Os últimos desafios cobriram uma série de métodos úteis de strings e arrays que usam princípios de programação funcional. Também aprendemos o poderoso método `reduce`, que é usado para reduzir arrays a um único valor. Seja para calcular médias ou para ordenação, qualquer operação de array pode ser feita ao usá-lo. Lembre-se que `map` e `filter` são casos especiais de `reduce`.
+Os últimos desafios cobriram uma série de métodos úteis de strings e arrays que usam princípios de programação funcional. Também aprendemos o poderoso método `reduce`, que é usado para reduzir arrays a um único valor. Seja para calcular médias ou para ordenação, qualquer operação de array pode ser feita ao usá-lo. Lembre-se de que `map` e `filter` são casos especiais de `reduce`.
 
 Vamos combinar o que aprendemos para resolver um problema prático.
 
-Muitos sites de gerenciamento de conteúdo (*content management sites*, CMS) usam o título das publicações como parte da URL para maior legibilidade. Por exemplo, se você publicar um artigo no Medium chamado `Pare de Usar reduce`, é provável que a URL use o título em sua composição: `.../pare-de-usar-reduce`. Talvez você já tenha percebido que acontece o mesmo no freeCodeCamp.
+Muitos sites de gerenciamento de conteúdo (*content management sites*, CMS) usam o título das publicações como parte da URL para maior legibilidade. Por exemplo, se você publicar um artigo no Medium chamado `Stop Using Reduce`, é provável que o URL use o título em sua composição: `.../stop-using-reduce`. Talvez você já tenha percebido que acontece o mesmo no freeCodeCamp.
 
 # --instructions--
 

curriculum/challenges/portuguese/02-javascript-algorithms-and-data-structures/functional-programming/avoid-mutations-and-side-effects-using-functional-programming.md

@@ -12,11 +12,11 @@ Caso você ainda não tenha descoberto, o problema do desafio anterior é com a
 
 Este é apenas um pequeno exemplo - você chama uma função e passa uma variável, array ou objeto a ela; a função modifica a variável ou alguma coisa no objeto.
 
-Um dos principais princípios da programação funcional é que não devemos alterar coisas. Alterações levam a bugs. É mais fácil prever bugs quando se sabe que as funções não mudam nada. Incluindo os seus argumentos e as variáveis globais.
+Um dos principais princípios da programação funcional é que não devemos alterar coisas. Alterações levam a bugs. É mais fácil prever bugs quando se sabe que as funções não mudam nada, nem mesmo os argumentos e as variáveis globais.
 
 No exemplo anterior não havia nenhuma operação complicada, mas o método `splice` modificou o array original e o resultado foi um bug.
 
-Lembre-se que, em programação funcional, modificar ou alterar coisas é chamado de <dfn>mutação</dfn> e a consequência é chamada de <dfn>efeito colateral</dfn>. Idealmente, uma função deveria ser uma <dfn>função pura</dfn>, que é uma função que não causa efeitos colaterais.
+Lembre-se de que, em programação funcional, modificar ou alterar coisas é chamado de <dfn>mutação</dfn> e a consequência é chamada de <dfn>efeito colateral</dfn>. Idealmente, uma função deveria ser uma <dfn>função pura</dfn>, que é uma função que não causa efeitos colaterais.
 
 Vamos tentar dominar esta disciplina e não alterar nenhuma variável ou objeto em nosso código.
 
@@ -26,21 +26,21 @@ Complete o código da função `incrementer` para que ela retorne o valor da var
 
 # --hints--
 
-Sua função `incrementer` não deve alterar o valor de `fixedValue` (que é `4`).
+A função `incrementer` não deve alterar o valor de `fixedValue` (que é `4`).
 
 ```js
 incrementer();
 assert(fixedValue === 4);
 ```
 
-Sua função `incrementer` deve retornar um valor que é maior que o valor `fixedValue`.
+A função `incrementer` deve retornar um valor que é maior que o valor `fixedValue`.
 
 ```js
 const __newValue = incrementer();
 assert(__newValue === 5);
 ```
 
-Sua função `incrementer` deve retornar um valor baseado no valor da variável global `fixedValue`.
+A função `incrementer` deve retornar um valor baseado no valor da variável global `fixedValue`.
 
 ```js
 (function () {

curriculum/challenges/portuguese/02-javascript-algorithms-and-data-structures/functional-programming/combine-an-array-into-a-string-using-the-join-method.md

@@ -20,7 +20,7 @@ var str = arr.join(" ");
 O valor de `str` é `Hello World`.
 # --instructions--
 
-Use o método `join` (junto com outros) dentro da função `sentensify` para criar uma frase a partir das palavras da string `str`. A função deve retornar uma string. Por exemplo, `I-like-Star-Wars` deve ser convertido para `I like Star Wars`. Não use o método `replace` neste desafio.
+Use o método `join` (entre outros) dentro da função `sentensify` para criar uma frase a partir das palavras da string `str`. A função deve retornar uma string. Por exemplo, `I-like-Star-Wars` deve ser convertido para `I like Star Wars`. Não use o método `replace` neste desafio.
 
 # --hints--
 

curriculum/challenges/portuguese/02-javascript-algorithms-and-data-structures/functional-programming/implement-map-on-a-prototype.md

@@ -8,7 +8,7 @@ dashedName: implement-map-on-a-prototype
 
 # --description--
 
-Como você viu ao aplicar `Array.prototype.map()`, ou simplesmente `map()` mais cedo, o método `map` retorna um array do mesmo tamanho que o no qual chamamos o método. Ele também não altera o array original desde que a sua função callback não o faça.
+Como você viu ao aplicar `Array.prototype.map()`, ou simplesmente `map()` mais cedo, o método `map` retorna um array do mesmo tamanho que o no qual chamamos o método. Ele também não altera o array original desde que a função de callback não o faça.
 
 Em outras palavras, `map` é uma função pura e a sua saída depende somente de suas entradas. Além disso, ele recebe outra função como argumento.
 

curriculum/challenges/portuguese/02-javascript-algorithms-and-data-structures/functional-programming/introduction-to-currying-and-partial-application.md

@@ -73,7 +73,7 @@ assert(add(1)(2)(3) === 6);
 assert(add(11)(22)(33) === 66);
 ```
 
-Em seu código deve haver uma instrução final que retorna `x + y + z`.
+No código deve haver uma instrução final que retorna `x + y + z`.
 
 ```js
 assert(code.match(/[xyz]\s*?\+\s*?[xyz]\s*?\+\s*?[xyz]/g));

curriculum/challenges/portuguese/02-javascript-algorithms-and-data-structures/functional-programming/pass-arguments-to-avoid-external-dependence-in-a-function.md

@@ -40,7 +40,7 @@ A função `incrementer` deve receber um argumento.
 assert(incrementer.length === 1);
 ```
 
-Sua função `incrementer` deve retornar um valor que é maior que o valor `fixedValue`.
+A função `incrementer` deve retornar um valor que é maior que o valor `fixedValue`.
 
 ```js
 const __newValue = incrementer(fixedValue);

curriculum/challenges/portuguese/02-javascript-algorithms-and-data-structures/functional-programming/refactor-global-variables-out-of-functions.md

@@ -20,7 +20,7 @@ Incrementar um número em um não é tão divertido, mas podemos aplicar esses p
 
 Reescreva o código de forma que o array global `bookList` não seja alterado em nenhuma das funções. A função `add` deve adicionar o nome do livro, `bookName` ao array passado e retornar um novo array. A função `remove` deve remover o `bookName` do array passado a ela.
 
-**Obs:** Ambas as funções devem retornar um array e novos parâmetros devem ser adicionados antes do parâmetro `bookName`.
+**Observação:** ambas as funções devem retornar um array e novos parâmetros devem ser adicionados antes do parâmetro `bookName`.
 
 # --hints--
 

curriculum/challenges/portuguese/02-javascript-algorithms-and-data-structures/functional-programming/remove-elements-from-an-array-using-slice-instead-of-splice.md

@@ -17,7 +17,7 @@ cities.splice(3, 1);
 
 Aqui `splice` retorna a string `London` e a remove do array cities. `cities` terá o valor `["Chicago", "Delhi", "Islamabad", "Berlin"]`.
 
-Como vimos no último desafio, o método `slice` não altera o array original; ele retorna um novo array que pode ser armazenado em uma variável. Lembre-se que o método `slice` toma dois argumentos para os índices de início e fim e retorna um array com os elementos presentes entre esses índices (o índice de fim é não-inclusivo). Usar o método `slice` em vez do `splice` ajuda a evitar alterações em arrays e, portanto, efeitos colaterais.
+Como vimos no último desafio, o método `slice` não altera o array original; ele retorna um novo array que pode ser armazenado em uma variável. Lembre-se de que o método `slice` toma dois argumentos para os índices de início e fim e retorna um array com os elementos presentes entre esses índices (o índice de fim é não-inclusivo). Usar o método `slice` em vez do `splice` ajuda a evitar alterações em arrays e, portanto, efeitos colaterais.
 
 # --instructions--
 

curriculum/challenges/portuguese/02-javascript-algorithms-and-data-structures/functional-programming/sort-an-array-alphabetically-using-the-sort-method.md

@@ -8,7 +8,7 @@ dashedName: sort-an-array-alphabetically-using-the-sort-method
 
 # --description--
 
-O método `sort` consegue ordenar os elementos de um array de acordo com uma função callback.
+O método `sort` consegue ordenar os elementos de um array de acordo com uma função de callback.
 
 Por exemplo:
 
@@ -34,7 +34,7 @@ reverseAlpha(['l', 'h', 'z', 'b', 's']);
 
 Este retorna o valor `['z', 's', 'l', 'h', 'b']`.
 
-O método de ordenação padrão do JavaScript é por valores de ponto Unicode, o que pode nos dar resultados inesperados. Por isso você é encorajado a providenciar uma função callback para especificar como a ordenação deve ocorrer. Quando tal função callback (comumente chamada de `compareFunction`, ou função de comparação) é providenciada, os elementos do array são ordenados de acordo com o valor de retorno dela: se `compareFunction(a,b)` retornar um valor menor que 0 para dois elementos `a` e `b`, então `a` virá antes de `b`. Se `compareFunction(a,b)` retornar um valor maior que 0 para dois elementos `a` e `b`, então `b` virá antes de `a`. Finalmente, se `compareFunction(a,b)` retornar 0, então `a` e `b` não trocarão de lugar entre si.
+O método de ordenação padrão do JavaScript é por valores de ponto Unicode, o que pode nos dar resultados inesperados. Por isso você é encorajado a providenciar uma função de callback para especificar como a ordenação deve ocorrer. Quando tal função callback (comumente chamada de `compareFunction`, ou função de comparação) é providenciada, os elementos do array são ordenados de acordo com o valor de retorno dela: se `compareFunction(a,b)` retornar um valor menor que 0 para dois elementos `a` e `b`, então `a` virá antes de `b`. Se `compareFunction(a,b)` retornar um valor maior que 0 para dois elementos `a` e `b`, então `b` virá antes de `a`. Finalmente, se `compareFunction(a,b)` retornar 0, então `a` e `b` não trocarão de lugar entre si.
 
 # --instructions--
 

curriculum/challenges/portuguese/02-javascript-algorithms-and-data-structures/functional-programming/understand-functional-programming-terminology.md

@@ -14,7 +14,7 @@ Por causa disso, precisaremos rever a função `getTea` do último desafio para
 
 Mas primeiro, vejamos um pouco de terminologia funcional:
 
-<dfn>Callbacks</dfn> são funções que são passadas a outras funções, que decidem quando e como são chamados. Você pode ter visto alguns sendo passados a outros métodos. Em `filter`, por exemplo, o callback diz ao JavaScript qual é o critério para filtrar um array.
+<dfn>Callbacks</dfn> são funções que são passadas a outras funções, que decidem quando e como são chamados. Você pode ter visto alguns sendo passados a outros métodos. Em `filter`, por exemplo, a função de callback diz ao JavaScript qual é o critério para filtrar um array.
 
 Funções que podem ser atribuídas a variáveis, passadas a outras funções ou retornadas de outra função como qualquer outro valor são chamadas de <dfn>funções de primeira classe</dfn>. Em JavaScript, todas as funções são funções de primeira classe.
 
@@ -26,7 +26,7 @@ Funções podem ser chamadas de <dfn>lambda</dfn> quando passadas para outra fun
 
 Prepare 27 xícaras de chá verde e 13 xícaras de chá preto; armazene-as nas variáveis `tea4GreenTeamFCC` e `tea4BlackTeamFCC`, respectivamente. Perceba que a função `getTea` foi alterada para receber uma função como primeiro argumento.
 
-Obs: O número de xícaras de chá se tornou o último parâmetro da função. Discutiremos mais sobre isso nas próximas aulas.
+Observação: o número de xícaras de chá se tornou o último parâmetro da função. Discutiremos mais sobre isso nas próximas aulas.
 
 # --hints--
 

curriculum/challenges/portuguese/02-javascript-algorithms-and-data-structures/functional-programming/understand-the-hazards-of-using-imperative-code.md

@@ -16,9 +16,9 @@ Essas instruções frequentemente alteram o estado do programa ao atualizar vari
 
 Em contrapartida, a programação funcional é uma forma de programação declarativa. Você diz ao computador o que quer fazer chamando um método ou função.
 
-O JavaScript oferece muitos métodos predefinidos que lidam com tarefas comuns, então você não precisa escrever como o computador deve executá-las. Por exemplo, em vez de usar um loop `for`, você pode chamar o método `map`, que lida com os detalhes de como percorrer um array. Isso ajuda a evitar erros semânticos, como o "Off By One", que foram cobertos na seção de depuração.
+O JavaScript oferece muitos métodos predefinidos que lidam com tarefas comuns, então você não precisa escrever como o computador deve executá-las. Por exemplo, em vez de usar um loop `for`, você pode chamar o método `map`, que lida com os detalhes de como percorrer um array. Isso ajuda a evitar erros semânticos, como os erros de "Off By One" (fora por um), que foram cobertos na seção de depuração.
 
-Considere o cenário: você está navegando na web com o seu navegador e quer rastrear as abas que você abriu. Vamos tentar modelar isso usando orientação a objetos de forma simples.
+Considere o cenário: você está navegando na web com o navegador e quer rastrear as abas que você abriu. Vamos tentar modelar isso usando orientação a objetos de forma simples.
 
 Um objeto Window (Janela) é composto de abas e normalmente há mais de uma janela aberta. Os títulos de cada site aberto em cada objeto Window é armazenado em um array. Depois de usar o navegador (abrindo novas abas, juntando janelas, fechando abas), você quer imprimir as abas que ainda estão abertas. Abas fechadas são removidas do array e novas abas são adicionadas ao fim dele (por simplicidade).
 

curriculum/challenges/portuguese/02-javascript-algorithms-and-data-structures/functional-programming/use-higher-order-functions-map-filter-or-reduce-to-solve-a-complex-problem.md

@@ -14,7 +14,7 @@ Agora que você já realizou alguns desafios usando funções de ordem superior
 
 Complete o código para a função `squareList` usando qualquer combinação de `map()`, `filter()` e `reduce()`. A função deve retornar uma nova matriz contendo *apenas* os inteiros positivos (números decimais não são inteiros) elevados ao quadrado quando uma matriz de números reais é passada para ela. Um exemplo de array de números reais é `[-3, 4.8, 5, 3, -3.2]`.
 
-**Obs:** Você não deve usar os loops `for` ou `while` ou a função `forEach()` na sua função.
+**Observação:** você não deve usar os loops `for` ou `while` ou a função `forEach()` na sua função.
 
 # --hints--
 

curriculum/challenges/portuguese/02-javascript-algorithms-and-data-structures/functional-programming/use-the-filter-method-to-extract-data-from-an-array.md

@@ -12,9 +12,9 @@ Outra função útil de array é `Array.prototype.filter()`, ou simplesmente `fi
 
 O `filter` chama uma função para cada elemento de um array e constrói um novo array contendo apenas os elementos para os quais a função retorna `true`. Em outras palavras, ele filtra o array de acordo com a função passada a ele. Ele o faz sem alterar o array original assim como `map`.
 
-A função callback toma três argumentos. O primeiro argumento é o elemento que está a ser processado. O segundo é o índice deste elemento e o terceiro é o array do qual `filter` foi chamado.
+A função de callback toma três argumentos. O primeiro argumento é o elemento que está a ser processado. O segundo é o índice deste elemento e o terceiro é o array do qual `filter` foi chamado.
 
-Abaixo você vê um exemplo do `filter` sendo usado do array `users` para retornar um novo array apenas com os usuários cuja idade é menor que 30. O exemplo usa apenas o primeiro argumento do callback por simplicidade.
+Abaixo você vê um exemplo do `filter` sendo usado do array `users` para retornar um novo array apenas com os usuários cuja idade é menor que 30. O exemplo usa apenas o primeiro argumento da função de callback por simplicidade.
 
 ```js
 const users = [

curriculum/challenges/portuguese/02-javascript-algorithms-and-data-structures/functional-programming/use-the-map-method-to-extract-data-from-an-array.md

@@ -16,11 +16,11 @@ Faz sentido conseguir passar funções como argumento a outras funções e retor
 
 Vamos começar com algumas funções simples de array. Alguns métodos no protótipo de objetos array. Neste exercício estamos de olho em `Array.prototype.map()`, ou simplesmente `map`.
 
-O método `map` percorre cada item de um array e retorna um novo array cujos elementos são os resultados da chamada do callback para cada item. Isso tudo acontece sem modificar o array original.
+O método `map` percorre cada item de um array e retorna um novo array cujos elementos são os resultados da chamada da função de callback para cada item. Isso tudo acontece sem modificar o array original.
 
-A função callback é chamada com três argumentos. O primeiro argumento é o elemento que está a ser processado. O segundo é o índice deste elemento e o terceiro é o array do qual `map` foi chamado.
+A função de callback é chamada com três argumentos. O primeiro argumento é o elemento que está a ser processado. O segundo é o índice deste elemento e o terceiro é o array do qual `map` foi chamado.
 
-Abaixo você vê um exemplo do `map` sendo usado do array `users` para retornar um novo array apenas com os nomes dos usuários. O exemplo usa apenas o primeiro argumento do callback por simplicidade.
+Abaixo você vê um exemplo do `map` sendo usado do array `users` para retornar um novo array apenas com os nomes dos usuários. O exemplo usa apenas o primeiro argumento da função de callback por simplicidade.
 
 ```js
 const users = [

curriculum/challenges/portuguese/02-javascript-algorithms-and-data-structures/functional-programming/use-the-reduce-method-to-analyze-data.md

@@ -10,11 +10,11 @@ dashedName: use-the-reduce-method-to-analyze-data
 
 `Array.prototype.reduce()`, ou simplesmente `reduce()`, realiza as operações mais gerais de todas as operações de array em JavaScript. Você pode resolver quase qualquer problema de processamento de array usando o método `reduce`.
 
-O método `reduce` permite formas mais gerais de processamento de array, e é possível mostrar que tanto o `filter` quanto o `map` podem ser derivados como aplicações especiais de `reduce`. O método `reduce` percorre cada elemento de um array e retorna um valor (uma string, um número, um objeto ou array). Isso é factível através de um callback que é chamado para cada elemento.
+O método `reduce` permite formas mais gerais de processamento de array, e é possível mostrar que tanto o `filter` quanto o `map` podem ser derivados como aplicações especiais de `reduce`. O método `reduce` percorre cada elemento de um array e retorna um valor (uma string, um número, um objeto ou array). Isso pode ser feito através de uma função de callback que é chamada para cada elemento.
 
-A função callback toma quatro argumentos. O primeiro argumento é conhecido como o acumulador, ao qual é atribuído o resultado do callback na iteração anterior. O segundo é o elemento a ser processado. O terceiro é o índice do elemento e o quarto é o array do qual `reduce` foi chamado.
+A função de callback recebe quatro argumentos. O primeiro argumento é conhecido como o acumulador, ao qual é atribuído o resultado da função de callback na iteração anterior. O segundo é o elemento a ser processado. O terceiro é o índice do elemento e o quarto é o array do qual `reduce` foi chamado.
 
-Além da função callback, `reduce` tem um parâmetro adicional que recebe um valor inicial para o acumulador. Se o segundo parâmetro não for usado, então a primeira iteração é ignorada e ao acumulador é atribuído o primeiro elemento do array na segunda iteração.
+Além da função de callback, `reduce` tem um parâmetro adicional que recebe um valor inicial para o acumulador. Se o segundo parâmetro não for usado, então a primeira iteração é ignorada e ao acumulador é atribuído o primeiro elemento do array na segunda iteração.
 
 Veja abaixo um exemplo usando `reduce` no array `users` para retornar a soma de todas as idades de todos os usuários. O exemplo usa apenas os dois primeiros argumentos pela simplicidade.
 
@@ -81,7 +81,7 @@ Você não deve usar loops `for`.
 assert(!code.match(/for\s*?\([\s\S]*?\)/g));
 ```
 
-Sua função deve retornar o valor correto após manipular `watchList` com filter, map e reduce.
+A função deve retornar o valor correto após manipular `watchList` com filter, map e reduce.
 
 ```js
 assert(getRating(watchList.filter((_, i) => i < 1 || i > 2)) === 8.55);

curriculum/challenges/portuguese/02-javascript-algorithms-and-data-structures/intermediate-algorithm-scripting/binary-agents.md

@@ -8,7 +8,7 @@ dashedName: binary-agents
 
 # --description--
 
-Retorne uma frase traduzida em Inglês da string binária passada.
+Retorne uma frase traduzida para o inglês da string binária passada.
 
 A string binária será separada por espaço.
 

curriculum/challenges/portuguese/02-javascript-algorithms-and-data-structures/intermediate-algorithm-scripting/spinal-tap-case.md

@@ -8,7 +8,7 @@ dashedName: spinal-tap-case
 
 # --description--
 
-Converta uma string transformado os espaços em hífens. Casos espinais são todas-as-palavras-minúsculas-unidas-por-traços.
+Converta uma string transformado os espaços em hifens. Casos espinais são todas-as-palavras-minúsculas-unidas-por-traços.
 
 # --hints--
 

curriculum/challenges/portuguese/02-javascript-algorithms-and-data-structures/intermediate-algorithm-scripting/steamroller.md

@@ -36,7 +36,7 @@ assert.deepEqual(steamrollArray([1, [], [3, [[4]]]]), [1, 3, 4]);
 assert.deepEqual(steamrollArray([1, {}, [3, [[4]]]]), [1, {}, 3, 4]);
 ```
 
-Sua solução não deve usar os métodos `Array.prototype.flat()` ou `Array.prototype.flatMap()`.
+A solução não deve usar os métodos `Array.prototype.flat()` ou `Array.prototype.flatMap()`.
 
 ```js
 assert(!code.match(/\.\s*flat\s*\(/) && !code.match(/\.\s*flatMap\s*\(/));

curriculum/challenges/portuguese/02-javascript-algorithms-and-data-structures/intermediate-algorithm-scripting/sum-all-numbers-in-a-range.md

@@ -10,7 +10,7 @@ dashedName: sum-all-numbers-in-a-range
 
 Vamos passar um array de dois números. Retorne a soma desses dois números mais a soma de todos os números entre eles. O menor número nem sempre chegará primeiro.
 
-Por exemplo, `somAll([4, 1])` deve retornar `10` porque a soma de todos os números entre 1 e 4 (ambos incluídos) é `10`.
+Por exemplo, `sumAll([4,1])` deve retornar `10` porque a soma de todos os números entre 1 e 4 (ambos incluídos) é `10`.
 
 # --hints--
 

curriculum/challenges/portuguese/02-javascript-algorithms-and-data-structures/javascript-algorithms-and-data-structures-projects/cash-register.md

@@ -1,6 +1,6 @@
 ---
 id: aa2e6f85cab2ab736c9a9b24
-title: Caixa Registradora
+title: Caixa registradora
 challengeType: 5
 forumTopicId: 16012
 dashedName: cash-register
@@ -8,7 +8,7 @@ dashedName: cash-register
 
 # --description--
 
-Implemente uma função de registradora de caixa `checkCashRegister()` que aceita o preço de compra como o primeiro argumento (`price`), pagamento como o segundo argumento (`cash`) e dinheiro na registradora (`cid`) como o terceiro argumento.
+Implemente uma função de caixa registradora `checkCashRegister()` que aceita o preço de compra como o primeiro argumento (`price`), pagamento como o segundo argumento (`cash`) e dinheiro na registradora (`cid`) como o terceiro argumento.
 
 `cid` é um array de duas dimensões listando a moeda disponível e a quantidade.
 
@@ -20,7 +20,7 @@ Retorne `{status: "CLOSED", change: [...]}` com dinheiro no caixa como o valor p
 
 Caso contrário, retorne `{status: "OPEN", change: [...]}`, com o troco devido em moedas e notas, ordenado do maior para o menor, como o valor da chave `change`.
 
-<table class='table table-striped'><tbody><tr><th>Unidade de moeda</th><th>Quantidade</th></tr><tr><td>Penny</td><td>$0,01 (MET)</td></tr><tr><td>Níquel</td><td>$0,05 (NICKEL)</td></tr><tr><td>Dime</td><td>$0,1 (DIME)</td></tr><tr><td>Quarter</td><td>$0,25 (QUARTER)</td></tr><tr><td>Dólar</td><td>$1 (UM)</td></tr><tr><td>Cinco Dólares</td><td>$5 (CINCO)</td></tr><tr><td>Dez Dólares</td><td>$10 (DEZ)</td></tr><tr><td>Vinte Dólares</td><td>$20 (VINTE)</td></tr><tr><td>Cem Dólares</td><td>$100 (CEM)</td></tr></tbody></table>
+<table class='table table-striped'><tbody><tr><th>Unidade de moeda</th><th>Quantidade</th></tr><tr><td>Penny</td><td>$0,01 (PENNY)</td></tr><tr><td>Nickel</td><td>$0,05 (NICKEL)</td></tr><tr><td>Dime</td><td>$0,1 (DIME)</td></tr><tr><td>Quarter</td><td>$0,25 (QUARTER)</td></tr><tr><td>Dólar</td><td>$1 (ONE)</td></tr><tr><td>Cinco dólares</td><td>$5 (FIVE)</td></tr><tr><td>Dez dólares</td><td>$10 (TEN)</td></tr><tr><td>Vinte dólares</td><td>$20 (TWENTY)</td></tr><tr><td>Cem dólares</td><td>$100 (ONE HUNDRED)</td></tr></tbody></table>
 
 Veja abaixo um exemplo de um array de dinheiro no caixa (cid):
 

curriculum/challenges/portuguese/02-javascript-algorithms-and-data-structures/javascript-algorithms-and-data-structures-projects/palindrome-checker.md

@@ -1,6 +1,6 @@
 ---
 id: aaa48de84e1ecc7c742e1124
-title: Verificador de Palíndromo
+title: Verificador de palíndromo
 challengeType: 5
 forumTopicId: 16004
 dashedName: palindrome-checker

curriculum/challenges/portuguese/02-javascript-algorithms-and-data-structures/javascript-algorithms-and-data-structures-projects/roman-numeral-converter.md

@@ -1,6 +1,6 @@
 ---
 id: a7f4d8f2483413a6ce226cac
-title: Conversor de Numerais Romanos
+title: Conversor de numerais romanos
 challengeType: 5
 forumTopicId: 16044
 dashedName: roman-numeral-converter

curriculum/challenges/portuguese/02-javascript-algorithms-and-data-structures/javascript-algorithms-and-data-structures-projects/telephone-number-validator.md

@@ -1,6 +1,6 @@
 ---
 id: aff0395860f5d3034dc0bfc9
-title: Validador de Número Telefônico
+title: Validador de número de telefone
 challengeType: 5
 forumTopicId: 16090
 dashedName: telephone-number-validator

curriculum/challenges/portuguese/02-javascript-algorithms-and-data-structures/object-oriented-programming/add-methods-after-inheritance.md

@@ -8,9 +8,9 @@ dashedName: add-methods-after-inheritance
 
 # --description--
 
-Uma função construtora, ou simplesmente construtor, que herda seu objeto de `protótipo` de uma função construtora de supertipo, além dos métodos herdados, ainda poderá ter seus próprios métodos.
+Uma função construtora, ou simplesmente construtor, que herda seu objeto de `prototype` de uma função construtora de supertipo, além dos métodos herdados, ainda poderá ter seus próprios métodos.
 
-Por exemplo, `Bird` é um construtor que herda seu `protótipo` de `Animal`:
+Por exemplo, `Bird` é um construtor que herda seu `prototype` de `Animal`:
 
 ```js
 function Animal() { }
@@ -22,7 +22,7 @@ Bird.prototype = Object.create(Animal.prototype);
 Bird.prototype.constructor = Bird;
 ```
 
-Como adicional do que é herdado da classe `Animal`, você deseja adicionar o comportamento que é único de objetos `Bird`. Aqui, `Bird` definirá a função `fly()`. As funções são adicionadas ao `protótipo` `Bird` da mesma forma que qualquer função construtora:
+Como adicional do que é herdado da classe `Animal`, você deseja adicionar o comportamento que é único de objetos `Bird`. Aqui, `Bird` definirá a função `fly()`. As funções são adicionadas ao `Bird's` `prototype` (protótipo do pássaro) da mesma forma que qualquer função construtora:
 
 ```js
 Bird.prototype.fly = function() {
@@ -42,7 +42,7 @@ duck.fly();
 
 # --instructions--
 
-Adiciona todos os códigos necessários para que o objeto `Dog` herde de `Animal` e o `protótipo` de construtor de `Dog` está definido para `Dog`. Então adiciona o método `bark()` para o objeto `Dog` para que um `beagle` possa `eat()` e `bark()`. O método `bark()` deveria imprimir no console a string: `Woof!`.
+Adiciona todos os códigos necessários para que o objeto `Dog` herde de `Animal` e o `prototype` de construtor de `Dog` está definido para `Dog`. Então adiciona o método `bark()` para o objeto `Dog` para que um `beagle` possa `eat()` e `bark()`. O método `bark()` deveria imprimir no console a string: `Woof!`.
 
 # --hints--
 
@@ -64,7 +64,7 @@ O protótipo de `Dog` deve ter o método `bark()`.
 assert('bark' in Dog.prototype);
 ```
 
-`beagle` deve ser uma `instância` de `Animal`.
+`beagle` deve ser uma `instanceof` de `Animal`.
 
 ```js
 assert(beagle instanceof Animal);

curriculum/challenges/portuguese/02-javascript-algorithms-and-data-structures/object-oriented-programming/change-the-prototype-to-a-new-object.md

@@ -8,7 +8,7 @@ dashedName: change-the-prototype-to-a-new-object
 
 # --description--
 
-Até o momento, você tem adicionado propriedades para cada `protótipo` individualmente:
+Até o momento, você tem adicionado propriedades para cada `prototype` individualmente:
 
 ```js
 Bird.prototype.numLegs = 2;
@@ -26,7 +26,7 @@ Bird.prototype.describe = function() {
 }
 ```
 
-Uma forma mais eficiente é definir o `protótipo` para um novo objeto que já possui as propriedades. Dessa maneira, as propriedades são adicionadas todas de uma vez:
+Uma forma mais eficiente é definir o `prototype` para um novo objeto que já possui as propriedades. Dessa maneira, as propriedades são adicionadas todas de uma vez:
 
 ```js
 Bird.prototype = {
@@ -42,7 +42,7 @@ Bird.prototype = {
 
 # --instructions--
 
-Adiciona a propriedade `numLegs` e os dois métodos `eat()` e `describe()` para o `protótipo` de `Dog` definindo o `protótipo` para um novo objeto.
+Adiciona a propriedade `numLegs` e os dois métodos `eat()` e `describe()` para o `prototype` de `Dog` definindo o `prototype` para um novo objeto.
 
 # --hints--
 

curriculum/challenges/portuguese/02-javascript-algorithms-and-data-structures/object-oriented-programming/create-a-basic-javascript-object.md

@@ -43,7 +43,7 @@ assert(typeof dog === 'object');
 assert(typeof dog.name === 'string');
 ```
 
-`dog` deve ter uma propriedade `numLeggs` definido para um número.
+`dog` deve ter uma propriedade `numLegs` definido para um número.
 
 ```js
 assert(typeof dog.numLegs === 'number');

curriculum/challenges/portuguese/02-javascript-algorithms-and-data-structures/object-oriented-programming/create-a-method-on-an-object.md

@@ -21,7 +21,7 @@ let duck = {
 duck.sayName();
 ```
 
-O exemplo adiciona o método `sayName`, que é uma função responsável por retornar uma frase contendo o nome do `duck`. Note que o método acessou a propriedade `name` na declaração de retorno usando `duck.name`. O próximo desafio irá mostrar outra forma de fazer isso.
+O exemplo adiciona o método `sayName`, que é uma função responsável por retornar uma frase contendo o nome do `duck`. Note que o método acessou a propriedade `name` na declaração de retorno usando `duck.name`. O próximo desafio vai mostrar outra forma de fazer isso.
 
 # --instructions--
 

curriculum/challenges/portuguese/02-javascript-algorithms-and-data-structures/object-oriented-programming/make-code-more-reusable-with-the-this-keyword.md

@@ -40,7 +40,7 @@ Modifique o método `dog.sayLegs` para remover qualquer referencia para `dog`. U
 assert(dog.sayLegs() === 'This dog has 4 legs.');
 ```
 
-Seu código deve utilizar a palavra-chave `this` para acessar a propriedade `numLegs` de `dog`.
+O código deve utilizar a palavra-chave `this` para acessar a propriedade `numLegs` de `dog`.
 
 ```js
 assert(code.match(/this\.numLegs/g));

curriculum/challenges/portuguese/02-javascript-algorithms-and-data-structures/object-oriented-programming/set-the-childs-prototype-to-an-instance-of-the-parent.md

@@ -16,7 +16,7 @@ Este desafio cobre o próximo passo: definir o `prototype` do subtipo (ou filho)
 Bird.prototype = Object.create(Animal.prototype);
 ```
 
-Lembre-se que o `prototype` é como uma receita para criar um objeto. De certa forma, a receita para `Bird` agora inclui todos os "ingredientes" chave para `Animal`.
+Lembre-se de que o `prototype` é como uma receita para criar um objeto. De certa forma, a receita para `Bird` agora inclui todos os "ingredientes" chave para `Animal`.
 
 ```js
 let duck = new Bird("Donald");

curriculum/challenges/portuguese/02-javascript-algorithms-and-data-structures/object-oriented-programming/understand-the-constructor-property.md

@@ -8,7 +8,7 @@ dashedName: understand-the-constructor-property
 
 # --description--
 
-Tem uma propriedade especial do `construtor` localizada nas instâncias dos objetos `duck` e `beagle` que foram criados nos desafios anteriores:
+Tem uma propriedade especial do `constructor` localizada nas instâncias dos objetos `duck` e `beagle` que foram criados nos desafios anteriores:
 
 ```js
 let duck = new Bird();
@@ -20,7 +20,7 @@ console.log(beagle.constructor === Dog);
 
 Ambas as chamadas a `console.log` vão exibir `true` no console.
 
-Note que a propriedade `construtor` é uma referência a função construtora que criou a instância. A vantagem da propriedade `construtor` é que se torna possível verificar essa propriedade para descobrir qual o tipo do objeto. Aqui está um exemplo de como isso poderia ser utilizado:
+Note que a propriedade `constructor` é uma referência a função construtora que criou a instância. A vantagem da propriedade `constructor` é que se torna possível verificar essa propriedade para descobrir qual o tipo do objeto. Aqui está um exemplo de como isso poderia ser utilizado:
 
 ```js
 function joinBirdFraternity(candidate) {
@@ -32,11 +32,11 @@ function joinBirdFraternity(candidate) {
 }
 ```
 
-**Note:** Desde que a propriedade `construtor` pode ser sobrescrita (o que será abordado nos próximos dois desafios), geralmente é melhor utilizar o método `instanceof` para verificar o tipo de um objeto.
+**Observação:** já que a propriedade `constructor` pode ser sobrescrita (o que será abordado nos próximos dois desafios), geralmente é melhor utilizar o método `instanceof` para verificar o tipo de um objeto.
 
 # --instructions--
 
-Escreva a função `joinDogFraternity` que recebe o parâmetro `candidate` e, utilizando a propriedade `construtora`, retorne `true` se o candidato é um `Dog`, e caso não seja, retorne `false`.
+Escreva a função `joinDogFraternity` que recebe o parâmetro `candidate` e, utilizando a propriedade `constructor`, retorne `true` se o candidato é um `Dog`, e caso não seja, retorne `false`.
 
 # --hints--
 

curriculum/challenges/portuguese/02-javascript-algorithms-and-data-structures/object-oriented-programming/understand-the-immediately-invoked-function-expression-iife.md

@@ -32,7 +32,7 @@ A função deve ser anônima.
 assert(/\((function|\(\))(=>|\(\)){?/.test(code.replace(/\s/g, '')));
 ```
 
-Sua função deve ter parênteses no final da expressão para chamar ela imediatamente.
+A função deve ter parênteses no final da expressão para chamar ela imediatamente.
 
 ```js
 assert(/\(.*(\)\(|\}\(\))\)/.test(code.replace(/[\s;]/g, '')));

curriculum/challenges/portuguese/02-javascript-algorithms-and-data-structures/object-oriented-programming/understand-the-prototype-chain.md

@@ -39,7 +39,7 @@ Modifique o código para mostrar corretamente a cadeia de protótipo.
 
 # --hints--
 
-Seu código deve mostrar que `Object.prototype` é o protótipo de `Dog.prototype`
+O código deve mostrar que `Object.prototype` é o protótipo de `Dog.prototype`
 
 ```js
 assert(/Object\.prototype\.isPrototypeOf/.test(code));

curriculum/challenges/portuguese/02-javascript-algorithms-and-data-structures/object-oriented-programming/understand-where-an-objects-prototype-comes-from.md

@@ -24,7 +24,7 @@ let duck = new Bird("Donald");
 Bird.prototype.isPrototypeOf(duck);
 ```
 
-Isso iria retornar `true`.
+Isso retornaria `true`.
 
 # --instructions--
 

curriculum/challenges/portuguese/02-javascript-algorithms-and-data-structures/object-oriented-programming/use-a-constructor-to-create-objects.md

@@ -20,7 +20,7 @@ function Bird() {
 let blueBird = new Bird();
 ```
 
-**Note:** `this` dentro do construtor sempre refere-se ao objeto sendo criado.
+**Observação:** `this` dentro do construtor sempre refere-se ao objeto sendo criado.
 
 Note que o operador `new` é usado quando chamamos o construtor. Isso avisa ao JavaScript para criar uma nova instância de `Bird` chamado `blueBird`. Sem o operador `new`, `this` dentro do construtor não iria apontar para o objeto recentemente criado, dando resultados inesperados. Agora `blueBird` possui todas as propriedades definidas dentro do construtor `Bird`:
 
@@ -49,7 +49,7 @@ Utilize o construtor de `Dog` da última lição para criar uma nova instância
 assert(hound instanceof Dog);
 ```
 
-Seu código deve utilizar o operador `new` para criar uma instância de `Dog`.
+O código deve utilizar o operador `new` para criar uma instância de `Dog`.
 
 ```js
 assert(code.match(/new/g));

curriculum/challenges/portuguese/02-javascript-algorithms-and-data-structures/object-oriented-programming/use-a-mixin-to-add-common-behavior-between-unrelated-objects.md

@@ -8,9 +8,9 @@ dashedName: use-a-mixin-to-add-common-behavior-between-unrelated-objects
 
 # --description--
 
-Como você já viu, comportamento é compartilhado através de herança. Porém, existem casos em que a herança não é a melhor solução. Herança não funciona muito bem para objetos não-relacionados como `Bird` e `Airplane`. Ambos podem voar, mas um `Bird` não é um tipo de `Airplane` e vice versa.
+Como você já viu, comportamento é compartilhado através de herança. Porém, existem casos em que a herança não é a melhor solução. Herança não funciona muito bem para objetos não-relacionados como `Bird` e `Airplane`. Ambos podem voar, mas um `Bird` não é um tipo de `Airplane` e vice-versa.
 
-Para objetos não-relacionados, é melhor usar <dfn>mixins</dfn>. Um mixin permite outros objetos para utilizar uma coleção de funções.
+Para objetos não relacionados, é melhor usar <dfn>mixins</dfn>. Um mixin permite outros objetos para utilizar uma coleção de funções.
 
 ```js
 let flyMixin = function(obj) {
@@ -54,19 +54,19 @@ Crie um mixin chamado `glideMixin` que define o método chamado `glide`. Em segu
 
 # --hints--
 
-Seu código deve declarar a variável `glideMixin`, a qual é uma função.
+O código deve declarar a variável `glideMixin`, a qual é uma função.
 
 ```js
 assert(typeof glideMixin === 'function');
 ```
 
-Seu código deve utilizar o `glideMixin` no objeto `bird` para dar ao objeto o método `glide`.
+O código deve utilizar o `glideMixin` no objeto `bird` para dar ao objeto o método `glide`.
 
 ```js
 assert(typeof bird.glide === 'function');
 ```
 
-Seu código deve utilizar `glideMixin` no objeto `boat` para dar ao objeto o método `glide`.
+O código deve utilizar `glideMixin` no objeto `boat` para dar ao objeto o método `glide`.
 
 ```js
 assert(typeof boat.glide === 'function');

curriculum/challenges/portuguese/02-javascript-algorithms-and-data-structures/object-oriented-programming/use-an-iife-to-create-a-module.md

@@ -8,7 +8,7 @@ dashedName: use-an-iife-to-create-a-module
 
 # --description--
 
-Uma expressão de função imediatamente invocada (IIFE) é frequentemente utilizado para agrupar funcionalidades relacionadas para um único objeto ou <dfn>module</dfn>. Por exemplo, um desafio anterior definiu dois mixins:
+Uma expressão de função imediatamente invocada (IIFE) é frequentemente utilizado para agrupar funcionalidades relacionadas para um único objeto ou <dfn>módulo</dfn>. Por exemplo, um desafio anterior definiu dois mixins:
 
 ```js
 function glideMixin(obj) {

curriculum/challenges/portuguese/02-javascript-algorithms-and-data-structures/object-oriented-programming/use-closure-to-protect-properties-within-an-object-from-being-modified-externally.md

@@ -46,13 +46,13 @@ A propriedade `weight` deve ser uma variável privada e deve ser atribuída a el
 assert(code.match(/(var|let|const)\s+weight\s*\=\s*15\;?/g));
 ```
 
-Seu código deve criar o método dentro de `Bird` chamado `getWeight` que retorna o valor da variável privada `weight`.
+O código deve criar o método dentro de `Bird` chamado `getWeight` que retorna o valor da variável privada `weight`.
 
 ```js
 assert(new Bird().getWeight() === 15);
 ```
 
-Sua função `getWeight` deve retornar a variável privada `weight`.
+A função `getWeight` deve retornar a variável privada `weight`.
 
 ```js
 assert(code.match(/((return\s+)|(\(\s*\)\s*\=\>\s*))weight\;?/g));

curriculum/challenges/portuguese/02-javascript-algorithms-and-data-structures/object-oriented-programming/use-inheritance-so-you-dont-repeat-yourself.md

@@ -8,9 +8,9 @@ dashedName: use-inheritance-so-you-dont-repeat-yourself
 
 # --description--
 
-Tem um princípio da programação chamado <dfn>Don't Repeat Yourself (DRY) (Não Repita Você Mesmo)</dfn>. O motivo pelo qual código repetido é um problema se deve ao fato de qualquer alteração exige correção de código em vários locais. Geralmente isso significa mais trabalho para os programadores e mais espaço para erros.
+Tem um princípio da programação chamado <dfn>Don't Repeat Yourself (DRY) - Não se Repita</dfn>. O motivo pelo qual código repetido é um problema se deve ao fato de qualquer alteração exige correção de código em vários locais. Geralmente isso significa mais trabalho para os programadores e mais espaço para erros.
 
-Note que o exemplo abaixo que `descreve` o método é compartilhado por `Bird` e `Dog`:
+Note que, no exemplo abaixo, o método `describe` é compartilhado por `Bird` e `Dog`:
 
 ```js
 Bird.prototype = {
@@ -28,7 +28,7 @@ Dog.prototype = {
 };
 ```
 
-O método `describe` é repetido em dois locais. O código pode ser editado para seguir o princípio DRY (Não Repita Você Mesmo) ao criar um `supertipo` (ou parente) chamado `Animal`:
+O método `describe` é repetido em dois locais. O código pode ser editado para seguir o princípio DRY (Não se Repita) ao criar um `supertype` (ou parente) chamado `Animal`:
 
 ```js
 function Animal() { };
@@ -55,7 +55,7 @@ Dog.prototype = {
 
 # --instructions--
 
-O método `eat` é repetido em `Cat` e `Bear`. Edite o código no espírito do princípio DRY ao mover o método `eat` do `supertipo` de `Animal`.
+O método `eat` é repetido em `Cat` e `Bear`. Edite o código no espírito do princípio DRY ao mover o método `eat` do `supertype` de `Animal`.
 
 # --hints--
 

curriculum/challenges/portuguese/02-javascript-algorithms-and-data-structures/object-oriented-programming/verify-an-objects-constructor-with-instanceof.md

@@ -1,6 +1,6 @@
 ---
 id: 587d7dae367417b2b2512b7a
-title: Verifique o Construtor de um Objeto com instanceof
+title: Verificar o construtor de um objeto com instanceof
 challengeType: 1
 forumTopicId: 301337
 dashedName: verify-an-objects-constructor-with-instanceof

curriculum/challenges/portuguese/02-javascript-algorithms-and-data-structures/regular-expressions/check-for-all-or-none.md

@@ -30,28 +30,28 @@ Altere a regex `favRegex` para encontrar as versões americana (`favorite`) e br
 
 # --hints--
 
-Sua regex deve usar a interrogação (`?`) para validação opcional.
+A regex deve usar a interrogação (`?`) para validação opcional.
 
 ```js
 favRegex.lastIndex = 0;
 assert(favRegex.source.match(/\?/).length > 0);
 ```
 
-Sua regex deve encontrar a string `favorite`
+A regex deve encontrar a string `favorite`
 
 ```js
 favRegex.lastIndex = 0;
 assert(favRegex.test('favorite'));
 ```
 
-Sua regex deve encontrar a string `favourite`
+A regex deve encontrar a string `favourite`
 
 ```js
 favRegex.lastIndex = 0;
 assert(favRegex.test('favourite'));
 ```
 
-Sua regex não deve encontrar a string `fav`
+A regex não deve encontrar a string `fav`
 
 ```js
 favRegex.lastIndex = 0;

curriculum/challenges/portuguese/02-javascript-algorithms-and-data-structures/regular-expressions/check-for-mixed-grouping-of-characters.md

@@ -1,6 +1,6 @@
 ---
 id: 5c3dda8b4d8df89bea71600f
-title: Validando grupos mistos de caracteres
+title: Validar grupos mistos de caracteres
 challengeType: 1
 forumTopicId: 301339
 dashedName: check-for-mixed-grouping-of-characters
@@ -30,28 +30,28 @@ Depois corrija o código, fazendo com que a regex seja testada na string `myStri
 
 # --hints--
 
-Sua regex `myRegex` deve retornar `true` para a string `Franklin D. Roosevelt`
+A regex `myRegex` deve retornar `true` para a string `Franklin D. Roosevelt`
 
 ```js
 myRegex.lastIndex = 0;
 assert(myRegex.test('Franklin D. Roosevelt'));
 ```
 
-Sua regex `myRegex` deve retornar `true` para a string `Eleanor Roosevelt`
+A regex `myRegex` deve retornar `true` para a string `Eleanor Roosevelt`
 
 ```js
 myRegex.lastIndex = 0;
 assert(myRegex.test('Eleanor Roosevelt'));
 ```
 
-Sua regex `myRegex` deve retornar `false` para a string `Franklin Rosevelt`
+A regex `myRegex` deve retornar `false` para a string `Franklin Rosevelt`
 
 ```js
 myRegex.lastIndex = 0;
 assert(!myRegex.test('Franklin Rosevelt'));
 ```
 
-Sua regex `myRegex` deve retornar `false` para a string `Frank Roosevelt`
+A regex `myRegex` deve retornar `false` para a string `Frank Roosevelt`
 
 ```js
 myRegex.lastIndex = 0;

curriculum/challenges/portuguese/02-javascript-algorithms-and-data-structures/regular-expressions/extract-matches.md

@@ -42,7 +42,7 @@ O resultado, `result`, deve conter a string `coding`
 assert(result.join() === 'coding');
 ```
 
-Sua regex `codingRegex` deve buscar a string `coding`
+A regex `codingRegex` deve buscar a string `coding`
 
 ```js
 assert(codingRegex.source === 'coding');

curriculum/challenges/portuguese/02-javascript-algorithms-and-data-structures/regular-expressions/find-characters-with-lazy-matching.md

@@ -16,7 +16,7 @@ Expressões regulares são gananciosas por padrão, então o resultado seria `["
 
 Mas você pode usar o caractere `?` para torná-la preguiçosa. Aplicar a regex adaptada `/t[a-z]*?i/` à string `"titanic"` retorna `["ti"]`.
 
-**Obs:** Ler HTML com expressões regulares deve ser evitado, mas procurar uma string HTML usando expressões regulares é perfeitamente aceitável.
+**Observação:** ler HTML com expressões regulares deve ser evitado, mas procurar uma string HTML usando expressões regulares é perfeitamente aceitável.
 
 # --instructions--
 

curriculum/challenges/portuguese/02-javascript-algorithms-and-data-structures/regular-expressions/find-more-than-the-first-match.md

@@ -31,24 +31,24 @@ Aqui, `match` retorna o valor `["Repeat", "Repeat", "Repeat"]`
 
 Usando a regex `starRegex`, encontre e extraia ambas ocorrências da palavra `Twinkle` da string `twinkleStar`.
 
-**Obs:**  
+**Observação:**  
-Você pode usar múltiplas flags em uma regex: `/search/gi`
+você pode usar múltiplas flags em uma regex: `/search/gi`
 
 # --hints--
 
-Sua regex `starRegex` deve usar a flag `g`
+A regex `starRegex` deve usar a flag `g`
 
 ```js
 assert(starRegex.flags.match(/g/).length == 1);
 ```
 
-Sua regex `starRegex` deve usar a flag de ignorar caixa, `i`
+A regex `starRegex` deve usar a flag de ignorar caixa, `i`
 
 ```js
 assert(starRegex.flags.match(/i/).length == 1);
 ```
 
-Seu resultado deve conter ambas as ocorrências da palavra `Twinkle`
+O resultado deve conter ambas as ocorrências da palavra `Twinkle`
 
 ```js
 assert(
@@ -60,7 +60,7 @@ assert(
 );
 ```
 
-Seu resultado, `result`, deve conter dois elementos.
+O resultado, `result`, deve conter dois elementos.
 
 ```js
 assert(result.length == 2);

curriculum/challenges/portuguese/02-javascript-algorithms-and-data-structures/regular-expressions/find-one-or-more-criminals-in-a-hunt.md

@@ -36,19 +36,19 @@ Escreva uma regex gananciosa que encontra uma ou mais criminosos em um grupo de
 
 # --hints--
 
-Sua regex deve encontrar um criminoso (`C`) na string `C`
+A regex deve encontrar um criminoso (`C`) na string `C`
 
 ```js
 assert('C'.match(reCriminals) && 'C'.match(reCriminals)[0] == 'C');
 ```
 
-Sua regex deve encontrar dois criminosos (`CC`) na string `CC`
+A regex deve encontrar dois criminosos (`CC`) na string `CC`
 
 ```js
 assert('CC'.match(reCriminals) && 'CC'.match(reCriminals)[0] == 'CC');
 ```
 
-Sua regex deve encontrar três criminosos (`CCC`) na string `P1P5P4CCCcP2P6P3`.
+A regex deve encontrar três criminosos (`CCC`) na string `P1P5P4CCCcP2P6P3`.
 
 ```js
 assert(
@@ -57,7 +57,7 @@ assert(
 );
 ```
 
-Sua regex deve encontrar cinco criminosos (`CCCCC`) na string `P6P2P7P4P5CCCCCP3P1`
+A regex deve encontrar cinco criminosos (`CCCCC`) na string `P6P2P7P4P5CCCCCP3P1`
 
 ```js
 assert(
@@ -66,19 +66,19 @@ assert(
 );
 ```
 
-Sua regex não deve encontrar nenhum criminoso na string vazia `""`
+A regex não deve encontrar nenhum criminoso na string vazia `""`
 
 ```js
 assert(!reCriminals.test(''));
 ```
 
-Sua regex não deve encontrar nenhum criminoso na string `P1P2P3`
+A regex não deve encontrar nenhum criminoso na string `P1P2P3`
 
 ```js
 assert(!reCriminals.test('P1P2P3'));
 ```
 
-Sua regex deve encontrar cinquenta criminosos (`CCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCC`) na string `P2P1P5P4CCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCP3`.
+A regex deve encontrar cinquenta criminosos (`CCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCC`) na string `P2P1P5P4CCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCP3`.
 
 ```js
 assert(

curriculum/challenges/portuguese/02-javascript-algorithms-and-data-structures/regular-expressions/ignore-case-while-matching.md

@@ -16,65 +16,65 @@ Você pode encontrar ambas as caixas usando algo que chamamos de <dfn>flag</dfn>
 
 # --instructions--
 
-Escreva uma regex `fccRegex` que encontre `freeCodeCamp`, não importa em que caixa esteja. Sua regex não deve buscar abreviações ou variações com espaços.
+Escreva uma regex `fccRegex` que encontre `freeCodeCamp`, não importa em que caixa esteja. A regex não deve buscar abreviações ou variações com espaços.
 
 # --hints--
 
-Sua regex deve encontrar a string `freeCodeCamp`
+A regex deve encontrar a string `freeCodeCamp`
 
 ```js
 assert(fccRegex.test('freeCodeCamp'));
 ```
 
-Sua regex deve encontrar a string `FreeCodeCamp`
+A regex deve encontrar a string `FreeCodeCamp`
 
 ```js
 assert(fccRegex.test('FreeCodeCamp'));
 ```
 
-Sua regex deve encontrar a string `FreecodeCamp`
+A regex deve encontrar a string `FreecodeCamp`
 
 ```js
 assert(fccRegex.test('FreecodeCamp'));
 ```
 
-Sua regex deve encontrar a string `FreeCodecamp`
+A regex deve encontrar a string `FreeCodecamp`
 
 ```js
 assert(fccRegex.test('FreeCodecamp'));
 ```
 
-Sua regex não deve encontrar a string `Free Code Camp`
+A regex não deve encontrar a string `Free Code Camp`
 
 ```js
 assert(!fccRegex.test('Free Code Camp'));
 ```
 
-Sua regex deve encontrar a string `FreeCOdeCamp`
+A regex deve encontrar a string `FreeCOdeCamp`
 
 ```js
 assert(fccRegex.test('FreeCOdeCamp'));
 ```
 
-Sua regex não deve encontrar a string `FCC`
+A regex não deve encontrar a string `FCC`
 
 ```js
 assert(!fccRegex.test('FCC'));
 ```
 
-Sua regex deve encontrar a string `FrEeCoDeCamp`
+A regex deve encontrar a string `FrEeCoDeCamp`
 
 ```js
 assert(fccRegex.test('FrEeCoDeCamp'));
 ```
 
-Sua regex deve encontrar a string `FrEeCodECamp`
+A regex deve encontrar a string `FrEeCodECamp`
 
 ```js
 assert(fccRegex.test('FrEeCodECamp'));
 ```
 
-Sua regex deve encontrar a string `FReeCodeCAmp`
+A regex deve encontrar a string `FReeCodeCAmp`
 
 ```js
 assert(fccRegex.test('FReeCodeCAmp'));

curriculum/challenges/portuguese/02-javascript-algorithms-and-data-structures/regular-expressions/match-a-literal-string-with-different-possibilities.md

@@ -22,43 +22,43 @@ Complete a regex `petRegex` para encontrar os pets `dog`, `cat`, `bird`, ou `fis
 
 # --hints--
 
-Sua regex `petRegex` deve retornar `true` para a string `John has a pet dog.`
+A regex `petRegex` deve retornar `true` para a string `John has a pet dog.`
 
 ```js
 assert(petRegex.test('John has a pet dog.'));
 ```
 
-Sua regex `petRegex` deve retornar `false` para a string `Emma has a pet rock.`
+A regex `petRegex` deve retornar `false` para a string `Emma has a pet rock.`
 
 ```js
 assert(!petRegex.test('Emma has a pet rock.'));
 ```
 
-Sua regex `petRegex` deve retornar `true` para a string `Emma has a pet bird.`
+A regex `petRegex` deve retornar `true` para a string `Emma has a pet bird.`
 
 ```js
 assert(petRegex.test('Emma has a pet bird.'));
 ```
 
-Sua regex `petRegex` deve retornar `true` para a string `Liz has a pet cat.`
+A regex `petRegex` deve retornar `true` para a string `Liz has a pet cat.`
 
 ```js
 assert(petRegex.test('Liz has a pet cat.'));
 ```
 
-Sua regex `petRegex` deve retornar `false` para a string `Kara has a pet dolphin.`
+A regex `petRegex` deve retornar `false` para a string `Kara has a pet dolphin.`
 
 ```js
 assert(!petRegex.test('Kara has a pet dolphin.'));
 ```
 
-Sua regex `petRegex` deve retornar `true` para a string `Alice has a pet fish.`
+A regex `petRegex` deve retornar `true` para a string `Alice has a pet fish.`
 
 ```js
 assert(petRegex.test('Alice has a pet fish.'));
 ```
 
-Sua regex `petRegex` deve retornar `false` para a string `Jimmy has a pet computer.`
+A regex `petRegex` deve retornar `false` para a string `Jimmy has a pet computer.`
 
 ```js
 assert(!petRegex.test('Jimmy has a pet computer.'));

curriculum/challenges/portuguese/02-javascript-algorithms-and-data-structures/regular-expressions/match-all-letters-and-numbers.md

@@ -33,19 +33,19 @@ Use o atalho `\w` para contar o número de caracteres alfanuméricos em várias
 
 # --hints--
 
-Sua regex deve usar a flag global.
+A regex deve usar a flag global.
 
 ```js
 assert(alphabetRegexV2.global);
 ```
 
-Sua regex deve usar o atalho `\w` para capturar todos os caracteres alfanuméricos.
+A regex deve usar o atalho `\w` para capturar todos os caracteres alfanuméricos.
 
 ```js
 assert(/\\w/.test(alphabetRegexV2.source));
 ```
 
-Sua regex deve encontrar 31 caracteres alfanuméricos na string `The five boxing wizards jump quickly.`
+A regex deve encontrar 31 caracteres alfanuméricos na string `The five boxing wizards jump quickly.`
 
 ```js
 assert(
@@ -53,7 +53,7 @@ assert(
 );
 ```
 
-Sua regex deve encontrar 32 caracteres alfanuméricos na string `Pack my box with five dozen liquor jugs.`
+A regex deve encontrar 32 caracteres alfanuméricos na string `Pack my box with five dozen liquor jugs.`
 
 ```js
 assert(
@@ -62,7 +62,7 @@ assert(
 );
 ```
 
-Sua regex deve encontrar 30 caracteres alfanuméricos na string `How vexingly quick daft zebras jump!`
+A regex deve encontrar 30 caracteres alfanuméricos na string `How vexingly quick daft zebras jump!`
 
 ```js
 assert(
@@ -70,7 +70,7 @@ assert(
 );
 ```
 
-Sua regex deve encontrar 36 caracteres alfanuméricos na string `123 456 7890 ABC def GHI jkl MNO pqr STU vwx YZ.`
+A regex deve encontrar 36 caracteres alfanuméricos na string `123 456 7890 ABC def GHI jkl MNO pqr STU vwx YZ.`
 
 ```js
 assert(

curriculum/challenges/portuguese/02-javascript-algorithms-and-data-structures/regular-expressions/match-all-non-numbers.md

@@ -8,59 +8,59 @@ dashedName: match-all-non-numbers
 
 # --description--
 
-O último desafio mostrou como procurar dígitos usando o atalho `\d` com um `d` minúsculo. Você também pode procurar não-dígitos usando um atalho semelhante que usa um `D` maiúsculo.
+O último desafio mostrou como procurar dígitos usando o atalho `\d` com um `d` minúsculo. Você também pode procurar não dígitos usando um atalho semelhante que usa um `D` maiúsculo.
 
-O atalho para procurar não-dígitos é `\D`. Esse atalho é o mesmo que `[^0-9]`, que serve para procurar qualquer caractere que não seja um dígito de zero a nove.
+O atalho para procurar não dígitos é `\D`. Esse atalho é o mesmo que `[^0-9]`, que serve para procurar qualquer caractere que não seja um dígito de zero a nove.
 
 # --instructions--
 
-Use o atalho `\D` para contar quantos não-dígitos existem em títulos de filmes.
+Use o atalho `\D` para contar quantos não dígitos existem em títulos de filmes.
 
 # --hints--
 
-Sua regex deve usar o atalho que captura não-dígitos
+A regex deve usar o atalho que captura não-dígitos
 
 ```js
 assert(/\\D/.test(noNumRegex.source));
 ```
 
-Sua regex deve usar a flag global.
+A regex deve usar a flag global.
 
 ```js
 assert(noNumRegex.global);
 ```
 
-Sua regex não deve encontrar nenhum não-dígito na string `9`.
+A regex não deve encontrar nenhum não dígito na string `9`.
 
 ```js
 assert('9'.match(noNumRegex) == null);
 ```
 
-Sua regex deve encontrar seis não-dígitos na string `Catch 22`.
+A regex deve encontrar seis não dígitos na string `Catch 22`.
 
 ```js
 assert('Catch 22'.match(noNumRegex).length == 6);
 ```
 
-Sua regex deve encontrar onze não-dígitos na string `101 Dalmatians`.
+A regex deve encontrar onze não dígitos na string `101 Dalmatians`.
 
 ```js
 assert('101 Dalmatians'.match(noNumRegex).length == 11);
 ```
 
-Sua regex deve encontrar quinze não-dígitos na string `One, Two, Three`.
+A regex deve encontrar quinze não dígitos na string `One, Two, Three`.
 
 ```js
 assert('One, Two, Three'.match(noNumRegex).length == 15);
 ```
 
-Sua regex deve encontrar 12 não-dígitos na string `21 Jump Street`.
+A regex deve encontrar 12 não dígitos na string `21 Jump Street`.
 
 ```js
 assert('21 Jump Street'.match(noNumRegex).length == 12);
 ```
 
-Sua regex deve encontrar dezessete não-dígitos na string `2001: A Space Odyssey`.
+A regex deve encontrar dezessete não dígitos na string `2001: A Space Odyssey`.
 
 ```js
 assert('2001: A Space Odyssey'.match(noNumRegex).length == 17);

curriculum/challenges/portuguese/02-javascript-algorithms-and-data-structures/regular-expressions/match-all-numbers.md

@@ -18,49 +18,49 @@ Use o atalho `\d` para contar quantos dígitos existem em títulos de filmes. N
 
 # --hints--
 
-Sua regex deve usar o atalho que captura dígitos
+A regex deve usar o atalho que captura dígitos
 
 ```js
 assert(/\\d/.test(numRegex.source));
 ```
 
-Sua regex deve usar a flag global.
+A regex deve usar a flag global.
 
 ```js
 assert(numRegex.global);
 ```
 
-Sua regex deve encontrar um dígito na string `9`.
+A regex deve encontrar um dígito na string `9`.
 
 ```js
 assert('9'.match(numRegex).length == 1);
 ```
 
-Sua regex deve encontrar dois dígitos na string `Catch 22`.
+A regex deve encontrar dois dígitos na string `Catch 22`.
 
 ```js
 assert('Catch 22'.match(numRegex).length == 2);
 ```
 
-Sua regex deve encontrar três dígitos na string `101 Dalmatians`.
+A regex deve encontrar três dígitos na string `101 Dalmatians`.
 
 ```js
 assert('101 Dalmatians'.match(numRegex).length == 3);
 ```
 
-Sua regex não deve encontrar dígito algum na string `One, Two, Three`.
+A regex não deve encontrar dígito algum na string `One, Two, Three`.
 
 ```js
 assert('One, Two, Three'.match(numRegex) == null);
 ```
 
-Sua regex deve encontrar dois dígitos na string `21 Jump Street`.
+A regex deve encontrar dois dígitos na string `21 Jump Street`.
 
 ```js
 assert('21 Jump Street'.match(numRegex).length == 2);
 ```
 
-Sua regex deve encontrar quatro dígitos na string `2001: A Space Odyssey`.
+A regex deve encontrar quatro dígitos na string `2001: A Space Odyssey`.
 
 ```js
 assert('2001: A Space Odyssey'.match(numRegex).length == 4);

curriculum/challenges/portuguese/02-javascript-algorithms-and-data-structures/regular-expressions/match-anything-with-wildcard-period.md

@@ -24,7 +24,7 @@ As duas chamadas a `test` retornam `true`.
 
 # --instructions--
 
-Complete a regex `unRegex` para que ela encontre as strings `run`, `sun`, `fun`, `pun`, `nun` e `bun`. Sua regex deve usar o caractere curinga.
+Complete a regex `unRegex` para que ela encontre as strings `run`, `sun`, `fun`, `pun`, `nun` e `bun`. A regex deve usar o caractere curinga.
 
 # --hints--
 
@@ -40,42 +40,42 @@ Você deve usar o caractere curinga na regex `unRegex`
 assert(/\./.test(unRegex.source));
 ```
 
-Sua regex `unRegex` deve encontrar `run` na string `Let us go on a run.`
+A regex `unRegex` deve encontrar `run` na string `Let us go on a run.`
 
 ```js
 unRegex.lastIndex = 0;
 assert(unRegex.test('Let us go on a run.'));
 ```
 
-Sua regex `unRegex` deve encontrar `sun` na string `The sun is out today.`
+A regex `unRegex` deve encontrar `sun` na string `The sun is out today.`
 
 ```js
 unRegex.lastIndex = 0;
 assert(unRegex.test('The sun is out today.'));
 ```
 
-Sua regex `unRegex` deve encontrar `fun` na string `Coding is a lot of fun.`
+A regex `unRegex` deve encontrar `fun` na string `Coding is a lot of fun.`
 
 ```js
 unRegex.lastIndex = 0;
 assert(unRegex.test('Coding is a lot of fun.'));
 ```
 
-Sua regex `unRegex` deve encontrar `pun` na string `Seven days without a pun makes one weak.`
+A regex `unRegex` deve encontrar `pun` na string `Seven days without a pun makes one weak.`
 
 ```js
 unRegex.lastIndex = 0;
 assert(unRegex.test('Seven days without a pun makes one weak.'));
 ```
 
-Sua regex `unRegex` deve encontrar `nun` na string `One takes a vow to be a nun.`
+A regex `unRegex` deve encontrar `nun` na string `One takes a vow to be a nun.`
 
 ```js
 unRegex.lastIndex = 0;
 assert(unRegex.test('One takes a vow to be a nun.'));
 ```
 
-Sua regex `unRegex` deve encontrar `bun` na string `She got fired from the hot dog stand for putting her hair in a bun.`
+A regex `unRegex` deve encontrar `bun` na string `She got fired from the hot dog stand for putting her hair in a bun.`
 
 ```js
 unRegex.lastIndex = 0;
@@ -86,14 +86,14 @@ assert(
 );
 ```
 
-Sua regex `unRegex` não deve incluir a string `There is a bug in my code.` no resultado
+A regex `unRegex` não deve incluir a string `There is a bug in my code.` no resultado
 
 ```js
 unRegex.lastIndex = 0;
 assert(!unRegex.test('There is a bug in my code.'));
 ```
 
-Sua regex `unRegex` não deve incluir a string `Catch me if you can.` no resultado
+A regex `unRegex` não deve incluir a string `Catch me if you can.` no resultado
 
 ```js
 unRegex.lastIndex = 0;

curriculum/challenges/portuguese/02-javascript-algorithms-and-data-structures/regular-expressions/match-beginning-string-patterns.md

@@ -28,25 +28,25 @@ Use o circunflexo em uma regex para encontrar `Cal`, mas apenas no começo da st
 
 # --hints--
 
-Sua regex deve buscar a string `Cal` com uma maiúscula.
+A regex deve buscar a string `Cal` com uma maiúscula.
 
 ```js
 assert(calRegex.source == '^Cal');
 ```
 
-Sua regex não deve usar nenhuma flag.
+A regex não deve usar nenhuma flag.
 
 ```js
 assert(calRegex.flags == '');
 ```
 
-Sua regex deve capturar a string `Cal` no começo de uma string.
+A regex deve capturar a string `Cal` no começo de uma string.
 
 ```js
 assert(calRegex.test('Cal and Ricky both like racing.'));
 ```
 
-Sua regex não deve capturar a string `Cal` no meio de uma string.
+A regex não deve capturar a string `Cal` no meio de uma string.
 
 ```js
 assert(!calRegex.test('Ricky and Cal both like racing.'));

curriculum/challenges/portuguese/02-javascript-algorithms-and-data-structures/regular-expressions/match-characters-that-occur-one-or-more-times.md

@@ -18,17 +18,17 @@ Se a string fosse `abab`, a operação retornaria `["a", "a"]` porque entre os d
 
 # --instructions--
 
-Você quer capturar as ocorrências de `s` quando acontecer uma ou mais vezes em `Mississippi`. Escreve uma regex que use o caractere `+`.
+Você quer capturar as ocorrências de `s` quando acontecer uma ou mais vezes em `Mississippi`. Escreva uma regex que use o caractere `+`.
 
 # --hints--
 
-Sua regex `myRegex` deve usar o caractere `+` para encontrar um ou mais `s`s.
+A regex `myRegex` deve usar o caractere `+` para encontrar um ou mais `s`s.
 
 ```js
 assert(/\+/.test(myRegex.source));
 ```
 
-Sua regex `myRegex` deve encontrar 2 itens.
+A regex `myRegex` deve encontrar 2 itens.
 
 ```js
 assert(result.length == 2);

curriculum/challenges/portuguese/02-javascript-algorithms-and-data-structures/regular-expressions/match-characters-that-occur-zero-or-more-times.md

@@ -26,35 +26,35 @@ As três chamadas a `match` retornam, na ordem, os valores: `["goooooooo"]`, `["
 
 # --instructions--
 
-Neste desafio, a string `chewieQuote` recebeu o valor `Aaaaaaaaaaaaaaaarrrgh!` por trás dos panos. Escreva uma regex, `chewieRegex`, que usa o caractere `*` para capturar um `A` maiúsculo seguido imediatamente de zero ou mais `a` minúsculos em `chewieQuote`. Sua regex não precisa de flags ou de classes de caracteres. Ela também não deve capturar nenhuma outra parte da string.
+Neste desafio, a string `chewieQuote` recebeu o valor `Aaaaaaaaaaaaaaaarrrgh!` por trás dos panos. Escreva uma regex, `chewieRegex`, que usa o caractere `*` para capturar um `A` maiúsculo seguido imediatamente de zero ou mais `a` minúsculos em `chewieQuote`. A regex não precisa de flags ou de classes de caracteres. Ela também não deve capturar nenhuma outra parte da string.
 
 # --hints--
 
-Sua regex `chewieRegex` deve usar o caractere `*` para encontrar zero ou mais `a`s.
+A regex `chewieRegex` deve usar o caractere `*` para encontrar zero ou mais `a`s.
 
 ```js
 assert(/\*/.test(chewieRegex.source));
 ```
 
-Sua regex deve encontrar a string `A` em `chewieQuote`.
+A regex deve encontrar a string `A` em `chewieQuote`.
 
 ```js
 assert(result[0][0] === 'A');
 ```
 
-Sua regex deve encontrar a string `Aaaaaaaaaaaaaaaa` em `chewieQuote`.
+A regex deve encontrar a string `Aaaaaaaaaaaaaaaa` em `chewieQuote`.
 
 ```js
 assert(result[0] === 'Aaaaaaaaaaaaaaaa');
 ```
 
-Sua regex `chewieRegex` deve capturar 16 caracteres em `chewieQuote`.
+A regex `chewieRegex` deve capturar 16 caracteres em `chewieQuote`.
 
 ```js
 assert(result[0].length === 16);
 ```
 
-Sua expressão regular não deve corresponder com nenhum caractere na string `He made a fair move. Screaming about it can't help you.`
+A expressão regular não deve corresponder com nenhum caractere na string `He made a fair move. Screaming about it can't help you.`
 
 ```js
 assert(
@@ -62,7 +62,7 @@ assert(
 );
 ```
 
-Sua expressão regular não deve corresponder a nenhum caractere na string `Let him have it. It's not wise to upset a Wookiee.`
+A expressão regular não deve corresponder a nenhum caractere na string `Let him have it. It's not wise to upset a Wookiee.`
 
 ```js
 assert(

curriculum/challenges/portuguese/02-javascript-algorithms-and-data-structures/regular-expressions/match-ending-string-patterns.md

@@ -34,7 +34,7 @@ Você deve usar o cifrão `$` na sua regex para buscar a string `caboose`.
 assert(lastRegex.source == 'caboose$');
 ```
 
-Sua regex não deve usar nenhuma flag.
+A regex não deve usar nenhuma flag.
 
 ```js
 assert(lastRegex.flags == '');

curriculum/challenges/portuguese/02-javascript-algorithms-and-data-structures/regular-expressions/match-everything-but-letters-and-numbers.md

@@ -10,7 +10,7 @@ dashedName: match-everything-but-letters-and-numbers
 
 Você aprendeu que você pode usar um atalho para capturar alfanuméricos `[A-Za-z0-9_]` usando `\w`. Você pode querer capturar exatamente o oposto disso.
 
-Você pode capturar não-alfanuméricos usando `\W` ao invés de `\w`. Observe que o atalho usa uma maiúscula. Este atalho é o mesmo que escrever `[^A-Za-z0-9_]`.
+Você pode capturar não alfanuméricos usando `\W` ao invés de `\w`. Observe que o atalho usa uma maiúscula. Este atalho é o mesmo que escrever `[^A-Za-z0-9_]`.
 
 ```js
 let shortHand = /\W/;
@@ -24,17 +24,17 @@ A primeira chamada a `match` retorna `["%"]` enquanto o segundo retorna `["!"]`.
 
 # --instructions--
 
-Use o atalho `\W` para contar o número de caracteres não-alfanuméricos em várias strings.
+Use o atalho `\W` para contar o número de caracteres não alfanuméricos em várias strings.
 
 # --hints--
 
-Sua regex deve usar a flag global.
+A regex deve usar a flag global.
 
 ```js
 assert(nonAlphabetRegex.global);
 ```
 
-Sua regex deve encontrar 6 caracteres não-alfanuméricos na string `The five boxing wizards jump quickly.`.
+A regex deve encontrar 6 caracteres não alfanuméricos na string `The five boxing wizards jump quickly.`.
 
 ```js
 assert(
@@ -42,13 +42,13 @@ assert(
 );
 ```
 
-Sua regex deve usar o atalho que captura os caracteres não-alfanuméricos.
+A regex deve usar o atalho que captura os caracteres não alfanuméricos.
 
 ```js
 assert(/\\W/.test(nonAlphabetRegex.source));
 ```
 
-Sua regex deve encontrar 8 caracteres não-alfanuméricos na string `Pack my box with five dozen liquor jugs.`
+A regex deve encontrar 8 caracteres não alfanuméricos na string `Pack my box with five dozen liquor jugs.`
 
 ```js
 assert(
@@ -56,7 +56,7 @@ assert(
 );
 ```
 
-Sua regex deve encontrar 6 caracteres não-alfanuméricos na string `How vexingly quick daft zebras jump!`
+A regex deve encontrar 6 caracteres não alfanuméricos na string `How vexingly quick daft zebras jump!`
 
 ```js
 assert(
@@ -64,7 +64,7 @@ assert(
 );
 ```
 
-Sua regex deve encontrar 12 caracteres não-alfanuméricos na string `123 456 7890 ABC def GHI jkl MNO pqr STU vwx YZ.`
+A regex deve encontrar 12 caracteres não alfanuméricos na string `123 456 7890 ABC def GHI jkl MNO pqr STU vwx YZ.`
 
 ```js
 assert(

curriculum/challenges/portuguese/02-javascript-algorithms-and-data-structures/regular-expressions/match-letters-of-the-alphabet.md

@@ -34,7 +34,7 @@ Capture todas as letras na string `quoteSample`.
 
 # --hints--
 
-Sua regex `alphabetRegex` deve encontrar 35 itens.
+A regex `alphabetRegex` deve encontrar 35 itens.
 
 ```js
 assert(result.length == 35);

curriculum/challenges/portuguese/02-javascript-algorithms-and-data-structures/regular-expressions/match-literal-strings.md

@@ -35,13 +35,13 @@ Complete a regex `waldoRegex` para encontrar `"Waldo"` na string `waldoIsHiding`
 
 # --hints--
 
-Sua regex `waldoRegex` deve encontrar a string `Waldo`
+A regex `waldoRegex` deve encontrar a string `Waldo`
 
 ```js
 assert(waldoRegex.test(waldoIsHiding));
 ```
 
-Sua regex `waldoRegex` não deve buscar nada além disso.
+A regex `waldoRegex` não deve buscar nada além disso.
 
 ```js
 assert(!waldoRegex.test('Somewhere is hiding in this text.'));

curriculum/challenges/portuguese/02-javascript-algorithms-and-data-structures/regular-expressions/match-non-whitespace-characters.md

@@ -10,7 +10,7 @@ dashedName: match-non-whitespace-characters
 
 Você aprendeu a procurar por espaço em branco usando `\s` com um `s` minúsculo. Você também pode buscar tudo exceto espaços em branco.
 
-Busque não-espaços em branco usando `\S` com um `s` maiúsculo. Este atalho não captura espaços em branco, retorno de carro, tabulações, feeds de formulário ou quebras de linha. O atalho é equivalente à classe de caracteres `[^ \r\t\f\n\v]`.
+Busque não espaços em branco usando `\S` com um `s` maiúsculo. Este atalho não captura espaços em branco, retorno de carro, tabulações, feeds de formulário ou quebras de linha. O atalho é equivalente à classe de caracteres `[^ \r\t\f\n\v]`.
 
 ```js
 let whiteSpace = "Whitespace. Whitespace everywhere!"
@@ -26,19 +26,19 @@ Modifique a regex `countNonWhiteSpace` para que encontre tudo exceto espaços em
 
 # --hints--
 
-Sua regex deve usar a flag global.
+A regex deve usar a flag global.
 
 ```js
 assert(countNonWhiteSpace.global);
 ```
 
-Sua regex deve usar o atalho `\S` para capturar tudo menos espaços em branco.
+A regex deve usar o atalho `\S` para capturar tudo menos espaços em branco.
 
 ```js
 assert(/\\S/.test(countNonWhiteSpace.source));
 ```
 
-Sua regex deve encontrar 35 não-espaços na string `Men are from Mars and women are from Venus.`
+A regex deve encontrar 35 não espaços na string `Men are from Mars and women are from Venus.`
 
 ```js
 assert(
@@ -47,13 +47,13 @@ assert(
 );
 ```
 
-Sua regex deve encontrar 23 não-espaços na string `Space: the final frontier.`
+A regex deve encontrar 23 não espaços na string `Space: the final frontier.`
 
 ```js
 assert('Space: the final frontier.'.match(countNonWhiteSpace).length == 23);
 ```
 
-Sua regex deve encontrar 21 não-espaços na string `MindYourPersonalSpace`
+A regex deve encontrar 21 não espaços na string `MindYourPersonalSpace`
 
 ```js
 assert('MindYourPersonalSpace'.match(countNonWhiteSpace).length == 21);

curriculum/challenges/portuguese/02-javascript-algorithms-and-data-structures/regular-expressions/match-numbers-and-letters-of-the-alphabet.md

@@ -26,7 +26,7 @@ Escreva uma única regex que encontra letras entre `h` e `s` e, também, número
 
 # --hints--
 
-Sua regex `myRegex` deve encontrar 17 itens.
+A regex `myRegex` deve encontrar 17 itens.
 
 ```js
 assert(result.length == 17);

curriculum/challenges/portuguese/02-javascript-algorithms-and-data-structures/regular-expressions/match-single-character-with-multiple-possibilities.md

@@ -60,7 +60,7 @@ Você deve usar a flag de ignorar caixa na sua regex `vowelRegex`.
 assert(vowelRegex.flags.match(/i/).length == 1);
 ```
 
-Sua regex não deve encontrar nenhuma consoante.
+A regex não deve encontrar nenhuma consoante.
 
 ```js
 assert(!/[b-df-hj-np-tv-z]/gi.test(result.join()));

curriculum/challenges/portuguese/02-javascript-algorithms-and-data-structures/regular-expressions/match-single-characters-not-specified.md

@@ -20,19 +20,19 @@ Crie uma única regex que captura todos os caracteres que não são números ou
 
 # --hints--
 
-Sua regex `myRegex` deve encontrar 9 itens.
+A regex `myRegex` deve encontrar 9 itens.
 
 ```js
 assert(result.length == 9);
 ```
 
-Você deve usar a flag global na sua regex `myRegex`.
+Você deve usar a flag global na regex `myRegex`.
 
 ```js
 assert(myRegex.flags.match(/g/).length == 1);
 ```
 
-Você deve usar a flag de ignorar caixa na sua regex `myRegex`.
+Você deve usar a flag de ignorar caixa na regex `myRegex`.
 
 ```js
 assert(myRegex.flags.match(/i/).length == 1);

curriculum/challenges/portuguese/02-javascript-algorithms-and-data-structures/regular-expressions/match-whitespace.md

@@ -25,19 +25,19 @@ Mude a regex `countWhiteSpace` para que capture múltiplos espaços em branco em
 
 # --hints--
 
-Sua regex deve usar a flag global.
+A regex deve usar a flag global.
 
 ```js
 assert(countWhiteSpace.global);
 ```
 
-Sua regex deve usar o atalho `\s` para capturar todos os espaços em branco.
+A regex deve usar o atalho `\s` para capturar todos os espaços em branco.
 
 ```js
 assert(/\\s/.test(countWhiteSpace.source));
 ```
 
-Sua regex deve encontrar oito espaços na string `Men are from Mars and women are from Venus.`
+A regex deve encontrar oito espaços na string `Men are from Mars and women are from Venus.`
 
 ```js
 assert(
@@ -46,13 +46,13 @@ assert(
 );
 ```
 
-Sua regex deve encontrar três espaços na string `Space: the final frontier.`
+A regex deve encontrar três espaços na string `Space: the final frontier.`
 
 ```js
 assert('Space: the final frontier.'.match(countWhiteSpace).length == 3);
 ```
 
-Sua regex não deve encontrar espaços na string `MindYourPersonalSpace`
+A regex não deve encontrar espaços na string `MindYourPersonalSpace`
 
 ```js
 assert('MindYourPersonalSpace'.match(countWhiteSpace) == null);

curriculum/challenges/portuguese/02-javascript-algorithms-and-data-structures/regular-expressions/positive-and-negative-lookahead.md

@@ -29,7 +29,7 @@ noquit.match(qRegex);
 
 As duas chamadas a `match` retornam `["q"]`.
 
-Validar dois padrões diferentes em uma string é considerado um uso mais prático de lookaheads. Neste não-tão-aprimorado validador de senhas, os lookaheads procuram por 3 a 6 caracteres e pelo menos um número, respectivamente, na string:
+Validar dois padrões diferentes em uma string é considerado um uso mais prático de lookaheads. Neste não tão aprimorado validador de senhas, os lookaheads procuram por 3 a 6 caracteres e pelo menos um número, respectivamente, na string:
 
 ```js
 let password = "abc123";
@@ -43,55 +43,55 @@ Faça com que `pwRegex` capture senhas que têm 5 ou mais caracteres e dois díg
 
 # --hints--
 
-Sua regex deve usar dois `lookaheads` positivos.
+A regex deve usar dois `lookaheads` positivos.
 
 ```js
 assert(pwRegex.source.match(/\(\?=.*?\)\(\?=.*?\)/) !== null);
 ```
 
-Sua regex não deve encontrar a string `astronaut`
+A regex não deve encontrar a string `astronaut`
 
 ```js
 assert(!pwRegex.test('astronaut'));
 ```
 
-Sua regex não deve encontrar a string `banan1`
+A regex não deve encontrar a string `banan1`
 
 ```js
 assert(!pwRegex.test('banan1'));
 ```
 
-Sua regex deve encontrar a string `bana12`
+A regex deve encontrar a string `bana12`
 
 ```js
 assert(pwRegex.test('bana12'));
 ```
 
-Sua regex deve encontrar a string `abc123`
+A regex deve encontrar a string `abc123`
 
 ```js
 assert(pwRegex.test('abc123'));
 ```
 
-Sua regex não deve encontrar a string `12345`
+A regex não deve encontrar a string `12345`
 
 ```js
 assert(!pwRegex.test('12345'));
 ```
 
-Sua regex deve encontrar a string `8pass99`
+A regex deve encontrar a string `8pass99`
 
 ```js
 assert(pwRegex.test('8pass99'));
 ```
 
-Sua regex não deve encontrar a string `1a2bcde`
+A regex não deve encontrar a string `1a2bcde`
 
 ```js
 assert(!pwRegex.test('1a2bcde'));
 ```
 
-Sua regex deve encontrar a string `astr1on11aut`
+A regex deve encontrar a string `astr1on11aut`
 
 ```js
 assert(pwRegex.test('astr1on11aut'));

curriculum/challenges/portuguese/02-javascript-algorithms-and-data-structures/regular-expressions/restrict-possible-usernames.md

@@ -26,79 +26,79 @@ Modifique a regex `userCheck` para que inclua as regras listadas.
 
 # --hints--
 
-Sua regex deve encontrar a string `JACK`
+A regex deve encontrar a string `JACK`
 
 ```js
 assert(userCheck.test('JACK'));
 ```
 
-Sua regex não deve encontrar a string `J`
+A regex não deve encontrar a string `J`
 
 ```js
 assert(!userCheck.test('J'));
 ```
 
-Sua regex deve encontrar a string `Jo`
+A regex deve encontrar a string `Jo`
 
 ```js
 assert(userCheck.test('Jo'));
 ```
 
-Sua regex deve encontrar a string `Oceans11`
+A regex deve encontrar a string `Oceans11`
 
 ```js
 assert(userCheck.test('Oceans11'));
 ```
 
-Sua regex deve encontrar a string `RegexGuru`
+A regex deve encontrar a string `RegexGuru`
 
 ```js
 assert(userCheck.test('RegexGuru'));
 ```
 
-Sua regex não deve encontrar a string `007`
+A regex não deve encontrar a string `007`
 
 ```js
 assert(!userCheck.test('007'));
 ```
 
-Sua regex não deve encontrar a string `9`
+A regex não deve encontrar a string `9`
 
 ```js
 assert(!userCheck.test('9'));
 ```
 
-Sua regex não deve encontrar a string `A1`
+A regex não deve encontrar a string `A1`
 
 ```js
 assert(!userCheck.test('A1'));
 ```
 
-Sua regex não deve encontrar a string `BadUs3rnam3`
+A regex não deve encontrar a string `BadUs3rnam3`
 
 ```js
 assert(!userCheck.test('BadUs3rnam3'));
 ```
 
-Sua regex deve encontrar a string `Z97`
+A regex deve encontrar a string `Z97`
 
 ```js
 assert(userCheck.test('Z97'));
 ```
 
-Sua regex não deve encontrar a string `c57bT3`
+A regex não deve encontrar a string `c57bT3`
 
 ```js
 assert(!userCheck.test('c57bT3'));
 ```
 
-Sua regex deve encontrar a string `AB1`
+A regex deve encontrar a string `AB1`
 
 ```js
 assert(userCheck.test('AB1'));
 ```
 
-Sua regex não deve encontrar a string `J%4`
+A regex não deve encontrar a string `J%4`
 
 ```js
 assert(!userCheck.test('J%4'))

curriculum/challenges/portuguese/02-javascript-algorithms-and-data-structures/regular-expressions/reuse-patterns-using-capture-groups.md

@@ -37,55 +37,55 @@ Use grupos de captura na regex `reRegex` para capturar em uma string um número
 
 # --hints--
 
-Sua regex deve usar o atalho de classe de caracteres para dígitos.
+A regex deve usar o atalho de classe de caracteres para dígitos.
 
 ```js
 assert(reRegex.source.match(/\\d/));
 ```
 
-Sua regex deve reusar um grupo de captura duas vezes.
+A regex deve reusar um grupo de captura duas vezes.
 
 ```js
 assert(reRegex.source.match(/\\1|\\2/g).length >= 2);
 ```
 
-Sua regex deve encontrar a string `42 42 42`.
+A regex deve encontrar a string `42 42 42`.
 
 ```js
 assert(reRegex.test('42 42 42'));
 ```
 
-Sua regex deve encontrar a string `100 100 100`.
+A regex deve encontrar a string `100 100 100`.
 
 ```js
 assert(reRegex.test('100 100 100'));
 ```
 
-Sua regex não deve encontrar a string `42 42 42 42`.
+A regex não deve encontrar a string `42 42 42 42`.
 
 ```js
 assert.equal('42 42 42 42'.match(reRegex.source), null);
 ```
 
-Sua regex não deve encontrar a string `42 42`.
+A regex não deve encontrar a string `42 42`.
 
 ```js
 assert.equal('42 42'.match(reRegex.source), null);
 ```
 
-Sua regex não deve encontrar a string `101 102 103`.
+A regex não deve encontrar a string `101 102 103`.
 
 ```js
 assert(!reRegex.test('101 102 103'));
 ```
 
-Sua regex não deve encontrar a string `1 2 3`.
+A regex não deve encontrar a string `1 2 3`.
 
 ```js
 assert(!reRegex.test('1 2 3'));
 ```
 
-Sua regex deve encontrar a string `10 10 10`.
+A regex deve encontrar a string `10 10 10`.
 
 ```js
 assert(reRegex.test('10 10 10'));

curriculum/challenges/portuguese/02-javascript-algorithms-and-data-structures/regular-expressions/specify-exact-number-of-matches.md

@@ -32,41 +32,41 @@ Modifique a regex `timRegex` para que capture quatro `m`s na string `Timber`.
 
 # --hints--
 
-Sua regex deve conter chaves.
+A regex deve conter chaves.
 
 ```js
 assert(timRegex.source.match(/{.*?}/).length > 0);
 ```
 
-Sua regex não deve encontrar a string `Timber`
+A regex não deve encontrar a string `Timber`
 
 ```js
 timRegex.lastIndex = 0;
 assert(!timRegex.test('Timber'));
 ```
 
-Sua regex não deve encontrar a string `Timmber`
+A regex não deve encontrar a string `Timmber`
 
 ```js
 timRegex.lastIndex = 0;
 assert(!timRegex.test('Timmber'));
 ```
 
-Sua regex não deve encontrar a string `Timmmber`
+A regex não deve encontrar a string `Timmmber`
 
 ```js
 timRegex.lastIndex = 0;
 assert(!timRegex.test('Timmmber'));
 ```
 
-Sua regex deve encontrar a string `Timmmmber`
+A regex deve encontrar a string `Timmmmber`
 
 ```js
 timRegex.lastIndex = 0;
 assert(timRegex.test('Timmmmber'));
 ```
 
-Sua regex não deve encontrar a string `Timber` se nela houver 30 `m`s.
+A regex não deve encontrar a string `Timber` se nela houver 30 `m`s.
 
 ```js
 timRegex.lastIndex = 0;

curriculum/challenges/portuguese/02-javascript-algorithms-and-data-structures/regular-expressions/specify-only-the-lower-number-of-matches.md

@@ -32,43 +32,43 @@ Modifique a regex `haRegex` para que capture quatro ou mais `z`s na string `Hazz
 
 # --hints--
 
-Sua regex deve usar chaves.
+A regex deve usar chaves.
 
 ```js
 assert(haRegex.source.match(/{.*?}/).length > 0);
 ```
 
-Sua regex não deve encontrar a string `Hazzah`
+A regex não deve encontrar a string `Hazzah`
 
 ```js
 assert(!haRegex.test('Hazzah'));
 ```
 
-Sua regex não deve encontrar a string `Hazzzah`
+A regex não deve encontrar a string `Hazzzah`
 
 ```js
 assert(!haRegex.test('Hazzzah'));
 ```
 
-Sua regex deve encontrar a string `Hazzzzah`
+A regex deve encontrar a string `Hazzzzah`
 
 ```js
 assert('Hazzzzah'.match(haRegex)[0].length === 8);
 ```
 
-Sua regex deve encontrar a string `Hazzzzzah`
+A regex deve encontrar a string `Hazzzzzah`
 
 ```js
 assert('Hazzzzzah'.match(haRegex)[0].length === 9);
 ```
 
-Sua regex deve encontrar a string `Hazzzzzzah`
+A regex deve encontrar a string `Hazzzzzzah`
 
 ```js
 assert('Hazzzzzzah'.match(haRegex)[0].length === 10);
 ```
 
-Sua regex deve capturar 30 `z`s, se presentes, na string `Hazzah`.
+A regex deve capturar 30 `z`s, se presentes, na string `Hazzah`.
 
 ```js
 assert('Hazzzzzzzzzzzzzzzzzzzzzzzzzzzzzzah'.match(haRegex)[0].length === 34);

curriculum/challenges/portuguese/02-javascript-algorithms-and-data-structures/regular-expressions/specify-upper-and-lower-number-of-matches.md

@@ -8,7 +8,7 @@ dashedName: specify-upper-and-lower-number-of-matches
 
 # --description--
 
-Lembre-se que você pode usar o sinal de `+` para procurar por uma ou mais ocorrências e o asterisco `*` para procurar por zero ou mais ocorrências. Eles são convenientes, mas às vezes você precisa capturar um número exato de caracteres.
+Lembre-se de que você pode usar o sinal de `+` para procurar por uma ou mais ocorrências e o asterisco `*` para procurar por zero ou mais ocorrências. Eles são convenientes, mas às vezes você precisa capturar um número exato de caracteres.
 
 Você pode especificar um número mínimo e um máximo de capturas com <dfn>especificadores de quantidade</dfn>. Para usar especificadores de quantidade, usa-se chaves: `{` e `}`. Você pode especificar os dois números dentro delas para restringir as capturas.
 
@@ -30,43 +30,43 @@ Altere a regex `ohRegex` para que capture a frase `Oh no`, mas apenas quando nel
 
 # --hints--
 
-Sua regex deve usar chaves.
+A regex deve usar chaves.
 
 ```js
 assert(ohRegex.source.match(/{.*?}/).length > 0);
 ```
 
-Sua regex não deve encontrar a string `Ohh no`
+A regex não deve encontrar a string `Ohh no`
 
 ```js
 assert(!ohRegex.test('Ohh no'));
 ```
 
-Sua regex deve encontrar a string `Ohhh no`
+A regex deve encontrar a string `Ohhh no`
 
 ```js
 assert('Ohhh no'.match(ohRegex)[0].length === 7);
 ```
 
-Sua regex deve encontrar a string `Ohhhh no`
+A regex deve encontrar a string `Ohhhh no`
 
 ```js
 assert('Ohhhh no'.match(ohRegex)[0].length === 8);
 ```
 
-Sua regex deve encontrar a string `Ohhhhh no`
+A regex deve encontrar a string `Ohhhhh no`
 
 ```js
 assert('Ohhhhh no'.match(ohRegex)[0].length === 9);
 ```
 
-Sua regex deve encontrar a string `Ohhhhhh no`
+A regex deve encontrar a string `Ohhhhhh no`
 
 ```js
 assert('Ohhhhhh no'.match(ohRegex)[0].length === 10);
 ```
 
-Sua regex não deve encontrar a string `Ohhhhhhh no`
+A regex não deve encontrar a string `Ohhhhhhh no`
 
 ```js
 assert(!ohRegex.test('Ohhhhhhh no'));

curriculum/challenges/portuguese/02-javascript-algorithms-and-data-structures/regular-expressions/use-capture-groups-to-search-and-replace.md

@@ -40,7 +40,7 @@ Você deve usar `.replace()` para buscar e substituir.
 assert(code.match(/\.replace\(.*\)/));
 ```
 
-Sua regex deve mudar a string `one two three` para `three two one`
+A regex deve mudar a string `one two three` para `three two one`
 
 ```js
 assert(result === 'three two one');

curriculum/challenges/portuguese/03-front-end-libraries/jquery/change-text-inside-an-element-using-jquery.md

@@ -1,6 +1,6 @@
 ---
 id: 564944c91be2204b269d51e3
-title: Altere Texto Dentro de um Elemento Usando JQuery
+title: Alterar texto dentro de um elemento usando jQuery
 challengeType: 6
 forumTopicId: 16773
 dashedName: change-text-inside-an-element-using-jquery
@@ -8,9 +8,9 @@ dashedName: change-text-inside-an-element-using-jquery
 
 # --description--
 
-Usando JQuery, você pode alterar o texto entre as tags de abertura e fechamento de um elemento. Você pode alterar até a marcação HTML.
+Usando jQuery, você pode alterar o texto entre as tags de abertura e fechamento de um elemento. Você pode alterar até a marcação HTML.
 
-jQuery possui uma função chamada `.html()` que permite a você adicionar tags HTML e texto dentro de um elemento. Qualquer conteúdo previamente dentro do elemento será completamente substituído com o conteúdo que você forneceu usando essa função.
+O jQuery possui uma função chamada `.html()` que permite a você adicionar tags HTML e texto dentro de um elemento. Qualquer conteúdo previamente dentro do elemento será completamente substituído com o conteúdo que você forneceu usando essa função.
 
 Aqui está como você rescreveria e enfatizaria o texto do nosso cabeçalho:
 
@@ -18,7 +18,7 @@ Aqui está como você rescreveria e enfatizaria o texto do nosso cabeçalho:
 $("h3").html("<em>jQuery Playground</em>");
 ```
 
-JQuery também possui uma função similar chamada `.text()` que altera apenas texto sem adicionar tags. Em outras palavras, essa função não irá avaliar nenhuma tag HTML passada a ela, mas ao invés disso irá tratá-la como o texto que você quer substituir o conteúdo atual existente.
+O jQuery também possui uma função similar chamada `.text()` que altera apenas texto sem adicionar tags. Em outras palavras, essa função não irá avaliar nenhuma tag HTML passada a ela, mas ao invés disso irá tratá-la como o texto que você quer substituir o conteúdo atual existente.
 
 Modifique o botão com id `target4` enfatizando seu texto.
 

curriculum/challenges/portuguese/03-front-end-libraries/jquery/change-the-css-of-an-element-using-jquery.md

@@ -1,6 +1,6 @@
 ---
 id: bad87fee1348bd9aed908826
-title: Altere o CSS de um Elemento Usando JQuery
+title: Alterar o CSS de um elemento usando o jQuery
 challengeType: 6
 forumTopicId: 16776
 required:
@@ -13,7 +13,7 @@ dashedName: change-the-css-of-an-element-using-jquery
 
 Nós podemos também alterar o CSS de um elemento HTML diretamente com JQuery.
 
-JQuery possui uma função chamada `.css()` que o permite alterar o CSS de um elemento.
+O jQuery possui uma função chamada `.css()` que o permite alterar o CSS de um elemento.
 
 Aqui está como mudaríamos sua cor para azul:
 
@@ -21,9 +21,9 @@ Aqui está como mudaríamos sua cor para azul:
 $("#target1").css("color", "blue");
 ```
 
-Isso é vagarosamente diferente de uma declaração normal de CSS, porque a propriedade CSS e o seu valor estão entre aspas e separada com vírgula ao invés de ponto e vírgula.
+Isso é um pouco diferente de uma declaração normal de CSS, porque a propriedade CSS e o seu valor estão entre aspas e separada com vírgula ao invés de ponto e vírgula.
 
-Remova seus seletores JQuery, deixando um `$(document).ready(function()` vazio.
+Remova seus seletores de jQuery, deixando uma `document ready function` vazia.
 
 Selecione `target1` e altere sua cor para vermelho.
 
@@ -35,7 +35,7 @@ Seu elemento `target1` deve ter o texto vermelho.
 assert($('#target1').css('color') === 'rgb(255, 0, 0)');
 ```
 
-Você deve usar apenas JQuery para adicionar essas classes ao elemento.
+Você deve usar apenas jQuery para adicionar essas classes ao elemento.
 
 ```js
 assert(!code.match(/class.*animated/g));