chore(i8n,curriculum): processed translations (#41504)

Co-authored-by: Crowdin Bot <support+bot@crowdin.com>

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

@@ -16,10 +16,12 @@ Las variables del siguiente ejemplo son diferentes:
 function myFunction() {
   return "You rock!";
 }
-let varOne = myFunction; // set to equal a function
-let varTwo = myFunction(); // set to equal the string "You rock!"
+let varOne = myFunction;
+let varTwo = myFunction();
 ```
 
+Aquí `varOne` es la función `myFunction`, y `varTwo` es la cadena `You rock!`.
+
 # --instructions--
 
 Corrige el código para que la variable `result` se establezca en el valor devuelto al llamar a la función `getNine`.

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

@@ -1,6 +1,6 @@
 ---
 id: 587d7b84367417b2b2512b35
-title: Catch Misspelled Variable and Function Names
+title: Captura nombres de variables y funciones mal escritos
 challengeType: 1
 forumTopicId: 301186
 dashedName: catch-misspelled-variable-and-function-names
@@ -8,41 +8,41 @@ dashedName: catch-misspelled-variable-and-function-names
 
 # --description--
 
-The `console.log()` and `typeof` methods are the two primary ways to check intermediate values and types of program output. Now it's time to get into the common forms that bugs take. One syntax-level issue that fast typers can commiserate with is the humble spelling error.
+Los métodos `console.log()` y `typeof` son las dos formas principales de comprobar los valores intermedios y los tipos de salida de un programa. Ahora es el momento de entrar en las formas comúnes que adoptan los errores (bugs). Un problema a nivel de sintaxis con el que las personas que escriben rápido pueden simpatizar es el humilde error ortográfico.
 
-Transposed, missing, or mis-capitalized characters in a variable or function name will have the browser looking for an object that doesn't exist - and complain in the form of a reference error. JavaScript variable and function names are case-sensitive.
+Los caracteres transpuestos, omitidos o mal escritos en el nombre de una variable o función harán que el navegador busque un objeto que no existe, y se queje en forma de error de referencia. Los nombres de variables y funciones de JavaScript distinguen entre mayúsculas y minúsculas.
 
 # --instructions--
 
-Fix the two spelling errors in the code so the `netWorkingCapital` calculation works.
+Corrige los dos errores ortográficos en el código para que funcione el cálculo de `netWorkingCapital`.
 
 # --hints--
 
-Check the spelling of the two variables used in the netWorkingCapital calculation, the console output should show that "Net working capital is: 2".
+Comprueba la ortografía de las dos variables utilizadas en el cálculo de netWorkingCapital, la salida de la consola debe mostrar que "Net working capital is: 2".
 
 ```js
 assert(netWorkingCapital === 2);
 ```
 
-There should be no instances of mis-spelled variables in the code.
+No debe haber casos de variables mal escritas en el código.
 
 ```js
 assert(!code.match(/recievables/g));
 ```
 
-The `receivables` variable should be declared and used properly in the code.
+La variable `receivables` debe ser declarada y utilizada correctamente en el código.
 
 ```js
 assert(code.match(/receivables/g).length == 2);
 ```
 
-There should be no instances of mis-spelled variables in the code.
+No debe haber casos de variables mal escritas en el código.
 
 ```js
 assert(!code.match(/payable;/g));
 ```
 
-The `payables` variable should be declared and used properly in the code.
+La variable `payables` debe ser declarada y utilizada correctamente en el código.
 
 ```js
 assert(code.match(/payables/g).length == 2);

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

@@ -15,17 +15,16 @@ Tener dos opciones es genial cuando una cadena tiene contracciones u otro fragme
 Aquí hay algunos ejemplos de comillas mezcladas:
 
 ```js
-// These are correct:
 const grouchoContraction = "I've had a perfectly wonderful evening, but this wasn't it.";
 const quoteInString = "Groucho Marx once said 'Quote me as saying I was mis-quoted.'";
-// This is incorrect:
 const uhOhGroucho = 'I've had a perfectly wonderful evening, but this wasn't it.';
 ```
 
-Por supuesto, está bien utilizar sólo un estilo de comillas. Puedes realizar un escape de las comillas dentro de la cadena utilizando el caracter de escape de la barra invertida (<code>\\</code>):
+Los dos primeros son correctos, pero el tercero es incorrecto.
+
+Por supuesto, está bien utilizar sólo un estilo de comillas. Puedes escapar las comillas dentro de una cadena usando el carácter de barra diagonal invertida (`\`):
 
 ```js
-// Correct use of same quotes:
 const allSameQuotes = 'I\'ve had a perfectly wonderful evening, but this wasn\'t it.';
 ```
 
@@ -35,7 +34,7 @@ Corrige la cadena para que use comillas diferentes para el valor de `href`, o re
 
 # --hints--
 
-Tu código debe corregir las comillas alrededor del valor `href` "#Home" cambiándolas o escapándolas.
+Tu código debe corregir las comillas alrededor del valor `href` `#Home` cambiándolas o escapándolas.
 
 ```js
 assert(code.match(/<a href=\s*?('|\\")#Home\1\s*?>/g));

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

@@ -1,6 +1,6 @@
 ---
 id: 587d7b86367417b2b2512b3b
-title: Catch Off By One Errors When Using Indexing
+title: Captura los errores por uno al utilizar indexación
 challengeType: 1
 forumTopicId: 301189
 dashedName: catch-off-by-one-errors-when-using-indexing
@@ -8,52 +8,51 @@ dashedName: catch-off-by-one-errors-when-using-indexing
 
 # --description--
 
-<dfn>Off by one errors</dfn> (sometimes called OBOE) crop up when you're trying to target a specific index of a string or array (to slice or access a segment), or when looping over the indices of them. JavaScript indexing starts at zero, not one, which means the last index is always one less than the length of the item. If you try to access an index equal to the length, the program may throw an "index out of range" reference error or print `undefined`.
+<dfn>Los errores por uno o por un paso</dfn> (en inglés: Off-by-one error -OBOE) aparecen cuando se intenta apuntar a un índice específico de una cadena o arreglo (para cortar o acceder a un segmento), o cuando se hace un bucle sobre los índices de los mismos. La indexación en JavaScript comienza en cero, no en uno, lo que significa que el último índice es siempre uno menos que la longitud del elemento. Si intentas acceder a un índice igual a la longitud, el programa puede lanzar un error de referencia "index out of range" (índice fuera de rango) o imprimir `undefined`.
 
-When you use string or array methods that take index ranges as arguments, it helps to read the documentation and understand if they are inclusive (the item at the given index is part of what's returned) or not. Here are some examples of off by one errors:
+Cuando se utilizan métodos de cadenas o arreglos que toman rangos de índices como argumentos, es útil leer la documentación y entender si son inclusivos (el elemento en el índice dado es parte de lo que se devuelve) o no. Estos son algunos ejemplos de errores por un paso:
 
 ```js
 let alphabet = "abcdefghijklmnopqrstuvwxyz";
 let len = alphabet.length;
 for (let i = 0; i <= len; i++) {
-  // loops one too many times at the end
   console.log(alphabet[i]);
 }
 for (let j = 1; j < len; j++) {
-  // loops one too few times and misses the first character at index 0
   console.log(alphabet[j]);
 }
 for (let k = 0; k < len; k++) {
-  // Goldilocks approves - this is just right
   console.log(alphabet[k]);
 }
 ```
 
+El primer ejemplo aquí hace un bucle de más, y el segundo hace un bucle de menos (falta el primer índice, 0). El tercer ejemplo es correcto.
+
 # --instructions--
 
-Fix the two indexing errors in the following function so all the numbers 1 through 5 are printed to the console.
+Corrige 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.
 
 # --hints--
 
-Your code should set the initial condition of the loop so it starts at the first index.
+Tu código debe establecer la condición inicial del bucle para que comience en el primer índice.
 
 ```js
 assert(code.match(/i\s*?=\s*?0\s*?;/g).length == 1);
 ```
 
-Your code should fix the initial condition of the loop so that the index starts at 0.
+Tu código debe corregir la condición inicial del bucle para que el índice comience en 0.
 
 ```js
 assert(!code.match(/i\s?=\s*?1\s*?;/g));
 ```
 
-Your code should set the terminal condition of the loop so it stops at the last index.
+Tu código debe establecer la condición terminal del bucle para que se detenga en el último índice.
 
 ```js
 assert(code.match(/i\s*?<\s*?len\s*?;/g).length == 1);
 ```
 
-Your code should fix the terminal condition of the loop so that it stops at 1 before the length.
+Tu código debe corregir la condición terminal del bucle para que se detenga en 1 antes de la longitud.
 
 ```js
 assert(!code.match(/i\s*?<=\s*?len;/g));

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

@@ -1,6 +1,6 @@
 ---
 id: 587d7b84367417b2b2512b36
-title: 'Catch Unclosed Parentheses, Brackets, Braces and Quotes'
+title: 'Captura paréntesis, corchetes, llaves y comillas sin cerrar'
 challengeType: 1
 forumTopicId: 301190
 dashedName: catch-unclosed-parentheses-brackets-braces-and-quotes
@@ -8,23 +8,23 @@ dashedName: catch-unclosed-parentheses-brackets-braces-and-quotes
 
 # --description--
 
-Another syntax error to be aware of is that all opening parentheses, brackets, curly braces, and quotes have a closing pair. Forgetting a piece tends to happen when you're editing existing code and inserting items with one of the pair types. Also, take care when nesting code blocks into others, such as adding a callback function as an argument to a method.
+Otro error de sintaxis a tener en cuenta es que todos los paréntesis de apertura, corchetes, llaves y comillas tienen un par de cierre. Olvidar una pieza suele suceder cuando se edita el código existente y se insertan elementos con uno de los tipos de pares. También hay que tener cuidado al anidar bloques de código dentro de otros, como agregar una función de callback como argumento de un método.
 
-One way to avoid this mistake is as soon as the opening character is typed, immediately include the closing match, then move the cursor back between them and continue coding. Fortunately, most modern code editors generate the second half of the pair automatically.
+Una forma de evitar este error es, tan pronto como se escriba el caracter de apertura, incluir inmediatamente su caracter de cierre, luego mover el cursor hacia atrás entre ellos y continuar escribiendo. Afortunadamente, la mayoría de los editores de código modernos generan la segunda mitad del par automáticamente.
 
 # --instructions--
 
-Fix the two pair errors in the code.
+Corrige los dos errores de par en el código.
 
 # --hints--
 
-Your code should fix the missing piece of the array.
+Tu código debe arreglar la pieza que falta en el arreglo.
 
 ```js
 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 `.reduce()` method. The console output should show that "Sum of array values is: 6".
+Tu código debe arreglar la pieza que falta del método `.reduce()`. La salida de la consola debe mostrar `Sum of array values is: 6`.
 
 ```js
 assert(arraySum === 6);

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

@@ -20,12 +20,14 @@ El código siguiente asigna a `x` el valor de 2, que se evalúa como `true`. Cas
 let x = 1;
 let y = 2;
 if (x = y) {
-  // this code block will run for any value of y (unless y were originally set as a falsy)
+
 } else {
-  // this code block is what should run (but won't) in this example
+
 }
 ```
 
+En este ejemplo, el bloque de código dentro de la sentencia `if` se ejecutará para cualquier valor de `y`, a menos que `y` sea algún valor falsy. El bloque `else`, que esperamos que se ejecute aquí, no se ejecutará realmente.
+
 # --instructions--
 
 Corrige la condición para que el programa ejecute la rama correcta y se asigne el valor adecuado a `result`.

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

@@ -1,6 +1,6 @@
 ---
 id: 587d7b83367417b2b2512b37
-title: Understanding the Differences between the freeCodeCamp and Browser Console
+title: Entendiendo las diferencias entre la consola de freeCodeCamp y la del navegador
 challengeType: 1
 forumTopicId: 301193
 dashedName: understanding-the-differences-between-the-freecodecamp-and-browser-console
@@ -8,27 +8,27 @@ dashedName: understanding-the-differences-between-the-freecodecamp-and-browser-c
 
 # --description--
 
-You may have noticed that some freeCodeCamp JavaScript challenges include their own console. This console behaves a little differently than the browser console you used in the last challenge.
+Habrás notado que algunos desafíos de JavaScript de freeCodeCamp incluyen su propia consola. Esta consola se comporta un poco diferente a la consola del navegador que utilizaste en el último desafío.
 
-The following challenge is meant to highlight the main difference between the freeCodeCamp console and your browser console.
+El siguiente desafío pretende destacar la principal diferencia entre la consola de freeCodeCamp y la de tu navegador.
 
-When you run ordinary JavaScript, the browser's console will display your `console.log()` statements the exact number of times it is called.
+Cuando se ejecuta JavaScript ordinario, la consola del navegador mostrará sus declaraciones `console.log()` el número exacto de veces que se llama.
 
-The freeCodeCamp console will print your `console.log()` statements a short time after the editor detects a change in the script, as well as during testing.
+La consola de freeCodeCamp imprimirá sus declaraciones `console.log()` poco después de que el editor detecte un cambio en el script, así como durante las pruebas.
 
-The freeCodeCamp console is cleared before the tests are run and, to avoid spam, only prints the logs during the first test (see the note below for exceptions).
+La consola de freeCodeCamp se borra antes de que se ejecuten las pruebas y, para evitar el spam, sólo imprime los registros durante la primera prueba (véase la nota siguiente para las excepciones).
 
-If you would like to see every log for every test, run the tests, and open the browser console. If you prefer to use the browser console, and want it to mimic the freeCodeCamp console, place `console.clear()` before any other `console` calls, to clear the browser console.
+Si quieres ver todos los registros de cada prueba, ejecuta las pruebas y abre la consola del navegador. Si prefieres usar la consola del navegador, y quieres que imite la consola de freeCodeCamp, coloca `console.clear()` antes de cualquier otra llamada a `console`, para limpiar la consola del navegador.
 
-**Note:** `console.log`s inside functions are printed to the freeCodeCamp console whenever those functions are called, this can help debugging functions that are called during testing.
+**Nota: ** las funciones internas de `console.log` se imprimen en la consola de freeCodeCamp siempre que se llaman. Esto puede ayudar a depurar funciones que se llaman durante la prueba.
 
 # --instructions--
 
-First, use `console.log` to log the `output` variable. Then, use `console.clear` to clear the browser console.
+Primero, usa `console.log` para imprimir la variable `output`. Luego, usa `console.clear` para limpiar la consola del navegador.
 
 # --hints--
 
-You should use `console.clear()` to clear the browser console.
+Debes utilizar `console.clear()` para limpiar la consola del navegador.
 
 ```js
 assert(
@@ -38,7 +38,7 @@ assert(
 );
 ```
 
-You should use `console.log()` to print the `output` variable.
+Debes utilizar `console.log()` para imprimir la variable `output`.
 
 ```js
 assert(__helpers.removeWhiteSpace(code).match(/console\.log\(output\)/));

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

@@ -14,7 +14,7 @@ Puedes encontrar las herramientas para desarrolladores en el menú de Chrome o l
 
 El método `console.log()`, que "imprime" la salida de lo que está dentro de sus paréntesis a la consola, será probablemente la herramienta de depuración más útil. Colocarlo en puntos estratégicos de tu código puede mostrarte 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 lo que es. Tener puntos de control para ver el estado de tus cálculos a lo largo de tu código ayudará a acotar dónde está el problema.
 
-Este es un ejemplo para imprimir "Hello world!" en la consola:
+Aquí hay un ejemplo para imprimir la cadena `Hello world!` en la consola:
 
 `console.log('Hello world!');`
 

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

@@ -13,12 +13,14 @@ Puedes utilizar `typeof` para comprobar la estructura de datos, o tipo, de una v
 Aquí hay algunos ejemplos que utilizan `typeof`:
 
 ```js
-console.log(typeof ""); // outputs "string"
-console.log(typeof 0); // outputs "number"
-console.log(typeof []); // outputs "object"
-console.log(typeof {}); // outputs "object"
+console.log(typeof "");
+console.log(typeof 0);
+console.log(typeof []);
+console.log(typeof {});
 ```
 
+En orden, la consola mostrará las cadenas `string`, `number`, `object`, y `object`.
+
 JavaScript reconoce seis tipos de datos primitivos (inmutables): `Boolean`, `Null`, `Undefined`, `Number`, `String`, y `Symbol` (nuevo con ES6) y un tipo para elementos mutables: `Object`. Ten en cuenta que en JavaScript, los arreglos son técnicamente un tipo de objeto.
 
 # --instructions--