jprdonnelly/freeCodeCamp
1
0
Fork 0
mirror of https://github.com/freeCodeCamp/freeCodeCamp.git synced 2026-01-01 00:03:50 -05:00
Code Issues Projects Releases Wiki Activity

chore(i18n,learn): processed translations (#47510)

Browse Source 
* chore(i18n,learn): processed translations

* Update Ukrainian file to match state on crowdin

Co-authored-by: Ilenia <nethleen@gmail.com>
This commit is contained in:
camperbot
2022-09-14 22:00:37 +05:30
committed by GitHub
parent 7ce2179f2b
commit 408968f0b9
589 changed files with 29458 additions and 955 deletions
Download Patch File Download Diff File Expand all files Collapse all files

8
curriculum/challenges/espanol/02-javascript-algorithms-and-data-structures/basic-javascript/access-multi-dimensional-arrays-with-indexes.md
View File

@@ -21,12 +21,12 @@ const arr = [
[[10, 11, 12], 13, 14]
];
arr[3];
arr[3][0];
arr[3][0][1];
const subarray = arr[3];
const nestedSubarray = arr[3][0];
const element = arr[3][0][1];
```
`arr[3]` es `[[10, 11, 12], 13, 14]`, `arr[3][0]` es `[10, 11, 12]` y `arr[3][0][1]` es `11`.
En este ejemplo, `subarray` tiene el valor `[[10, 11, 12], 13, 14]`, `nestedSubarray` tiene el valor `[10, 11, 12]`, y `element` tiene el valor `11`.
**Nota:** No debe haber ningún espacio entre el nombre del arreglo y los corchetes, ni `array [0][0]` o `array [0] [0]` están permitidos. Aunque JavaScript pueda procesar esto correctamente, puedes confundir a otros programadores al leer tu código.

26
curriculum/challenges/espanol/02-javascript-algorithms-and-data-structures/basic-javascript/accessing-object-properties-with-variables.md
View File

@@ -27,29 +27,11 @@ console.log(myBreed);
La cadena `Doberman` se mostrará en la consola.
Otra forma de usar este concepto es cuando el nombre de la propiedad se recoge dinámicamente durante la ejecución del programa, de la siguiente manera:
```js
const someObj = {
propName: "John"
};
function propPrefix(str) {
const s = "prop";
return s + str;
}
const someProp = propPrefix("Name");
console.log(someObj[someProp]);
```
`someProp` tendrá una cadena con un valor `propName` y la cadena `John` se mostrará en la consola.
Ten en cuenta que *no* usamos comillas alrededor del nombre de la variable cuando la usamos para acceder a la propiedad porque utilizamos el *valor* de la variable, no el *nombre*.
Ten en cuenta que *no* utilizamos comillas alrededor del nombre de la variable cuando la usamos para acceder a la propiedad porque utilizamos el *valor* de la variable, no el *nombre*.
# --instructions--
Establece la variable `playerNumber` a `16`. Luego, usa la variable para buscar el nombre del jugador y asignarlo a `player`.
Asigna la variable `playerNumber` a `16`. Luego, usa la variable para buscar el nombre del jugador y asignarlo a `player`.
# --hints--
@@ -71,7 +53,7 @@ El valor de `player` debe ser la cadena `Montana`
assert(player === 'Montana');
```
Debes usar la notación de corchete para acceder a `testObj`
Debes usar la notación de corchetes para acceder a `testObj`
```js
assert(/testObj\s*?\[.*?\]/.test(code));
@@ -83,7 +65,7 @@ No debes asignar el valor de `Montana` a la variable `player` directamente.
assert(!code.match(/player\s*=\s*"|\'\s*Montana\s*"|\'\s*;/gi));
```
Debes usar la variable `playerNumber` en tu notación de corchete
Debes usar la variable `playerNumber` en tu notación de corchetes
```js
assert(/testObj\s*?\[\s*playerNumber\s*\]/.test(code));

2
curriculum/challenges/espanol/02-javascript-algorithms-and-data-structures/basic-javascript/assignment-with-a-returned-value.md
View File

@@ -9,7 +9,7 @@ dashedName: assignment-with-a-returned-value
# --description--
Si recuerdas de nuestra discusión sobre [almacenar valores con el operador de asignación](/learn/javascript-algorithms-and-data-structures/basic-javascript/storing-values-with-the-assignment-operator), todo a la derecha del signo de igualdad se resuelve antes de asignar el valor. Esto significa que podemos tomar el valor devuelto de una función y asignarlo a una variable.
Si recuerda nuestra discusión sobre <a href="/learn/javascript-algorithms-and-data-structures/basic-javascript/storing-values-with-the-assignment-operator" target="_blank" rel="noopener noreferrer nofollow">el almacenamiento de valores con el operador de asignación</a>, todo lo que está a la derecha del signo de igualdad se resuelve antes de asignar el valor. Esto significa que podemos tomar el valor devuelto de una función y asignarlo a una variable.
Supongamos que hemos predefinido una función `sum` que suma dos números juntos, entonces:

14
curriculum/challenges/espanol/02-javascript-algorithms-and-data-structures/basic-javascript/concatenating-strings-with-plus-operator.md
View File

@@ -25,26 +25,32 @@ Ejemplo:
const ourStr = "I come first. " + "I come second.";
```
La cadena `I come first. I come second.` se mostrará en la consola.
La cadena `I come first. I come second.` se mostraría en la consola.
# --instructions--
Construye `myStr` a partir de las cadenas `This is the start.` y `This is the end.` utilizando el operador `+`. Asegúrate de incluir un espacio entre las dos cadenas.
# --hints--
`myStr` debe tener una cadena con valor `This is the start. This is the end.`
`myStr` Debe tener un solo carácter de espacio entre las dos cadenas.
```js
assert(/start\. This/.test(myStr));
```
`myStr` debe tener un valor de la cadena `This is the start. This is the end.`
```js
assert(myStr === 'This is the start. This is the end.');
```
Debes usar el operador `+` para construir `myStr`.
Deberías usar el operador `+` para construir `myStr`.
```js
assert(code.match(/(["']).*\1\s*\+\s*(["']).*\2/g));
```
`myStr` debe ser creada usando la palabra clave `const`.
`myStr` Debe crearse una variable con la palabra reservada `const`.
```js
assert(/const\s+myStr/.test(code));

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

@@ -28,13 +28,19 @@ Construye `myStr` en varias líneas concatenando estas dos cadenas: `This is the
# --hints--
`myStr` debe tener una cadena con valor `This is the first sentence. This is the second sentence.`
`myStr` Debe tener un solo carácter de espacio entre las dos cadenas.
```js
assert(/sentence\. This/.test(myStr));
```
`myStr` Debe tener un valor de la cadena `This is the first sentence. This is the second sentence.`
```js
assert(myStr === 'This is the first sentence. This is the second sentence.');
```
Debes usar el operador `+=` para construir `myStr`.
Deberías usar el operador `+=` para construir `myStr`.
```js
assert(code.match(/myStr\s*\+=\s*(["']).*\1/g));

13
curriculum/challenges/espanol/02-javascript-algorithms-and-data-structures/basic-javascript/counting-cards.md
View File

@@ -25,6 +25,19 @@ NO incluyas comillas (individuales o dobles) en el resultado.
# --hints--
Su función debe devolver un valor para el conteo y el texto (`Bet` o `Hold`) con un carácter de espacio entre ellos.
```js
assert(//
(function () {
count = 0;
let out = cc(10);
const hasSpace = /-?\d+ (Bet|Hold)/.test('' + out);
return hasSpace;
})()
);
```
La secuencia de cartas 2, 3, 4, 5, 6 debe devolver la cadena `5 Bet`
```js

2
curriculum/challenges/espanol/02-javascript-algorithms-and-data-structures/basic-javascript/create-decimal-numbers-with-javascript.md
View File

@@ -11,7 +11,7 @@ dashedName: create-decimal-numbers-with-javascript
También podemos almacenar números decimales en variables. Los números decimales a veces se denominan números de <dfn>coma flotante</dfn> o <dfn>flotantes</dfn>.
**Nota:** computadoras representan números con precisión finita. Por eso las operaciones de punto flotante no pueden representar exactamente verdaderas operaciones aritméticas, y esto conduce a muchas situaciones sorprendentes. si te enfrentas con uno de estos problemas, abre el tema en el [foro de freeCodeCamp](https://forum.freecodecamp.org/).
**Nota:** cuando calculas números, se calculan con precisión finita. Las operaciones con puntos flotantes pueden producir resultados diferentes a los deseados. Si obtiene uno de estos resultados, abra un tema en el <a href="https://forum.freecodecamp.org/" target="_blank" rel="noopener noreferrer nofollow">foro de freeCodeCamp</a>.
# --instructions--

2
curriculum/challenges/espanol/02-javascript-algorithms-and-data-structures/basic-javascript/escaping-literal-quotes-in-strings.md
View File

@@ -39,7 +39,7 @@ Debes usar dos comillas dobles (`"`) y cuatro comillas dobles escapadas (`\"`).
assert(code.match(/\\"/g).length === 4 && code.match(/[^\\]"/g).length === 2);
```
La variable myStr debe contener la cadena: `I am a "double quoted" string inside "double quotes".`
La variable `myStr` debe contener la cadena: `I am a "double quoted" string inside "double quotes".`
```js
assert(/I am a "double quoted" string inside "double quotes(\."|"\.)$/.test(myStr));

2
curriculum/challenges/espanol/02-javascript-algorithms-and-data-structures/basic-javascript/generate-random-fractions-with-javascript.md
View File

@@ -13,7 +13,7 @@ Los números aleatorios son útiles para crear comportamientos aleatorios.
JavaScript tiene una función `Math.random()` que genera un número decimal aleatorio entre `0` (inclusivo) y `1` (exclusivo). Así que `Math.random()` puede devolver un `0` pero nunca devuelve un `1`.
**Nota:** Así como aprendimos en [almacenando valores con el operador de igualdad](/learn/javascript-algorithms-and-data-structures/basic-javascript/storing-values-with-the-assignment-operator), todas las llamadas de funciones se resolverán antes de que el `return` se ejecute, así que podemos devolver (`return`) el valor de la función `Math.random()`.
**Nota:** Al igual que el <a href="/learn/javascript-algorithms-and-data-structures/basic-javascript/storing-values-with-the-assignment-operator" target="_blank" rel="noopener noreferrer nofollow">almacenamiento de valores con el operador de asignación</a>, todas las llamadas a la función se resolverán antes de que se ejecute el `return`, por lo que el `return` devuelve el valor de la función `Math.random()`.
# --instructions--

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

@@ -17,7 +17,7 @@ Las variables que se declaran sin las palabras clave `let` o `const` se crean au
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 las palabras clave `let` o `const`.
Dentro de la función `fun1`, asigna `5` a `oopsGlobal` ***sin usar*** las palabras clave `var`, `let` o `const`.
# --hints--

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

@@ -21,7 +21,7 @@ do {
} while (i < 5);
```
El ejemplo anterior se comporta de forma similar a otros tipos de bucles, siendo el arreglo resultante `[0, 1, 2, 3, 4]`. Sin embargo, lo que hace que el bucle `do...while` sea diferente a otros bucles es cómo se comporta cuando la condición falla en la primera verificación. Veamos esto en acción: Aquí puedes ver un bucle `while` que ejecutará el código una y otra vez siempre que `i < 5`:
El ejemplo anterior se comporta de forma similar a otros tipos de bucles, siendo el arreglo resultante `[0, 1, 2, 3, 4]`. Sin embargo, lo que hace que el bucle `do...while` sea diferente a otros bucles es cómo se comporta cuando la condición falla en la primera verificación. Veamos esto en acción. Aquí hay un bucle `while` normal que ejecutara el código en el bucle mientras `i < 5`:
```js
const ourArray = [];

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

@@ -28,8 +28,8 @@ Lo anterior mostrará la cadena `Hello` en la consola y devolverá la cadena `Wo
Modifica la función `abTest` para que cuando `a` o `b` sean menores que `0` la función salga inmediatamente con un valor `undefined`.
**Sugerencia**
Recuerda que [`undefined` es una palabra clave](https://www.freecodecamp.org/learn/javascript-algorithms-and-data-structures/basic-javascript/understanding-uninitialized-variables), no una cadena.
**Pista**
Recuerda que <a href="https://www.freecodecamp.org/learn/javascript-algorithms-and-data-structures/basic-javascript/understanding-uninitialized-variables" target="_blank" rel="noopener noreferrer nofollow"><code>undefined</code> es una palabra clave</a>, no una cadena.
# --hints--

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

@@ -9,7 +9,7 @@ dashedName: returning-boolean-values-from-functions
# --description--
Podrás recordar que en [Comparación con el operador de igualdad](/learn/javascript-algorithms-and-data-structures/basic-javascript/comparison-with-the-equality-operator) todos los operadores de comparación devuelven un valor booleano `true`, o `false`.
Puede recordar de la <a href="/learn/javascript-algorithms-and-data-structures/basic-javascript/comparison-with-the-equality-operator" target="_blank" rel="noopener noreferrer nofollow">comparación con el operador de igualdad</a> que todos los operadores de comparación devuelven un valor booleano `true` o `false`.
A veces la gente usa una sentencia `if/else` para hacer una comparación, como esta:

2
curriculum/challenges/espanol/02-javascript-algorithms-and-data-structures/basic-javascript/use-recursion-to-create-a-countdown.md
View File

@@ -8,7 +8,7 @@ dashedName: use-recursion-to-create-a-countdown
# --description--
En el [desafío anterior](/learn/javascript-algorithms-and-data-structures/basic-javascript/replace-loops-using-recursion), aprendiste como usar la recursión para reemplazar un bucle `for`. Ahora, echemos un vistazo a una función más compleja que devuelve un arreglo de enteros consecutivos empezando con `1` hasta el número pasado a la función.
En un <a href="/learn/javascript-algorithms-and-data-structures/basic-javascript/replace-loops-using-recursion" target="_blank" rel="noopener noreferrer nofollow">reto anterior</a>, aprendiste a utilizar la recursividad para sustituir un bucle `for`. Ahora, echemos un vistazo a una función más compleja que devuelve un arreglo de enteros consecutivos empezando con `1` hasta el número pasado a la función.
Como se menciona en el desafío anterior, habrá un <dfn>caso base</dfn>. El caso base le dice a la función recursiva cuando no necesita llamarse a sí misma. Es un caso simple donde el valor de retorno ya se conoce. También habrá una <dfn>llamada recursiva</dfn> la cual ejecuta la función original con argumentos diferentes. Si la función se escribe correctamente, eventualmente el caso base será alcanzado.

8
curriculum/challenges/espanol/02-javascript-algorithms-and-data-structures/basic-javascript/using-objects-for-lookups.md
View File

@@ -25,14 +25,14 @@ const alpha = {
26:"A"
};
alpha[2];
alpha[24];
const thirdLetter = alpha[2];
const lastLetter = alpha[24];
const value = 2;
alpha[value];
const valueLookup = alpha[value];
```
`alpha[2]` es la cadena `Y`, `alpha[24]` es la cadena `C`, y `alpha[value]` es la cadena `Y`.
`thirdLetter` es la cadena `Y`, `lastLetter` es la cadena `C`, y `valueLookup` es la cadena `Y`.
# --instructions--

12
curriculum/challenges/espanol/02-javascript-algorithms-and-data-structures/basic-javascript/word-blanks.md
View File

@@ -9,11 +9,9 @@ dashedName: word-blanks
# --description--
Ahora vamos a usar nuestro conocimiento sobre cadenas para construir un juego de palabras estilo "Mad Libs" que llamaremos "Palabras en blanco". Crearás una frase (opcionalmente humorística) del estilo: Rellena los espacios vacíos.
Se te proporcionan oraciones con algunas palabras faltantes, como sustantivos, verbos, adjetivos y adverbios. Luego, completa las piezas que faltan con palabras de tu elección de una manera que la oración completa tenga sentido.
En un juego de "Mad Libs", se te proporcionan oraciones con algunas palabras faltantes, como sustantivos, verbos, adjetivos y adverbios. Luego, rellenas las piezas que faltan con palabras de tu elección de una manera que la frase completa tenga sentido.
Considera esta oración: It was really **\_\_\_\_**, and we **\_\_\_\_** ourselves **\_\_\_\_**. Esta oración tiene tres piezas faltantes: un adjetivo, un verbo y un adverbio, y podemos añadir palabras de nuestra elección para completarla. A continuación, podemos asignar la oración completa a una variable de la siguiente manera:
Considera esta oración: It was really **\_\_\_\_**, and we **\_\_\_\_** ourselves **\_\_\_\_**. Esta oración tiene tres piezas faltantes: un adjetivo, un verbo y un adverbio, y podemos añadir palabras de nuestra elección para completarla. Luego podemos asignar la oración completa a una variable de la siguiente manera:
```js
const sentence = "It was really " + "hot" + ", and we " + "laughed" + " ourselves " + "silly" + ".";
@@ -21,9 +19,9 @@ const sentence = "It was really " + "hot" + ", and we " + "laughed" + " ourselve
# --instructions--
En este desafío, te proporcionamos un sustantivo, un verbo, un adjetivo y un adverbio. Necesita formar una oración completa usando palabras de tu elección, junto con las palabras que te proporcionamos.
En este desafío, te proporcionamos un sustantivo, un verbo, un adjetivo y un adverbio. Necesitas formar una oración completa usando palabras de tu elección, junto con las palabras que te proporcionamos.
Necesitarás usar el operador de concatenación de cadenas `+` para construir una nueva cadena, usando las variables proporcionadas: `myNoun`, `myAdjective`, `myVerb`, y `myAdverb`. Luego asignarás la cadena formada a la variable `wordBlanks`. No debes cambiar las palabras asignadas a las variables.
Necesitarás usar el operador de concatenación de cadenas `+` para construir una nueva cadena, usando las variables proporcionadas: `myNoun`, `myAdjective`, `myVerb`, y `myAdverb`. A continuación, asignarás la cadena formada a la variable `wordBlanks`. No debes cambiar las palabras asignadas a las variables.
También tendrás que tener en cuenta los espacios en tu cadena, para que la frase final tenga espacios entre todas las palabras. El resultado debe ser una oración completa.
@@ -58,7 +56,7 @@ assert(
);
```
`wordBlanks` debe contener todas las palabras asignadas a las variables `myNoun`, `myVerb`, `myAdjective` y `myAdverb` separados por espacios (y cualquier palabra adicional en tu madlib).
`wordBlanks` debe contener todas las palabras asignadas a las variables `myNoun`, `myVerb`, `myAdjective` y `myAdverb` separadas por espacios (y cualquier palabra adicional a tu elección).
```js
assert(