chore(i18n,curriculum): update translations

curriculum/challenges/portuguese/02-javascript-algorithms-and-data-structures/basic-javascript/access-array-data-with-indexes.md

@@ -18,9 +18,9 @@ Os índices de um array são escritos na mesma notação com colchetes que as st
 **Exemplo**
 
 ```js
-var array = [50,60,70];
+const array = [50, 60, 70];
 array[0];
-var data = array[1];
+const data = array[1];
 ```
 
 `array[0]` agora é `50` e `data` tem o valor `60`.
@@ -76,7 +76,7 @@ if(typeof myArray !== "undefined" && typeof myData !== "undefined"){(function(y,
 ## --seed-contents--
 
 ```js
-var myArray = [50,60,70];
+const myArray = [50, 60, 70];
 
 
 ```
@@ -84,6 +84,6 @@ var myArray = [50,60,70];
 # --solutions--
 
 ```js
-var myArray = [50,60,70];
-var myData = myArray[0];
+const myArray = [50, 60, 70];
+const myData = myArray[0];
 ```

curriculum/challenges/portuguese/02-javascript-algorithms-and-data-structures/basic-javascript/access-multi-dimensional-arrays-with-indexes.md

@@ -14,12 +14,13 @@ Uma maneira de pensar em um array <dfn>multidimensional</dfn> é como um *array
 **Exemplo**
 
 ```js
-var arr = [
-  [1,2,3],
-  [4,5,6],
-  [7,8,9],
-  [[10,11,12], 13, 14]
+const arr = [
+  [1, 2, 3],
+  [4, 5, 6],
+  [7, 8, 9],
+  [[10, 11, 12], 13, 14]
 ];
+
 arr[3];
 arr[3][0];
 arr[3][0][1];
@@ -58,14 +59,19 @@ if(typeof myArray !== "undefined"){(function(){return "myData: " + myData + " my
 ## --seed-contents--
 
 ```js
-var myArray = [[1,2,3], [4,5,6], [7,8,9], [[10,11,12], 13, 14]];
+const myArray = [
+  [1, 2, 3],
+  [4, 5, 6],
+  [7, 8, 9],
+  [[10, 11, 12], 13, 14],
+];
 
-var myData = myArray[0][0];
+const myData = myArray[0][0];
 ```
 
 # --solutions--
 
 ```js
-var myArray = [[1,2,3],[4,5,6], [7,8,9], [[10,11,12], 13, 14]];
-var myData = myArray[2][1];
+const myArray = [[1, 2, 3], [4, 5, 6], [7, 8, 9], [[10, 11, 12], 13, 14]];
+const myData = myArray[2][1];
 ```

curriculum/challenges/portuguese/02-javascript-algorithms-and-data-structures/basic-javascript/accessing-nested-arrays.md

@@ -14,7 +14,7 @@ Como vimos em exemplos anteriores, objetos podem conter tanto objetos aninhados
 Aqui está um exemplo de como se acessar um array aninhado:
 
 ```js
-var ourPets = [
+const ourPets = [
   {
     animalType: "cat",
     names: [
@@ -32,6 +32,7 @@ var ourPets = [
     ]
   }
 ];
+
 ourPets[0].names[1];
 ourPets[1].names[0];
 ```
@@ -72,7 +73,7 @@ assert(/=\s*myPlants\[1\].list\[1\]/.test(code));
 ## --seed-contents--
 
 ```js
-var myPlants = [
+const myPlants = [
   {
     type: "flowers",
     list: [
@@ -91,13 +92,13 @@ var myPlants = [
   }
 ];
 
-var secondTree = "";
+const secondTree = "";
 ```
 
 # --solutions--
 
 ```js
-var myPlants = [
+const myPlants = [
   {
     type: "flowers",
     list: [
@@ -116,5 +117,5 @@ var myPlants = [
   }
 ];
 
-var secondTree = myPlants[1].list[1];
+const secondTree = myPlants[1].list[1];
 ```

curriculum/challenges/portuguese/02-javascript-algorithms-and-data-structures/basic-javascript/accessing-nested-objects.md

@@ -14,7 +14,7 @@ As subpropriedades de objetos podem ser acessadas ao encadear a notação de pon
 Aqui está um objeto aninhado:
 
 ```js
-var ourStorage = {
+const ourStorage = {
   "desk": {
     "drawer": "stapler"
   },
@@ -26,6 +26,7 @@ var ourStorage = {
     "bottom drawer": "soda"
   }
 };
+
 ourStorage.cabinet["top drawer"].folder2;
 ourStorage.desk.drawer;
 ```
@@ -66,7 +67,7 @@ assert(/=\s*myStorage\.car\.inside\[\s*("|')glove box\1\s*\]/g.test(code));
 ## --seed-contents--
 
 ```js
-var myStorage = {
+const myStorage = {
   "car": {
     "inside": {
       "glove box": "maps",
@@ -78,13 +79,13 @@ var myStorage = {
   }
 };
 
-var gloveBoxContents = undefined;
+const gloveBoxContents = undefined;
 ```
 
 # --solutions--
 
 ```js
-var myStorage = {
+const myStorage = {
   "car":{
     "inside":{
       "glove box":"maps",
@@ -95,5 +96,5 @@ var myStorage = {
     }
   }
 };
-var gloveBoxContents = myStorage.car.inside["glove box"];
+const gloveBoxContents = myStorage.car.inside["glove box"];
 ```

curriculum/challenges/portuguese/02-javascript-algorithms-and-data-structures/basic-javascript/accessing-object-properties-with-bracket-notation.md

@@ -16,11 +16,12 @@ No entanto, você ainda pode usar a notação de colchetes nas propriedades dos
 Aqui está um exemplo usando a notação de colchetes para ler uma propriedade de um objeto:
 
 ```js
-var myObj = {
+const myObj = {
   "Space Name": "Kirk",
   "More Space": "Spock",
   "NoSpace": "USS Enterprise"
 };
+
 myObj["Space Name"];
 myObj['More Space'];
 myObj["NoSpace"];
@@ -78,26 +79,25 @@ assert(code.match(/testObj\s*?\[('|")[^'"]+\1\]/g).length > 1);
 
 ```js
 // Setup
-var testObj = {
+const testObj = {
   "an entree": "hamburger",
   "my side": "veggies",
   "the drink": "water"
 };
 
 // Only change code below this line
-
-var entreeValue = testObj;   // Change this line
-var drinkValue = testObj;    // Change this line
+const entreeValue = testObj;   // Change this line
+const drinkValue = testObj;    // Change this line
 ```
 
 # --solutions--
 
 ```js
-var testObj = {
+const testObj = {
   "an entree": "hamburger",
   "my side": "veggies",
   "the drink": "water"
 };
-var entreeValue = testObj["an entree"];
-var drinkValue = testObj['the drink'];
+const entreeValue = testObj["an entree"];
+const drinkValue = testObj['the drink'];
 ```

curriculum/challenges/portuguese/02-javascript-algorithms-and-data-structures/basic-javascript/accessing-object-properties-with-dot-notation.md

@@ -16,15 +16,17 @@ Notação de ponto é o que você utiliza quando você sabe o nome da propriedad
 Aqui está um exemplo usando notação de ponto (`.`) para ler uma propriedade do objeto:
 
 ```js
-var myObj = {
+const myObj = {
   prop1: "val1",
   prop2: "val2"
 };
-var prop1val = myObj.prop1;
-var prop2val = myObj.prop2;
+
+const prop1val = myObj.prop1;
+const prop2val = myObj.prop2;
 ```
 
 `prop1val` teria o valor `val1` e `prop2val` teria o valor `val2`.
+
 # --instructions--
 
 Leia os valores de propriedade de `testObj` usando a notação de ponto. Defina a variável `hatValue` igual à propriedade `hat` do objeto e defina a variável `shirtValue` igual à propriedade `shirt` do objeto.
@@ -73,27 +75,26 @@ assert(code.match(/testObj\.\w+/g).length > 1);
 
 ```js
 // Setup
-var testObj = {
+const testObj = {
   "hat": "ballcap",
   "shirt": "jersey",
   "shoes": "cleats"
 };
 
 // Only change code below this line
-
-var hatValue = testObj;      // Change this line
-var shirtValue = testObj;    // Change this line
+const hatValue = testObj;      // Change this line
+const shirtValue = testObj;    // Change this line
 ```
 
 # --solutions--
 
 ```js
-var testObj = {
+const testObj = {
   "hat": "ballcap",
   "shirt": "jersey",
   "shoes": "cleats"
 };
 
-var hatValue = testObj.hat;
-var shirtValue = testObj.shirt;
+const hatValue = testObj.hat;
+const shirtValue = testObj.shirt;
 ```

curriculum/challenges/portuguese/02-javascript-algorithms-and-data-structures/basic-javascript/accessing-object-properties-with-variables.md

@@ -14,11 +14,14 @@ Outro uso de notação de colchetes em objetos é para acessar a propriedade a q
 Aqui está um exemplo de usar uma variável para acessar uma propriedade:
 
 ```js
-var dogs = {
-  Fido: "Mutt",  Hunter: "Doberman",  Snoopie: "Beagle"
+const dogs = {
+  Fido: "Mutt",
+  Hunter: "Doberman",
+  Snoopie: "Beagle"
 };
-var myDog = "Hunter";
-var myBreed = dogs[myDog];
+
+const myDog = "Hunter";
+const myBreed = dogs[myDog];
 console.log(myBreed);
 ```
 
@@ -27,14 +30,16 @@ A string `Doberman` seria exibida no console.
 Outra forma de você usar esse conceito é quando o nome da propriedade é coletado dinamicamente, durante a execução do programa, da seguinte forma:
 
 ```js
-var someObj = {
+const someObj = {
   propName: "John"
 };
+
 function propPrefix(str) {
-  var s = "prop";
+  const s = "prop";
   return s + str;
 }
-var someProp = propPrefix("Name");
+
+const someProp = propPrefix("Name");
 console.log(someObj[someProp]);
 ```
 
@@ -96,26 +101,25 @@ if(typeof player !== "undefined"){(function(v){return v;})(player);}
 
 ```js
 // Setup
-var testObj = {
+const testObj = {
   12: "Namath",
   16: "Montana",
   19: "Unitas"
 };
 
 // Only change code below this line
-
-var playerNumber;       // Change this line
-var player = testObj;   // Change this line
+const playerNumber = 42;  // Change this line
+const player = testObj;   // Change this line
 ```
 
 # --solutions--
 
 ```js
-var testObj = {
+const testObj = {
   12: "Namath",
   16: "Montana",
   19: "Unitas"
 };
-var playerNumber = 16;
-var player = testObj[playerNumber];
+const playerNumber = 16;
+const player = testObj[playerNumber];
 ```

curriculum/challenges/portuguese/02-javascript-algorithms-and-data-structures/basic-javascript/add-new-properties-to-a-javascript-object.md

@@ -28,7 +28,7 @@ Agora, quando acessamos `ourDog.bark`, nós teremos o seu latido, `bow-wow`.
 Exemplo:
 
 ```js
-var ourDog = {
+const ourDog = {
   "name": "Camper",
   "legs": 4,
   "tails": 1,
@@ -67,7 +67,7 @@ assert(!/bark[^\n]:/.test(code));
 ## --seed-contents--
 
 ```js
-var myDog = {
+const myDog = {
   "name": "Happy Coder",
   "legs": 4,
   "tails": 1,
@@ -80,7 +80,7 @@ var myDog = {
 # --solutions--
 
 ```js
-var myDog = {
+const myDog = {
   "name": "Happy Coder",
   "legs": 4,
   "tails": 1,

curriculum/challenges/portuguese/02-javascript-algorithms-and-data-structures/basic-javascript/add-two-numbers-with-javascript.md

@@ -18,7 +18,7 @@ JavaScript utiliza o símbolo `+` como um operador de adição quando colocado e
 **Exemplo:**
 
 ```js
-myVar = 5 + 10;
+const myVar = 5 + 10;
 ```
 
 `myVar` agora tem o valor de `15`.
@@ -52,11 +52,11 @@ assert(/\+/.test(code));
 ## --seed-contents--
 
 ```js
-var sum = 10 + 0;
+const sum = 10 + 0;
 ```
 
 # --solutions--
 
 ```js
-var sum = 10 + 10;
+const sum = 10 + 10;
 ```

curriculum/challenges/portuguese/02-javascript-algorithms-and-data-structures/basic-javascript/adding-a-default-option-in-switch-statements.md

@@ -92,7 +92,7 @@ assert(code.match(/break/g).length > 2);
 
 ```js
 function switchOfStuff(val) {
-  var answer = "";
+  let answer = "";
   // Only change code below this line
 
 
@@ -108,7 +108,7 @@ switchOfStuff(1);
 
 ```js
 function switchOfStuff(val) {
-  var answer = "";
+  let answer = "";
 
   switch(val) {
     case "a":

curriculum/challenges/portuguese/02-javascript-algorithms-and-data-structures/basic-javascript/appending-variables-to-strings.md

@@ -14,8 +14,8 @@ Assim como podemos construir uma string em várias linhas através das strings <
 Exemplo:
 
 ```js
-var anAdjective = "awesome!";
-var ourStr = "freeCodeCamp is ";
+const anAdjective = "awesome!";
+let ourStr = "freeCodeCamp is ";
 ourStr += anAdjective;
 ```
 
@@ -64,15 +64,14 @@ assert(code.match(/myStr\s*\+=\s*someAdjective\s*/).length > 0);
 
 ```js
 // Change code below this line
-
-var someAdjective;
-var myStr = "Learning to code is ";
+const someAdjective = "";
+let myStr = "Learning to code is ";
 ```
 
 # --solutions--
 
 ```js
-var someAdjective = "neat";
-var myStr = "Learning to code is ";
+const someAdjective = "neat";
+let myStr = "Learning to code is ";
 myStr += someAdjective;
 ```

curriculum/challenges/portuguese/02-javascript-algorithms-and-data-structures/basic-javascript/build-javascript-objects.md

@@ -18,7 +18,7 @@ Objetos são úteis para armazenar dados de forma estruturada e podem representa
 Aqui está um exemplo de objeto gato:
 
 ```js
-var cat = {
+const cat = {
   "name": "Whiskers",
   "legs": 4,
   "tails": 1,
@@ -29,7 +29,7 @@ var cat = {
 Neste exemplo, todas as propriedades são armazenadas como strings, como `name`, `legs` e `tails`. Porém, você também pode usar números como propriedades. Você pode até omitir as aspas para propriedades de string com uma única palavra, da seguinte forma:
 
 ```js
-var anotherObject = {
+const anotherObject = {
   make: "Ford",
   5: "five",
   "model": "focus"
@@ -139,18 +139,18 @@ assert(
 ## --seed-contents--
 
 ```js
-var myDog = {
-// Only change code below this line
+const myDog = {
+  // Only change code below this line
 
 
-// Only change code above this line
+  // Only change code above this line
 };
 ```
 
 # --solutions--
 
 ```js
-var myDog = {
+const myDog = {
   "name": "Camper",
   "legs": 4,
   "tails": 1,

curriculum/challenges/portuguese/02-javascript-algorithms-and-data-structures/basic-javascript/comparison-with-the-equality-operator.md

@@ -16,7 +16,7 @@ O operador mais básico é o operador de igualdade `==`. O operador de igualdade
 ```js
 function equalityTest(myVal) {
   if (myVal == 10) {
-     return "Equal";
+    return "Equal";
   }
   return "Not Equal";
 }

curriculum/challenges/portuguese/02-javascript-algorithms-and-data-structures/basic-javascript/compound-assignment-with-augmented-addition.md

@@ -20,7 +20,7 @@ para adicionar `5` a `myVar`. Como este é um padrão tão comum, existem operad
 Um desses operadores é o operador `+=`.
 
 ```js
-var myVar = 1;
+let myVar = 1;
 myVar += 5;
 console.log(myVar);
 ```
@@ -61,9 +61,9 @@ Você não deve modificar o código acima do comentário especificado.
 
 ```js
 assert(
-  /var a = 3;/.test(code) &&
-    /var b = 17;/.test(code) &&
-    /var c = 12;/.test(code)
+  /let a = 3;/.test(code) &&
+    /let b = 17;/.test(code) &&
+    /let c = 12;/.test(code)
 );
 ```
 
@@ -78,9 +78,9 @@ assert(
 ## --seed-contents--
 
 ```js
-var a = 3;
-var b = 17;
-var c = 12;
+let a = 3;
+let b = 17;
+let c = 12;
 
 // Only change code below this line
 a = a + 12;
@@ -91,9 +91,9 @@ c = c + 7;
 # --solutions--
 
 ```js
-var a = 3;
-var b = 17;
-var c = 12;
+let a = 3;
+let b = 17;
+let c = 12;
 
 a += 12;
 b += 9;

curriculum/challenges/portuguese/02-javascript-algorithms-and-data-structures/basic-javascript/compound-assignment-with-augmented-division.md

@@ -55,9 +55,9 @@ Você não deve modificar o código acima do comentário especificado.
 
 ```js
 assert(
-  /var a = 48;/.test(code) &&
-    /var b = 108;/.test(code) &&
-    /var c = 33;/.test(code)
+  /let a = 48;/.test(code) &&
+    /let b = 108;/.test(code) &&
+    /let c = 33;/.test(code)
 );
 ```
 
@@ -72,9 +72,9 @@ assert(
 ## --seed-contents--
 
 ```js
-var a = 48;
-var b = 108;
-var c = 33;
+let a = 48;
+let b = 108;
+let c = 33;
 
 // Only change code below this line
 a = a / 12;
@@ -85,9 +85,9 @@ c = c / 11;
 # --solutions--
 
 ```js
-var a = 48;
-var b = 108;
-var c = 33;
+let a = 48;
+let b = 108;
+let c = 33;
 
 a /= 12;
 b /= 4;

curriculum/challenges/portuguese/02-javascript-algorithms-and-data-structures/basic-javascript/compound-assignment-with-augmented-multiplication.md

@@ -55,9 +55,9 @@ Você não deve modificar o código acima do comentário especificado.
 
 ```js
 assert(
-  /var a = 5;/.test(code) &&
-    /var b = 12;/.test(code) &&
-    /var c = 4\.6;/.test(code)
+  /let a = 5;/.test(code) &&
+    /let b = 12;/.test(code) &&
+    /let c = 4\.6;/.test(code)
 );
 ```
 
@@ -72,9 +72,9 @@ assert(
 ## --seed-contents--
 
 ```js
-var a = 5;
-var b = 12;
-var c = 4.6;
+let a = 5;
+let b = 12;
+let c = 4.6;
 
 // Only change code below this line
 a = a * 5;
@@ -85,9 +85,9 @@ c = c * 10;
 # --solutions--
 
 ```js
-var a = 5;
-var b = 12;
-var c = 4.6;
+let a = 5;
+let b = 12;
+let c = 4.6;
 
 a *= 5;
 b *= 3;

curriculum/challenges/portuguese/02-javascript-algorithms-and-data-structures/basic-javascript/compound-assignment-with-augmented-subtraction.md

@@ -55,7 +55,7 @@ Você não deve modificar o código acima do comentário especificado.
 
 ```js
 assert(
-  /var a = 11;/.test(code) && /var b = 9;/.test(code) && /var c = 3;/.test(code)
+  /let a = 11;/.test(code) && /let b = 9;/.test(code) && /let c = 3;/.test(code)
 );
 ```
 
@@ -70,9 +70,9 @@ assert(
 ## --seed-contents--
 
 ```js
-var a = 11;
-var b = 9;
-var c = 3;
+let a = 11;
+let b = 9;
+let c = 3;
 
 // Only change code below this line
 a = a - 6;
@@ -83,9 +83,9 @@ c = c - 1;
 # --solutions--
 
 ```js
-var a = 11;
-var b = 9;
-var c = 3;
+let a = 11;
+let b = 9;
+let c = 3;
 
 a -= 6;
 b -= 15;

curriculum/challenges/portuguese/02-javascript-algorithms-and-data-structures/basic-javascript/concatenating-strings-with-the-plus-equals-operator.md

@@ -16,7 +16,7 @@ Também podemos usar o operador `+=` para <dfn>concatenar</dfn> uma string no fi
 Exemplo:
 
 ```js
-var ourStr = "I come first. ";
+let ourStr = "I come first. ";
 ourStr += "I come second.";
 ```
 
@@ -57,14 +57,12 @@ assert(code.match(/myStr\s*\+=\s*(["']).*\1/g));
 ## --seed-contents--
 
 ```js
-// Only change code below this line
-
-var myStr;
+let myStr;
 ```
 
 # --solutions--
 
 ```js
-var myStr = "This is the first sentence. ";
+let myStr = "This is the first sentence. ";
 myStr += "This is the second sentence.";
 ```

curriculum/challenges/portuguese/02-javascript-algorithms-and-data-structures/basic-javascript/constructing-strings-with-variables.md

@@ -14,8 +14,8 @@ dashedName: constructing-strings-with-variables
 Exemplo:
 
 ```js
-var ourName = "freeCodeCamp";
-var ourStr = "Hello, our name is " + ourName + ", how are you?";
+const ourName = "freeCodeCamp";
+const ourStr = "Hello, our name is " + ourName + ", how are you?";
 ```
 
 `ourStr` teria o valor da string `Hello, our name is freeCodeCamp, how are you?`.
@@ -63,13 +63,13 @@ assert(code.match(/["']\s*\+\s*myName\s*\+\s*["']/g).length > 0);
 
 ```js
 // Only change code below this line
-var myName;
-var myStr;
+const myName = "";
+const myStr = "";
 ```
 
 # --solutions--
 
 ```js
-var myName = "Bob";
-var myStr = "My name is " + myName + " and I am well!";
+const myName = "Bob";
+const myStr = "My name is " + myName + " and I am well!";
 ```

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

@@ -159,7 +159,7 @@ assert(
 ## --seed-contents--
 
 ```js
-var count = 0;
+let count = 0;
 
 function cc(card) {
   // Only change code below this line
@@ -175,7 +175,7 @@ cc(2); cc(3); cc(7); cc('K'); cc('A');
 # --solutions--
 
 ```js
-var count = 0;
+let count = 0;
 function cc(card) {
   switch(card) {
     case 2:

curriculum/challenges/portuguese/02-javascript-algorithms-and-data-structures/basic-javascript/create-decimal-numbers-with-javascript.md

@@ -42,13 +42,14 @@ assert(myDecimal % 1 != 0);
 ## --seed-contents--
 
 ```js
-var ourDecimal = 5.7;
+const ourDecimal = 5.7;
 
 // Only change code below this line
+
 ```
 
 # --solutions--
 
 ```js
-var myDecimal = 9.9;
+const myDecimal = 9.9;
 ```

curriculum/challenges/portuguese/02-javascript-algorithms-and-data-structures/basic-javascript/decrement-a-number-with-javascript.md

@@ -39,7 +39,7 @@ assert(myVar === 10);
 
 ```js
 assert(
-  /var\s*myVar\s*=\s*11;\s*\/*.*\s*([-]{2}\s*myVar|myVar\s*[-]{2});/.test(code)
+  /let\s*myVar\s*=\s*11;\s*\/*.*\s*([-]{2}\s*myVar|myVar\s*[-]{2});/.test(code)
 );
 ```
 
@@ -52,7 +52,7 @@ assert(/[-]{2}\s*myVar|myVar\s*[-]{2}/.test(code));
 Você não deve alterar o código acima do comentário especificado.
 
 ```js
-assert(/var myVar = 11;/.test(code));
+assert(/let myVar = 11;/.test(code));
 ```
 
 # --seed--
@@ -66,7 +66,7 @@ assert(/var myVar = 11;/.test(code));
 ## --seed-contents--
 
 ```js
-var myVar = 11;
+let myVar = 11;
 
 // Only change code below this line
 myVar = myVar - 1;
@@ -75,6 +75,6 @@ myVar = myVar - 1;
 # --solutions--
 
 ```js
-var myVar = 11;
+let myVar = 11;
 myVar--;
 ```

curriculum/challenges/portuguese/02-javascript-algorithms-and-data-structures/basic-javascript/delete-properties-from-a-javascript-object.md

@@ -18,7 +18,7 @@ delete ourDog.bark;
 Exemplo:
 
 ```js
-var ourDog = {
+const ourDog = {
   "name": "Camper",
   "legs": 4,
   "tails": 1,
@@ -70,7 +70,7 @@ assert(code.match(/"tails": 1/g).length > 0);
 
 ```js
 // Setup
-var myDog = {
+const myDog = {
   "name": "Happy Coder",
   "legs": 4,
   "tails": 1,
@@ -79,12 +79,13 @@ var myDog = {
 };
 
 // Only change code below this line
+
 ```
 
 # --solutions--
 
 ```js
-var myDog = {
+const myDog = {
   "name": "Happy Coder",
   "legs": 4,
   "tails": 1,

curriculum/challenges/portuguese/02-javascript-algorithms-and-data-structures/basic-javascript/divide-one-decimal-by-another-with-javascript.md

@@ -46,11 +46,11 @@ assert(code.match(/quotient/g).length === 1);
 ## --seed-contents--
 
 ```js
-var quotient = 0.0 / 2.0; // Change this line
+const quotient = 0.0 / 2.0; // Change this line
 ```
 
 # --solutions--
 
 ```js
-var quotient = 4.4 / 2.0;
+const quotient = 4.4 / 2.0;
 ```

curriculum/challenges/portuguese/02-javascript-algorithms-and-data-structures/basic-javascript/divide-one-number-by-another-with-javascript.md

@@ -16,7 +16,7 @@ JavaScript usa o símbolo `/` para divisão.
 **Exemplo**
 
 ```js
-myVar = 16 / 2;
+const myVar = 16 / 2;
 ```
 
 `myVar` agora possui o valor `8`.
@@ -49,11 +49,11 @@ assert(/\d+\s*\/\s*\d+/.test(code));
 ## --seed-contents--
 
 ```js
-var quotient = 66 / 0;
+const quotient = 66 / 0;
 ```
 
 # --solutions--
 
 ```js
-var quotient = 66 / 33;
+const quotient = 66 / 33;
 ```

curriculum/challenges/portuguese/02-javascript-algorithms-and-data-structures/basic-javascript/escape-sequences-in-strings.md

@@ -89,11 +89,11 @@ console.log('myStr:\n' + myStr);}})();
 ## --seed-contents--
 
 ```js
-var myStr; // Change this line
+const myStr = ""; // Change this line
 ```
 
 # --solutions--
 
 ```js
-var myStr = "FirstLine\n\t\\SecondLine\nThirdLine";
+const myStr = "FirstLine\n\t\\SecondLine\nThirdLine";
 ```

curriculum/challenges/portuguese/02-javascript-algorithms-and-data-structures/basic-javascript/escaping-literal-quotes-in-strings.md

@@ -14,7 +14,7 @@ Quando você estiver definindo uma sequência de caracteres você deve iniciar e
 Em JavaScript, você pode <dfn>escapar</dfn> uma aspa para que não seja considerada como o fim de uma string ao colocar a <dfn>barra invertida</dfn> (`\`) na frente da aspa.
 
 ```js
-var sampleStr = "Alan said, \"Peter is learning JavaScript\".";
+const sampleStr = "Alan said, \"Peter is learning JavaScript\".";
 ```
 
 Isso sinaliza ao JavaScript que a aspa seguinte não é o fim de uma string, mas que deve aparecer dentro da string. Então, se você fosse imprimir isso no console, você obteria:
@@ -62,11 +62,11 @@ assert(/I am a "double quoted" string inside "double quotes(\."|"\.)$/.test(mySt
 ## --seed-contents--
 
 ```js
-var myStr = ""; // Change this line
+const myStr = ""; // Change this line
 ```
 
 # --solutions--
 
 ```js
-var myStr = "I am a \"double quoted\" string inside \"double quotes\".";
+const myStr = "I am a \"double quoted\" string inside \"double quotes\".";
 ```

curriculum/challenges/portuguese/02-javascript-algorithms-and-data-structures/basic-javascript/finding-a-remainder-in-javascript.md

@@ -31,7 +31,7 @@ Define o `resto` igual ao restante de `11` dividido por `3` usando o operador de
 A variável `remainder` deve ser inicializada
 
 ```js
-assert(/var\s+?remainder/.test(code));
+assert(/(const|let|var)\s+?remainder/.test(code));
 ```
 
 O valor de `remainder` deve ser `2`
@@ -57,13 +57,11 @@ assert(/\s+?remainder\s*?=\s*?.*%.*;?/.test(code));
 ## --seed-contents--
 
 ```js
-// Only change code below this line
-
-var remainder;
+const remainder = 0;
 ```
 
 # --solutions--
 
 ```js
-var remainder =  11 % 3;
+const remainder = 11 % 3;
 ```

curriculum/challenges/portuguese/02-javascript-algorithms-and-data-structures/basic-javascript/global-vs.-local-scope-in-functions.md

@@ -14,9 +14,10 @@ dashedName: global-vs--local-scope-in-functions
 Neste exemplo:
 
 ```js
-var someVar = "Hat";
+const someVar = "Hat";
+
 function myFun() {
-  var someVar = "Head";
+  const someVar = "Head";
   return someVar;
 }
 ```
@@ -53,13 +54,11 @@ assert(/return outerWear/.test(code));
 
 ```js
 // Setup
-var outerWear = "T-Shirt";
+const outerWear = "T-Shirt";
 
 function myOutfit() {
   // Only change code below this line
 
-
-
   // Only change code above this line
   return outerWear;
 }
@@ -70,9 +69,9 @@ myOutfit();
 # --solutions--
 
 ```js
-var outerWear = "T-Shirt";
+const outerWear = "T-Shirt";
 function myOutfit() {
-  var outerWear = "sweater";
+  const outerWear = "sweater";
   return outerWear;
 }
 ```

curriculum/challenges/portuguese/02-javascript-algorithms-and-data-structures/basic-javascript/golf-code.md

@@ -90,7 +90,8 @@ assert(golfScore(5, 9) === 'Go Home!');
 ## --seed-contents--
 
 ```js
-var names = ["Hole-in-one!", "Eagle", "Birdie", "Par", "Bogey", "Double Bogey", "Go Home!"];
+const names = ["Hole-in-one!", "Eagle", "Birdie", "Par", "Bogey", "Double Bogey", "Go Home!"];
+
 function golfScore(par, strokes) {
   // Only change code below this line
 

curriculum/challenges/portuguese/02-javascript-algorithms-and-data-structures/basic-javascript/increment-a-number-with-javascript.md

@@ -39,7 +39,7 @@ Você não deve usar o operador de atribuição.
 
 ```js
 assert(
-  /var\s*myVar\s*=\s*87;\s*\/*.*\s*([+]{2}\s*myVar|myVar\s*[+]{2});/.test(code)
+  /let\s*myVar\s*=\s*87;\s*\/*.*\s*([+]{2}\s*myVar|myVar\s*[+]{2});/.test(code)
 );
 ```
 
@@ -52,7 +52,7 @@ assert(/[+]{2}\s*myVar|myVar\s*[+]{2}/.test(code));
 Você não deve alterar o código acima do comentário especificado.
 
 ```js
-assert(/var myVar = 87;/.test(code));
+assert(/let myVar = 87;/.test(code));
 ```
 
 # --seed--
@@ -66,7 +66,7 @@ assert(/var myVar = 87;/.test(code));
 ## --seed-contents--
 
 ```js
-var myVar = 87;
+let myVar = 87;
 
 // Only change code below this line
 myVar = myVar + 1;
@@ -75,6 +75,6 @@ myVar = myVar + 1;
 # --solutions--
 
 ```js
-var myVar = 87;
+let myVar = 87;
 myVar++;
 ```

curriculum/challenges/portuguese/02-javascript-algorithms-and-data-structures/basic-javascript/introducing-else-statements.md

@@ -64,7 +64,7 @@ assert(testElse(10) === 'Bigger than 5');
 Você não deve alterar o código acima ou abaixo dos comentários especificados.
 
 ```js
-assert(/var result = "";/.test(code) && /return result;/.test(code));
+assert(/let result = "";/.test(code) && /return result;/.test(code));
 ```
 
 # --seed--
@@ -73,7 +73,7 @@ assert(/var result = "";/.test(code) && /return result;/.test(code));
 
 ```js
 function testElse(val) {
-  var result = "";
+  let result = "";
   // Only change code below this line
 
   if (val > 5) {
@@ -95,7 +95,7 @@ testElse(4);
 
 ```js
 function testElse(val) {
-  var result = "";
+  let result = "";
   if(val > 5) {
     result = "Bigger than 5";
   } else {

curriculum/challenges/portuguese/02-javascript-algorithms-and-data-structures/basic-javascript/iterate-through-an-array-with-a-for-loop.md

@@ -12,8 +12,9 @@ dashedName: iterate-through-an-array-with-a-for-loop
 Uma tarefa comum em JavaScript é para iterar através do conteúdo de um array. Uma forma de fazer isso é com um laço `for`. Esse código vai exibir cada elemento do array `arr` no console:
 
 ```js
-var arr = [10, 9, 8, 7, 6];
-for (var i = 0; i < arr.length; i++) {
+const arr = [10, 9, 8, 7, 6];
+
+for (let i = 0; i < arr.length; i++) {
    console.log(arr[i]);
 }
 ```
@@ -62,18 +63,19 @@ assert(!__helpers.removeWhiteSpace(code).match(/total[=+-]0*[1-9]+/gm));
 
 ```js
 // Setup
-var myArr = [ 2, 3, 4, 5, 6];
+const myArr = [2, 3, 4, 5, 6];
 
 // Only change code below this line
+
 ```
 
 # --solutions--
 
 ```js
-var myArr = [ 2, 3, 4, 5, 6];
-var total = 0;
+const myArr = [2, 3, 4, 5, 6];
+let total = 0;
 
-for (var i = 0; i < myArr.length; i++) {
+for (let i = 0; i < myArr.length; i++) {
   total += myArr[i];
 }
 ```

curriculum/challenges/portuguese/02-javascript-algorithms-and-data-structures/basic-javascript/iterate-with-javascript-do...while-loops.md

@@ -12,8 +12,9 @@ dashedName: iterate-with-javascript-do---while-loops
 O próximo tipo de laço que você aprenderá é chamado de laço `do...while`. O laço `do...while` é chamado assim porque primeiro fará algo (`do`) ou executará algo uma vez dentro do bloco de código, não importando o que acontecer. Em seguida, continuará a executar o laço enquanto (`while`) a condição for `true`.
 
 ```js
-var ourArray = [];
-var i = 0;
+const ourArray = [];
+let i = 0;
+
 do {
   ourArray.push(i);
   i++;
@@ -23,8 +24,9 @@ do {
 O exemplo acima se comporta de forma similar a outros tipos de laços, e o array resultante se parecerá com `[0,1,2,3,4]`. No entanto, o que torna o laço `do...while` diferente de outros laços é como ele se comporta quando uma condição falha na primeira verificação. Vamos ver isso na prática: Aqui está um laço comum `while` que rodará o código no laço enquanto `i < 5`:
 
 ```js
-var ourArray = []; 
-var i = 5;
+const ourArray = []; 
+let i = 5;
+
 while (i < 5) {
   ourArray.push(i);
   i++;
@@ -34,8 +36,9 @@ while (i < 5) {
 Nesse exemplo, inicializamos o valor de `ourArray` como um array vazio e o valor de `i` sendo 5. Quando executamos o laço `while`, a condição é igual a `false` porque `i` não é menor que 5, portanto nós não executamos o código dentro do laço. O resultado é que `ourArray` terminará sem valores adicionados a ele, e ainda se parecerá com `[]` quando todas as linhas do código no exemplo acima forem completamente executadas. Agora, dê uma olhada no laço `do...while`:
 
 ```js
-var ourArray = []; 
-var i = 5;
+const ourArray = []; 
+let i = 5;
+
 do {
   ourArray.push(i);
   i++;
@@ -80,8 +83,8 @@ if(typeof myArray !== "undefined"){(function(){return myArray;})();}
 
 ```js
 // Setup
-var myArray = [];
-var i = 10;
+const myArray = [];
+let i = 10;
 
 // Only change code below this line
 while (i < 5) {
@@ -93,8 +96,8 @@ while (i < 5) {
 # --solutions--
 
 ```js
-var myArray = [];
-var i = 10;
+const myArray = [];
+let i = 10;
 do {
   myArray.push(i);
   i++;

curriculum/challenges/portuguese/02-javascript-algorithms-and-data-structures/basic-javascript/local-scope-and-functions.md

@@ -15,9 +15,10 @@ Aqui está uma função `myTest` com uma variável local chamada `loc`.
 
 ```js
 function myTest() {
-  var loc = "foo";
+  const loc = "foo";
   console.log(loc);
 }
+
 myTest();
 console.log(loc);
 ```
@@ -38,6 +39,7 @@ O código não deve conter uma variável global `myVar`.
 function declared() {
   myVar;
 }
+
 assert.throws(declared, ReferenceError);
 ```
 
@@ -57,7 +59,6 @@ assert(
 
 ```js
 function myLocalScope() {
-
   // Only change code below this line
 
   console.log('inside myLocalScope', myVar);
@@ -73,9 +74,8 @@ console.log('outside myLocalScope', myVar);
 
 ```js
 function myLocalScope() {
-
   // Only change code below this line
-  var myVar;
+  let myVar;
   console.log('inside myLocalScope', myVar);
 }
 myLocalScope();

curriculum/challenges/portuguese/02-javascript-algorithms-and-data-structures/basic-javascript/manipulate-arrays-with-push.md

@@ -16,10 +16,10 @@ Uma forma fácil de adicionar dados no final de um array é através da função
 Exemplos:
 
 ```js
-var arr1 = [1,2,3];
+const arr1 = [1, 2, 3];
 arr1.push(4);
 
-var arr2 = ["Stimpson", "J", "cat"];
+const arr2 = ["Stimpson", "J", "cat"];
 arr2.push(["happy", "joy"]);
 ```
 
@@ -64,14 +64,15 @@ assert(
 
 ```js
 // Setup
-var myArray = [["John", 23], ["cat", 2]];
+const myArray = [["John", 23], ["cat", 2]];
 
 // Only change code below this line
+
 ```
 
 # --solutions--
 
 ```js
-var myArray = [["John", 23], ["cat", 2]];
+const myArray = [["John", 23], ["cat", 2]];
 myArray.push(["dog",3]);
 ```

curriculum/challenges/portuguese/02-javascript-algorithms-and-data-structures/basic-javascript/manipulating-complex-objects.md

@@ -14,7 +14,7 @@ dashedName: manipulating-complex-objects
 Aqui está um exemplo de estrutura de dados complexas:
 
 ```js
-var ourMusic = [
+const ourMusic = [
   {
     "artist": "Daft Punk",
     "title": "Homework",
@@ -135,7 +135,7 @@ myMusic.forEach(object => {
 ## --seed-contents--
 
 ```js
-var myMusic = [
+const myMusic = [
   {
     "artist": "Billy Joel",
     "title": "Piano Man",
@@ -153,7 +153,7 @@ var myMusic = [
 # --solutions--
 
 ```js
-var myMusic = [
+const myMusic = [
   {
     "artist": "Billy Joel",
     "title": "Piano Man",

curriculum/challenges/portuguese/02-javascript-algorithms-and-data-structures/basic-javascript/multiple-identical-options-in-switch-statements.md

@@ -12,7 +12,7 @@ dashedName: multiple-identical-options-in-switch-statements
 Se a instrução `break` for omitida de uma instrução `case` de um `switch`, as instruções `case` seguintes serão executadas até que seja encontrado um `break`. Se você tem várias entradas com a mesma saída, você pode representá-las em uma instrução `switch` da seguinte forma:
 
 ```js
-var result = "";
+let result = "";
 switch(val) {
   case 1:
   case 2:
@@ -109,7 +109,7 @@ assert(code.match(/case/g).length === 9);
 
 ```js
 function sequentialSizes(val) {
-  var answer = "";
+  let answer = "";
   // Only change code below this line
 
 
@@ -125,7 +125,7 @@ sequentialSizes(1);
 
 ```js
 function sequentialSizes(val) {
-  var answer = "";
+  let answer = "";
 
   switch(val) {
     case 1:

curriculum/challenges/portuguese/02-javascript-algorithms-and-data-structures/basic-javascript/multiply-two-decimals-with-javascript.md

@@ -42,11 +42,11 @@ assert(/\*/.test(code));
 ## --seed-contents--
 
 ```js
-var product = 2.0 * 0.0;
+const product = 2.0 * 0.0;
 ```
 
 # --solutions--
 
 ```js
-var product = 2.0 * 2.5;
+const product = 2.0 * 2.5;
 ```

curriculum/challenges/portuguese/02-javascript-algorithms-and-data-structures/basic-javascript/multiply-two-numbers-with-javascript.md

@@ -16,7 +16,7 @@ JavaScript usa o símbolo `*` para multiplicação de dois números.
 **Exemplo**
 
 ```js
-myVar = 13 * 13;
+const myVar = 13 * 13;
 ```
 
 `myVar` teria o valor `169`.
@@ -50,11 +50,11 @@ assert(/\*/.test(code));
 ## --seed-contents--
 
 ```js
-var product = 8 * 0;
+const product = 8 * 0;
 ```
 
 # --solutions--
 
 ```js
-var product = 8 * 10;
+const product = 8 * 10;
 ```

curriculum/challenges/portuguese/02-javascript-algorithms-and-data-structures/basic-javascript/nest-one-array-within-another-array.md

@@ -12,7 +12,7 @@ dashedName: nest-one-array-within-another-array
 Você também pode aninhar arrays dentro de outros arrays, como abaixo:
 
 ```js
-[["Bulls", 23], ["White Sox", 45]]
+const teams = [["Bulls", 23], ["White Sox", 45]];
 ```
 
 Isso é chamado um <dfn>array multidimensional</dfn>.
@@ -41,11 +41,11 @@ if(typeof myArray !== "undefined"){(function(){return myArray;})();}
 
 ```js
 // Only change code below this line
-var myArray = [];
+const myArray = [];
 ```
 
 # --solutions--
 
 ```js
-var myArray = [[1,2,3]];
+const myArray = [[1, 2, 3]];
 ```

curriculum/challenges/portuguese/02-javascript-algorithms-and-data-structures/basic-javascript/profile-lookup.md

@@ -68,34 +68,33 @@ assert(lookUpProfile('Akira', 'address') === 'No such property');
 
 ```js
 // Setup
-var contacts = [
-    {
-        "firstName": "Akira",
-        "lastName": "Laine",
-        "number": "0543236543",
-        "likes": ["Pizza", "Coding", "Brownie Points"]
-    },
-    {
-        "firstName": "Harry",
-        "lastName": "Potter",
-        "number": "0994372684",
-        "likes": ["Hogwarts", "Magic", "Hagrid"]
-    },
-    {
-        "firstName": "Sherlock",
-        "lastName": "Holmes",
-        "number": "0487345643",
-        "likes": ["Intriguing Cases", "Violin"]
-    },
-    {
-        "firstName": "Kristian",
-        "lastName": "Vos",
-        "number": "unknown",
-        "likes": ["JavaScript", "Gaming", "Foxes"]
-    }
+const contacts = [
+  {
+    firstName: "Akira",
+    lastName: "Laine",
+    number: "0543236543",
+    likes: ["Pizza", "Coding", "Brownie Points"],
+  },
+  {
+    firstName: "Harry",
+    lastName: "Potter",
+    number: "0994372684",
+    likes: ["Hogwarts", "Magic", "Hagrid"],
+  },
+  {
+    firstName: "Sherlock",
+    lastName: "Holmes",
+    number: "0487345643",
+    likes: ["Intriguing Cases", "Violin"],
+  },
+  {
+    firstName: "Kristian",
+    lastName: "Vos",
+    number: "unknown",
+    likes: ["JavaScript", "Gaming", "Foxes"],
+  },
 ];
 
-
 function lookUpProfile(name, prop) {
   // Only change code below this line
 
@@ -108,44 +107,38 @@ lookUpProfile("Akira", "likes");
 # --solutions--
 
 ```js
-var contacts = [
-    {
-        "firstName": "Akira",
-        "lastName": "Laine",
-        "number": "0543236543",
-        "likes": ["Pizza", "Coding", "Brownie Points"]
-    },
-    {
-        "firstName": "Harry",
-        "lastName": "Potter",
-        "number": "0994372684",
-        "likes": ["Hogwarts", "Magic", "Hagrid"]
-    },
-    {
-        "firstName": "Sherlock",
-        "lastName": "Holmes",
-        "number": "0487345643",
-        "likes": ["Intriguing Cases", "Violin"]
-    },
-    {
-        "firstName": "Kristian",
-        "lastName": "Vos",
-        "number": "unknown",
-        "likes": ["JavaScript", "Gaming", "Foxes"]
-    },
+const contacts = [
+  {
+    firstName: "Akira",
+    lastName: "Laine",
+    number: "0543236543",
+    likes: ["Pizza", "Coding", "Brownie Points"],
+  },
+  {
+    firstName: "Harry",
+    lastName: "Potter",
+    number: "0994372684",
+    likes: ["Hogwarts", "Magic", "Hagrid"],
+  },
+  {
+    firstName: "Sherlock",
+    lastName: "Holmes",
+    number: "0487345643",
+    likes: ["Intriguing Cases", "Violin"],
+  },
+  {
+    firstName: "Kristian",
+    lastName: "Vos",
+    number: "unknown",
+    likes: ["JavaScript", "Gaming", "Foxes"],
+  },
 ];
-
-
-//Write your function in between these comments
-function lookUpProfile(name, prop){
-    for(var i in contacts){
-      if(contacts[i].firstName === name) {
-        return contacts[i][prop] || "No such property";
-      }
+function lookUpProfile(name, prop) {
+  for (let i in contacts) {
+    if (contacts[i].firstName === name) {
+      return contacts[i][prop] || "No such property";
     }
-   return "No such contact";
+  }
+  return "No such contact";
 }
-//Write your function in between these comments
-
-lookUpProfile("Akira", "likes");
 ```

curriculum/challenges/portuguese/02-javascript-algorithms-and-data-structures/basic-javascript/quoting-strings-with-single-quotes.md

@@ -12,21 +12,21 @@ dashedName: quoting-strings-with-single-quotes
 Valores de <dfn>string</dfn> em JavaScript podem ser escritas com aspas simples ou duplas, desde que você comece e termine com o mesmo tipo de aspas. Diferente de outras linguagens de programação, aspas simples e duplas funcionam da mesma forma em JavaScript.
 
 ```js
-doubleQuoteStr = "This is a string"; 
-singleQuoteStr = 'This is also a string';
+const doubleQuoteStr = "This is a string"; 
+const singleQuoteStr = 'This is also a string';
 ```
 
 O motivo pelo qual você pode querer usar um tipo de aspas no lugar da outra é se você vir a querer usar ambas em uma string. Isso pode acontecer se você quiser salvar uma conversa em uma string e ter a conversa entre aspas. Outro uso para isso seria salvar uma tag `<a>` com vários atributos em aspas, tudo dentro de uma string.
 
 ```js
-conversation = 'Finn exclaims to Jake, "Algebraic!"';
+const conversation = 'Finn exclaims to Jake, "Algebraic!"';
 ```
 
 Porém, isso se torna um problema se você precisar usar as aspas mais extremas dentro dela. Lembre-se, uma string tem o mesmo tipo de aspas no início e no final. Mas se você tem aquela mesma aspa em algum lugar no meio, a string vai terminar mais cedo e lançará um erro.
 
 ```js
-goodStr = 'Jake asks Finn, "Hey, let\'s go on an adventure?"'; 
-badStr = 'Finn responds, "Let's go!"';
+const goodStr = 'Jake asks Finn, "Hey, let\'s go on an adventure?"'; 
+const badStr = 'Finn responds, "Let's go!"';
 ```
 
 Aqui `badStr` lançará um erro.
@@ -71,11 +71,11 @@ assert(code.match(/"/g).length === 4 && code.match(/'/g).length === 2);
 ## --seed-contents--
 
 ```js
-var myStr = "<a href=\"http://www.example.com\" target=\"_blank\">Link</a>";
+const myStr = "<a href=\"http://www.example.com\" target=\"_blank\">Link</a>";
 ```
 
 # --solutions--
 
 ```js
-var myStr = '<a href="http://www.example.com" target="_blank">Link</a>';
+const myStr = '<a href="http://www.example.com" target="_blank">Link</a>';
 ```

curriculum/challenges/portuguese/02-javascript-algorithms-and-data-structures/basic-javascript/record-collection.md

@@ -115,7 +115,7 @@ const _recordCollection = {
 
 ```js
 // Setup
-var recordCollection = {
+const recordCollection = {
   2548: {
     albumTitle: 'Slippery When Wet',
     artist: 'Bon Jovi',
@@ -146,7 +146,7 @@ updateRecords(recordCollection, 5439, 'artist', 'ABBA');
 # --solutions--
 
 ```js
-var recordCollection = {
+const recordCollection = {
   2548: {
     albumTitle: 'Slippery When Wet',
     artist: 'Bon Jovi',

curriculum/challenges/portuguese/02-javascript-algorithms-and-data-structures/basic-javascript/replace-loops-using-recursion.md

@@ -14,9 +14,9 @@ Recursão é o conceito de que uma função pode ser chamada por ela mesma. Para
 
 ```js
   function multiply(arr, n) {
-    var product = 1;
-    for (var i = 0; i < n; i++) {
-        product *= arr[i];
+    let product = 1;
+    for (let i = 0; i < n; i++) {
+      product *= arr[i];
     }
     return product;
   }

curriculum/challenges/portuguese/02-javascript-algorithms-and-data-structures/basic-javascript/replacing-if-else-chains-with-switch.md

@@ -108,7 +108,7 @@ assert(chainToSwitch(156) === '');
 
 ```js
 function chainToSwitch(val) {
-  var answer = "";
+  let answer = "";
   // Only change code below this line
 
   if (val === "bob") {
@@ -134,7 +134,7 @@ chainToSwitch(7);
 
 ```js
 function chainToSwitch(val) {
-  var answer = "";
+  let answer = "";
 
   switch(val) {
     case "bob":

curriculum/challenges/portuguese/02-javascript-algorithms-and-data-structures/basic-javascript/return-a-value-from-a-function-with-return.md

@@ -17,7 +17,8 @@ Nós podemos passar valores para uma função com <dfn>argumentos</dfn>. Você p
 function plusThree(num) {
   return num + 3;
 }
-var answer = plusThree(5);
+
+const answer = plusThree(5);
 ```
 
 `answer` tem o valor de `8`.

curriculum/challenges/portuguese/02-javascript-algorithms-and-data-structures/basic-javascript/selecting-from-many-options-with-switch-statements.md

@@ -78,7 +78,7 @@ assert(code.match(/break/g).length > 2);
 
 ```js
 function caseInSwitch(val) {
-  var answer = "";
+  let answer = "";
   // Only change code below this line
 
 
@@ -94,7 +94,7 @@ caseInSwitch(1);
 
 ```js
 function caseInSwitch(val) {
-  var answer = "";
+  let answer = "";
 
   switch(val) {
     case 1:

curriculum/challenges/portuguese/02-javascript-algorithms-and-data-structures/basic-javascript/shopping-list.md

@@ -81,13 +81,13 @@ var hasNumber = false;
 ## --seed-contents--
 
 ```js
-var myList = [];
+const myList = [];
 ```
 
 # --solutions--
 
 ```js
-var myList = [
+const myList = [
   ["Candy", 10],
   ["Potatoes", 12],
   ["Eggs", 12],

curriculum/challenges/portuguese/02-javascript-algorithms-and-data-structures/basic-javascript/stand-in-line.md

@@ -93,12 +93,10 @@ function nextInLine(arr, item) {
 
   return item;
   // Only change code above this line
-
-
 }
 
 // Setup
-var testArr = [1,2,3,4,5];
+const testArr = [1, 2, 3, 4, 5];
 
 // Display code
 console.log("Before: " + JSON.stringify(testArr));
@@ -109,7 +107,7 @@ console.log("After: " + JSON.stringify(testArr));
 # --solutions--
 
 ```js
-var testArr = [ 1,2,3,4,5];
+const testArr = [1, 2, 3, 4, 5];
 
 function nextInLine(arr, item) {
     arr.push(item);

curriculum/challenges/portuguese/02-javascript-algorithms-and-data-structures/basic-javascript/store-multiple-values-in-one-variable-using-javascript-arrays.md

@@ -14,7 +14,7 @@ Com as variáveis de `array` em JavaScript, podemos armazenar diversos dados em
 Você começa uma declaração de um array com a abertura de um colchetes, terminando com o fechamento do colchetes e colocando vírgulas entre cada entrada, dessa forma:
 
 ```js
-var sandwich = ["peanut butter", "jelly", "bread"]
+const sandwich = ["peanut butter", "jelly", "bread"];
 ```
 
 # --instructions--
@@ -53,11 +53,11 @@ assert(typeof myArray[1] !== 'undefined' && typeof myArray[1] == 'number');
 
 ```js
 // Only change code below this line
-var myArray = [];
+const myArray = [];
 ```
 
 # --solutions--
 
 ```js
-var myArray = ["The Answer", 42];
+const myArray = ["The Answer", 42];
 ```

curriculum/challenges/portuguese/02-javascript-algorithms-and-data-structures/basic-javascript/subtract-one-number-from-another-with-javascript.md

@@ -16,7 +16,7 @@ JavaScript usa o símbolo `-` para subtração.
 **Exemplo**
 
 ```js
-myVar = 12 - 6;
+const myVar = 12 - 6;
 ```
 
 `myVar` teria o valor `6`.
@@ -49,11 +49,11 @@ assert(/difference=45-33;?/.test(__helpers.removeWhiteSpace(code)));
 ## --seed-contents--
 
 ```js
-var difference = 45 - 0;
+const difference = 45 - 0;
 ```
 
 # --solutions--
 
 ```js
-var difference = 45 - 33;
+const difference = 45 - 33;
 ```

curriculum/challenges/portuguese/02-javascript-algorithms-and-data-structures/basic-javascript/testing-objects-for-properties.md

@@ -13,10 +13,11 @@ dashedName: testing-objects-for-properties
 **Exemplo**
 
 ```js
-var myObj = {
+const myObj = {
   top: "hat",
   bottom: "pants"
 };
+
 myObj.hasOwnProperty("top");
 myObj.hasOwnProperty("middle");
 ```

curriculum/challenges/portuguese/02-javascript-algorithms-and-data-structures/basic-javascript/understand-string-immutability.md

@@ -14,14 +14,14 @@ Em JavaScript, valores `String` são <dfn>imutáveis</dfn>, o que significa que
 Por exemplo, o código a seguir:
 
 ```js
-var myStr = "Bob";
+let myStr = "Bob";
 myStr[0] = "J";
 ```
 
 não permite alterar o valor de `myStr` para `Job`, porque o conteúdo de `myStr` não pode ser alterado. Note que isso *não* significa que `myStr` não pode ser alterado, apenas que os caracteres individuais de uma <dfn>string literal</dfn> não podem ser alterados. A única forma de alterar `myStr` seria atribuindo a ela uma nova string, dessa forma:
 
 ```js
-var myStr = "Bob";
+let myStr = "Bob";
 myStr = "Job";
 ```
 
@@ -55,7 +55,7 @@ assert(/myStr = "Jello World"/.test(code));
 
 ```js
 // Setup
-var myStr = "Jello World";
+let myStr = "Jello World";
 
 // Only change code below this line
 myStr[0] = "H"; // Change this line
@@ -65,6 +65,6 @@ myStr[0] = "H"; // Change this line
 # --solutions--
 
 ```js
-var myStr = "Jello World";
+let myStr = "Jello World";
 myStr = "Hello World";
 ```

curriculum/challenges/portuguese/02-javascript-algorithms-and-data-structures/basic-javascript/understanding-boolean-values.md

@@ -43,7 +43,6 @@ welcomeToBooleans();
 
 ```js
 function welcomeToBooleans() {
-
   // Only change code below this line
 
   return false; // Change this line

curriculum/challenges/portuguese/02-javascript-algorithms-and-data-structures/basic-javascript/understanding-undefined-value-returned-from-a-function.md

@@ -14,10 +14,12 @@ Uma função pode incluir a instrução `return` mas ela não precisa fazer isso
 **Exemplo**
 
 ```js
-var sum = 0;
+let sum = 0;
+
 function addSum(num) {
   sum = sum + num;
 }
+
 addSum(3);
 ```
 
@@ -61,7 +63,7 @@ assert(
 
 ```js
 // Setup
-var sum = 0;
+let sum = 0;
 
 function addThree() {
   sum = sum + 3;
@@ -79,7 +81,7 @@ addFive();
 # --solutions--
 
 ```js
-var sum = 0;
+let sum = 0;
 
 function addThree() {
   sum = sum + 3;

curriculum/challenges/portuguese/02-javascript-algorithms-and-data-structures/basic-javascript/updating-object-properties.md

@@ -14,7 +14,7 @@ Depois de criar um objeto JavaScript, você pode atualizar suas propriedades a q
 Por exemplo, vamos dar uma olhada em `ourDog`:
 
 ```js
-var ourDog = {
+const ourDog = {
   "name": "Camper",
   "legs": 4,
   "tails": 1,
@@ -54,7 +54,7 @@ assert(/"name": "Coder"/.test(code));
 
 ```js
 // Setup
-var myDog = {
+const myDog = {
   "name": "Coder",
   "legs": 4,
   "tails": 1,
@@ -62,12 +62,13 @@ var myDog = {
 };
 
 // Only change code below this line
+
 ```
 
 # --solutions--
 
 ```js
-var myDog = {
+const myDog = {
   "name": "Coder",
   "legs": 4,
   "tails": 1,

curriculum/challenges/portuguese/02-javascript-algorithms-and-data-structures/basic-javascript/use-bracket-notation-to-find-the-nth-character-in-a-string.md

@@ -16,8 +16,8 @@ Lembre-se de que computadores começam contando do `0`. Então, o primeiro carac
 Exemplo:
 
 ```js
-var firstName = "Ada";
-var secondLetterOfFirstName = firstName[1];
+const firstName = "Ada";
+const secondLetterOfFirstName = firstName[1];
 ```
 
 `secondLetterOfFirstName` teria o valor da string `d`.
@@ -54,15 +54,15 @@ assert(code.match(/thirdLetterOfLastName\s*?=\s*?lastName\[.*?\]/));
 
 ```js
 // Setup
-var lastName = "Lovelace";
+const lastName = "Lovelace";
 
 // Only change code below this line
-var thirdLetterOfLastName = lastName; // Change this line
+const thirdLetterOfLastName = lastName; // Change this line
 ```
 
 # --solutions--
 
 ```js
-var lastName = "Lovelace";
-var thirdLetterOfLastName = lastName[2];
+const lastName = "Lovelace";
+const thirdLetterOfLastName = lastName[2];
 ```

curriculum/challenges/portuguese/02-javascript-algorithms-and-data-structures/basic-javascript/use-recursion-to-create-a-range-of-numbers.md

@@ -73,7 +73,7 @@ function rangeOfNumbers(startNum, endNum) {
   if (endNum - startNum === 0) {
     return [startNum];
   } else {
-    var numbers = rangeOfNumbers(startNum, endNum - 1);
+    const numbers = rangeOfNumbers(startNum, endNum - 1);
     numbers.push(endNum);
     return numbers;
   }

curriculum/challenges/portuguese/02-javascript-algorithms-and-data-structures/basic-javascript/use-the-parseint-function-with-a-radix.md

@@ -20,7 +20,7 @@ parseInt(string, radix);
 Exemplo:
 
 ```js
-var a = parseInt("11", 2);
+const a = parseInt("11", 2);
 ```
 
 A variável radix diz que `11` está no sistema binário, ou base 2. Esse exemplo converte a string `11` para um inteiro `3`.

curriculum/challenges/portuguese/02-javascript-algorithms-and-data-structures/basic-javascript/use-the-parseint-function.md

@@ -12,7 +12,7 @@ dashedName: use-the-parseint-function
 A função `parseInt()` analisa uma string e retorna um inteiro. Exemplo:
 
 ```js
-var a = parseInt("007");
+const a = parseInt("007");
 ```
 
 A função acima converte a string `007` para o inteiro `7`. Se o primeiro caractere na string não pode ser convertido em um número, então ele retorna `NaN`.

curriculum/challenges/portuguese/02-javascript-algorithms-and-data-structures/basic-javascript/using-objects-for-lookups.md

@@ -14,7 +14,7 @@ Objetos podem ser pensados como armazenamento de chave/valor, como um dicionári
 Aqui está um exemplo de uma simples pesquisa reversa no alfabeto:
 
 ```js
-var alpha = {
+const alpha = {
   1:"Z",
   2:"Y",
   3:"X",
@@ -24,10 +24,11 @@ var alpha = {
   25:"B",
   26:"A"
 };
+
 alpha[2];
 alpha[24];
 
-var value = 2;
+const value = 2;
 alpha[value];
 ```
 
@@ -102,7 +103,7 @@ assert(
 ```js
 // Setup
 function phoneticLookup(val) {
-  var result = "";
+  let result = "";
 
   // Only change code below this line
   switch(val) {
@@ -136,9 +137,9 @@ phoneticLookup("charlie");
 
 ```js
 function phoneticLookup(val) {
-  var result = "";
+  let result = "";
 
-  var lookup = {
+  const lookup = {
     alpha: "Adams",
     bravo: "Boston",
     charlie: "Chicago",

curriculum/challenges/portuguese/02-javascript-algorithms-and-data-structures/basic-javascript/word-blanks.md

@@ -16,7 +16,7 @@ Em um jogo de "Mad Libs", você recebe frases com algumas palavras faltando, com
 Considere a frase - Era realmente **\_\_\_\_** e nós **\_\_\_\_** nós mesmos **\_\_\_\_**. Essa frase possui três pedaços faltando - um adjetivo, um verbo e um advérbio, e nós podemos adicionar palavras de nossa escolha para completar. Em seguida, podemos atribuir a frase completa para uma variável como se segue:
 
 ```js
-var sentence = "It was really " + "hot" + ", and we " + "laughed" + " ourselves " + "silly" + ".";
+const sentence = "It was really " + "hot" + ", and we " + "laughed" + " ourselves " + "silly" + ".";
 ```
 
 # --instructions--
@@ -84,24 +84,24 @@ const removeAssignments = str => str
 ## --seed-contents--
 
 ```js
-var myNoun = "dog";
-var myAdjective = "big";
-var myVerb = "ran";
-var myAdverb = "quickly";
+const myNoun = "dog";
+const myAdjective = "big";
+const myVerb = "ran";
+const myAdverb = "quickly";
 
 // Only change code below this line
-var wordBlanks = ""; // Change this line
+const wordBlanks = ""; // Change this line
 // Only change code above this line
 ```
 
 # --solutions--
 
 ```js
-var myNoun = "dog";
-var myAdjective = "big";
-var myVerb = "ran";
-var myAdverb = "quickly";
+const myNoun = "dog";
+const myAdjective = "big";
+const myVerb = "ran";
+const myAdverb = "quickly";
 
-var wordBlanks = "Once there was a " + myNoun + " which was very " + myAdjective + ". ";
+let wordBlanks = "Once there was a " + myNoun + " which was very " + myAdjective + ". ";
 wordBlanks += "It " + myVerb + " " + myAdverb + " around the yard.";
 ```