docs: add Spanish docs

curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/debugging/catch-arguments-passed-in-the-wrong-order-when-calling-a-function.spanish.md

@@ -0,0 +1,60 @@
+---
+id: 587d7b85367417b2b2512b3a
+title: Catch Arguments Passed in the Wrong Order When Calling a Function
+localeTitle: Detectar argumentos pasados ​​en el orden incorrecto al llamar a una función
+challengeType: 1
+---
+
+## Description
+<section id='description'> 
+Continuando con la discusión sobre las funciones de llamada, el siguiente error a tener en cuenta es cuando los argumentos de una función se suministran en el orden incorrecto. Si los argumentos son de tipos diferentes, como una función que espera una matriz y un entero, es probable que se produzca un error de tiempo de ejecución. Si los argumentos son del mismo tipo (todos los enteros, por ejemplo), entonces la lógica del código no tendrá sentido. Asegúrese de proporcionar todos los argumentos necesarios, en el orden correcto para evitar estos problemas. 
+</section>
+
+## Instructions
+<section id='instructions'> 
+La función <code>raiseToPower</code> eleva una base a un exponente. Desafortunadamente, no se llama correctamente: repare el código para que el valor de la <code>power</code> sea ​​el esperado 8. 
+</section>
+
+## Tests
+<section id='tests'>
+
+```yml
+tests:
+  - text: &#39;Su código debería fijar la <code>power</code> variable de modo que sea igual a 2 elevado a la tercera potencia, no 3 elevado a la segunda potencia&#39;.
+    testString: 'assert(power == 8, "Your code should fix the variable <code>power</code> so it equals 2 raised to the 3rd power, not 3 raised to the 2nd power.");'
+  - text: Su código debe usar el orden correcto de los argumentos para la <code>raiseToPower</code> función <code>raiseToPower</code> .
+    testString: 'assert(code.match(/raiseToPower\(\s*?base\s*?,\s*?exp\s*?\);/g), "Your code should use the correct order of the arguments for the <code>raiseToPower</code> function call.");'
+
+```
+
+</section>
+
+## Challenge Seed
+<section id='challengeSeed'>
+
+<div id='js-seed'>
+
+```js
+function raiseToPower(b, e) {
+  return Math.pow(b, e);
+}
+
+let base = 2;
+let exp = 3;
+let power = raiseToPower(exp, base);
+console.log(power);
+```
+
+</div>
+
+
+
+</section>
+
+## Solution
+<section id='solution'>
+
+```js
+// solution required
+```
+</section>

curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/debugging/catch-missing-open-and-closing-parenthesis-after-a-function-call.spanish.md

@@ -0,0 +1,62 @@
+---
+id: 587d7b85367417b2b2512b39
+title: Catch Missing Open and Closing Parenthesis After a Function Call
+localeTitle: Atrapa los paréntesis abiertos y de cierre que faltan después de una llamada de función
+challengeType: 1
+---
+
+## Description
+<section id='description'> 
+Cuando una función o método no acepta ningún argumento, puede olvidarse de incluir los paréntesis de apertura y cierre (vacíos) al llamarla. Muchas veces, el resultado de una llamada de función se guarda en una variable para otro uso en su código. Este error se puede detectar registrando valores de variables (o sus tipos) en la consola y al ver que uno se establece en una referencia de función, en lugar del valor esperado que devuelve la función. 
+Las variables en el siguiente ejemplo son diferentes: 
+<blockquote>function myFunction() {<br>&nbsp;&nbsp;return "You rock!";<br>}<br>let varOne = myFunction; // set to equal a function<br>let varTwo = myFunction(); // set to equal the string "You rock!"</blockquote> 
+</section>
+
+## Instructions
+<section id='instructions'> 
+Corrija el código para que el <code>result</code> variable se establezca en el valor devuelto al llamar a la función <code>getNine</code> . 
+</section>
+
+## Tests
+<section id='tests'>
+
+```yml
+tests:
+  - text: Su código debe arreglar el <code>result</code> variable para que se establezca en el número que devuelve la función <code>getNine</code> .
+    testString: 'assert(result == 9, "Your code should fix the variable <code>result</code> so it is set to the number that the function <code>getNine</code> returns.");'
+  - text: Su código debe llamar a la función <code>getNine</code> .
+    testString: 'assert(code.match(/getNine\(\)/g).length == 2, "Your code should call the <code>getNine</code> function.");'
+
+```
+
+</section>
+
+## Challenge Seed
+<section id='challengeSeed'>
+
+<div id='js-seed'>
+
+```js
+function getNine() {
+  let x = 6;
+  let y = 3;
+  return x + y;
+}
+
+let result = getNine;
+console.log(result);
+```
+
+</div>
+
+
+
+</section>
+
+## Solution
+<section id='solution'>
+
+```js
+// solution required
+```
+</section>

curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/debugging/catch-misspelled-variable-and-function-names.spanish.md

@@ -0,0 +1,63 @@
+---
+id: 587d7b84367417b2b2512b35
+title: Catch Misspelled Variable and Function Names
+localeTitle: Capturar nombres de funciones y variables mal escritas
+challengeType: 1
+---
+
+## Description
+<section id='description'> 
+<code>console.log()</code> y los métodos de <code>typeof</code> son las dos formas principales de verificar los valores intermedios y los tipos de salida del programa. Ahora es el momento de entrar en las formas comunes que toman los errores. Un problema de nivel de sintaxis con el que los usuarios rápidos pueden compadecerse es el humilde error de ortografía. 
+transpuestos, faltantes o mal colocados en una variable o nombre de función harán que el navegador busque un objeto que no existe, y se quejen en forma de un error de referencia. Las variables de JavaScript y los nombres de funciones distinguen entre mayúsculas y minúsculas. 
+</section>
+
+## Instructions
+<section id='instructions'> 
+Corrija los dos errores de ortografía en el código para que <code>netWorkingCapital</code> cálculo de <code>netWorkingCapital</code> . 
+</section>
+
+## Tests
+<section id='tests'>
+
+```yml
+tests:
+  - text: 'Verifique la ortografía de las dos variables utilizadas en el cálculo de netWorkingCapital, la salida de la consola debe mostrar que "El capital de trabajo neto es: 2".
+    testString: 'assert(netWorkingCapital === 2, "Check the spelling of the two variables used in the netWorkingCapital calculation, the console output should show that "Net working capital is: 2".");'
+  - text: No debe haber instancias de variables mal escritas en el código.
+    testString: 'assert(!code.match(/recievables/g), "There should be no instances of mis-spelled variables in the code.");'
+  - text: La variable <code clase = "notranslate"> cuentas por cobrar </code> debe declararse y usarse correctamente en el código.
+    testString: 'assert(code.match(/receivables/g).length == 2, "The <code>receivables</code> variable should be declared and used properly in the code.");'
+  - text: No debe haber instancias de variables mal escritas en el código.
+    testString: 'assert(!code.match(/payable;/g), "There should be no instances of mis-spelled variables in the code.");'
+  - text: La variable <code class = "notranslate"> payables </code> debe declararse y usarse correctamente en el código.
+    testString: 'assert(code.match(/payables/g).length == 2, "The <code>payables</code> variable should be declared and used properly in the code.");'
+
+```
+
+</section>
+
+## Challenge Seed
+<section id='challengeSeed'>
+
+<div id='js-seed'>
+
+```js
+let receivables = 10;
+let payables = 8;
+let netWorkingCapital = recievables - payable;
+console.log(`Net working capital is: ${netWorkingCapital}`);
+```
+
+</div>
+
+
+
+</section>
+
+## Solution
+<section id='solution'>
+
+```js
+// solution required
+```
+</section>

curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/debugging/catch-mixed-usage-of-single-and-double-quotes.spanish.md

@@ -0,0 +1,59 @@
+---
+id: 587d7b84367417b2b2512b37
+title: Catch Mixed Usage of Single and Double Quotes
+localeTitle: Uso mixto de capturas de comillas simples y dobles
+challengeType: 1
+---
+
+## Description
+<section id='description'> 
+JavaScript permite el uso de comillas simples (&quot;) y dobles (&quot; &quot;) para declarar una cadena. Decidir cuál usar generalmente se reduce a preferencias personales, con algunas excepciones. 
+Tener dos opciones es excelente cuando una cadena tiene contracciones u otro fragmento de texto entre comillas. Solo tenga cuidado de no cerrar la cadena demasiado pronto, lo que provoca un error de sintaxis. 
+Aquí hay algunos ejemplos de comillas de mezcla: 
+<blockquote>// These are correct:<br>const grouchoContraction = "I've had a perfectly wonderful evening, but this wasn't it.";<br>const quoteInString = "Groucho Marx once said 'Quote me as saying I was mis-quoted.'";<br>// This is incorrect:<br>const uhOhGroucho = 'I've had a perfectly wonderful evening, but this wasn't it.';</blockquote> 
+Por supuesto, está bien usar solo un estilo de citas. Puede escapar de las comillas dentro de la cadena usando el carácter de escape de barra invertida (\): 
+<blockquote>// Correct use of same quotes:<br>const allSameQuotes = 'I\'ve had a perfectly wonderful evening, but this wasn\'t it.';</blockquote> 
+</section>
+
+## Instructions
+<section id='instructions'> 
+Arregle la cadena para que use comillas diferentes para el valor <code>href</code> , o escape de las existentes. Mantenga las comillas dobles alrededor de toda la cadena. 
+</section>
+
+## Tests
+<section id='tests'>
+
+```yml
+tests:
+  - text: &#39;Tu código debe corregir las comillas alrededor del valor <code>href</code> &quot;#Home&quot;, ya sea cambiándolos o escapándolos.&#39;
+    testString: 'assert(code.match(/<a href=\s*?("|\\")#Home\1\s*?>/g), "Your code should fix the quotes around the <code>href</code> value "#Home" by either changing or escaping them.");'
+  - text: Su código debe mantener las comillas dobles alrededor de toda la cadena.
+    testString: 'assert(code.match(/"<p>.*?<\/p>";/g), "Your code should keep the double quotes around the entire string.");'
+
+```
+
+</section>
+
+## Challenge Seed
+<section id='challengeSeed'>
+
+<div id='js-seed'>
+
+```js
+let innerHtml = "<p>Click here to <a href="#Home">return home</a></p>";
+console.log(innerHtml);
+```
+
+</div>
+
+
+
+</section>
+
+## Solution
+<section id='solution'>
+
+```js
+// solution required
+```
+</section>

curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/debugging/catch-off-by-one-errors-when-using-indexing.spanish.md

@@ -0,0 +1,69 @@
+---
+id: 587d7b86367417b2b2512b3b
+title: Catch Off By One Errors When Using Indexing
+localeTitle: Descubrir por uno errores al utilizar la indexación
+challengeType: 1
+---
+
+## Description
+<section id='description'> 
+<code>Off by one errors</code> (a veces llamado OBOE) se recortan cuando intentas apuntar a un índice específico de una cadena o matriz (para dividir o acceder a un segmento), o cuando se recorren los índices de ellos. La indexación de JavaScript comienza en cero, no en uno, lo que significa que el último índice siempre es uno menos que la longitud del elemento. Si intenta acceder a un índice igual a la longitud, el programa puede arrojar un error de referencia de &quot;índice fuera de rango&quot; o imprimir <code>undefined</code> . 
+Cuando usa métodos de cadena o matriz que toman rangos de índice como argumentos, es útil leer la documentación y comprender si son inclusivos (el elemento en el índice dado es parte de lo que se devuelve) o no. Aquí hay algunos ejemplos de errores off por uno: 
+<blockquote>let alphabet = "abcdefghijklmnopqrstuvwxyz";<br>let len = alphabet.length;<br>for (let i = 0; i <= len; i++) {<br>&nbsp;&nbsp;// loops one too many times at the end<br>&nbsp;&nbsp;console.log(alphabet[i]);<br>}<br>for (let j = 1; j < len; j++) {<br>&nbsp;&nbsp;// loops one too few times and misses the first character at index 0<br>&nbsp;&nbsp;console.log(alphabet[j]);<br>}<br>for (let k = 0; k < len; k++) {<br>&nbsp;&nbsp;// Goldilocks approves - this is just right<br>&nbsp;&nbsp;console.log(alphabet[k]);<br>}</blockquote> 
+</section>
+
+## Instructions
+<section id='instructions'> 
+Corrija los dos errores de indexación en la siguiente función para que todos los números del 1 al 5 se impriman en la consola. 
+</section>
+
+## Tests
+<section id='tests'>
+
+```yml
+tests:
+  - text: Su código debe establecer la condición inicial del bucle para que comience en el primer índice.
+    testString: 'assert(code.match(/i\s*?=\s*?0\s*?;/g).length == 1, "Your code should set the initial condition of the loop so it starts at the first index.");'
+  - text: Su código debe arreglar la condición inicial del bucle para que el índice comience en 0.
+    testString: 'assert(!code.match(/i\s?=\s*?1\s*?;/g), "Your code should fix the initial condition of the loop so that the index starts at 0.");'
+  - text: Su código debe establecer la condición de terminal del bucle para que se detenga en el último índice.
+    testString: 'assert(code.match(/i\s*?<\s*?len\s*?;/g).length == 1, "Your code should set the terminal condition of the loop so it stops at the last index.");'
+  - text: Su código debe fijar la condición de terminal del bucle para que se detenga en 1 antes de la longitud.
+    testString: 'assert(!code.match(/i\s*?<=\s*?len;/g), "Your code should fix the terminal condition of the loop so that it stops at 1 before the length.");'
+
+```
+
+</section>
+
+## Challenge Seed
+<section id='challengeSeed'>
+
+<div id='js-seed'>
+
+```js
+function countToFive() {
+  let firstFive = "12345";
+  let len = firstFive.length;
+  // Fix the line below
+  for (let i = 1; i <= len; i++) {
+  // Do not alter code below this line
+    console.log(firstFive[i]);
+  }
+}
+
+countToFive();
+```
+
+</div>
+
+
+
+</section>
+
+## Solution
+<section id='solution'>
+
+```js
+// solution required
+```
+</section>

curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/debugging/catch-unclosed-parentheses-brackets-braces-and-quotes.spanish.md

@@ -0,0 +1,56 @@
+---
+id: 587d7b84367417b2b2512b36
+title: 'Catch Unclosed Parentheses, Brackets, Braces and Quotes'
+localeTitle: 'Captura paréntesis, corchetes, llaves y citas'
+challengeType: 1
+---
+
+## Description
+<section id='description'> 
+Otro error de sintaxis a tener en cuenta es que todos los paréntesis de apertura, paréntesis, llaves y comillas tienen un par de cierre. El olvido de una pieza suele suceder cuando edita el código existente e inserta elementos con uno de los tipos de pares. Además, tenga cuidado al anidar bloques de código en otros, como agregar una función de devolución de llamada como un argumento a un método. 
+Una forma de evitar este error es tan pronto como se escribe el carácter de apertura, incluya inmediatamente la coincidencia de cierre, luego mueva el cursor entre ellos y continúe la codificación. Afortunadamente, la mayoría de los editores de código modernos generan la segunda mitad del par automáticamente. 
+</section>
+
+## Instructions
+<section id='instructions'> 
+Arreglar los errores de dos pares en el código. 
+</section>
+
+## Tests
+<section id='tests'>
+
+```yml
+tests:
+  - text: Tu código debería arreglar la pieza faltante de la matriz.
+    testString: 'assert(code.match(/myArray\s*?=\s*?\[\s*?1\s*?,\s*?2\s*?,\s*?3\s*?\];/g), "Your code should fix the missing piece of the array.");'
+  - text: 'Su código debe arreglar la pieza faltante del método <code clase = "notranslate">. Reduce () </code>. La salida de la consola debería mostrar que "la suma de los valores de la matriz es: 6".
+    testString: 'assert(arraySum === 6, "Your code should fix the missing piece of the <code>.reduce()</code> method. The console output should show that "Sum of array values is: 6".");'
+
+```
+
+</section>
+
+## Challenge Seed
+<section id='challengeSeed'>
+
+<div id='js-seed'>
+
+```js
+let myArray = [1, 2, 3;
+let arraySum = myArray.reduce((previous, current =>  previous + current);
+console.log(`Sum of array values is: ${arraySum}`);
+```
+
+</div>
+
+
+
+</section>
+
+## Solution
+<section id='solution'>
+
+```js
+// solution required
+```
+</section>

curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/debugging/catch-use-of-assignment-operator-instead-of-equality-operator.spanish.md

@@ -0,0 +1,67 @@
+---
+id: 587d7b85367417b2b2512b38
+title: Catch Use of Assignment Operator Instead of Equality Operator
+localeTitle: Captura el uso del operador de asignación en lugar del operador de igualdad
+challengeType: 1
+---
+
+## Description
+<section id='description'> 
+Los programas de derivación, es decir, los que hacen cosas diferentes si se cumplen ciertas condiciones, dependen de las declaraciones <code>if</code> , <code>else if</code> , y <code>else</code> en JavaScript. La condición a veces toma la forma de probar si un resultado es igual a un valor. 
+Esta lógica se habla (en inglés, al menos) como &quot;si x es igual a y, entonces ...&quot; que puede traducirse literalmente en código usando el operador <code>=</code> , o asignación. Esto conduce a un flujo de control inesperado en su programa. 
+Como se cubrió en desafíos anteriores, el operador de asignación ( <code>=</code> ) en JavaScript asigna un valor a un nombre de variable. Y los operadores <code>==</code> y <code>===</code> verifican la igualdad (las pruebas triples <code>===</code> para la igualdad estricta, lo que significa que tanto el valor como el tipo son iguales). 
+El siguiente código asigna <code>x</code> para ser 2, que se evalúa como <code>true</code> . Casi todos los valores en JavaScript se evalúan como <code>true</code> , excepto lo que se conoce como valores &quot;falsos&quot;: <code>false</code> , <code>0</code> , <code>&quot;&quot;</code> (una cadena vacía), <code>NaN</code> , <code>undefined</code> y <code>null</code> . 
+<blockquote>let x = 1;<br>let y = 2;<br>if (x = y) {<br>&nbsp;&nbsp;// this code block will run for any value of y (unless y were originally set as a falsy)<br>} else {<br>&nbsp;&nbsp;// this code block is what should run (but won't) in this example<br>}</blockquote> 
+</section>
+
+## Instructions
+<section id='instructions'> 
+Corrija la condición para que el programa ejecute la rama derecha y se asigne el valor apropiado al <code>result</code> . 
+</section>
+
+## Tests
+<section id='tests'>
+
+```yml
+tests:
+  - text: 'Tu código debería arreglar la condición para que verifique la igualdad, en lugar de usar la asignación'.
+    testString: 'assert(result == "Not equal!", "Your code should fix the condition so it checks for equality, instead of using assignment.");'
+  - text: La condición puede usar <code class = "notranslate"> == </code> o <code class = "notranslate"> === </code> para probar la igualdad.
+    testString: 'assert(code.match(/x\s*?===?\s*?y/g), "The condition can use either <code>==</code> or <code>===</code> to test for equality.");'
+
+```
+
+</section>
+
+## Challenge Seed
+<section id='challengeSeed'>
+
+<div id='js-seed'>
+
+```js
+let x = 7;
+let y = 9;
+let result = "to come";
+
+if(x = y) {
+  result = "Equal!";
+} else {
+  result = "Not equal!";
+}
+
+console.log(result);
+```
+
+</div>
+
+
+
+</section>
+
+## Solution
+<section id='solution'>
+
+```js
+// solution required
+```
+</section>

curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/debugging/prevent-infinite-loops-with-a-valid-terminal-condition.spanish.md

@@ -0,0 +1,60 @@
+---
+id: 587d7b86367417b2b2512b3d
+title: Prevent Infinite Loops with a Valid Terminal Condition
+localeTitle: Prevenga los bucles infinitos con una condición de terminal válida
+challengeType: 1
+---
+
+## Description
+<section id='description'> 
+El tema final es el bucle infinito temido. Los bucles son excelentes herramientas cuando necesita que su programa ejecute un bloque de código un cierto número de veces o hasta que se cumpla una condición, pero necesitan una condición de terminal que termine el bucle. Es probable que los bucles infinitos congelen o bloqueen el navegador, y causen un caos general en la ejecución del programa, que nadie quiere. 
+No fue un ejemplo de un bucle infinito en la introducción a esta sección - que no tenía condición terminal para salir de la <code>while</code> bucle interior <code>loopy()</code> . ¡NO llames a esta función! 
+<blockquote>function loopy() {<br>&nbsp;&nbsp;while(true) {<br>&nbsp;&nbsp;&nbsp;&nbsp;console.log("Hello, world!");<br>&nbsp;&nbsp;}<br>}</blockquote> 
+El trabajo del programador es asegurarse de que finalmente se alcance la condición del terminal, que le indica al programa cuándo salir del código de bucle. Un error es aumentar o disminuir una variable de contador en la dirección incorrecta de la condición del terminal. Otro es restablecer accidentalmente un contador o variable de índice dentro del código de bucle, en lugar de incrementarlo o disminuirlo. 
+</section>
+
+## Instructions
+<section id='instructions'> 
+El <code>myFunc()</code> función contiene un bucle infinito debido a que la condición terminal <code>i != 4</code> Nunca será evaluada como <code>false</code> (y romper el bucle) - <code>i</code> aumentará en 2 de cada pasada, y saltar a la derecha durante 4 desde <code>i</code> es impar para empezar. Corrija el operador de comparación en la condición de terminal para que el bucle solo se ejecute para <code>i</code> menor o igual a 4. 
+</section>
+
+## Tests
+<section id='tests'>
+
+```yml
+tests:
+  - text: Su código debe cambiar el operador de comparación en la condición del terminal (la parte media) del bucle <code>for</code> .
+    testString: 'assert(code.match(/i\s*?<=\s*?4;/g).length == 1, "Your code should change the comparison operator in the terminal condition (the middle part) of the <code>for</code> loop.");'
+  - text: Su código debe arreglar el operador de comparación en la condición terminal del bucle.
+    testString: 'assert(!code.match(/i\s*?!=\s*?4;/g), "Your code should fix the comparison operator in the terminal condition of the loop.");'
+
+```
+
+</section>
+
+## Challenge Seed
+<section id='challengeSeed'>
+
+<div id='js-seed'>
+
+```js
+function myFunc() {
+  for (let i = 1; i != 4; i += 2) {
+    console.log("Still going!");
+  }
+}
+```
+
+</div>
+
+
+
+</section>
+
+## Solution
+<section id='solution'>
+
+```js
+// solution required
+```
+</section>

curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/debugging/understanding-the-differences-between-the-freecodecamp-and-browser-console.spanish.md

@@ -0,0 +1,76 @@
+---
+id: 587d7b83367417b2b2512b37
+title: Understanding the Differences between the freeCodeCamp and Browser Console
+localeTitle: Comprender las diferencias entre freeCodeCamp y Browser Console
+challengeType: 1
+---
+
+## Description
+<section id='description'> 
+Es posible que haya notado que algunos desafíos de JavaScript de freeCodeCamp incluyen su propia consola. Esta consola se comporta de forma un poco diferente a la consola del navegador que usó en el último desafío. 
+El siguiente desafío pretende resaltar algunas de las diferencias entre la consola freeCodeCamp y la consola del navegador. 
+Primero, la consola del navegador. Cuando cargue y ejecute un archivo JavaScript normal en su navegador, las declaraciones de <code>console.log()</code> imprimirán exactamente lo que usted les dice que impriman en la consola del navegador la cantidad exacta de veces que solicitó. En su editor de texto en el navegador, el proceso es ligeramente diferente y puede ser confuso al principio. 
+valores pasados ​​a <code>console.log()</code> en el bloque del editor de texto ejecutan cada conjunto de pruebas, así como una vez más para cualquier llamada de función que tenga en su código. 
+Esto se presta a un comportamiento interesante y puede hacer que se tropiece con usted al principio, porque un valor registrado que espera ver solo una vez puede imprimirse muchas más, dependiendo de la cantidad de pruebas y los valores que se pasan a esas pruebas. 
+Si desea ver solo su salida única y no tiene que preocuparse por ejecutar los ciclos de prueba, puede usar <code>console.clear()</code> . 
+</section>
+
+## Instructions
+<section id='instructions'> 
+Use <code>console.log()</code> para imprimir las variables en el código donde se indica. 
+
+</section>
+
+## Tests
+<section id='tests'>
+
+```yml
+tests:
+  - text: Use <code>console.log()</code> para imprimir la variable <code>outputTwo</code> . En la consola del navegador, esto debería imprimir el valor de la variable dos veces.
+    testString: 'assert(code.match(/console\.log\(outputTwo\)/g), "Use <code>console.log()</code> to print the <code>outputTwo</code> variable.  In your Browser Console this should print out the value of the variable two times.");'
+  - text: Utilice <code>console.log()</code> para imprimir la variable <code>outputOne</code> .
+    testString: 'assert(code.match(/console\.log\(outputOne\)/g), "Use <code>console.log()</code> to print the <code>outputOne</code> variable.");'
+  - text: Use <code>console.clear()</code> para modificar su salida de modo que la variable <code>outputOne</code> solo <code>outputOne</code> una vez.
+    testString: 'assert(code.match(/^(\s*console.clear\(\);?\s*)$/gm), "Use <code>console.clear()</code> to modify your output so that <code>outputOne</code> variable only outputs once.");'
+
+```
+
+</section>
+
+## Challenge Seed
+<section id='challengeSeed'>
+
+<div id='js-seed'>
+
+```js
+// Open your browser console
+let outputTwo = "This will print to the browser console 2 times";
+// Use console.log() to print the outputTwo variable
+
+
+let outputOne = "Try to get this to log only once to the browser console";
+// Use console.clear() in the next line to print the outputOne only once
+
+
+// Use console.log() to print the outputOne variable
+
+
+```
+
+</div>
+
+
+
+</section>
+
+## Solution
+<section id='solution'>
+
+
+```js
+let outputTwo = "This will print to the browser console 2 times"; console.log(outputTwo); let outputOne = "Try to get this to log only once to the browser console";
+console.clear();
+console.log(outputOne);
+```
+
+</section>

curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/debugging/use-caution-when-reinitializing-variables-inside-a-loop.spanish.md

@@ -0,0 +1,74 @@
+---
+id: 587d7b86367417b2b2512b3c
+title: Use Caution When Reinitializing Variables Inside a Loop
+localeTitle: Tenga cuidado al reinicializar variables dentro de un bucle
+challengeType: 1
+---
+
+## Description
+<section id='description'> 
+A veces es necesario guardar información, incrementar los contadores o restablecer las variables dentro de un bucle. Un problema potencial es cuando las variables deben reinicializarse y no, o viceversa. Esto es particularmente peligroso si restablece accidentalmente la variable que se está utilizando para la condición del terminal, causando un bucle infinito. 
+impresión de valores de variables con cada ciclo de su ciclo utilizando <code>console.log()</code> puede descubrir un comportamiento defectuoso relacionado con el restablecimiento, o no restablecer una variable. 
+</section>
+
+## Instructions
+<section id='instructions'> 
+Se supone que la siguiente función crea una matriz bidimensional con <code>m</code> filas <code>n</code> columnas de ceros. Desafortunadamente, no está produciendo el resultado esperado porque la variable de <code>row</code> no se está reinicializando (configurada de nuevo en una matriz vacía) en el bucle externo. Corrija el código para que devuelva una matriz correcta de 3x2 de ceros, que se parece a <code>[[0, 0], [0, 0], [0, 0]]</code> . 
+</section>
+
+## Tests
+<section id='tests'>
+
+```yml
+tests:
+  - text: Su código debe establecer la variable de <code>matrix</code> en una matriz que contenga 3 filas de 2 columnas de ceros cada una.
+    testString: 'assert(JSON.stringify(matrix) == "[[0,0],[0,0],[0,0]]", "Your code should set the <code>matrix</code> variable to an array holding 3 rows of 2 columns of zeroes each.");'
+  - text: La variable <code>matrix</code> debe tener 3 filas.
+    testString: 'assert(matrix.length == 3, "The <code>matrix</code> variable should have 3 rows.");'
+  - text: La variable <code>matrix</code> debe tener 2 columnas en cada fila.
+    testString: 'assert(matrix[0].length == 2 && matrix[1].length === 2 && matrix[2].length === 2, "The <code>matrix</code> variable should have 2 columns in each row.");'
+
+```
+
+</section>
+
+## Challenge Seed
+<section id='challengeSeed'>
+
+<div id='js-seed'>
+
+```js
+function zeroArray(m, n) {
+  // Creates a 2-D array with m rows and n columns of zeroes
+  let newArray = [];
+  let row = [];
+  for (let i = 0; i < m; i++) {
+    // Adds the m-th row into newArray
+
+    for (let j = 0; j < n; j++) {
+      // Pushes n zeroes into the current row to create the columns
+      row.push(0);
+    }
+    // Pushes the current row, which now has n zeroes in it, to the array
+    newArray.push(row);
+  }
+  return newArray;
+}
+
+let matrix = zeroArray(3, 2);
+console.log(matrix);
+```
+
+</div>
+
+
+
+</section>
+
+## Solution
+<section id='solution'>
+
+```js
+// solution required
+```
+</section>

curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/debugging/use-the-javascript-console-to-check-the-value-of-a-variable.spanish.md

@@ -0,0 +1,64 @@
+---
+id: 587d7b83367417b2b2512b33
+title: Use the JavaScript Console to Check the Value of a Variable
+localeTitle: Use la consola de JavaScript para verificar el valor de una variable
+challengeType: 1
+---
+
+## Description
+<section id='description'> 
+Tanto Chrome como Firefox tienen excelentes consolas de JavaScript, también conocidas como DevTools, para depurar su JavaScript. 
+Puede encontrar Herramientas de desarrollador en el menú de Chrome o la Consola web en el menú de FireFox. Si está utilizando un navegador diferente o un teléfono móvil, le recomendamos que cambie a la computadora de escritorio Firefox o Chrome. 
+El método <code>console.log()</code> , que &quot;imprime&quot; la salida de lo que está entre sus paréntesis en la consola, probablemente sea la herramienta de depuración más útil. Colocarlo en puntos estratégicos en su código puede mostrarle los valores intermedios de las variables. Es una buena práctica tener una idea de lo que debería ser la salida antes de ver qué es. Tener puntos de control para ver el estado de sus cálculos a lo largo de su código ayudará a reducir dónde está el problema. 
+Aquí hay un ejemplo para imprimir &#39;¡Hola mundo!&#39; a la consola: 
+<code>console.log(&#39;Hello world!&#39;);</code> 
+</section>
+
+## Instructions
+<section id='instructions'> 
+Use el método <code>console.log()</code> para imprimir el valor de la variable <code>a</code> donde se indica en el código. 
+</section>
+
+## Tests
+<section id='tests'>
+
+```yml
+tests:
+  - text: Su código debe usar <code>console.log()</code> para verificar el valor de la variable <code>a</code> .
+    testString: 'assert(code.match(/console\.log\(a\)/g), "Your code should use <code>console.log()</code> to check the value of the variable <code>a</code>.");'
+
+```
+
+</section>
+
+## Challenge Seed
+<section id='challengeSeed'>
+
+<div id='js-seed'>
+
+```js
+let a = 5;
+let b = 1;
+a++;
+// Add your code below this line
+
+
+let sumAB = a + b;
+console.log(sumAB);
+```
+
+</div>
+
+
+
+</section>
+
+## Solution
+<section id='solution'>
+
+
+```js
+var a = 5; console.log(a);
+```
+
+</section>

curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/debugging/use-typeof-to-check-the-type-of-a-variable.spanish.md

@@ -0,0 +1,65 @@
+---
+id: 587d7b84367417b2b2512b34
+title: Use typeof to Check the Type of a Variable
+localeTitle: Utilice typeof para comprobar el tipo de una variable
+challengeType: 1
+---
+
+## Description
+<section id='description'> 
+Puede usar <code>typeof</code> para verificar la estructura de datos, o tipo, de una variable. Esto es útil en la depuración cuando se trabaja con múltiples tipos de datos. Si crees que estás agregando dos números, pero uno es en realidad una cadena, los resultados pueden ser inesperados. Los errores de tipo pueden estar al acecho en cálculos o llamadas de función. Tenga cuidado especialmente cuando esté accediendo y trabajando con datos externos en forma de un objeto de notación de objetos de JavaScript (JSON). 
+Aquí hay algunos ejemplos usando <code>typeof</code> : 
+<blockquote>console.log(typeof ""); // outputs "string"<br>console.log(typeof 0); // outputs "number"<br>console.log(typeof []); // outputs "object"<br>console.log(typeof {}); // outputs "object"</blockquote> 
+JavaScript reconoce seis tipos de datos primitivos (inmutables): <code>Boolean</code> , <code>Null</code> , no <code>Undefined</code> , <code>Number</code> , <code>String</code> y <code>Symbol</code> (nuevo con ES6) y un tipo para elementos mutables: <code>Object</code> . Tenga en cuenta que en JavaScript, las matrices son técnicamente un tipo de objeto. 
+</section>
+
+## Instructions
+<section id='instructions'> 
+Añadir dos <code>console.log()</code> declaraciones para comprobar el <code>typeof</code> cada una de las dos variables de <code>seven</code> y <code>three</code> en el código. 
+</section>
+
+## Tests
+<section id='tests'>
+
+```yml
+tests:
+  - text: Su código debe usar <code>typeof</code> en dos sentencias <code>console.log()</code> para verificar el tipo de las variables.
+    testString: 'assert(code.match(/console\.log\(typeof[\( ].*\)?\)/g).length == 2, "Your code should use <code>typeof</code> in two <code>console.log()</code> statements to check the type of the variables.");'
+  - text: Su código debe usar <code>typeof</code> para verificar el tipo de la variable <code>seven</code> .
+    testString: 'assert(code.match(/typeof[\( ]seven\)?/g), "Your code should use <code>typeof</code> to check the type of the variable <code>seven</code>.");'
+  - text: Su código debe usar <code>typeof</code> para verificar el tipo de la variable <code>three</code> .
+    testString: 'assert(code.match(/typeof[\( ]three\)?/g), "Your code should use <code>typeof</code> to check the type of the variable <code>three</code>.");'
+
+```
+
+</section>
+
+## Challenge Seed
+<section id='challengeSeed'>
+
+<div id='js-seed'>
+
+```js
+let seven = 7;
+let three = "3";
+console.log(seven + three);
+// Add your code below this line
+
+```
+
+</div>
+
+
+
+</section>
+
+## Solution
+<section id='solution'>
+
+
+```js
+let seven = 7;let three = "3";console.log(typeof seven);
+console.log(typeof three);
+```
+
+</section>