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

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

@@ -71,13 +71,10 @@ assert.match(code, /const\s+FCC/);
 ## --seed-contents--
 
 ```js
-// Only change code below this line
-var fCC = "freeCodeCamp";
-var fact = "is cool!";
-// Only change code above this line
-
+var fCC = "freeCodeCamp"; // Change this line
+var fact = "is cool!"; // Change this line
 fact = "is awesome!";
-console.log(fCC, fact);
+console.log(fCC, fact); // Change this line
 ```
 
 # --solutions--

curriculum/challenges/espanol/02-javascript-algorithms-and-data-structures/basic-javascript/find-the-length-of-a-string.md

@@ -17,7 +17,7 @@ console.log("Alan Peter".length);
 
 El valor `10` se mostrará en la consola.
 
-Por ejemplo, si creamos una variable `var firstName = "Ada"`, podríamos averiguar la longitud de la cadena `Ada` usando la propiedad `firstName.length`.
+Por ejemplo, si creamos una variable `const firstName = "Ada"`, podríamos averiguar la longitud de la cadena `Ada` usando la propiedad `firstName.length`.
 
 # --instructions--
 
@@ -29,8 +29,8 @@ No debes cambiar las declaraciones de variables en la sección `// Setup`.
 
 ```js
 assert(
-  code.match(/var lastNameLength = 0;/) &&
-    code.match(/var lastName = "Lovelace";/)
+  code.match(/let lastNameLength = 0;/) &&
+    code.match(/const lastName = "Lovelace";/)
 );
 ```
 
@@ -52,18 +52,17 @@ assert(code.match(/=\s*lastName\.length/g) && !code.match(/lastName\s*=\s*8/));
 
 ```js
 // Setup
-var lastNameLength = 0;
-var lastName = "Lovelace";
+let lastNameLength = 0;
+const lastName = "Lovelace";
 
 // Only change code below this line
-
 lastNameLength = lastName;
 ```
 
 # --solutions--
 
 ```js
-var lastNameLength = 0;
-var lastName = "Lovelace";
+let lastNameLength = 0;
+const lastName = "Lovelace";
 lastNameLength = lastName.length;
 ```

curriculum/challenges/espanol/02-javascript-algorithms-and-data-structures/basic-javascript/global-scope-and-functions.md

@@ -11,13 +11,13 @@ dashedName: global-scope-and-functions
 
 En JavaScript, el <dfn>ámbito</dfn> se refiere a la visibilidad de las variables. Las variables definidas fuera de un bloque de función tienen un ámbito <dfn>Global</dfn>. Esto significa que pueden ser observadas desde cualquier lugar en tu código JavaScript.
 
-Las variables que se usan sin la palabra clave `var` se crean automáticamente en el ámbito `global`. Esto puede crear consecuencias no intencionadas en cualquier lugar de tu código o al volver a ejecutar una función. Siempre debes declarar tus variables con `var`.
+Las variables que se declaran sin las palabras clave `let` o `const` se crean automáticamente en el ámbito `global`. Esto puede crear consecuencias no intencionadas en cualquier lugar de tu código o al volver a ejecutar una función. Siempre debes declarar tus variables con `let` o `const`.
 
 # --instructions--
 
-Usando `var`, declara una variable global llamada `myGlobal` fuera de cualquier función. Inicialízala con un valor de `10`.
+Usando `let` o `const`, declara una variable global llamada `myGlobal` fuera de cualquier función. Inicialízala con un valor de `10`.
 
-Dentro de la función `fun1`, asigna `5` a `oopsGlobal` ***sin*** usar la palabra clave `var`.
+Dentro de la función `fun1`, asigna `5` a `oopsGlobal` ***sin*** usar las palabras clave `let` o `const`.
 
 # --hints--
 
@@ -33,10 +33,10 @@ assert(typeof myGlobal != 'undefined');
 assert(myGlobal === 10);
 ```
 
-`myGlobal` debe declararse usando la palabra clave `var`
+`myGlobal` debe declararse usando las palabras clave `let` o `const`
 
 ```js
-assert(/var\s+myGlobal/.test(code));
+assert(/(let|const)\s+myGlobal/.test(code));
 ```
 
 `oopsGlobal` debe ser una variable global y tener un valor de `5`
@@ -109,7 +109,7 @@ function fun2() {
 # --solutions--
 
 ```js
-var myGlobal = 10;
+const myGlobal = 10;
 
 function fun1() {
   oopsGlobal = 5;

curriculum/challenges/espanol/02-javascript-algorithms-and-data-structures/basic-javascript/iterate-odd-numbers-with-a-for-loop.md

@@ -14,13 +14,14 @@ Los bucles "for" no tienen que iterar de uno en uno a la vez. Al cambiar nuestra
 Empezaremos en `i = 0` y realizaremos el bucle mientras `i < 10`. Incrementaremos `i` en 2 cada bucle utilizando `i += 2`.
 
 ```js
-var ourArray = [];
-for (var i = 0; i < 10; i += 2) {
+const ourArray = [];
+
+for (let i = 0; i < 10; i += 2) {
   ourArray.push(i);
 }
 ```
 
-`ourArray` ahora contendrá `[0,2,4,6,8]`. Cambiemos nuestra `initialization` (inicialización) para que podamos contar por números impares.
+`ourArray` ahora contendrá `[0, 2, 4, 6, 8]`. Cambiemos nuestra `initialization` (inicialización) para que podamos contar por números impares.
 
 # --instructions--
 
@@ -34,7 +35,7 @@ Debes utilizar un bucle `for` para esto.
 assert(/for\s*\([^)]+?\)/.test(code));
 ```
 
-`myArray` debe ser igual a `[1,3,5,7,9]`.
+`myArray` debe ser igual a `[1, 3, 5, 7, 9]`.
 
 ```js
 assert.deepEqual(myArray, [1, 3, 5, 7, 9]);
@@ -52,16 +53,17 @@ if(typeof myArray !== "undefined"){(function(){return myArray;})();}
 
 ```js
 // Setup
-var myArray = [];
+const myArray = [];
 
 // Only change code below this line
+
 ```
 
 # --solutions--
 
 ```js
-var myArray = [];
-for (var i = 1; i < 10; i += 2) {
+const myArray = [];
+for (let i = 1; i < 10; i += 2) {
   myArray.push(i);
 }
 ```

curriculum/challenges/espanol/02-javascript-algorithms-and-data-structures/basic-javascript/iterate-with-javascript-for-loops.md

@@ -26,13 +26,14 @@ La expresión final se ejecuta al final de cada iteración del bucle, antes de l
 En el siguiente ejemplo inicializamos con `i = 0` e iteramos mientras nuestra condición `i < 5` es verdadera. Incrementaremos `i` por `1` en cada iteración de bucle con `i++` como nuestra expresión final.
 
 ```js
-var ourArray = [];
-for (var i = 0; i < 5; i++) {
+const ourArray = [];
+
+for (let i = 0; i < 5; i++) {
   ourArray.push(i);
 }
 ```
 
-`ourArray` ahora tendrá el valor `[0,1,2,3,4]`.
+`ourArray` ahora tendrá el valor `[0, 1, 2, 3, 4]`.
 
 # --instructions--
 
@@ -46,7 +47,7 @@ Debes usar un bucle `for` para esto.
 assert(/for\s*\([^)]+?\)/.test(code));
 ```
 
-`myArray` debe ser igual a `[1,2,3,4,5]`.
+`myArray` debe ser igual a `[1, 2, 3, 4, 5]`.
 
 ```js
 assert.deepEqual(myArray, [1, 2, 3, 4, 5]);
@@ -64,16 +65,17 @@ if (typeof myArray !== "undefined"){(function(){return myArray;})();}
 
 ```js
 // Setup
-var myArray = [];
+const myArray = [];
 
 // Only change code below this line
+
 ```
 
 # --solutions--
 
 ```js
-var myArray = [];
-for (var i = 1; i < 6; i++) {
+const myArray = [];
+for (let i = 1; i < 6; i++) {
   myArray.push(i);
 }
 ```

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

@@ -14,9 +14,10 @@ Puedes ejecutar el mismo código múltiples veces usando un bucle.
 El primer tipo de bucle que aprenderemos se llama bucle `while` porque ejecuta una condición específica mientras esta sea verdadera, y se detiene una vez que esa condición ya no sea verdadera.
 
 ```js
-var ourArray = [];
-var i = 0;
-while(i < 5) {
+const ourArray = [];
+let i = 0;
+
+while (i < 5) {
   ourArray.push(i);
   i++;
 }
@@ -38,7 +39,7 @@ Debes utilizar un bucle `while` para esto.
 assert(code.match(/while/g));
 ```
 
-`myArray` debe ser igual a `[5,4,3,2,1,0]`.
+`myArray` debe ser igual a `[5, 4, 3, 2, 1, 0]`.
 
 ```js
 assert.deepEqual(myArray, [5, 4, 3, 2, 1, 0]);
@@ -56,17 +57,18 @@ if(typeof myArray !== "undefined"){(function(){return myArray;})();}
 
 ```js
 // Setup
-var myArray = [];
+const myArray = [];
 
 // Only change code below this line
+
 ```
 
 # --solutions--
 
 ```js
-var myArray = [];
-var i = 5;
-while(i >= 0) {
+const myArray = [];
+let i = 5;
+while (i >= 0) {
   myArray.push(i);
   i--;
 }

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

@@ -16,8 +16,8 @@ Otra manera de cambiar los datos en un arreglo es con la función `.pop()`.
 Cualquier tipo de entrada puede ser sacada de un arreglo: números, cadenas, incluso arreglos anidados.
 
 ```js
-var threeArr = [1, 4, 6];
-var oneDown = threeArr.pop();
+const threeArr = [1, 4, 6];
+const oneDown = threeArr.pop();
 console.log(oneDown);
 console.log(threeArr);
 ```
@@ -26,7 +26,7 @@ El primer `console.log` mostrará el valor `6` y el segundo mostrará el valor `
 
 # --instructions--
 
-Utiliza la función `.pop()` para eliminar el último elemento de `myArray`, asignando el valor sacado a `removedFromMyArray`.
+Utiliza la función `.pop()` para eliminar el último elemento de `myArray`, y asigna el valor sacado a un variable nuevo `removedFromMyArray`.
 
 # --hints--
 
@@ -69,22 +69,22 @@ assert(
 ## --after-user-code--
 
 ```js
-(function(y, z){return 'myArray = ' + JSON.stringify(y) + ' & removedFromMyArray = ' + JSON.stringify(z);})(myArray, removedFromMyArray);
+if (typeof removedFromMyArray !== 'undefined') (function(y, z){return 'myArray = ' + JSON.stringify(y) + ' & removedFromMyArray = ' + JSON.stringify(z);})(myArray, removedFromMyArray);
 ```
 
 ## --seed-contents--
 
 ```js
 // Setup
-var myArray = [["John", 23], ["cat", 2]];
+const myArray = [["John", 23], ["cat", 2]];
 
 // Only change code below this line
-var removedFromMyArray;
+
 ```
 
 # --solutions--
 
 ```js
-var myArray = [["John", 23], ["cat", 2]];
-var removedFromMyArray = myArray.pop();
+const myArray = [["John", 23], ["cat", 2]];
+const removedFromMyArray = myArray.pop();
 ```

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

@@ -16,15 +16,15 @@ Ahí es donde entra `.shift()`. Funciona igual que `.pop()`, excepto que elimina
 Ejemplo:
 
 ```js
-var ourArray = ["Stimpson", "J", ["cat"]];
-var removedFromOurArray = ourArray.shift();
+const ourArray = ["Stimpson", "J", ["cat"]];
+const removedFromOurArray = ourArray.shift();
 ```
 
 `removedFromOurArray` tendrá una cadena con valor `Stimpson` y `ourArray` tendrá `["J", ["cat"]]`.
 
 # --instructions--
 
-Utiliza la función `.shift()` para eliminar el primer elemento de `myArray`, asignando el valor "desplazado" a `removedFromMyArray`.
+Utiliza la función `.shift()` para eliminar el primer elemento de `myArray`, y asigna el valor "desplazado" a un variable nuevo `removedFromMyArray`.
 
 # --hints--
 
@@ -65,24 +65,24 @@ assert(
 ## --after-user-code--
 
 ```js
-(function(y, z){return 'myArray = ' + JSON.stringify(y) + ' & removedFromMyArray = ' + JSON.stringify(z);})(myArray, removedFromMyArray);
+if (typeof removedFromMyArray !== 'undefined') (function(y, z){return 'myArray = ' + JSON.stringify(y) + ' & removedFromMyArray = ' + JSON.stringify(z);})(myArray, removedFromMyArray);
 ```
 
 ## --seed-contents--
 
 ```js
 // Setup
-var myArray = [["John", 23], ["dog", 3]];
+const myArray = [["John", 23], ["dog", 3]];
 
 // Only change code below this line
-var removedFromMyArray;
+
 ```
 
 # --solutions--
 
 ```js
-var myArray = [["John", 23], ["dog", 3]];
+const myArray = [["John", 23], ["dog", 3]];
 
 // Only change code below this line
-var removedFromMyArray = myArray.shift();
+const removedFromMyArray = myArray.shift();
 ```

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

@@ -16,7 +16,7 @@ No solo puedes desplazar (`shift`) elementos del comienzo de un arreglo, tambié
 Ejemplo:
 
 ```js
-var ourArray = ["Stimpson", "J", "cat"];
+const ourArray = ["Stimpson", "J", "cat"];
 ourArray.shift();
 ourArray.unshift("Happy");
 ```
@@ -25,7 +25,7 @@ Después del `shift`, `ourArray` tendrá el valor `["J", "cat"]`. Después del `
 
 # --instructions--
 
-Añade `["Paul",35]` al principio de la variable `myArray` usando `unshift()`.
+Agrega `["Paul", 35]` al principio de la variable `myArray` usando `unshift()`.
 
 # --hints--
 
@@ -63,16 +63,17 @@ assert(
 
 ```js
 // Setup
-var myArray = [["John", 23], ["dog", 3]];
+const myArray = [["John", 23], ["dog", 3]];
 myArray.shift();
 
 // Only change code below this line
+
 ```
 
 # --solutions--
 
 ```js
-var myArray = [["John", 23], ["dog", 3]];
+const myArray = [["John", 23], ["dog", 3]];
 myArray.shift();
 myArray.unshift(["Paul", 35]);
 ```

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

@@ -9,12 +9,12 @@ dashedName: modify-array-data-with-indexes
 
 # --description--
 
-A diferencia de las cadenas, las entradas de los arreglos son <dfn>mutables</dfn> y pueden cambiarse libremente.
+A diferencia de las cadenas, las entradas de los arreglos son <dfn>mutables</dfn> y pueden cambiarse libremente, incluso si el arreglo fue declarado con `const`.
 
 **Ejemplo**
 
 ```js
-var ourArray = [50,40,30];
+const ourArray = [50, 40, 30];
 ourArray[0] = 15;
 ```
 
@@ -28,7 +28,7 @@ Modifica los datos almacenados en el índice `0` de `myArray` a un valor de `45`
 
 # --hints--
 
-`myArray` ahora debe ser `[45,64,99]`.
+`myArray` ahora debe ser `[45, 64, 99]`.
 
 ```js
 assert(
@@ -73,14 +73,15 @@ if(typeof myArray !== "undefined"){(function(){return myArray;})();}
 
 ```js
 // Setup
-var myArray = [18,64,99];
+const myArray = [18, 64, 99];
 
 // Only change code below this line
+
 ```
 
 # --solutions--
 
 ```js
-var myArray = [18,64,99];
+const myArray = [18, 64, 99];
 myArray[0] = 45;
 ```

curriculum/challenges/espanol/02-javascript-algorithms-and-data-structures/basic-javascript/nesting-for-loops.md

@@ -12,11 +12,12 @@ dashedName: nesting-for-loops
 Si tienes un arreglo multidimensional, puedes utilizar la misma lógica que aprendimos anteriormente para recorrer tanto el arreglo como cualquier sub-arreglo. Aquí hay un ejemplo:
 
 ```js
-var arr = [
-  [1,2], [3,4], [5,6]
+const arr = [
+  [1, 2], [3, 4], [5, 6]
 ];
-for (var i=0; i < arr.length; i++) {
-  for (var j=0; j < arr[i].length; j++) {
+
+for (let i = 0; i < arr.length; i++) {
+  for (let j = 0; j < arr[i].length; j++) {
     console.log(arr[i][j]);
   }
 }
@@ -30,13 +31,13 @@ Modifica la función `multiplyAll` para que devuelva el producto de todos los n
 
 # --hints--
 
-`multiplyAll([[1],[2],[3]])` debe devolver `6`
+`multiplyAll([[1], [2], [3]])` debe devolver `6`
 
 ```js
 assert(multiplyAll([[1], [2], [3]]) === 6);
 ```
 
-`multiplyAll([[1,2],[3,4],[5,6,7]])` debe devolver `5040`
+`multiplyAll([[1, 2], [3, 4], [5, 6, 7]])` debe devolver `5040`
 
 ```js
 assert(
@@ -48,7 +49,7 @@ assert(
 );
 ```
 
-`multiplyAll([[5,1],[0.2, 4, 0.5],[3, 9]])` debe devolver `54`
+`multiplyAll([[5, 1], [0.2, 4, 0.5], [3, 9]])` debe devolver `54`
 
 ```js
 assert(
@@ -66,28 +67,26 @@ assert(
 
 ```js
 function multiplyAll(arr) {
-  var product = 1;
+  let product = 1;
   // Only change code below this line
 
   // Only change code above this line
   return product;
 }
 
-multiplyAll([[1,2],[3,4],[5,6,7]]);
+multiplyAll([[1, 2], [3, 4], [5, 6, 7]]);
 ```
 
 # --solutions--
 
 ```js
 function multiplyAll(arr) {
-  var product = 1;
-  for (var i = 0; i < arr.length; i++) {
-    for (var j = 0; j < arr[i].length; j++) {
+  let product = 1;
+  for (let i = 0; i < arr.length; i++) {
+    for (let j = 0; j < arr[i].length; j++) {
       product *= arr[i][j];
     }
   }
   return product;
 }
-
-multiplyAll([[1,2],[3,4],[5,6,7]]);
 ```

curriculum/challenges/espanol/02-javascript-algorithms-and-data-structures/basic-javascript/return-early-pattern-for-functions.md

@@ -33,43 +33,43 @@ Recuerda que [`undefined` es una palabra clave](https://www.freecodecamp.org/lea
 
 # --hints--
 
-`abTest(2,2)` debe devolver un número
+`abTest(2, 2)` debe devolver un número
 
 ```js
 assert(typeof abTest(2, 2) === 'number');
 ```
 
-`abTest(2,2)` debe devolver `8`
+`abTest(2, 2)` debe devolver `8`
 
 ```js
 assert(abTest(2, 2) === 8);
 ```
 
-`abTest(-2,2)` debe devolver `undefined`
+`abTest(-2, 2)` debe devolver `undefined`
 
 ```js
 assert(abTest(-2, 2) === undefined);
 ```
 
-`abTest(2,-2)` debe devolver `undefined`
+`abTest(2, -2)` debe devolver `undefined`
 
 ```js
 assert(abTest(2, -2) === undefined);
 ```
 
-`abTest(2,8)` debe devolver `18`
+`abTest(2, 8)` debe devolver `18`
 
 ```js
 assert(abTest(2, 8) === 18);
 ```
 
-`abTest(3,3)` debe devolver `12`
+`abTest(3, 3)` debe devolver `12`
 
 ```js
 assert(abTest(3, 3) === 12);
 ```
 
-`abTest(0,0)` debe devolver `0`
+`abTest(0, 0)` debe devolver `0`
 
 ```js
 assert(abTest(0, 0) === 0);

curriculum/challenges/espanol/02-javascript-algorithms-and-data-structures/basic-javascript/returning-boolean-values-from-functions.md

@@ -14,7 +14,7 @@ Podrás recordar que en [Comparación con el operador de igualdad](/learn/javasc
 A veces la gente usa una sentencia `if/else` para hacer una comparación, como esta:
 
 ```js
-function isEqual(a,b) {
+function isEqual(a, b) {
   if (a === b) {
     return true;
   } else {
@@ -26,7 +26,7 @@ function isEqual(a,b) {
 Pero hay una mejor manera de hacer esto. Puesto que `===` devuelve `true` o `false`, podemos devolver el resultado de la comparación:
 
 ```js
-function isEqual(a,b) {
+function isEqual(a, b) {
   return a === b;
 }
 ```
@@ -37,13 +37,13 @@ Corrige la función `isLess` para eliminar las sentencias `if/else`.
 
 # --hints--
 
-`isLess(10,15)` debe devolver `true`
+`isLess(10, 15)` debe devolver `true`
 
 ```js
 assert(isLess(10, 15) === true);
 ```
 
-`isLess(15,10)` debe devolver `false`
+`isLess(15, 10)` debe devolver `false`
 
 ```js
 assert(isLess(15, 10) === false);

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

@@ -13,13 +13,13 @@ La <dfn>notación de corchetes</dfn> es una forma de obtener un carácter en un
 
 La mayoría de lenguajes de programación modernos, como JavaScript, no empiezan a contar desde 1 como lo hacen los humanos. Empiezan desde 0. Esto se conoce como indexación <dfn>basada en cero</dfn>.
 
-Por ejemplo, el carácter en el índice 0 de la palabra `Charles` es `C`. Así que si declaramos `var firstName = "Charles"`, puedes obtener el valor de la primera letra de la cadena usando `firstName[0]`.
+Por ejemplo, el carácter en el índice 0 de la palabra `Charles` es `C`. Así que si declaramos `const firstName = "Charles"`, puedes obtener el valor de la primera letra de la cadena usando `firstName[0]`.
 
 Ejemplo:
 
 ```js
-var firstName = "Charles";
-var firstLetter = firstName[0];
+const firstName = "Charles";
+const firstLetter = firstName[0];
 ```
 
 `firstLetter` tendrá una cadena con valor `C`.
@@ -56,8 +56,8 @@ assert(code.match(/firstLetterOfLastName\s*?=\s*?lastName\[.*?\]/));
 
 ```js
 // Setup
-var firstLetterOfLastName = "";
-var lastName = "Lovelace";
+let firstLetterOfLastName = "";
+const lastName = "Lovelace";
 
 // Only change code below this line
 firstLetterOfLastName = lastName; // Change this line
@@ -66,8 +66,8 @@ firstLetterOfLastName = lastName; // Change this line
 # --solutions--
 
 ```js
-var firstLetterOfLastName = "";
-var lastName = "Lovelace";
+let firstLetterOfLastName = "";
+const lastName = "Lovelace";
 
 // Only change code below this line
 firstLetterOfLastName = lastName[0];

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

@@ -11,13 +11,13 @@ dashedName: use-bracket-notation-to-find-the-last-character-in-a-string
 
 Con el fin de obtener la última letra de una cadena, puedes restar uno a la longitud del texto.
 
-Por ejemplo, sí `var firstName = "Ada"`, puedes obtener el valor de la última letra de la cadena usando `firstName[firstName.length - 1]`.
+Por ejemplo, sí `const firstName = "Ada"`, puedes obtener el valor de la última letra de la cadena usando `firstName[firstName.length - 1]`.
 
 Ejemplo:
 
 ```js
-var firstName = "Ada";
-var lastLetter = firstName[firstName.length - 1];
+const firstName = "Ada";
+const lastLetter = firstName[firstName.length - 1];
 ```
 
 `lastLetter` tendrá una cadena con valor `a`.
@@ -54,15 +54,15 @@ assert(code.match(/\.length/g).length > 0);
 
 ```js
 // Setup
-var lastName = "Lovelace";
+const lastName = "Lovelace";
 
 // Only change code below this line
-var lastLetterOfLastName = lastName; // Change this line
+const lastLetterOfLastName = lastName; // Change this line
 ```
 
 # --solutions--
 
 ```js
-var lastName = "Lovelace";
-var lastLetterOfLastName = lastName[lastName.length - 1];
+const lastName = "Lovelace";
+const lastLetterOfLastName = lastName[lastName.length - 1];
 ```

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

@@ -11,13 +11,13 @@ dashedName: use-bracket-notation-to-find-the-nth-to-last-character-in-a-string
 
 Puedes usar el mismo principio que acabamos de usar para recuperar el último carácter de una cadena para recuperar el carácter enésimo final.
 
-Por ejemplo, puedes obtener el valor de la antepenúltima letra de la cadena `var firstName = "Augusta"` usando `firstName[firstName.length - 3]`
+Por ejemplo, puedes obtener el valor de la antepenúltima letra de la cadena `const firstName = "Augusta"` usando `firstName[firstName.length - 3]`
 
 Ejemplo:
 
 ```js
-var firstName = "Augusta";
-var thirdToLastLetter = firstName[firstName.length - 3];
+const firstName = "Augusta";
+const thirdToLastLetter = firstName[firstName.length - 3];
 ```
 
 `thirdToLastLetter` tendrá una cadena con valor `s`.
@@ -54,15 +54,15 @@ assert(code.match(/\.length/g).length > 0);
 
 ```js
 // Setup
-var lastName = "Lovelace";
+const lastName = "Lovelace";
 
 // Only change code below this line
-var secondToLastLetterOfLastName = lastName; // Change this line
+const secondToLastLetterOfLastName = lastName; // Change this line
 ```
 
 # --solutions--
 
 ```js
-var lastName = "Lovelace";
-var secondToLastLetterOfLastName = lastName[lastName.length - 2];
+const lastName = "Lovelace";
+const secondToLastLetterOfLastName = lastName[lastName.length - 2];
 ```

curriculum/challenges/espanol/02-javascript-algorithms-and-data-structures/basic-javascript/use-conditional-logic-with-if-statements.md

@@ -9,7 +9,7 @@ dashedName: use-conditional-logic-with-if-statements
 
 # --description--
 
-Las sentencias `If` son utilizadas para tomar decisiones en el código. La palabra clave `if` le dice a JavaScript que ejecute el código entre llaves bajo ciertas condiciones, definidas en los paréntesis. Estas condiciones son conocidas como condiciones booleanas (`Boolean`) y sólo pueden ser `true` o `false`.
+Las sentencias `if` son utilizadas para tomar decisiones en el código. La palabra clave `if` le dice a JavaScript que ejecute el código entre llaves bajo ciertas condiciones, definidas en los paréntesis. Estas condiciones son conocidas como condiciones booleanas (`Boolean`) y sólo pueden ser `true` o `false`.
 
 Cuando la condición se evalúa como `true`, el programa ejecuta el comando dentro de las llaves. Cuando la condición booleana se evalúa como `false`, la sentencia dentro de las llaves no se ejecutará.
 
@@ -22,10 +22,11 @@ Cuando la condición se evalúa como `true`, el programa ejecuta el comando dent
 ```js
 function test (myCondition) {
   if (myCondition) {
-     return "It was true";
+    return "It was true";
   }
   return "It was false";
 }
+
 test(true);
 test(false);
 ```