fix(guide): simplify directory structure

guide/spanish/certifications/javascript-algorithms-and-data-structures/debugging/catch-arguments-passed-in-the-wrong-order-when-calling-a-function/index.md

@@ -0,0 +1,22 @@
+---
+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
+---
+## Detectar argumentos pasados ​​en el orden incorrecto al llamar a una función
+
+```javascript
+function raiseToPower(b, e) { 
+  return Math.pow(b, e); 
+ } 
+```
+
+*   La función anterior se utiliza para elevar el número base `b` a la potencia del exponente `e` .
+*   La función debe ser llamada específicamente con variables en el orden correcto. De lo contrario, la función mezclará ambas variables y devolverá una respuesta no deseada.
+*   Asegúrese de que la `power` variable esté implementando la función `raiseToPower` correctamente.
+
+## Solución:
+
+```javascript
+let power = raiseToPower(base, exp); 
+
+```

guide/spanish/certifications/javascript-algorithms-and-data-structures/debugging/catch-missing-open-and-closing-parenthesis-after-a-function-call/index.md

@@ -0,0 +1,15 @@
+---
+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
+---
+## Atrapa los paréntesis abiertos y de cierre que faltan después de una llamada de función
+
+*   Recuerde agregar paréntesis de apertura y cierre al llamar a una función.
+*   FunctionName + ();
+
+## Solución:
+
+```javascript
+ let result = getNine(); 
+
+```

guide/spanish/certifications/javascript-algorithms-and-data-structures/debugging/catch-misspelled-variable-and-function-names/index.md

@@ -0,0 +1,27 @@
+---
+title: Catch Misspelled Variable and Function Names
+localeTitle: Capturar nombres de funciones y variables mal escritas
+---
+## Capturar nombres de funciones y variables mal escritas
+
+### Explicación del problema:
+
+Corrija los dos errores de ortografía en el código para que funcione el cálculo de netWorkingCapital.
+
+### Insinuación
+
+Verifique la ortografía de las dos primeras variables cuando se usa.
+
+## ¡Alerta de spoiler!
+
+**¡Solución por delante!**
+
+```javascript
+// 'i' and 'e' swapped in "receivables" and missing 's' in "payables" 
+ 
+ let receivables = 10; 
+ let payables = 8; 
+ let netWorkingCapital = receivables - payables; 
+ console.log(`Net working capital is: ${netWorkingCapital}`); 
+
+```

guide/spanish/certifications/javascript-algorithms-and-data-structures/debugging/catch-mixed-usage-of-single-and-double-quotes/index.md

@@ -0,0 +1,17 @@
+---
+title: Catch Mixed Usage of Single and Double Quotes
+localeTitle: Uso mixto de capturas de comillas simples y dobles
+---
+## Uso mixto de capturas de comillas simples y dobles
+
+*   Recuerde si elige usar comillas simples o dobles, simplemente agregando un `\` antes de que el carácter permita que el carácter encaje en la cadena sin cerrar las comillas simples o dobles.
+*   Los casos de prueba solo se pasarán utilizando comillas dobles.
+
+## Solución:
+
+```javascript
+//Solution1: 
+ let innerHtml = "<p>Click here to <a href=\"#Home\">return home</a></p>"; 
+ console.log(innerHtml); 
+
+```

guide/spanish/certifications/javascript-algorithms-and-data-structures/debugging/catch-off-by-one-errors-when-using-indexing/index.md

@@ -0,0 +1,70 @@
+---
+title: Catch Off By One Errors When Using Indexing
+localeTitle: Descubrir por uno errores al utilizar la indexación
+---
+## Descubrir por uno errores al utilizar la indexación
+
+### Lo esencial
+
+Debido a la forma en que funcionan los índices de JavaScript, ¡los `firstFive` **cinco** tienen **cinco elementos** pero están indexados de **0 a 4** !
+
+```javascript
+console.log(len); // 5 
+ console.log(firstFive[0]); // 1 
+ /**/ 
+ console.log(firstFive[4]); // 5 
+ console.log(firstFive[5]); // undefined 
+```
+
+Eso debería darte lo suficiente para comprender los límites de los `firstFive` . Dirige tu atención al bucle. ¿Qué hace? Puedes intentar depurarlo para averiguarlo!
+
+### Depuración
+
+Te han dado este código:
+
+```javascript
+  for (let i = 1; i <= len; i++) { 
+    console.log(firstFive[i]); 
+  } 
+```
+
+Para depurar este fragmento de código, use `console.clear()` . ¿Cuál sería el mejor lugar para ello? La respuesta es justo antes de la declaración `for` !
+
+```javascript
+  console.clear(); 
+  for (let i = 1; i <= len; i++) { 
+    console.log(firstFive[i]); 
+  } 
+```
+
+Salida de consola:
+
+```text
+  Console was cleared. 
+  2 
+  3 
+  4 
+  5 
+  undefined 
+```
+
+### Análisis
+
+Examina la salida. En estas condiciones, el bucle primero imprime el elemento posicionado en 1 ... ¡que es 2! También intenta imprimir el elemento indexado en 5, que `undefined` está `undefined` .
+
+Esto puede considerarse el punto de este desafío. Mantenga `console.log()` y `console.clear()` presentes. Te ayudarán a entender cómo funciona tu código.
+
+### Solución
+
+La forma más sencilla de solucionar este problema es alterar las condiciones for (). Hago `i` empezar a 0. También el bucle **no debe** ser ejecutado para i == 5. En otras palabras, la relación entre `i` y `len` debe ser `false` cuando i == 5. Que se puede lograr mediante el uso de `i < len` (Is 5 <len? false, y el bucle no se ejecutará!).
+
+```javascript
+  for (let i = 0; i < len; i++) { 
+```
+
+**¡Feliz codificación!** :computadora:
+
+### Recursos
+
+*   [Para declaraciones de desafío en FreeCodeCamp](https://learn.freecodecamp.org/javascript-algorithms-and-data-structures/basic-javascript/iterate-with-javascript-for-loops)
+*   [Para declaraciones en documentos web de MDN](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Loops_and_iteration#for_statement)

guide/spanish/certifications/javascript-algorithms-and-data-structures/debugging/catch-unclosed-parentheses-brackets-braces-and-quotes/index.md

@@ -0,0 +1,34 @@
+---
+title: Catch Unclosed Parentheses, Brackets, Braces and Quotes
+localeTitle: Captura paréntesis, corchetes, llaves y citas sin cerrar
+---
+## Captura paréntesis, corchetes, llaves y citas sin cerrar
+
+El método reduce () reduce una matriz a un solo valor. Si no está familiarizado con él, el siguiente código muestra un ejemplo de cómo usar el método:
+```
+const array1 = [1, 2, 3, 4]; 
+ console.log(array1.reduce((accumulator, currentValue) => accumulator + currentValue));  // expected output: 10 
+```
+
+También puede definir el argumento del método de reducción como una variable o constante y entregarlo a la función, por ejemplo,
+```
+const array1 = [1, 2, 3, 4]; 
+ const reducer = (accumulator, currentValue) => accumulator + currentValue; 
+ 
+ // 1 + 2 + 3 + 4 
+ console.log(array1.reduce(reducer));      // expected output: 10 
+ 
+ // 5 + 1 + 2 + 3 + 4 
+ console.log(array1.reduce(reducer, 5));   // expected output: 15 
+```
+
+Puede ver y ejecutar este código en [Array.prototype.reduce ()](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/reduce) .
+
+## Solución:
+
+```javascript
+let myArray = [1, 2, 3]; 
+ let arraySum = myArray.reduce((previous, current) =>  previous + current); 
+ console.log(`Sum of array values is: ${arraySum}`); 
+
+```

guide/spanish/certifications/javascript-algorithms-and-data-structures/debugging/catch-use-of-assignment-operator-instead-of-equality-operator/index.md

@@ -0,0 +1,25 @@
+---
+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
+---
+## Captura el uso del operador de asignación en lugar del operador de igualdad
+
+*   Solo la sentencia if debe ser editada en este desafío.
+*   El operador `=` solo se usa para asignar valores, no para compararlos.
+
+## Solución
+
+```javascript
+let x = 7; 
+ let y = 9; 
+ let result = "to come"; 
+ 
+ if(x == y) { 
+  result = "Equal!"; 
+ } else { 
+  result = "Not equal!"; 
+ } 
+ 
+ console.log(result); 
+
+```

guide/spanish/certifications/javascript-algorithms-and-data-structures/debugging/index.md

@@ -0,0 +1,11 @@
+---
+title: Debugging
+localeTitle: Depuración
+---
+## Depuración
+
+Esto es un talón. [Ayuda a nuestra comunidad a expandirla](https://github.com/freecodecamp/guides/tree/master/src/pages/mathematics/quadratic-equations/index.md) .
+
+[Esta guía rápida de estilo ayudará a asegurar que su solicitud de extracción sea aceptada](https://github.com/freecodecamp/guides/blob/master/README.md) .
+
+#### Más información:

guide/spanish/certifications/javascript-algorithms-and-data-structures/debugging/prevent-infinite-loops-with-a-valid-terminal-condition/index.md

@@ -0,0 +1,31 @@
+---
+title: Prevent Infinite Loops with a Valid Terminal Condition
+localeTitle: Prevenga los bucles infinitos con una condición de terminal válida
+---
+## Prevenga los bucles infinitos con una condición de terminal válida
+
+*   Para evitar un bucle infinito, la `while-condition` debe alcanzar una condición terminal para salir del bucle.
+*   Entonces, el error en este desafío ocurre debido a la condición - `i != 4` - en el bucle for.
+*   Si echas un vistazo más de cerca al código:
+
+```javascript
+function myFunc() { 
+  for (let i = 1; i != 4; i += 2) { 
+    console.log("Still going!"); 
+  } 
+ } 
+```
+
+*   Verá que `i` se inicializa primero como 1 y después de cada iteración del bucle, `i` se incrementa en 2.
+*   Usando esta lógica, después de la primera iteración - `i = 3` y la segunda iteración `i = 5` , la condición `i != 4` nunca se cumplirá y se producirá un bucle infinito.
+
+## Solución:
+
+```javascript
+function myFunc() { 
+  for (let i = 1; i <= 4; i += 2) { 
+    console.log("Still going!"); 
+  } 
+ } 
+
+```

guide/spanish/certifications/javascript-algorithms-and-data-structures/debugging/understanding-the-differences-between-the-freecodecamp-and-browser-console/index.md

@@ -0,0 +1,9 @@
+---
+title: Understanding the Differences between the freeCodeCamp and Browser Console
+localeTitle: Comprender las diferencias entre freeCodeCamp y Browser Console
+---
+## Comprender las diferencias entre freeCodeCamp y Browser Console
+
+Esto es un talón. [Ayuda a nuestra comunidad a expandirla](https://github.com/freecodecamp/guides/tree/master/src/pages/certifications/javascript-algorithms-and-data-structures/debugging/understanding-the-differences-between-the-freecodecamp-and-browser-console/index.md) .
+
+[Esta guía rápida de estilo ayudará a asegurar que su solicitud de extracción sea aceptada](https://github.com/freecodecamp/guides/blob/master/README.md) .

guide/spanish/certifications/javascript-algorithms-and-data-structures/debugging/use-caution-when-reinitializing-variables-inside-a-loop/index.md

@@ -0,0 +1,51 @@
+---
+title: Use Caution When Reinitializing Variables Inside a Loop
+localeTitle: Tenga cuidado al reinicializar variables dentro de un bucle
+---
+## Tenga cuidado al reinicializar variables dentro de un bucle
+
+*   Este desafío debe resolverse redefiniendo el alcance de la `row[]` .
+*   A continuación se muestra un ejemplo de la matriz deseada.
+
+```javascript
+[ 
+ [0][0], 
+ [0][0], 
+ [0][0] 
+ ] 
+```
+
+*   Sin embargo, la matriz actual, que se ve a continuación, está lejos de la matriz deseada
+
+```javascript
+[ 
+ [0][0][0][0][0][0], 
+ [0][0][0][0][0][0], 
+ [0][0][0][0][0][0] 
+ ] 
+```
+
+*   Este error se produce debido a que la matriz `row[]` se declara como una variable global fuera del bucle anidado.
+*   Sin embargo, para rellenar la matriz correctamente, la `row[]` debe restablecerse después de cada iteración del bucle externo.
+
+## Solución
+
+```javascript
+function zeroArray(m, n) { 
+  let newArray = []; 
+  for (let i = 0; i < m; i++) { 
+     let row = []; /* <-----  row has been declared inside the outer loop. 
+     Now a new row will be initialised during each iteration of the outer loop allowing 
+     for the desired matrix. */ 
+    for (let j = 0; j < n; j++) { 
+ 
+      row.push(0); 
+    } 
+    newArray.push(row); 
+  } 
+  return newArray; 
+ } 
+ let matrix = zeroArray(3, 2); 
+ console.log(matrix); 
+
+```

guide/spanish/certifications/javascript-algorithms-and-data-structures/debugging/use-the-javascript-console-to-check-the-value-of-a-variable/index.md

@@ -0,0 +1,9 @@
+---
+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
+---
+## Use la consola de JavaScript para verificar el valor de una variable
+
+Esto es un talón. [Ayuda a nuestra comunidad a expandirla](https://github.com/freecodecamp/guides/tree/master/src/pages/certifications/javascript-algorithms-and-data-structures/debugging/use-the-javascript-console-to-check-the-value-of-a-variable/index.md) .
+
+[Esta guía rápida de estilo ayudará a asegurar que su solicitud de extracción sea aceptada](https://github.com/freecodecamp/guides/blob/master/README.md) .

guide/spanish/certifications/javascript-algorithms-and-data-structures/debugging/use-typeof-to-check-the-type-of-a-variable/index.md

@@ -0,0 +1,15 @@
+---
+title: Use typeof to Check the Type of a Variable
+localeTitle: Utilice typeof para comprobar el tipo de una variable
+---
+## Utilice typeof para comprobar el tipo de una variable
+
+*   Use `console.log(typeof variable)` para mostrar el tipo de la variable deseada.
+
+## Solución:
+
+```javascript
+console.log(typeof seven); 
+ console.log(typeof three); 
+
+```