chore(i18n,curriculum): update translations (#44047)
This commit is contained in:
camperbot
GitHub
@ -1,6 +1,6 @@
|
||||
---
|
||||
id: 587d781b367417b2b2512abd
|
||||
title: Ajusta el tamaño de un título contra una etiqueta de párrafo
|
||||
title: Ajustar el tamaño de un elemento de encabezado frente a un elemento de párrafo
|
||||
challengeType: 0
|
||||
videoUrl: 'https://scrimba.com/c/c3bRPTz'
|
||||
forumTopicId: 301037
|
||||
@ -9,11 +9,11 @@ dashedName: adjust-the-size-of-a-heading-element-versus-a-paragraph-element
|
||||
|
||||
# --description--
|
||||
|
||||
El tamaño de fuente de las etiquetas de encabezado (`h1` a `h6`) generalmente debería ser mayor que el tamaño de fuente de las etiquetas de párrafos. Esto hace que sea más sencillo para que el usuario entienda visualmente el diseño y el nivel de importancia de cada elemento en la página. Utiliza la propiedad `font-size` para ajustar el tamaño del texto en un elemento.
|
||||
El tamaño de fuente de las etiquetas de encabezado (`h1` a `h6`) generalmente debe ser mayor que el tamaño de fuente de las etiquetas de párrafos. Esto hace que sea más sencillo para que el usuario entienda visualmente el diseño y el nivel de importancia de cada elemento en la página. Utiliza la propiedad `font-size` para ajustar el tamaño del texto en un elemento.
|
||||
|
||||
# --instructions--
|
||||
|
||||
Para que el encabezado sea significativamente más grande que el párrafo, cambia la etiqueta `font-size` de la etiqueta `h4` a 27 píxeles.
|
||||
Para que el encabezado sea significativamente más grande que el párrafo, cambia el `font-size` del elemento `h4` a 27 píxeles.
|
||||
|
||||
# --hints--
|
||||
|
||||
@ -116,3 +116,4 @@ assert($('h4').css('font-size') == '27px');
|
||||
</div>
|
||||
</div>
|
||||
```
|
||||
|
||||
|
||||
@ -49,13 +49,14 @@ assert(/processed\s*=\s*processArg\(\s*7\s*\)/.test(code));
|
||||
|
||||
```js
|
||||
// Setup
|
||||
var processed = 0;
|
||||
let processed = 0;
|
||||
|
||||
function processArg(num) {
|
||||
return (num + 3) / 5;
|
||||
}
|
||||
|
||||
// Only change code below this line
|
||||
|
||||
```
|
||||
|
||||
# --solutions--
|
||||
|
||||
@ -25,7 +25,7 @@ En orden, estas expresiones se evaluarían como `true`, `false`, `false`, `false
|
||||
|
||||
# --instructions--
|
||||
|
||||
Agrega el operador de desigualdad `!=` en la sentencia `if` para que la función devuelva la cadena `Not Equal` cuando `val` no sea equivalente a `99`
|
||||
Agrega el operador de desigualdad `!=` en la sentencia `if` para que la función devuelva la cadena `Not Equal` cuando `val` no sea equivalente a `99`.
|
||||
|
||||
# --hints--
|
||||
|
||||
|
||||
@ -26,7 +26,7 @@ En el segundo ejemplo, `3` es de tipo `Number` (número) y `'3'` es de tipo `Str
|
||||
|
||||
# --instructions--
|
||||
|
||||
Usa el operador de estricta igualdad en la sentencia `if` para que la función devuelva la cadena `Equal` cuando `val` sea estrictamente igual a `7`
|
||||
Usa el operador de estricta igualdad en la sentencia `if` para que la función devuelva la cadena `Equal` cuando `val` sea estrictamente igual a `7`.
|
||||
|
||||
# --hints--
|
||||
|
||||
|
||||
@ -22,7 +22,7 @@ En JavaScript, cuando el operador `+` se utiliza con un valor de cadena (`String
|
||||
Ejemplo:
|
||||
|
||||
```js
|
||||
var ourStr = "I come first. " + "I come second.";
|
||||
const ourStr = "I come first. " + "I come second.";
|
||||
```
|
||||
|
||||
La cadena `I come first. I come second.` se mostrará en la consola.
|
||||
@ -44,10 +44,10 @@ Debes usar el operador `+` para construir `myStr`.
|
||||
assert(code.match(/(["']).*\1\s*\+\s*(["']).*\2/g));
|
||||
```
|
||||
|
||||
`myStr` debe ser creada usando la palabra clave `var`.
|
||||
`myStr` debe ser creada usando la palabra clave `const`.
|
||||
|
||||
```js
|
||||
assert(/var\s+myStr/.test(code));
|
||||
assert(/const\s+myStr/.test(code));
|
||||
```
|
||||
|
||||
Debes asignar el resultado a la variable `myStr`.
|
||||
@ -73,11 +73,11 @@ assert(/myStr\s*=/.test(code));
|
||||
## --seed-contents--
|
||||
|
||||
```js
|
||||
var myStr; // Change this line
|
||||
const myStr = ""; // Change this line
|
||||
```
|
||||
|
||||
# --solutions--
|
||||
|
||||
```js
|
||||
var myStr = "This is the start. " + "This is the end.";
|
||||
const myStr = "This is the start. " + "This is the end.";
|
||||
```
|
||||
|
||||
@ -16,13 +16,14 @@ Para poder disminuirle dos cada iteración, necesitaremos cambiar nuestra inicia
|
||||
Empezaremos en `i = 10` e iteraremos mientras `i > 0`. Disminuiremos `i` en 2 por cada bucle con `i -= 2`.
|
||||
|
||||
```js
|
||||
var ourArray = [];
|
||||
for (var i = 10; i > 0; i -= 2) {
|
||||
const ourArray = [];
|
||||
|
||||
for (let i = 10; i > 0; i -= 2) {
|
||||
ourArray.push(i);
|
||||
}
|
||||
```
|
||||
|
||||
`ourArray` ahora contendrá `[10,8,6,4,2]`. Ahora cambiemos el valor de inicialización y la expresión final de nuestro bucle para que podamos contar hacia atrás de dos en dos y así crear un arreglo descendente de números impares.
|
||||
`ourArray` ahora contendrá `[10, 8, 6, 4, 2]`. Ahora cambiemos el valor de inicialización y la expresión final de nuestro bucle para que podamos contar hacia atrás de dos en dos y así crear un arreglo descendente de números impares.
|
||||
|
||||
# --instructions--
|
||||
|
||||
@ -42,7 +43,7 @@ Debes utilizar el método de arreglo `push`.
|
||||
assert(code.match(/myArray.push/));
|
||||
```
|
||||
|
||||
`myArray` debe ser igual a `[9,7,5,3,1]`.
|
||||
`myArray` debe ser igual a `[9, 7, 5, 3, 1]`.
|
||||
|
||||
```js
|
||||
assert.deepEqual(myArray, [9, 7, 5, 3, 1]);
|
||||
@ -60,16 +61,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 = 9; i > 0; i -= 2) {
|
||||
const myArray = [];
|
||||
for (let i = 9; i > 0; i -= 2) {
|
||||
myArray.push(i);
|
||||
}
|
||||
```
|
||||
|
||||
@ -1,6 +1,6 @@
|
||||
---
|
||||
id: 587d7b87367417b2b2512b41
|
||||
title: Declara una variable de sólo lectura con la palabra clave const
|
||||
title: Declara una variable de solo lectura con la palabra clave const
|
||||
challengeType: 1
|
||||
forumTopicId: 301201
|
||||
dashedName: declare-a-read-only-variable-with-the-const-keyword
|
||||
@ -8,9 +8,9 @@ dashedName: declare-a-read-only-variable-with-the-const-keyword
|
||||
|
||||
# --description--
|
||||
|
||||
La palabra clave `let` no es la única manera nueva de declarar variables. En ES6, tú puedes declarar variables usando la palabra clave `const`.
|
||||
La palabra clave `let` no es la única manera nueva de declarar variables. En ES6, tú también puedes declarar variables usando la palabra clave `const`.
|
||||
|
||||
`const` tiene todas las características increíbles que tiene `let`, con el bono añadido de que las variables declaradas usando `const` son de solo lectura. Son un valor constante, lo que significa que una vez que una variable es asignada con `const`, no se puede reasignar.
|
||||
`const` tiene todas las características increíbles que tiene `let`, con el bono añadido de que las variables declaradas usando `const` son de solo lectura. Son un valor constante, lo que significa que una vez que una variable es asignada con `const`, no se puede reasignar:
|
||||
|
||||
```js
|
||||
const FAV_PET = "Cats";
|
||||
@ -19,13 +19,15 @@ FAV_PET = "Dogs";
|
||||
|
||||
La consola mostrará un error debido a la reasignación del valor de `FAV_PET`.
|
||||
|
||||
Como puedes ver, intentar reasignar una variable declarada con `const` arrojará un error. Siempre debes nombrar variables que no quieras reasignar usando la palabra clave `const`. Esto ayuda cuando intentas reasignar accidentalmente una variable que está destinada a permanecer constante. Una práctica común al nombrar constantes es utilizar todas las letras en mayúsculas, con palabras separadas por un guion bajo.
|
||||
Siempre debes nombrar variables que no quieras reasignar usando la palabra clave `const`. Esto ayuda cuando intentas reasignar accidentalmente una variable que está destinada a permanecer constante.
|
||||
|
||||
**Nota:** Es común que los desarrolladores usen identificadores de variables en mayúsculas para valores inmutables y minúsculas o camelCase para valores mutables (objetos y arreglos). En un desafío posterior verás un ejemplo de un identificador de variable en minúsculas que se usa para un arreglo.
|
||||
Una práctica común al nombrar constantes es utilizar todas las letras en mayúsculas, con palabras separadas por un guion bajo.
|
||||
|
||||
**Nota:** Es común que los desarrolladores usen identificadores de variables en mayúsculas para valores inmutables y minúsculas o camelCase para valores mutables (objetos y arreglos). Aprenderás más sobre objetos, arreglos y valores inmutables y mutables en desafíos posteriores. También en desafíos posteriores, verás ejemplos de identificadores de variables mayúsculas, minúsculas o camelCase.
|
||||
|
||||
# --instructions--
|
||||
|
||||
Cambia el código para que todas las variables sean declaradas usando `let` o `const`. Usa `let` cuando quieras que la variable cambie y `const` cuando quieras que la variable permanezca constante. Además, renombra las variables declaradas con `const` para adaptarse a las prácticas comunes, lo que significa que las constantes deben estar todas en mayúsculas.
|
||||
Cambia el código para que todas las variables sean declaradas usando `let` o `const`. Usa `let` cuando quieras que la variable cambie, y `const` cuando quieras que la variable permanezca constante. Además, renombra las variables declaradas con `const` para adaptarse a las prácticas comunes, lo que significa que las constantes deben estar todas en mayúsculas.
|
||||
|
||||
# --hints--
|
||||
|
||||
@ -35,23 +37,33 @@ Cambia el código para que todas las variables sean declaradas usando `let` o `c
|
||||
(getUserInput) => assert(!getUserInput('index').match(/var/g));
|
||||
```
|
||||
|
||||
`SENTENCE` debe ser una variable constante declarada con `const`.
|
||||
Debes cambiar `fCC` todas a mayúsculas.
|
||||
|
||||
```js
|
||||
(getUserInput) => assert(getUserInput('index').match(/(const SENTENCE)/g));
|
||||
(getUserInput) => {
|
||||
assert(getUserInput('index').match(/(FCC)/));
|
||||
assert(!getUserInput('index').match(/fCC/));
|
||||
}
|
||||
```
|
||||
|
||||
`i` debe ser declarada con `let`.
|
||||
`FCC` debe ser una variable constante declarada con `const`.
|
||||
|
||||
```js
|
||||
(getUserInput) => assert(getUserInput('index').match(/(let i)/g));
|
||||
assert.equal(FCC, 'freeCodeCamp');
|
||||
assert.match(code, /const\s+FCC/);
|
||||
```
|
||||
|
||||
`console.log` debe cambiarse para imprimir la variable `SENTENCE`.
|
||||
`fact` debe ser declarada con `let`.
|
||||
|
||||
```js
|
||||
(getUserInput) => assert(getUserInput('index').match(/(let fact)/g));
|
||||
```
|
||||
|
||||
`console.log` debe cambiarse para imprimir las variables `FCC` y `fact`.
|
||||
|
||||
```js
|
||||
(getUserInput) =>
|
||||
assert(getUserInput('index').match(/console\.log\(\s*SENTENCE\s*\)\s*;?/g));
|
||||
assert(getUserInput('index').match(/console\.log\(\s*FCC\s*\,\s*fact\s*\)\s*;?/g));
|
||||
```
|
||||
|
||||
# --seed--
|
||||
@ -59,31 +71,21 @@ Cambia el código para que todas las variables sean declaradas usando `let` o `c
|
||||
## --seed-contents--
|
||||
|
||||
```js
|
||||
function printManyTimes(str) {
|
||||
// Only change code below this line
|
||||
var fCC = "freeCodeCamp";
|
||||
var fact = "is cool!";
|
||||
// Only change code above this line
|
||||
|
||||
// Only change code below this line
|
||||
|
||||
var sentence = str + " is cool!";
|
||||
for (var i = 0; i < str.length; i+=2) {
|
||||
console.log(sentence);
|
||||
}
|
||||
|
||||
// Only change code above this line
|
||||
|
||||
}
|
||||
printManyTimes("freeCodeCamp");
|
||||
fact = "is awesome!";
|
||||
console.log(fCC, fact);
|
||||
```
|
||||
|
||||
# --solutions--
|
||||
|
||||
```js
|
||||
function printManyTimes(str) {
|
||||
const FCC = "freeCodeCamp";
|
||||
let fact = "is cool!";
|
||||
|
||||
const SENTENCE = str + " is cool!";
|
||||
for (let i = 0; i < str.length; i+=2) {
|
||||
console.log(SENTENCE);
|
||||
}
|
||||
|
||||
}
|
||||
printManyTimes("freeCodeCamp");
|
||||
fact = "is awesome!";
|
||||
console.log(FCC, fact);
|
||||
```
|
||||
|
||||
@ -9,21 +9,27 @@ dashedName: declare-string-variables
|
||||
|
||||
# --description--
|
||||
|
||||
Anteriormente hemos usado el código
|
||||
Anteriormente utilizaste el siguiente código para declarar una variable:
|
||||
|
||||
```js
|
||||
var myName;
|
||||
```
|
||||
|
||||
Pero también puedes declarar una variable de cadena como esta:
|
||||
|
||||
```js
|
||||
var myName = "your name";
|
||||
```
|
||||
|
||||
`"your name"` es conocida como una <dfn>cadena</dfn> <dfn>literal</dfn>. Es una cadena porque es una serie de cero o más caracteres encerrados en comillas simples o dobles.
|
||||
`"your name"` es llamada una <dfn>cadena</dfn> <dfn>literal</dfn>. Una cadena literal o cadena es una serie de ceros o más caracteres encerrados en comillas simples o dobles.
|
||||
|
||||
# --instructions--
|
||||
|
||||
Crea dos nuevas variables de tipo cadena: `myFirstName`(miNombre) y `myLastName`(miApellido) y asígnales tu nombre y apellido, respectivamente.
|
||||
Crea dos nuevas variables de cadena: `myFirstName` y `myLastName` y asígnales los valores de tu nombre y apellido, respectivamente.
|
||||
|
||||
# --hints--
|
||||
|
||||
`myFirstName` debe ser una cadena con al menos un carácter.
|
||||
`myFirstName` debe ser una cadena con al menos un carácter en ella.
|
||||
|
||||
```js
|
||||
assert(
|
||||
|
||||
@ -8,32 +8,30 @@ dashedName: explore-differences-between-the-var-and-let-keywords
|
||||
|
||||
# --description--
|
||||
|
||||
Uno de los mayores problemas con la declaración de variables utilizando la palabra clave `var` es que tú puedes sobrescribir declaraciones de variables sin un error.
|
||||
Uno de los mayores problemas con la declaración de variables utilizando la palabra clave `var` es que tú puedes fácilmente sobrescribir declaraciones de variables:
|
||||
|
||||
```js
|
||||
var camper = 'James';
|
||||
var camper = 'David';
|
||||
var camper = "James";
|
||||
var camper = "David";
|
||||
console.log(camper);
|
||||
```
|
||||
|
||||
Aquí la consola mostrará la cadena de caracteres `David`.
|
||||
En el código anterior, la variable `camper` se declara originalmente como `James`, y se anula para ser `David`. La consola después muestra la cadena de texto `David`.
|
||||
|
||||
Como puedes ver en el código anterior, la variable `camper` es originalmente declarada como `James` luego de anularse pasa a ser `David`. En una aplicación pequeña, puede que no te topes con este tipo de problema, pero cuando tu código se vuelve mas grande, puede que accidentalmente sobrescribas una variable que no pretendías sobrescribir. Debido a que este comportamiento no arroja un error, buscar y corregir errores se vuelve mas difícil.
|
||||
Una nueva palabra clave llamada `let` que fue introducida en ES6 para resolver este posible problema con la palabra clave `var`. Si reemplazas `var` por `let` en las declaraciones de variables del código anterior, el resultado será un error.
|
||||
En una aplicación pequeña, tal vez no te encuentres con este tipo de problema. Pero a medida que tu código base se hace más grande, puedes ser que accidentalmente sobrescribas una variable que no tenías la intención de hacer. Debido a que este comportamiento no causa un error, la búsqueda y corrección de errores se vuelve más difícil.
|
||||
|
||||
Una palabra clave llamada `let` fue introducida en ES6, una actualización importante para JavaScript, para resolver este problema potencial con la palabra clave `var`. Aprenderás sobre otras características de ES6 en desafíos posteriores.
|
||||
|
||||
Si reemplazas `var` por `let` en el código anterior, resultará en un error:
|
||||
|
||||
```js
|
||||
let camper = 'James';
|
||||
let camper = 'David';
|
||||
let camper = "James";
|
||||
let camper = "David";
|
||||
```
|
||||
|
||||
Este error se puede ver en la consola de tu navegador. Así que a diferencia de `var`, al usar `let`, una variable con el mismo nombre solo puede declararse una vez. Toma en cuenta el `"use strict"` (uso estricto). Esto habilita el modo estricto, el cual captura errores comunes de programación y acciones "inseguras". Por ejemplo:
|
||||
El error se puede ver en tu consola de tu navegador.
|
||||
|
||||
```js
|
||||
"use strict";
|
||||
x = 3.14;
|
||||
```
|
||||
|
||||
Esto mostrará el error `x is not defined`.
|
||||
Así que a diferencia de `var`, al usar `let`, una variable con el mismo nombre solo puede declararse una vez.
|
||||
|
||||
# --instructions--
|
||||
|
||||
@ -53,10 +51,10 @@ Actualiza el código para que solo utilice la palabra clave `let`.
|
||||
assert(catName === 'Oliver');
|
||||
```
|
||||
|
||||
`quote` debe ser la cadena `Oliver says Meow!`
|
||||
`catSound` debe ser la cadena `Meow!`
|
||||
|
||||
```js
|
||||
assert(quote === 'Oliver says Meow!');
|
||||
assert(catSound === 'Meow!');
|
||||
```
|
||||
|
||||
# --seed--
|
||||
@ -64,28 +62,13 @@ assert(quote === 'Oliver says Meow!');
|
||||
## --seed-contents--
|
||||
|
||||
```js
|
||||
var catName;
|
||||
var quote;
|
||||
function catTalk() {
|
||||
"use strict";
|
||||
|
||||
catName = "Oliver";
|
||||
quote = catName + " says Meow!";
|
||||
|
||||
}
|
||||
catTalk();
|
||||
var catName = "Oliver";
|
||||
var catSound = "Meow!";
|
||||
```
|
||||
|
||||
# --solutions--
|
||||
|
||||
```js
|
||||
let catName;
|
||||
let quote;
|
||||
function catTalk() {
|
||||
'use strict';
|
||||
|
||||
catName = 'Oliver';
|
||||
quote = catName + ' says Meow!';
|
||||
}
|
||||
catTalk();
|
||||
let catName = "Oliver";
|
||||
let catSound = "Meow!";
|
||||
```
|
||||
|
||||
Reference in New Issue
Block a user