feat: add Spanish and language parser
This commit is contained in:
Beau Carnes
committed by
mrugesh mohapatra
mrugesh mohapatra
parent
c2a45b58be
commit
e3f9dc4b86
@@ -1,21 +1,17 @@
|
||||
---
|
||||
id: a77dbc43c33f39daa4429b4f
|
||||
title: Boo who
|
||||
localeTitle: Boo quien
|
||||
isRequired: true
|
||||
challengeType: 5
|
||||
videoUrl: ''
|
||||
localeTitle: Boo quien
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
Compruebe si un valor está clasificado como un primitivo booleano. Devuelve verdadero o falso.
|
||||
Los primitivos booleanos son verdaderos y falsos.
|
||||
Recuerda usar <a href='http://forum.freecodecamp.org/t/how-to-get-help-when-you-are-stuck/19514' target='_blank'>Read-Search-Ask</a> si te atascas. Trate de emparejar el programa. Escribe tu propio código.
|
||||
</section>
|
||||
<section id="description"> Compruebe si un valor está clasificado como un primitivo booleano. Devuelve verdadero o falso. Los primitivos booleanos son verdaderos y falsos. Recuerda usar <a href="http://forum.freecodecamp.org/t/how-to-get-help-when-you-are-stuck/19514" target="_blank">Read-Search-Ask</a> si te atascas. Trate de emparejar el programa. Escribe tu propio código. </section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
|
||||
<section id="instructions">
|
||||
</section>
|
||||
|
||||
## Tests
|
||||
@@ -27,11 +23,11 @@ tests:
|
||||
testString: 'assert.strictEqual(booWho(true), true, "<code>booWho(true)</code> should return true.");'
|
||||
- text: <code>booWho(false)</code> debe devolver verdadero.
|
||||
testString: 'assert.strictEqual(booWho(false), true, "<code>booWho(false)</code> should return true.");'
|
||||
- text: ' <code>booWho([1, 2, 3])</code> debe devolver falso.'
|
||||
- text: '<code>booWho([1, 2, 3])</code> debe devolver falso.'
|
||||
testString: 'assert.strictEqual(booWho([1, 2, 3]), false, "<code>booWho([1, 2, 3])</code> should return false.");'
|
||||
- text: ' <code>booWho([].slice)</code> debe devolver falso.'
|
||||
- text: '<code>booWho([].slice)</code> debe devolver falso.'
|
||||
testString: 'assert.strictEqual(booWho([].slice), false, "<code>booWho([].slice)</code> should return false.");'
|
||||
- text: ' <code>booWho({ "a": 1 })</code> debe devolver falso.'
|
||||
- text: '<code>booWho({ "a": 1 })</code> debe devolver falso.'
|
||||
testString: 'assert.strictEqual(booWho({ "a": 1 }), false, "<code>booWho({ "a": 1 })</code> should return false.");'
|
||||
- text: <code>booWho(1)</code> debe devolver falso.
|
||||
testString: 'assert.strictEqual(booWho(1), false, "<code>booWho(1)</code> should return false.");'
|
||||
@@ -60,6 +56,7 @@ function booWho(bool) {
|
||||
}
|
||||
|
||||
booWho(null);
|
||||
|
||||
```
|
||||
|
||||
</div>
|
||||
@@ -71,13 +68,7 @@ booWho(null);
|
||||
## Solution
|
||||
<section id='solution'>
|
||||
|
||||
|
||||
```js
|
||||
function booWho(bool) {
|
||||
return typeof bool === "boolean";
|
||||
}
|
||||
|
||||
booWho(null);
|
||||
// solution required
|
||||
```
|
||||
|
||||
</section>
|
||||
|
||||
@@ -1,20 +1,17 @@
|
||||
---
|
||||
id: a9bd25c716030ec90084d8a1
|
||||
title: Chunky Monkey
|
||||
localeTitle: Mono grueso
|
||||
isRequired: true
|
||||
challengeType: 5
|
||||
videoUrl: ''
|
||||
localeTitle: Mono grueso
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
Escriba una función que divida una matriz (primer argumento) en grupos de la longitud del <code>size</code> (segundo argumento) y los devuelva como una matriz bidimensional.
|
||||
Recuerda usar <a href="http://forum.freecodecamp.org/t/how-to-get-help-when-you-are-stuck/19514" target="_blank">Read-Search-Ask</a> si te atascas. Escribe tu propio código.
|
||||
</section>
|
||||
<section id="description"> Escriba una función que divida una matriz (primer argumento) en grupos de la longitud del <code>size</code> (segundo argumento) y los devuelva como una matriz bidimensional. Recuerda usar <a href="http://forum.freecodecamp.org/t/how-to-get-help-when-you-are-stuck/19514" target="_blank">Read-Search-Ask</a> si te atascas. Escribe tu propio código. </section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
|
||||
<section id="instructions">
|
||||
</section>
|
||||
|
||||
## Tests
|
||||
@@ -22,19 +19,19 @@ Recuerda usar <a href="http://forum.freecodecamp.org/t/how-to-get-help-when-you-
|
||||
|
||||
```yml
|
||||
tests:
|
||||
- text: ' <code>chunkArrayInGroups(["a", "b", "c", "d"], 2)</code> debe devolver <code>[["a", "b"], ["c", "d"]]</code> .'
|
||||
- text: '<code>chunkArrayInGroups(["a", "b", "c", "d"], 2)</code> debe devolver <code>[["a", "b"], ["c", "d"]]</code> .'
|
||||
testString: 'assert.deepEqual(chunkArrayInGroups(["a", "b", "c", "d"], 2), [["a", "b"], ["c", "d"]], "<code>chunkArrayInGroups(["a", "b", "c", "d"], 2)</code> should return <code>[["a", "b"], ["c", "d"]]</code>.");'
|
||||
- text: ' <code>chunkArrayInGroups([0, 1, 2, 3, 4, 5], 3)</code> debe devolver <code>[[0, 1, 2], [3, 4, 5]]</code> .'
|
||||
- text: '<code>chunkArrayInGroups([0, 1, 2, 3, 4, 5], 3)</code> debe devolver <code>[[0, 1, 2], [3, 4, 5]]</code> .'
|
||||
testString: 'assert.deepEqual(chunkArrayInGroups([0, 1, 2, 3, 4, 5], 3), [[0, 1, 2], [3, 4, 5]], "<code>chunkArrayInGroups([0, 1, 2, 3, 4, 5], 3)</code> should return <code>[[0, 1, 2], [3, 4, 5]]</code>.");'
|
||||
- text: ' <code>chunkArrayInGroups([0, 1, 2, 3, 4, 5], 2)</code> debe devolver <code>[[0, 1], [2, 3], [4, 5]]</code> .'
|
||||
- text: '<code>chunkArrayInGroups([0, 1, 2, 3, 4, 5], 2)</code> debe devolver <code>[[0, 1], [2, 3], [4, 5]]</code> .'
|
||||
testString: 'assert.deepEqual(chunkArrayInGroups([0, 1, 2, 3, 4, 5], 2), [[0, 1], [2, 3], [4, 5]], "<code>chunkArrayInGroups([0, 1, 2, 3, 4, 5], 2)</code> should return <code>[[0, 1], [2, 3], [4, 5]]</code>.");'
|
||||
- text: ' <code>chunkArrayInGroups([0, 1, 2, 3, 4, 5], 4)</code> debe devolver <code>[[0, 1, 2, 3], [4, 5]]</code> .'
|
||||
- text: '<code>chunkArrayInGroups([0, 1, 2, 3, 4, 5], 4)</code> debe devolver <code>[[0, 1, 2, 3], [4, 5]]</code> .'
|
||||
testString: 'assert.deepEqual(chunkArrayInGroups([0, 1, 2, 3, 4, 5], 4), [[0, 1, 2, 3], [4, 5]], "<code>chunkArrayInGroups([0, 1, 2, 3, 4, 5], 4)</code> should return <code>[[0, 1, 2, 3], [4, 5]]</code>.");'
|
||||
- text: ' <code>chunkArrayInGroups([0, 1, 2, 3, 4, 5, 6], 3)</code> debe devolver <code>[[0, 1, 2], [3, 4, 5], [6]]</code> .'
|
||||
- text: '<code>chunkArrayInGroups([0, 1, 2, 3, 4, 5, 6], 3)</code> debe devolver <code>[[0, 1, 2], [3, 4, 5], [6]]</code> .'
|
||||
testString: 'assert.deepEqual(chunkArrayInGroups([0, 1, 2, 3, 4, 5, 6], 3), [[0, 1, 2], [3, 4, 5], [6]], "<code>chunkArrayInGroups([0, 1, 2, 3, 4, 5, 6], 3)</code> should return <code>[[0, 1, 2], [3, 4, 5], [6]]</code>.");'
|
||||
- text: ' <code>chunkArrayInGroups([0, 1, 2, 3, 4, 5, 6, 7, 8], 4)</code> debe devolver <code>[[0, 1, 2, 3], [4, 5, 6, 7], [8]]</code> . '
|
||||
- text: '<code>chunkArrayInGroups([0, 1, 2, 3, 4, 5, 6, 7, 8], 4)</code> debe devolver <code>[[0, 1, 2, 3], [4, 5, 6, 7], [8]]</code> .'
|
||||
testString: 'assert.deepEqual(chunkArrayInGroups([0, 1, 2, 3, 4, 5, 6, 7, 8], 4), [[0, 1, 2, 3], [4, 5, 6, 7], [8]], "<code>chunkArrayInGroups([0, 1, 2, 3, 4, 5, 6, 7, 8], 4)</code> should return <code>[[0, 1, 2, 3], [4, 5, 6, 7], [8]]</code>.");'
|
||||
- text: ' <code>chunkArrayInGroups([0, 1, 2, 3, 4, 5, 6, 7, 8], 2)</code> debe devolver <code>[[0, 1], [2, 3], [4, 5], [6, 7], [8]]</code> .
|
||||
- text: '<code>chunkArrayInGroups([0, 1, 2, 3, 4, 5, 6, 7, 8], 2)</code> debe devolver <code>[[0, 1], [2, 3], [4, 5], [6, 7], [8]]</code> .'
|
||||
testString: 'assert.deepEqual(chunkArrayInGroups([0, 1, 2, 3, 4, 5, 6, 7, 8], 2), [[0, 1], [2, 3], [4, 5], [6, 7], [8]], "<code>chunkArrayInGroups([0, 1, 2, 3, 4, 5, 6, 7, 8], 2)</code> should return <code>[[0, 1], [2, 3], [4, 5], [6, 7], [8]]</code>.");'
|
||||
|
||||
```
|
||||
@@ -53,6 +50,7 @@ function chunkArrayInGroups(arr, size) {
|
||||
}
|
||||
|
||||
chunkArrayInGroups(["a", "b", "c", "d"], 2);
|
||||
|
||||
```
|
||||
|
||||
</div>
|
||||
@@ -64,20 +62,7 @@ chunkArrayInGroups(["a", "b", "c", "d"], 2);
|
||||
## Solution
|
||||
<section id='solution'>
|
||||
|
||||
|
||||
```js
|
||||
function chunkArrayInGroups(arr, size) {
|
||||
let out = [];
|
||||
|
||||
for (let i = 0; i < arr.length; i += size) {
|
||||
out.push(arr.slice(i, i + size));
|
||||
}
|
||||
|
||||
return out;
|
||||
}
|
||||
|
||||
chunkArrayInGroups(["a", "b", "c", "d"], 2);
|
||||
|
||||
// solution required
|
||||
```
|
||||
|
||||
</section>
|
||||
|
||||
@@ -1,21 +1,17 @@
|
||||
---
|
||||
id: acda2fb1324d9b0fa741e6b5
|
||||
title: Confirm the Ending
|
||||
localeTitle: Confirmar el final
|
||||
isRequired: true
|
||||
challengeType: 5
|
||||
videoUrl: ''
|
||||
localeTitle: Confirmar el final
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
Compruebe si una cadena (primer argumento, <code>str</code> ) termina con la cadena de destino dada (segundo argumento, <code>target</code> ).
|
||||
Este desafío <em>se</em> puede resolver con el método <code>.endsWith()</code> , que se introdujo en ES2015. Pero para el propósito de este desafío, nos gustaría que utilices uno de los métodos de subcadena de JavaScript.
|
||||
Recuerda usar <a href="http://forum.freecodecamp.org/t/how-to-get-help-when-you-are-stuck/19514" target="_blank">Read-Search-Ask</a> si te atascas. Escribe tu propio código.
|
||||
</section>
|
||||
<section id="description"> Compruebe si una cadena (primer argumento, <code>str</code> ) termina con la cadena de destino dada (segundo argumento, <code>target</code> ). Este desafío <em>se</em> puede resolver con el método <code>.endsWith()</code> , que se introdujo en ES2015. Pero para el propósito de este desafío, nos gustaría que utilices uno de los métodos de subcadena de JavaScript. Recuerda usar <a href="http://forum.freecodecamp.org/t/how-to-get-help-when-you-are-stuck/19514" target="_blank">Read-Search-Ask</a> si te atascas. Escribe tu propio código. </section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
|
||||
<section id="instructions">
|
||||
</section>
|
||||
|
||||
## Tests
|
||||
@@ -23,25 +19,25 @@ Recuerda usar <a href="http://forum.freecodecamp.org/t/how-to-get-help-when-you-
|
||||
|
||||
```yml
|
||||
tests:
|
||||
- text: ' <code>confirmEnding("Bastian", "n")</code> debe devolver verdadero.'
|
||||
- text: '<code>confirmEnding("Bastian", "n")</code> debe devolver verdadero.'
|
||||
testString: 'assert(confirmEnding("Bastian", "n") === true, "<code>confirmEnding("Bastian", "n")</code> should return true.");'
|
||||
- text: ' <code>confirmEnding("Congratulation", "on")</code> debe devolver verdadero.'
|
||||
- text: '<code>confirmEnding("Congratulation", "on")</code> debe devolver verdadero.'
|
||||
testString: 'assert(confirmEnding("Congratulation", "on") === true, "<code>confirmEnding("Congratulation", "on")</code> should return true.");'
|
||||
- text: ' <code>confirmEnding("Connor", "n")</code> debe devolver falso.'
|
||||
- text: '<code>confirmEnding("Connor", "n")</code> debe devolver falso.'
|
||||
testString: 'assert(confirmEnding("Connor", "n") === false, "<code>confirmEnding("Connor", "n")</code> should return false.");'
|
||||
- text: ' <code>confirmEnding("Walking on water and developing software from a specification are easy if both are frozen", "specification")</code> debe devolver falso.
|
||||
- text: '<code>confirmEnding("Walking on water and developing software from a specification are easy if both are frozen", "specification")</code> debe devolver falso.'
|
||||
testString: 'assert(confirmEnding("Walking on water and developing software from a specification are easy if both are frozen", "specification") === false, "<code>confirmEnding("Walking on water and developing software from a specification are easy if both are frozen", "specification")</code> should return false.");'
|
||||
- text: ' <code>confirmEnding("He has to give me a new name", "name")</code> debe devolver verdadero.'
|
||||
- text: '<code>confirmEnding("He has to give me a new name", "name")</code> debe devolver verdadero.'
|
||||
testString: 'assert(confirmEnding("He has to give me a new name", "name") === true, "<code>confirmEnding("He has to give me a new name", "name")</code> should return true.");'
|
||||
- text: ' <code>confirmEnding("Open sesame", "same")</code> debe devolver verdadero.'
|
||||
- text: '<code>confirmEnding("Open sesame", "same")</code> debe devolver true.'
|
||||
testString: 'assert(confirmEnding("Open sesame", "same") === true, "<code>confirmEnding("Open sesame", "same")</code> should return true.");'
|
||||
- text: ' <code>confirmEnding("Open sesame", "pen")</code> debe devolver falso.
|
||||
- text: '<code>confirmEnding("Open sesame", "pen")</code> debe devolver falso.'
|
||||
testString: 'assert(confirmEnding("Open sesame", "pen") === false, "<code>confirmEnding("Open sesame", "pen")</code> should return false.");'
|
||||
- text: ' <code>confirmEnding("Open sesame", "game")</code> debe devolver falso.
|
||||
- text: '<code>confirmEnding("Open sesame", "game")</code> debe devolver falso.'
|
||||
testString: 'assert(confirmEnding("Open sesame", "game") === false, "<code>confirmEnding("Open sesame", "game")</code> should return false.");'
|
||||
- text: ' <code>confirmEnding("If you want to save our world, you must hurry. We dont know how much longer we can withstand the nothing", "mountain")</code> debería devolver el valor falso ".
|
||||
- text: '<code>confirmEnding("If you want to save our world, you must hurry. We dont know how much longer we can withstand the nothing", "mountain")</code> debería devolver el valor falso.'
|
||||
testString: 'assert(confirmEnding("If you want to save our world, you must hurry. We dont know how much longer we can withstand the nothing", "mountain") === false, "<code>confirmEnding("If you want to save our world, you must hurry. We dont know how much longer we can withstand the nothing", "mountain")</code> should return false.");'
|
||||
- text: ' <code>confirmEnding("Abstraction", "action")</code> debe devolver verdadero.'
|
||||
- text: '<code>confirmEnding("Abstraction", "action")</code> debe devolver verdadero.'
|
||||
testString: 'assert(confirmEnding("Abstraction", "action") === true, "<code>confirmEnding("Abstraction", "action")</code> should return true.");'
|
||||
- text: No use el método <code>.endsWith()</code> para resolver el desafío.
|
||||
testString: 'assert(!(/\.endsWith\(.*?\)\s*?;?/.test(code)) && !(/\["endsWith"\]/.test(code)), "Do not use the built-in method <code>.endsWith()</code> to solve the challenge.");'
|
||||
@@ -63,6 +59,7 @@ function confirmEnding(str, target) {
|
||||
}
|
||||
|
||||
confirmEnding("Bastian", "n");
|
||||
|
||||
```
|
||||
|
||||
</div>
|
||||
@@ -74,14 +71,7 @@ confirmEnding("Bastian", "n");
|
||||
## Solution
|
||||
<section id='solution'>
|
||||
|
||||
|
||||
```js
|
||||
function confirmEnding(str, target) {
|
||||
return str.substring(str.length - target.length) === target;
|
||||
}
|
||||
|
||||
confirmEnding("Bastian", "n");
|
||||
|
||||
// solution required
|
||||
```
|
||||
|
||||
</section>
|
||||
|
||||
@@ -1,21 +1,17 @@
|
||||
---
|
||||
id: 56533eb9ac21ba0edf2244b3
|
||||
title: Convert Celsius to Fahrenheit
|
||||
localeTitle: Convertir Celsius a Fahrenheit
|
||||
challengeType: 1
|
||||
isRequired: true
|
||||
videoUrl: ''
|
||||
localeTitle: Convertir Celsius a Fahrenheit
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
El algoritmo para convertir de Celsius a Fahrenheit es la temperatura en grados Celsius <code>9/5</code> , más <code>32</code> .
|
||||
Se le da una variable <code>celsius</code> representa una temperatura en grados centígrados. Use la variable <code>fahrenheit</code> ya definida y asígnele la temperatura Fahrenheit equivalente a la temperatura Celsius dada. Use el algoritmo mencionado anteriormente para ayudar a convertir la temperatura en grados Celsius a Fahrenheit.
|
||||
No se preocupe demasiado por la función y las declaraciones de devolución, ya que se cubrirán en futuros desafíos. Por ahora, solo utiliza operadores que ya hayas aprendido.
|
||||
</section>
|
||||
<section id="description"> El algoritmo para convertir de Celsius a Fahrenheit es la temperatura en grados Celsius <code>9/5</code> , más <code>32</code> . Te dan una variable <code>celsius</code> representa una temperatura en grados celsius. Use la variable <code>fahrenheit</code> ya definida y asígnele la temperatura Fahrenheit equivalente a la temperatura Celsius dada. Use el algoritmo mencionado anteriormente para ayudar a convertir la temperatura en grados Celsius a Fahrenheit. No se preocupe demasiado por la función y las declaraciones de devolución, ya que se cubrirán en futuros desafíos. Por ahora, solo utiliza operadores que ya hayas aprendido. </section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
|
||||
<section id="instructions">
|
||||
</section>
|
||||
|
||||
## Tests
|
||||
@@ -52,6 +48,7 @@ function convertToF(celsius) {
|
||||
}
|
||||
|
||||
convertToF(30);
|
||||
|
||||
```
|
||||
|
||||
</div>
|
||||
@@ -63,16 +60,7 @@ convertToF(30);
|
||||
## Solution
|
||||
<section id='solution'>
|
||||
|
||||
|
||||
```js
|
||||
function convertToF(celsius) {
|
||||
let fahrenheit = celsius * 9/5 + 32;
|
||||
|
||||
return fahrenheit;
|
||||
}
|
||||
|
||||
convertToF(30);
|
||||
|
||||
// solution required
|
||||
```
|
||||
|
||||
</section>
|
||||
|
||||
@@ -1,24 +1,17 @@
|
||||
---
|
||||
id: a302f7aae1aa3152a5b413bc
|
||||
title: Factorialize a Number
|
||||
localeTitle: Factorializar un número
|
||||
isRequired: true
|
||||
challengeType: 5
|
||||
videoUrl: ''
|
||||
localeTitle: Factorializar un número
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
Devuelve el factorial del entero proporcionado.
|
||||
Si el entero se representa con la letra n, un factorial es el producto de todos los enteros positivos menores o iguales a n.
|
||||
factoriales a menudo se representan con la notación abreviada <code>n!</code>
|
||||
Por ejemplo: <code>5! = 1 * 2 * 3 * 4 * 5 = 120</code>
|
||||
Solo se proporcionarán a la función números enteros mayores o iguales a cero.
|
||||
Recuerda usar <a href="http://forum.freecodecamp.org/t/how-to-get-help-when-you-are-stuck/19514" target="_blank">Read-Search-Ask</a> si te atascas. Escribe tu propio código.
|
||||
</section>
|
||||
<section id="description"> Devuelve el factorial del entero proporcionado. Si el número entero se representa con la letra n, un factorial es el producto de todos los números enteros positivos menores o iguales a n. Los factoriales a menudo se representan con la notación abreviada <code>n!</code> Por ejemplo: <code>5! = 1 * 2 * 3 * 4 * 5 = 120</code> Solo se proporcionarán a la función números enteros mayores o iguales a cero. Recuerda usar <a href="http://forum.freecodecamp.org/t/how-to-get-help-when-you-are-stuck/19514" target="_blank">Read-Search-Ask</a> si te atascas. Escribe tu propio código. </section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
|
||||
<section id="instructions">
|
||||
</section>
|
||||
|
||||
## Tests
|
||||
@@ -52,6 +45,7 @@ function factorialize(num) {
|
||||
}
|
||||
|
||||
factorialize(5);
|
||||
|
||||
```
|
||||
|
||||
</div>
|
||||
@@ -63,14 +57,7 @@ factorialize(5);
|
||||
## Solution
|
||||
<section id='solution'>
|
||||
|
||||
|
||||
```js
|
||||
function factorialize(num) {
|
||||
return num < 1 ? 1 : num * factorialize(num - 1);
|
||||
}
|
||||
|
||||
factorialize(5);
|
||||
|
||||
// solution required
|
||||
```
|
||||
|
||||
</section>
|
||||
|
||||
@@ -1,22 +1,17 @@
|
||||
---
|
||||
id: adf08ec01beb4f99fc7a68f2
|
||||
title: Falsy Bouncer
|
||||
localeTitle: Falsy Bouncer
|
||||
isRequired: true
|
||||
challengeType: 5
|
||||
videoUrl: ''
|
||||
localeTitle: Falsy Bouncer
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
Eliminar todos los valores falsos de una matriz.
|
||||
valores de <code>false</code> en JavaScript son <code>false</code> , <code>null</code> , <code>0</code> , <code>""</code> , <code>undefined</code> y <code>NaN</code> .
|
||||
Sugerencia: intente convertir cada valor a un booleano.
|
||||
Recuerda usar <a href="http://forum.freecodecamp.org/t/how-to-get-help-when-you-are-stuck/19514" target="_blank">Read-Search-Ask</a> si te atascas. Escribe tu propio código.
|
||||
</section>
|
||||
<section id="description"> Eliminar todos los valores falsos de una matriz. Los valores de <code>false</code> en JavaScript son <code>false</code> , <code>null</code> , <code>0</code> , <code>""</code> , <code>undefined</code> y <code>NaN</code> . Sugerencia: intente convertir cada valor a un booleano. Recuerda usar <a href="http://forum.freecodecamp.org/t/how-to-get-help-when-you-are-stuck/19514" target="_blank">Read-Search-Ask</a> si te atascas. Escribe tu propio código. </section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
|
||||
<section id="instructions">
|
||||
</section>
|
||||
|
||||
## Tests
|
||||
@@ -24,13 +19,13 @@ Recuerda usar <a href="http://forum.freecodecamp.org/t/how-to-get-help-when-you-
|
||||
|
||||
```yml
|
||||
tests:
|
||||
- text: ' <code>bouncer([7, "ate", "", false, 9])</code> debe devolver <code>[7, "ate", 9]</code> .'
|
||||
- text: '<code>bouncer([7, "ate", "", false, 9])</code> debe devolver <code>[7, "ate", 9]</code> .'
|
||||
testString: 'assert.deepEqual(bouncer([7, "ate", "", false, 9]), [7, "ate", 9], "<code>bouncer([7, "ate", "", false, 9])</code> should return <code>[7, "ate", 9]</code>.");'
|
||||
- text: ' <code>bouncer(["a", "b", "c"])</code> debe devolver <code>["a", "b", "c"]</code> .'
|
||||
- text: '<code>bouncer(["a", "b", "c"])</code> debe devolver <code>["a", "b", "c"]</code> .'
|
||||
testString: 'assert.deepEqual(bouncer(["a", "b", "c"]), ["a", "b", "c"], "<code>bouncer(["a", "b", "c"])</code> should return <code>["a", "b", "c"]</code>.");'
|
||||
- text: ' <code>bouncer([false, null, 0, NaN, undefined, ""])</code> debe devolver <code>[]</code> .'
|
||||
- text: '<code>bouncer([false, null, 0, NaN, undefined, ""])</code> debe devolver <code>[]</code> .'
|
||||
testString: 'assert.deepEqual(bouncer([false, null, 0, NaN, undefined, ""]), [], "<code>bouncer([false, null, 0, NaN, undefined, ""])</code> should return <code>[]</code>.");'
|
||||
- text: ' <code>bouncer([1, null, NaN, 2, undefined])</code> debe devolver <code>[1, 2]</code> .'
|
||||
- text: '<code>bouncer([1, null, NaN, 2, undefined])</code> debe devolver <code>[1, 2]</code> .'
|
||||
testString: 'assert.deepEqual(bouncer([1, null, NaN, 2, undefined]), [1, 2], "<code>bouncer([1, null, NaN, 2, undefined])</code> should return <code>[1, 2]</code>.");'
|
||||
|
||||
```
|
||||
@@ -49,6 +44,7 @@ function bouncer(arr) {
|
||||
}
|
||||
|
||||
bouncer([7, "ate", "", false, 9]);
|
||||
|
||||
```
|
||||
|
||||
</div>
|
||||
@@ -60,14 +56,7 @@ bouncer([7, "ate", "", false, 9]);
|
||||
## Solution
|
||||
<section id='solution'>
|
||||
|
||||
|
||||
```js
|
||||
function bouncer(arr) {
|
||||
return arr.filter(e => e);
|
||||
}
|
||||
|
||||
bouncer([7, "ate", "", false, 9]);
|
||||
|
||||
// solution required
|
||||
```
|
||||
|
||||
</section>
|
||||
|
||||
@@ -1,21 +1,17 @@
|
||||
---
|
||||
id: a26cbbe9ad8655a977e1ceb5
|
||||
title: Find the Longest Word in a String
|
||||
localeTitle: Encuentra la palabra más larga en una cadena
|
||||
isRequired: true
|
||||
challengeType: 5
|
||||
videoUrl: ''
|
||||
localeTitle: Encuentra la palabra más larga en una cadena
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
Devuelve la longitud de la palabra más larga en la oración provista.
|
||||
Tu respuesta debe ser un número.
|
||||
Recuerda usar <a href="http://forum.freecodecamp.org/t/how-to-get-help-when-you-are-stuck/19514" target="_blank">Read-Search-Ask</a> si te atascas. Escribe tu propio código.
|
||||
</section>
|
||||
<section id="description"> Devuelve la longitud de la palabra más larga en la oración provista. Tu respuesta debe ser un número. Recuerda usar <a href="http://forum.freecodecamp.org/t/how-to-get-help-when-you-are-stuck/19514" target="_blank">Read-Search-Ask</a> si te atascas. Escribe tu propio código. </section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
|
||||
<section id="instructions">
|
||||
</section>
|
||||
|
||||
## Tests
|
||||
@@ -51,6 +47,7 @@ function findLongestWordLength(str) {
|
||||
}
|
||||
|
||||
findLongestWordLength("The quick brown fox jumped over the lazy dog");
|
||||
|
||||
```
|
||||
|
||||
</div>
|
||||
@@ -62,14 +59,7 @@ findLongestWordLength("The quick brown fox jumped over the lazy dog");
|
||||
## Solution
|
||||
<section id='solution'>
|
||||
|
||||
|
||||
```js
|
||||
function findLongestWordLength(str) {
|
||||
return str.split(' ').sort((a, b) => b.length - a.length)[0].length;
|
||||
}
|
||||
|
||||
findLongestWordLength("The quick brown fox jumped over the lazy dog");
|
||||
|
||||
// solution required
|
||||
```
|
||||
|
||||
</section>
|
||||
|
||||
@@ -1,20 +1,17 @@
|
||||
---
|
||||
id: a6e40f1041b06c996f7b2406
|
||||
title: Finders Keepers
|
||||
localeTitle: Buscadores guardianes
|
||||
isRequired: true
|
||||
challengeType: 5
|
||||
videoUrl: ''
|
||||
localeTitle: Buscadores guardianes
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
Cree una función que examine una matriz (primer argumento) y devuelva el primer elemento de la matriz que pase una prueba de verdad (segundo argumento). Si ningún elemento pasa la prueba, devuelva indefinido.
|
||||
Recuerda usar <a href='http://forum.freecodecamp.org/t/how-to-get-help-when-you-are-stuck/19514' target='_blank'>Read-Search-Ask</a> si te atascas. Trate de emparejar el programa. Escribe tu propio código.
|
||||
</section>
|
||||
<section id="description"> Cree una función que examine una matriz (primer argumento) y devuelva el primer elemento de la matriz que pase una prueba de verdad (segundo argumento). Si ningún elemento pasa la prueba, devuelva indefinido. Recuerda usar <a href="http://forum.freecodecamp.org/t/how-to-get-help-when-you-are-stuck/19514" target="_blank">Read-Search-Ask</a> si te atascas. Trate de emparejar el programa. Escribe tu propio código. </section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
|
||||
<section id="instructions">
|
||||
</section>
|
||||
|
||||
## Tests
|
||||
@@ -22,9 +19,9 @@ Recuerda usar <a href='http://forum.freecodecamp.org/t/how-to-get-help-when-you-
|
||||
|
||||
```yml
|
||||
tests:
|
||||
- text: ' <code>findElement([1, 3, 5, 8, 9, 10], function(num) { return num % 2 === 0; })</code> debe devolver 8.'
|
||||
- text: '<code>findElement([1, 3, 5, 8, 9, 10], function(num) { return num % 2 === 0; })</code> debe devolver 8.'
|
||||
testString: 'assert.strictEqual(findElement([1, 3, 5, 8, 9, 10], function(num) { return num % 2 === 0; }), 8, "<code>findElement([1, 3, 5, 8, 9, 10], function(num) { return num % 2 === 0; })</code> should return 8.");'
|
||||
- text: ' <code>findElement([1, 3, 5, 9], function(num) { return num % 2 === 0; })</code> debe devolver undefined.'
|
||||
- text: '<code>findElement([1, 3, 5, 9], function(num) { return num % 2 === 0; })</code> debe devolver undefined.'
|
||||
testString: 'assert.strictEqual(findElement([1, 3, 5, 9], function(num) { return num % 2 === 0; }), undefined, "<code>findElement([1, 3, 5, 9], function(num) { return num % 2 === 0; })</code> should return undefined.");'
|
||||
|
||||
```
|
||||
@@ -43,6 +40,7 @@ function findElement(arr, func) {
|
||||
}
|
||||
|
||||
findElement([1, 2, 3, 4], num => num % 2 === 0);
|
||||
|
||||
```
|
||||
|
||||
</div>
|
||||
@@ -54,23 +52,7 @@ findElement([1, 2, 3, 4], num => num % 2 === 0);
|
||||
## Solution
|
||||
<section id='solution'>
|
||||
|
||||
|
||||
```js
|
||||
function findElement(arr, func) {
|
||||
let num;
|
||||
|
||||
arr.some(e => {
|
||||
if (func(e)) {
|
||||
num = e;
|
||||
return true;
|
||||
}
|
||||
});
|
||||
|
||||
return num;
|
||||
}
|
||||
|
||||
findElement([1, 2, 3, 4], num => num % 2 === 0);
|
||||
|
||||
// solution required
|
||||
```
|
||||
|
||||
</section>
|
||||
|
||||
@@ -1,23 +1,17 @@
|
||||
---
|
||||
id: af2170cad53daa0770fabdea
|
||||
title: Mutations
|
||||
localeTitle: Mutaciones
|
||||
isRequired: true
|
||||
challengeType: 5
|
||||
videoUrl: ''
|
||||
localeTitle: Mutaciones
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
Devuelva verdadero si la cadena en el primer elemento de la matriz contiene todas las letras de la cadena en el segundo elemento de la matriz.
|
||||
Por ejemplo, <code>["hello", "Hello"]</code> , debería devolver verdadero porque todas las letras en la segunda cadena están presentes en el primer caso, ignorando el caso.
|
||||
Los argumentos <code>["hello", "hey"]</code> deben devolver falso porque la cadena "hola" no contiene una "y".
|
||||
Por último, <code>["Alien", "line"]</code> , debe devolver verdadero porque todas las letras en "line" están presentes en "Alien".
|
||||
Recuerda usar <a href="http://forum.freecodecamp.org/t/how-to-get-help-when-you-are-stuck/19514" target="_blank">Read-Search-Ask</a> si te atascas. Escribe tu propio código.
|
||||
</section>
|
||||
<section id="description"> Devuelva verdadero si la cadena en el primer elemento de la matriz contiene todas las letras de la cadena en el segundo elemento de la matriz. Por ejemplo, <code>["hello", "Hello"]</code> , debería devolver verdadero porque todas las letras en la segunda cadena están presentes en la primera, ignorando el caso. Los argumentos <code>["hello", "hey"]</code> deben devolver falso porque la cadena "hola" no contiene una "y". Por último, <code>["Alien", "line"]</code> , debe devolver verdadero porque todas las letras en "line" están presentes en "Alien". Recuerda usar <a href="http://forum.freecodecamp.org/t/how-to-get-help-when-you-are-stuck/19514" target="_blank">Read-Search-Ask</a> si te atascas. Escribe tu propio código. </section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
|
||||
<section id="instructions">
|
||||
</section>
|
||||
|
||||
## Tests
|
||||
@@ -25,23 +19,23 @@ Recuerda usar <a href="http://forum.freecodecamp.org/t/how-to-get-help-when-you-
|
||||
|
||||
```yml
|
||||
tests:
|
||||
- text: ' <code>mutation(["hello", "hey"])</code> debe devolver falso.'
|
||||
- text: '<code>mutation(["hello", "hey"])</code> debe devolver falso.'
|
||||
testString: 'assert(mutation(["hello", "hey"]) === false, "<code>mutation(["hello", "hey"])</code> should return false.");'
|
||||
- text: ' <code>mutation(["hello", "Hello"])</code> debe devolver verdadero.'
|
||||
- text: '<code>mutation(["hello", "Hello"])</code> debe devolver verdadero.'
|
||||
testString: 'assert(mutation(["hello", "Hello"]) === true, "<code>mutation(["hello", "Hello"])</code> should return true.");'
|
||||
- text: ' <code>mutation(["zyxwvutsrqponmlkjihgfedcba", "qrstu"])</code> debe devolver verdadero.'
|
||||
- text: '<code>mutation(["zyxwvutsrqponmlkjihgfedcba", "qrstu"])</code> debe devolver verdadero.'
|
||||
testString: 'assert(mutation(["zyxwvutsrqponmlkjihgfedcba", "qrstu"]) === true, "<code>mutation(["zyxwvutsrqponmlkjihgfedcba", "qrstu"])</code> should return true.");'
|
||||
- text: 'la <code>mutation(["Mary", "Army"])</code> debería devolver la verdad.'
|
||||
- text: '<code>mutation(["Mary", "Army"])</code> debe devolver la verdad.'
|
||||
testString: 'assert(mutation(["Mary", "Army"]) === true, "<code>mutation(["Mary", "Army"])</code> should return true.");'
|
||||
- text: 'la <code>mutation(["Mary", "Aarmy"])</code> debe devolver la verdad.'
|
||||
- text: '<code>mutation(["Mary", "Aarmy"])</code> debe devolver la verdad.'
|
||||
testString: 'assert(mutation(["Mary", "Aarmy"]) === true, "<code>mutation(["Mary", "Aarmy"])</code> should return true.");'
|
||||
- text: ' <code>mutation(["Alien", "line"])</code> debe devolver true.'
|
||||
- text: '<code>mutation(["Alien", "line"])</code> debe devolver true.'
|
||||
testString: 'assert(mutation(["Alien", "line"]) === true, "<code>mutation(["Alien", "line"])</code> should return true.");'
|
||||
- text: ' <code>mutation(["floor", "for"])</code> debe devolver verdadero.'
|
||||
- text: '<code>mutation(["floor", "for"])</code> debe devolver verdadero.'
|
||||
testString: 'assert(mutation(["floor", "for"]) === true, "<code>mutation(["floor", "for"])</code> should return true.");'
|
||||
- text: ' <code>mutation(["hello", "neo"])</code> debe devolver falso.'
|
||||
- text: '<code>mutation(["hello", "neo"])</code> debe devolver falso.'
|
||||
testString: 'assert(mutation(["hello", "neo"]) === false, "<code>mutation(["hello", "neo"])</code> should return false.");'
|
||||
- text: ' <code>mutation(["voodoo", "no"])</code> debe devolver falso.'
|
||||
- text: '<code>mutation(["voodoo", "no"])</code> debe devolver falso.'
|
||||
testString: 'assert(mutation(["voodoo", "no"]) === false, "<code>mutation(["voodoo", "no"])</code> should return false.");'
|
||||
|
||||
```
|
||||
@@ -59,6 +53,7 @@ function mutation(arr) {
|
||||
}
|
||||
|
||||
mutation(["hello", "hey"]);
|
||||
|
||||
```
|
||||
|
||||
</div>
|
||||
@@ -70,18 +65,7 @@ mutation(["hello", "hey"]);
|
||||
## Solution
|
||||
<section id='solution'>
|
||||
|
||||
|
||||
```js
|
||||
function mutation(arr) {
|
||||
let hash = Object.create(null);
|
||||
|
||||
arr[0].toLowerCase().split('').forEach(c => hash[c] = true);
|
||||
|
||||
return !arr[1].toLowerCase().split('').filter(c => !hash[c]).length;
|
||||
}
|
||||
|
||||
mutation(["hello", "hey"]);
|
||||
|
||||
// solution required
|
||||
```
|
||||
|
||||
</section>
|
||||
|
||||
@@ -1,20 +1,17 @@
|
||||
---
|
||||
id: afcc8d540bea9ea2669306b6
|
||||
title: Repeat a String Repeat a String
|
||||
localeTitle: Repetir una cadena Repetir una cadena
|
||||
isRequired: true
|
||||
challengeType: 5
|
||||
videoUrl: ''
|
||||
localeTitle: Repetir una cadena Repetir una cadena
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
Repetir una determinada cadena <code>str</code> (primer argumento) para <code>num</code> veces (segundo argumento). Devuelve una cadena vacía si <code>num</code> no es un número positivo.
|
||||
Recuerda usar <a href="http://forum.freecodecamp.org/t/how-to-get-help-when-you-are-stuck/19514" target="_blank">Read-Search-Ask</a> si te atascas. Escribe tu propio código.
|
||||
</section>
|
||||
<section id="description"> Repetir una determinada cadena <code>str</code> (primer argumento) para <code>num</code> veces (segundo argumento). Devuelve una cadena vacía si <code>num</code> no es un número positivo. Recuerda usar <a href="http://forum.freecodecamp.org/t/how-to-get-help-when-you-are-stuck/19514" target="_blank">Read-Search-Ask</a> si te atascas. Escribe tu propio código. </section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
|
||||
<section id="instructions">
|
||||
</section>
|
||||
|
||||
## Tests
|
||||
@@ -22,17 +19,17 @@ Recuerda usar <a href="http://forum.freecodecamp.org/t/how-to-get-help-when-you-
|
||||
|
||||
```yml
|
||||
tests:
|
||||
- text: ' <code>repeatStringNumTimes("*", 3)</code> debe devolver <code>"***"</code> .'
|
||||
- text: '<code>repeatStringNumTimes("*", 3)</code> debe devolver <code>"***"</code> .'
|
||||
testString: 'assert(repeatStringNumTimes("*", 3) === "***", "<code>repeatStringNumTimes("*", 3)</code> should return <code>"***"</code>.");'
|
||||
- text: ' <code>repeatStringNumTimes("abc", 3)</code> debe devolver <code>"abcabcabc"</code> .'
|
||||
- text: '<code>repeatStringNumTimes("abc", 3)</code> debe devolver <code>"abcabcabc"</code> .'
|
||||
testString: 'assert(repeatStringNumTimes("abc", 3) === "abcabcabc", "<code>repeatStringNumTimes("abc", 3)</code> should return <code>"abcabcabc"</code>.");'
|
||||
- text: ' <code>repeatStringNumTimes("abc", 4)</code> debe devolver <code>"abcabcabcabc"</code> .'
|
||||
- text: '<code>repeatStringNumTimes("abc", 4)</code> debe devolver <code>"abcabcabcabc"</code> .'
|
||||
testString: 'assert(repeatStringNumTimes("abc", 4) === "abcabcabcabc", "<code>repeatStringNumTimes("abc", 4)</code> should return <code>"abcabcabcabc"</code>.");'
|
||||
- text: ' <code>repeatStringNumTimes("abc", 1)</code> debe devolver <code>"abc"</code> .'
|
||||
- text: '<code>repeatStringNumTimes("abc", 1)</code> debe devolver <code>"abc"</code> .'
|
||||
testString: 'assert(repeatStringNumTimes("abc", 1) === "abc", "<code>repeatStringNumTimes("abc", 1)</code> should return <code>"abc"</code>.");'
|
||||
- text: ' <code>repeatStringNumTimes("*", 8)</code> debe devolver <code>"********"</code> .'
|
||||
- text: '<code>repeatStringNumTimes("*", 8)</code> debe devolver <code>"********"</code> .'
|
||||
testString: 'assert(repeatStringNumTimes("*", 8) === "********", "<code>repeatStringNumTimes("*", 8)</code> should return <code>"********"</code>.");'
|
||||
- text: ' <code>repeatStringNumTimes("abc", -2)</code> debe devolver <code>""</code> .'
|
||||
- text: '<code>repeatStringNumTimes("abc", -2)</code> debe devolver <code>""</code> .'
|
||||
testString: 'assert(repeatStringNumTimes("abc", -2) === "", "<code>repeatStringNumTimes("abc", -2)</code> should return <code>""</code>.");'
|
||||
- text: El método <code>repeat()</code> incorporado no debe utilizarse
|
||||
testString: 'assert(!/\.repeat/g.test(code), "The built-in <code>repeat()</code>-method should not be used");'
|
||||
@@ -53,6 +50,7 @@ function repeatStringNumTimes(str, num) {
|
||||
}
|
||||
|
||||
repeatStringNumTimes("abc", 3);
|
||||
|
||||
```
|
||||
|
||||
</div>
|
||||
@@ -64,15 +62,7 @@ repeatStringNumTimes("abc", 3);
|
||||
## Solution
|
||||
<section id='solution'>
|
||||
|
||||
|
||||
```js
|
||||
function repeatStringNumTimes(str, num) {
|
||||
if (num < 0) return ";
|
||||
return num === 1 ? str : str + repeatStringNumTimes(str, num-1);
|
||||
}
|
||||
|
||||
repeatStringNumTimes("abc", 3);
|
||||
|
||||
// solution required
|
||||
```
|
||||
|
||||
</section>
|
||||
|
||||
@@ -1,21 +1,17 @@
|
||||
---
|
||||
id: a789b3483989747d63b0e427
|
||||
title: Return Largest Numbers in Arrays
|
||||
localeTitle: Devolver los números más grandes en matrices
|
||||
isRequired: true
|
||||
challengeType: 5
|
||||
videoUrl: ''
|
||||
localeTitle: Devolver los números más grandes en matrices
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
Devolver una matriz que consiste en el número más grande de cada sub-matriz proporcionada. Por simplicidad, la matriz provista contendrá exactamente 4 sub-matrices.
|
||||
Recuerde, puede recorrer una matriz con un simple bucle for, y acceder a cada miembro con sintaxis de matriz <code>arr[i]</code> .
|
||||
Recuerda usar <a href="http://forum.freecodecamp.org/t/how-to-get-help-when-you-are-stuck/19514" target="_blank">Read-Search-Ask</a> si te atascas. Escribe tu propio código.
|
||||
</section>
|
||||
<section id="description"> Devuelve una matriz que consiste en el número más grande de cada sub-matriz proporcionada. Por simplicidad, la matriz provista contendrá exactamente 4 sub-matrices. Recuerde, puede recorrer una matriz con un simple bucle for, y acceder a cada miembro con la sintaxis de matriz <code>arr[i]</code> . Recuerda usar <a href="http://forum.freecodecamp.org/t/how-to-get-help-when-you-are-stuck/19514" target="_blank">Read-Search-Ask</a> si te atascas. Escribe tu propio código. </section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
|
||||
<section id="instructions">
|
||||
</section>
|
||||
|
||||
## Tests
|
||||
@@ -23,13 +19,13 @@ Recuerda usar <a href="http://forum.freecodecamp.org/t/how-to-get-help-when-you-
|
||||
|
||||
```yml
|
||||
tests:
|
||||
- text: ' <code>largestOfFour([[4, 5, 1, 3], [13, 27, 18, 26], [32, 35, 37, 39], [1000, 1001, 857, 1]])</code> debe devolver una matriz. '
|
||||
- text: '<code>largestOfFour([[4, 5, 1, 3], [13, 27, 18, 26], [32, 35, 37, 39], [1000, 1001, 857, 1]])</code> debe devolver una matriz.'
|
||||
testString: 'assert(largestOfFour([[4, 5, 1, 3], [13, 27, 18, 26], [32, 35, 37, 39], [1000, 1001, 857, 1]]).constructor === Array, "<code>largestOfFour([[4, 5, 1, 3], [13, 27, 18, 26], [32, 35, 37, 39], [1000, 1001, 857, 1]])</code> should return an array.");'
|
||||
- text: ' <code>largestOfFour([[13, 27, 18, 26], [4, 5, 1, 3], [32, 35, 37, 39], [1000, 1001, 857, 1]])</code> debe devolver <code>[27, 5, 39, 1001]</code> .
|
||||
- text: '<code>largestOfFour([[13, 27, 18, 26], [4, 5, 1, 3], [32, 35, 37, 39], [1000, 1001, 857, 1]])</code> debe devolver <code>[27, 5, 39, 1001]</code> .'
|
||||
testString: 'assert.deepEqual(largestOfFour([[13, 27, 18, 26], [4, 5, 1, 3], [32, 35, 37, 39], [1000, 1001, 857, 1]]), [27, 5, 39, 1001], "<code>largestOfFour([[13, 27, 18, 26], [4, 5, 1, 3], [32, 35, 37, 39], [1000, 1001, 857, 1]])</code> should return <code>[27, 5, 39, 1001]</code>.");'
|
||||
- text: ' <code>largestOfFour([[4, 9, 1, 3], [13, 35, 18, 26], [32, 35, 97, 39], [1000000, 1001, 857, 1]])</code> debe devolver <code>[9, 35, 97, 1000000]</code> .
|
||||
- text: '<code>largestOfFour([[4, 9, 1, 3], [13, 35, 18, 26], [32, 35, 97, 39], [1000000, 1001, 857, 1]])</code> debe devolver <code>[9, 35, 97, 1000000]</code> .'
|
||||
testString: 'assert.deepEqual(largestOfFour([[4, 9, 1, 3], [13, 35, 18, 26], [32, 35, 97, 39], [1000000, 1001, 857, 1]]), [9, 35, 97, 1000000], "<code>largestOfFour([[4, 9, 1, 3], [13, 35, 18, 26], [32, 35, 97, 39], [1000000, 1001, 857, 1]])</code> should return <code>[9, 35, 97, 1000000]</code>.");'
|
||||
- text: ' <code>largestOfFour([[17, 23, 25, 12], [25, 7, 34, 48], [4, -10, 18, 21], [-72, -3, -17, -10]])</code> debe devolver <code>[25, 48, 21, -3]</code> . '
|
||||
- text: '<code>largestOfFour([[17, 23, 25, 12], [25, 7, 34, 48], [4, -10, 18, 21], [-72, -3, -17, -10]])</code> debe retorno <code>[25, 48, 21, -3]</code> .'
|
||||
testString: 'assert.deepEqual(largestOfFour([[17, 23, 25, 12], [25, 7, 34, 48], [4, -10, 18, 21], [-72, -3, -17, -10]]), [25, 48, 21, -3], "<code>largestOfFour([[17, 23, 25, 12], [25, 7, 34, 48], [4, -10, 18, 21], [-72, -3, -17, -10]])</code> should return <code>[25, 48, 21, -3]</code>.");'
|
||||
|
||||
```
|
||||
@@ -48,6 +44,7 @@ function largestOfFour(arr) {
|
||||
}
|
||||
|
||||
largestOfFour([[4, 5, 1, 3], [13, 27, 18, 26], [32, 35, 37, 39], [1000, 1001, 857, 1]]);
|
||||
|
||||
```
|
||||
|
||||
</div>
|
||||
@@ -59,14 +56,7 @@ largestOfFour([[4, 5, 1, 3], [13, 27, 18, 26], [32, 35, 37, 39], [1000, 1001, 85
|
||||
## Solution
|
||||
<section id='solution'>
|
||||
|
||||
|
||||
```js
|
||||
function largestOfFour(arr) {
|
||||
return arr.map(subArr => Math.max.apply(null, subArr));
|
||||
}
|
||||
|
||||
largestOfFour([[4, 5, 1, 3], [13, 27, 18, 26], [32, 35, 37, 39], [1000, 1001, 857, 1]]);
|
||||
|
||||
// solution required
|
||||
```
|
||||
|
||||
</section>
|
||||
|
||||
@@ -1,22 +1,17 @@
|
||||
---
|
||||
id: a202eed8fc186c8434cb6d61
|
||||
title: Reverse a String
|
||||
localeTitle: Revertir una cadena
|
||||
isRequired: true
|
||||
challengeType: 5
|
||||
videoUrl: ''
|
||||
localeTitle: Revertir una cadena
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
Invertir la cadena proporcionada.
|
||||
Es posible que deba convertir la cadena en una matriz antes de poder revertirla.
|
||||
Su resultado debe ser una cadena.
|
||||
Recuerda usar <a href="http://forum.freecodecamp.org/t/how-to-get-help-when-you-are-stuck/19514" target="_blank">Read-Search-Ask</a> si te atascas. Escribe tu propio código.
|
||||
</section>
|
||||
<section id="description"> Invierta la cadena provista. Es posible que deba convertir la cadena en una matriz antes de poder revertirla. Su resultado debe ser una cadena. Recuerda usar <a href="http://forum.freecodecamp.org/t/how-to-get-help-when-you-are-stuck/19514" target="_blank">Read-Search-Ask</a> si te atascas. Escribe tu propio código. </section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
|
||||
<section id="instructions">
|
||||
</section>
|
||||
|
||||
## Tests
|
||||
@@ -48,6 +43,7 @@ function reverseString(str) {
|
||||
}
|
||||
|
||||
reverseString("hello");
|
||||
|
||||
```
|
||||
|
||||
</div>
|
||||
@@ -59,14 +55,7 @@ reverseString("hello");
|
||||
## Solution
|
||||
<section id='solution'>
|
||||
|
||||
|
||||
```js
|
||||
function reverseString(str) {
|
||||
return str.split('').reverse().join('');
|
||||
}
|
||||
|
||||
reverseString("hello");
|
||||
|
||||
// solution required
|
||||
```
|
||||
|
||||
</section>
|
||||
|
||||
@@ -1,24 +1,18 @@
|
||||
---
|
||||
id: 579e2a2c335b9d72dd32e05c
|
||||
title: Slice and Splice
|
||||
localeTitle: Rebanada y empalme
|
||||
isRequired: true
|
||||
isBeta: true
|
||||
challengeType: 5
|
||||
videoUrl: ''
|
||||
localeTitle: Rebanada y empalme
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
Te dan dos matrices y un índice.
|
||||
Utilice la matriz métodos <code>slice</code> y <code>splice</code> para copiar cada elemento de la primera matriz en la segunda matriz, en orden.
|
||||
Comenzar a insertar elementos en el índice <code>n</code> de la segunda matriz.
|
||||
Devuelve la matriz resultante. Las matrices de entrada deben permanecer iguales después de que se ejecute la función.
|
||||
Recuerda usar <a href="http://forum.freecodecamp.org/t/how-to-get-help-when-you-are-stuck/19514" target="_blank">Read-Search-Ask</a> si te atascas. Escribe tu propio código.
|
||||
</section>
|
||||
<section id="description"> Te dan dos matrices y un índice. Utilizar los métodos de matriz <code>slice</code> y <code>splice</code> para copiar cada elemento de la primera matriz en la segunda matriz, en orden. Comience a insertar elementos en el índice <code>n</code> de la segunda matriz. Devuelve la matriz resultante. Las matrices de entrada deben permanecer iguales después de que se ejecute la función. Recuerda usar <a href="http://forum.freecodecamp.org/t/how-to-get-help-when-you-are-stuck/19514" target="_blank">Read-Search-Ask</a> si te atascas. Escribe tu propio código. </section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
|
||||
<section id="instructions">
|
||||
</section>
|
||||
|
||||
## Tests
|
||||
@@ -26,11 +20,11 @@ Recuerda usar <a href="http://forum.freecodecamp.org/t/how-to-get-help-when-you-
|
||||
|
||||
```yml
|
||||
tests:
|
||||
- text: ' <code>frankenSplice([1, 2, 3], [4, 5], 1)</code> debe devolver <code>[4, 1, 2, 3, 5]</code> .'
|
||||
- text: '<code>frankenSplice([1, 2, 3], [4, 5], 1)</code> debe devolver <code>[4, 1, 2, 3, 5]</code> .'
|
||||
testString: 'assert.deepEqual(frankenSplice([1, 2, 3], [4, 5], 1), [4, 1, 2, 3, 5], "<code>frankenSplice([1, 2, 3], [4, 5], 1)</code> should return <code>[4, 1, 2, 3, 5]</code>.");'
|
||||
- text: ' <code>frankenSplice([1, 2], ["a", "b"], 1)</code> debe devolver <code>["a", 1, 2, "b"]</code> .'
|
||||
- text: '<code>frankenSplice([1, 2], ["a", "b"], 1)</code> debe devolver <code>["a", 1, 2, "b"]</code> .'
|
||||
testString: 'assert.deepEqual(frankenSplice(testArr1, testArr2, 1), ["a", 1, 2, "b"], "<code>frankenSplice([1, 2], ["a", "b"], 1)</code> should return <code>["a", 1, 2, "b"]</code>.");'
|
||||
- text: ' <code>frankenSplice(["claw", "tentacle"], ["head", "shoulders", "knees", "toes"], 2)</code> debe devolver <code>["head", "shoulders", "claw", "tentacle", "knees", "toes"]</code> . '
|
||||
- text: '<code>frankenSplice(["claw", "tentacle"], ["head", "shoulders", "knees", "toes"], 2)</code> debe devolver <code>["head", "shoulders", "claw", "tentacle", "knees", "toes"]</code> .'
|
||||
testString: 'assert.deepEqual(frankenSplice(["claw", "tentacle"], ["head", "shoulders", "knees", "toes"], 2), ["head", "shoulders", "claw", "tentacle", "knees", "toes"], "<code>frankenSplice(["claw", "tentacle"], ["head", "shoulders", "knees", "toes"], 2)</code> should return <code>["head", "shoulders", "claw", "tentacle", "knees", "toes"]</code>.");'
|
||||
- text: Todos los elementos de la primera matriz se deben agregar a la segunda matriz en su orden original.
|
||||
testString: 'assert.deepEqual(frankenSplice([1, 2, 3, 4], [], 0), [1, 2, 3, 4], "All elements from the first array should be added to the second array in their original order.");'
|
||||
@@ -55,6 +49,7 @@ function frankenSplice(arr1, arr2, n) {
|
||||
}
|
||||
|
||||
frankenSplice([1, 2, 3], [4, 5, 6], 1);
|
||||
|
||||
```
|
||||
|
||||
</div>
|
||||
@@ -74,19 +69,7 @@ console.info('after the test');
|
||||
## Solution
|
||||
<section id='solution'>
|
||||
|
||||
|
||||
```js
|
||||
function frankenSplice(arr1, arr2, n) {
|
||||
// It's alive. It's alive!
|
||||
let result = arr2.slice();
|
||||
for (let i = 0; i < arr1.length; i++) {
|
||||
result.splice(n+i, 0, arr1[i]);
|
||||
}
|
||||
return result;
|
||||
}
|
||||
|
||||
frankenSplice([1, 2, 3], [4, 5], 1);
|
||||
|
||||
// solution required
|
||||
```
|
||||
|
||||
</section>
|
||||
|
||||
@@ -1,21 +1,17 @@
|
||||
---
|
||||
id: ab6137d4e35944e21037b769
|
||||
title: Title Case a Sentence
|
||||
localeTitle: Título Caso una oración
|
||||
isRequired: true
|
||||
challengeType: 5
|
||||
videoUrl: ''
|
||||
localeTitle: Título Caso una oración
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
Devuelva la cadena provista con la primera letra de cada palabra en mayúscula. Asegúrese de que el resto de la palabra esté en minúscula.
|
||||
A los efectos de este ejercicio, también debe poner mayúsculas en las palabras de conexión como "el" y "de".
|
||||
Recuerda usar <a href="http://forum.freecodecamp.org/t/how-to-get-help-when-you-are-stuck/19514" target="_blank">Read-Search-Ask</a> si te atascas. Escribe tu propio código.
|
||||
</section>
|
||||
<section id="description"> Devuelva la cadena provista con la primera letra de cada palabra en mayúscula. Asegúrese de que el resto de la palabra esté en minúscula. Para el propósito de este ejercicio, también debe usar mayúsculas para conectar palabras como "el" y "de". Recuerda usar <a href="http://forum.freecodecamp.org/t/how-to-get-help-when-you-are-stuck/19514" target="_blank">Read-Search-Ask</a> si te atascas. Escribe tu propio código. </section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
|
||||
<section id="instructions">
|
||||
</section>
|
||||
|
||||
## Tests
|
||||
@@ -23,9 +19,9 @@ Recuerda usar <a href="http://forum.freecodecamp.org/t/how-to-get-help-when-you-
|
||||
|
||||
```yml
|
||||
tests:
|
||||
- text: ' <code>titleCase("I'm a little tea pot")</code> debería devolver una cadena.'
|
||||
- text: '<code>titleCase("I'm a little tea pot")</code> debería devolver una cadena.'
|
||||
testString: 'assert(typeof titleCase("I"m a little tea pot") === "string", "<code>titleCase("I'm a little tea pot")</code> should return a string.");'
|
||||
- text: ' <code>titleCase("I'm a little tea pot")</code> debería devolver <code>I'm A Little Tea Pot</code> '
|
||||
- text: '<code>titleCase("I'm a little tea pot")</code> debería devolver <code>I'm A Little Tea Pot</code> .'
|
||||
testString: 'assert(titleCase("I"m a little tea pot") === "I"m A Little Tea Pot", "<code>titleCase("I'm a little tea pot")</code> should return <code>I'm A Little Tea Pot</code>.");'
|
||||
- text: <code>titleCase("sHoRt AnD sToUt")</code> debe devolver <code>Short And Stout</code> .
|
||||
testString: 'assert(titleCase("sHoRt AnD sToUt") === "Short And Stout", "<code>titleCase("sHoRt AnD sToUt")</code> should return <code>Short And Stout</code>.");'
|
||||
@@ -47,6 +43,7 @@ function titleCase(str) {
|
||||
}
|
||||
|
||||
titleCase("I'm a little tea pot");
|
||||
|
||||
```
|
||||
|
||||
</div>
|
||||
@@ -58,14 +55,7 @@ titleCase("I'm a little tea pot");
|
||||
## Solution
|
||||
<section id='solution'>
|
||||
|
||||
|
||||
```js
|
||||
function titleCase(str) {
|
||||
return str.split(' ').map(word => word.charAt(0).toUpperCase() + word.substring(1).toLowerCase()).join(' ');
|
||||
}
|
||||
|
||||
titleCase("I'm a little tea pot");
|
||||
|
||||
// solution required
|
||||
```
|
||||
|
||||
</section>
|
||||
|
||||
@@ -1,20 +1,17 @@
|
||||
---
|
||||
id: ac6993d51946422351508a41
|
||||
title: Truncate a String
|
||||
localeTitle: Truncar una cadena
|
||||
isRequired: true
|
||||
challengeType: 5
|
||||
videoUrl: ''
|
||||
localeTitle: Truncar una cadena
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
Truncar una cadena (primer argumento) si es más larga que la longitud de cadena máxima dada (segundo argumento). Devuelve la cadena truncada con un <code>...</code> final.
|
||||
Recuerda usar <a href="http://forum.freecodecamp.org/t/how-to-get-help-when-you-are-stuck/19514" target="_blank">Read-Search-Ask</a> si te atascas. Escribe tu propio código.
|
||||
</section>
|
||||
<section id="description"> Truncar una cadena (primer argumento) si es más larga que la longitud de cadena máxima dada (segundo argumento). Devuelve la cadena truncada con un <code>...</code> final. Recuerda usar <a href="http://forum.freecodecamp.org/t/how-to-get-help-when-you-are-stuck/19514" target="_blank">Read-Search-Ask</a> si te atascas. Escribe tu propio código. </section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
|
||||
<section id="instructions">
|
||||
</section>
|
||||
|
||||
## Tests
|
||||
@@ -22,17 +19,17 @@ Recuerda usar <a href="http://forum.freecodecamp.org/t/how-to-get-help-when-you-
|
||||
|
||||
```yml
|
||||
tests:
|
||||
- text: ' <code>truncateString("A-tisket a-tasket A green and yellow basket", 8)</code> debe devolver "A-tisket ...".'
|
||||
- text: '<code>truncateString("A-tisket a-tasket A green and yellow basket", 8)</code> debe devolver "A-tisket ...".'
|
||||
testString: 'assert(truncateString("A-tisket a-tasket A green and yellow basket", 8) === "A-tisket...", "<code>truncateString("A-tisket a-tasket A green and yellow basket", 8)</code> should return "A-tisket...".");'
|
||||
- text: ' <code>truncateString("Peter Piper picked a peck of pickled peppers", 11)</code> debería devolver "Peter Piper ...".
|
||||
- text: '<code>truncateString("Peter Piper picked a peck of pickled peppers", 11)</code> debe devolver "Peter Piper ...".'
|
||||
testString: 'assert(truncateString("Peter Piper picked a peck of pickled peppers", 11) === "Peter Piper...", "<code>truncateString("Peter Piper picked a peck of pickled peppers", 11)</code> should return "Peter Piper...".");'
|
||||
- text: ' <code>truncateString("A-tisket a-tasket A green and yellow basket", "A-tisket a-tasket A green and yellow basket".length)</code> debe devolver "A-tisket a-tasket Una canasta verde y amarilla".'
|
||||
- text: '<code>truncateString("A-tisket a-tasket A green and yellow basket", "A-tisket a-tasket A green and yellow basket".length)</code> debe devolver "A-tisket a-tasket Una canasta verde y amarilla".'
|
||||
testString: 'assert(truncateString("A-tisket a-tasket A green and yellow basket", "A-tisket a-tasket A green and yellow basket".length) === "A-tisket a-tasket A green and yellow basket", "<code>truncateString("A-tisket a-tasket A green and yellow basket", "A-tisket a-tasket A green and yellow basket".length)</code> should return "A-tisket a-tasket A green and yellow basket".");'
|
||||
- text: ' <code>truncateString("A-tisket a-tasket A green and yellow basket", "A-tisket a-tasket A green and yellow basket".length + 2)</code> debe devolver "A-tisket a-tasket Una canasta verde y amarilla" .
|
||||
- text: '<code>truncateString("A-tisket a-tasket A green and yellow basket", "A-tisket a-tasket A green and yellow basket".length + 2)</code> debe devolver "A-tisket a-tasket Una canasta verde y amarilla".'
|
||||
testString: 'assert(truncateString("A-tisket a-tasket A green and yellow basket", "A-tisket a-tasket A green and yellow basket".length + 2) === "A-tisket a-tasket A green and yellow basket", "<code>truncateString("A-tisket a-tasket A green and yellow basket", "A-tisket a-tasket A green and yellow basket".length + 2)</code> should return "A-tisket a-tasket A green and yellow basket".");'
|
||||
- text: ' <code>truncateString("A-", 1)</code> debe devolver "A ...".'
|
||||
- text: '<code>truncateString("A-", 1)</code> debe devolver "A ...".'
|
||||
testString: 'assert(truncateString("A-", 1) === "A...", "<code>truncateString("A-", 1)</code> should return "A...".");'
|
||||
- text: ' <code>truncateString("Absolutely Longer", 2)</code> debe devolver "Ab ...".'
|
||||
- text: '<code>truncateString("Absolutely Longer", 2)</code> debe devolver "Ab ...".'
|
||||
testString: 'assert(truncateString("Absolutely Longer", 2) === "Ab...", "<code>truncateString("Absolutely Longer", 2)</code> should return "Ab...".");'
|
||||
|
||||
```
|
||||
@@ -51,6 +48,7 @@ function truncateString(str, num) {
|
||||
}
|
||||
|
||||
truncateString("A-tisket a-tasket A green and yellow basket", 8);
|
||||
|
||||
```
|
||||
|
||||
</div>
|
||||
@@ -62,18 +60,7 @@ truncateString("A-tisket a-tasket A green and yellow basket", 8);
|
||||
## Solution
|
||||
<section id='solution'>
|
||||
|
||||
|
||||
```js
|
||||
function truncateString(str, num) {
|
||||
if (num >= str.length) {
|
||||
return str;
|
||||
}
|
||||
|
||||
return str.slice(0, num) + '...';
|
||||
}
|
||||
|
||||
truncateString("A-tisket a-tasket A green and yellow basket", 8);
|
||||
|
||||
// solution required
|
||||
```
|
||||
|
||||
</section>
|
||||
|
||||
@@ -1,22 +1,17 @@
|
||||
---
|
||||
id: a24c1a4622e3c05097f71d67
|
||||
title: Where do I Belong
|
||||
localeTitle: Dónde pertenezco
|
||||
isRequired: true
|
||||
challengeType: 5
|
||||
videoUrl: ''
|
||||
localeTitle: Dónde pertenezco
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
Devuelva el índice más bajo en el que se debe insertar un valor (segundo argumento) en una matriz (primer argumento) una vez que se haya ordenado. El valor devuelto debe ser un número.
|
||||
Por ejemplo, <code>getIndexToIns([1,2,3,4], 1.5)</code> debe devolver <code>1</code> porque es mayor que <code>1</code> (índice 0), pero menor que <code>2</code> (índice 1).
|
||||
Del mismo modo, <code>getIndexToIns([20,3,5], 19)</code> debe devolver <code>2</code> porque una vez que se ha ordenado la matriz se verá como <code>[3,5,20]</code> y <code>19</code> es menor que <code>20</code> (índice 2) y mayor que <code>5</code> (índice 1).
|
||||
Recuerda usar <a href="http://forum.freecodecamp.org/t/how-to-get-help-when-you-are-stuck/19514" target="_blank">Read-Search-Ask</a> si te atascas. Escribe tu propio código.
|
||||
</section>
|
||||
<section id="description"> Devuelve el índice más bajo en el que se debe insertar un valor (segundo argumento) en una matriz (primer argumento) una vez que se haya ordenado. El valor devuelto debe ser un número. Por ejemplo, <code>getIndexToIns([1,2,3,4], 1.5)</code> debe devolver <code>1</code> porque es mayor que <code>1</code> (índice 0), pero menor que <code>2</code> (índice 1). Del mismo modo, <code>getIndexToIns([20,3,5], 19)</code> debe devolver <code>2</code> porque una vez que se ha ordenado la matriz se verá como <code>[3,5,20]</code> y <code>19</code> es menor que <code>20</code> (índice 2) y mayor que <code>5</code> ( índice 1). Recuerda usar <a href="http://forum.freecodecamp.org/t/how-to-get-help-when-you-are-stuck/19514" target="_blank">Read-Search-Ask</a> si te atascas. Escribe tu propio código. </section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
|
||||
<section id="instructions">
|
||||
</section>
|
||||
|
||||
## Tests
|
||||
@@ -24,37 +19,37 @@ Recuerda usar <a href="http://forum.freecodecamp.org/t/how-to-get-help-when-you-
|
||||
|
||||
```yml
|
||||
tests:
|
||||
- text: ' <code>getIndexToIns([10, 20, 30, 40, 50], 35)</code> debe devolver <code>3</code> '
|
||||
- text: '<code>getIndexToIns([10, 20, 30, 40, 50], 35)</code> debe devolver <code>3</code> .'
|
||||
testString: 'assert(getIndexToIns([10, 20, 30, 40, 50], 35) === 3, "<code>getIndexToIns([10, 20, 30, 40, 50], 35)</code> should return <code>3</code>.");'
|
||||
- text: ' <code>getIndexToIns([10, 20, 30, 40, 50], 35)</code> debe devolver un número'
|
||||
- text: '<code>getIndexToIns([10, 20, 30, 40, 50], 35)</code> debe devolver un número.'
|
||||
testString: 'assert(typeof(getIndexToIns([10, 20, 30, 40, 50], 35)) === "number", "<code>getIndexToIns([10, 20, 30, 40, 50], 35)</code> should return a number.");'
|
||||
- text: ' <code>getIndexToIns([10, 20, 30, 40, 50], 30)</code> debe devolver <code>2</code> '
|
||||
- text: '<code>getIndexToIns([10, 20, 30, 40, 50], 30)</code> debe devolver <code>2</code> .'
|
||||
testString: 'assert(getIndexToIns([10, 20, 30, 40, 50], 30) === 2, "<code>getIndexToIns([10, 20, 30, 40, 50], 30)</code> should return <code>2</code>.");'
|
||||
- text: ' <code>getIndexToIns([10, 20, 30, 40, 50], 30)</code> debe devolver un número'
|
||||
- text: '<code>getIndexToIns([10, 20, 30, 40, 50], 30)</code> debe devolver un número.'
|
||||
testString: 'assert(typeof(getIndexToIns([10, 20, 30, 40, 50], 30)) === "number", "<code>getIndexToIns([10, 20, 30, 40, 50], 30)</code> should return a number.");'
|
||||
- text: ' <code>getIndexToIns([40, 60], 50)</code> debe devolver <code>1</code> '
|
||||
- text: '<code>getIndexToIns([40, 60], 50)</code> debe devolver <code>1</code> .'
|
||||
testString: 'assert(getIndexToIns([40, 60], 50) === 1, "<code>getIndexToIns([40, 60], 50)</code> should return <code>1</code>.");'
|
||||
- text: ' <code>getIndexToIns([40, 60], 50)</code> debe devolver un número.'
|
||||
- text: '<code>getIndexToIns([40, 60], 50)</code> debe devolver un número.'
|
||||
testString: 'assert(typeof(getIndexToIns([40, 60], 50)) === "number", "<code>getIndexToIns([40, 60], 50)</code> should return a number.");'
|
||||
- text: ' <code>getIndexToIns([3, 10, 5], 3)</code> debe devolver <code>0</code> '
|
||||
- text: '<code>getIndexToIns([3, 10, 5], 3)</code> debe devolver <code>0</code> .'
|
||||
testString: 'assert(getIndexToIns([3, 10, 5], 3) === 0, "<code>getIndexToIns([3, 10, 5], 3)</code> should return <code>0</code>.");'
|
||||
- text: ' <code>getIndexToIns([3, 10, 5], 3)</code> debe devolver un número'
|
||||
- text: '<code>getIndexToIns([3, 10, 5], 3)</code> debe devolver un número.'
|
||||
testString: 'assert(typeof(getIndexToIns([3, 10, 5], 3)) === "number", "<code>getIndexToIns([3, 10, 5], 3)</code> should return a number.");'
|
||||
- text: ' <code>getIndexToIns([5, 3, 20, 3], 5)</code> debe devolver <code>2</code> '
|
||||
- text: '<code>getIndexToIns([5, 3, 20, 3], 5)</code> debe devolver <code>2</code> .'
|
||||
testString: 'assert(getIndexToIns([5, 3, 20, 3], 5) === 2, "<code>getIndexToIns([5, 3, 20, 3], 5)</code> should return <code>2</code>.");'
|
||||
- text: ' <code>getIndexToIns([5, 3, 20, 3], 5)</code> debe devolver un número'
|
||||
- text: '<code>getIndexToIns([5, 3, 20, 3], 5)</code> debe devolver un número.'
|
||||
testString: 'assert(typeof(getIndexToIns([5, 3, 20, 3], 5)) === "number", "<code>getIndexToIns([5, 3, 20, 3], 5)</code> should return a number.");'
|
||||
- text: ' <code>getIndexToIns([2, 20, 10], 19)</code> debe devolver <code>2</code> '
|
||||
- text: '<code>getIndexToIns([2, 20, 10], 19)</code> debe devolver <code>2</code> .'
|
||||
testString: 'assert(getIndexToIns([2, 20, 10], 19) === 2, "<code>getIndexToIns([2, 20, 10], 19)</code> should return <code>2</code>.");'
|
||||
- text: ' <code>getIndexToIns([2, 20, 10], 19)</code> debe devolver un número'
|
||||
- text: '<code>getIndexToIns([2, 20, 10], 19)</code> debe devolver un número.'
|
||||
testString: 'assert(typeof(getIndexToIns([2, 20, 10], 19)) === "number", "<code>getIndexToIns([2, 20, 10], 19)</code> should return a number.");'
|
||||
- text: ' <code>getIndexToIns([2, 5, 10], 15)</code> debe devolver <code>3</code> '
|
||||
- text: '<code>getIndexToIns([2, 5, 10], 15)</code> debe devolver <code>3</code> .'
|
||||
testString: 'assert(getIndexToIns([2, 5, 10], 15) === 3, "<code>getIndexToIns([2, 5, 10], 15)</code> should return <code>3</code>.");'
|
||||
- text: ' <code>getIndexToIns([2, 5, 10], 15)</code> debe devolver un número'
|
||||
- text: '<code>getIndexToIns([2, 5, 10], 15)</code> debe devolver un número.'
|
||||
testString: 'assert(typeof(getIndexToIns([2, 5, 10], 15)) === "number", "<code>getIndexToIns([2, 5, 10], 15)</code> should return a number.");'
|
||||
- text: ' <code>getIndexToIns([], 1)</code> debe devolver <code>0</code> '
|
||||
- text: '<code>getIndexToIns([], 1)</code> debe devolver <code>0</code> .'
|
||||
testString: 'assert(getIndexToIns([], 1) === 0, "<code>getIndexToIns([], 1)</code> should return <code>0</code>.");'
|
||||
- text: ' <code>getIndexToIns([], 1)</code> debe devolver un número.'
|
||||
- text: '<code>getIndexToIns([], 1)</code> debe devolver un número.'
|
||||
testString: 'assert(typeof(getIndexToIns([], 1)) === "number", "<code>getIndexToIns([], 1)</code> should return a number.");'
|
||||
|
||||
```
|
||||
@@ -73,6 +68,7 @@ function getIndexToIns(arr, num) {
|
||||
}
|
||||
|
||||
getIndexToIns([40, 60], 50);
|
||||
|
||||
```
|
||||
|
||||
</div>
|
||||
@@ -84,22 +80,7 @@ getIndexToIns([40, 60], 50);
|
||||
## Solution
|
||||
<section id='solution'>
|
||||
|
||||
|
||||
```js
|
||||
function getIndexToIns(arr, num) {
|
||||
arr = arr.sort((a, b) => a - b);
|
||||
|
||||
for (let i = 0; i < arr.length; i++) {
|
||||
if (arr[i] >= num) {
|
||||
return i;
|
||||
}
|
||||
}
|
||||
|
||||
return arr.length;
|
||||
}
|
||||
|
||||
getIndexToIns([40, 60], 50);
|
||||
|
||||
// solution required
|
||||
```
|
||||
|
||||
</section>
|
||||
|
||||
@@ -1,22 +1,16 @@
|
||||
---
|
||||
id: 587d7b7d367417b2b2512b1d
|
||||
title: ' Iterate Through the Keys of an Object with a for...in Statement'
|
||||
localeTitle: 'Iterar a través de las claves de un objeto con una for ... in Statement'
|
||||
challengeType: 1
|
||||
videoUrl: ''
|
||||
localeTitle: Iterar a través de las claves de un objeto con una for ... in Statement
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
A veces es posible que deba recorrer todas las claves dentro de un objeto. Esto requiere una sintaxis específica en JavaScript llamada <dfn>for ... in</dfn> statement. Para el objeto de nuestros <code>users</code> , esto podría verse como:
|
||||
<blockquote>for (let user in users) {<br> console.log(user);<br>};<br><br>// logs:<br>Alan<br>Jeff<br>Sarah<br>Ryan</blockquote>
|
||||
En esta declaración, definimos una variable de <code>user</code> y, como puede ver, esta variable se restableció durante cada iteración de cada una de las claves del objeto a medida que la declaración se desplazaba a través del objeto, lo que daba como resultado que el nombre de cada usuario se imprimiera en la consola.
|
||||
<strong>NOTA:</strong> <br> Los objetos no mantienen un orden para las claves almacenadas como lo hacen las matrices; por lo tanto, una posición de las teclas en un objeto, o el orden relativo en el que aparece, es irrelevante cuando se hace referencia o se accede a esa tecla.
|
||||
</section>
|
||||
<section id="description"> A veces es posible que deba recorrer todas las claves dentro de un objeto. Esto requiere una sintaxis específica en JavaScript llamada <dfn>for ... in</dfn> statement. Para el objeto de nuestros <code>users</code> , esto podría verse como: <blockquote> para (dejar usuario en usuarios) { <br> console.log (usuario); <br> }; <br><br> // logs: <br> Alan <br> Jeff <br> Sarah <br> Ryan </blockquote> En esta declaración, definimos una variable de <code>user</code> y, como puede ver, esta variable se restableció durante cada iteración de cada una de las claves del objeto a medida que la declaración se desplazaba a través del objeto, lo que daba como resultado que el nombre de cada usuario se imprimiera en la consola. <strong>NOTA:</strong> <br> Los objetos no mantienen un orden para las claves almacenadas como lo hacen las matrices; por lo tanto, una posición de las teclas en un objeto, o el orden relativo en el que aparece, es irrelevante cuando se hace referencia o se accede a esa tecla. </section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
Hemos definido una función, <code>countOnline</code> ; use una instrucción <dfn>for ... in</dfn> dentro de esta función para recorrer los usuarios en el objeto de los <code>users</code> y devolver el número de usuarios cuya propiedad en <code>online</code> está establecida en <code>true</code> .
|
||||
</section>
|
||||
<section id="instructions"> Hemos definido una función, <code>countOnline</code> ; use una instrucción <dfn>for ... in</dfn> dentro de esta función para recorrer los usuarios en el objeto de los <code>users</code> y devolver el número de usuarios cuya propiedad en <code>online</code> está establecida en <code>true</code> . </section>
|
||||
|
||||
## Tests
|
||||
<section id='tests'>
|
||||
@@ -64,6 +58,7 @@ function countOnline(obj) {
|
||||
}
|
||||
|
||||
console.log(countOnline(users));
|
||||
|
||||
```
|
||||
|
||||
</div>
|
||||
|
||||
@@ -1,41 +1,29 @@
|
||||
---
|
||||
id: 5a661e0f1068aca922b3ef17
|
||||
title: Access an Array's Contents Using Bracket Notation
|
||||
localeTitle: Acceder a los contenidos de una matriz usando notación de corchete
|
||||
challengeType: 1
|
||||
videoUrl: ''
|
||||
localeTitle: Acceder a los contenidos de una matriz usando notación de corchete
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
La característica fundamental de cualquier estructura de datos es, por supuesto, la capacidad no solo de almacenar datos, sino también de poder recuperar esos datos en el comando. Entonces, ahora que hemos aprendido cómo crear una matriz, comencemos a pensar cómo podemos acceder a la información de esa matriz.
|
||||
Cuando definimos una matriz simple como se ve a continuación, hay 3 elementos en ella:
|
||||
<blockquote>let ourArray = ["a", "b", "c"];</blockquote>
|
||||
En una matriz, cada elemento de la matriz tiene un <dfn>índice</dfn> . Este índice se duplica como la posición de ese elemento en la matriz y cómo se hace referencia a él. Sin embargo, es importante tener en cuenta que las matrices de JavaScript tienen <dfn>un índice de cero</dfn> , lo que significa que el primer elemento de una matriz está en realidad en la posición <em><strong>cero</strong></em> , no en el primero.
|
||||
Para recuperar un elemento de una matriz, podemos encerrar un índice entre paréntesis y agregarlo al final de una matriz, o más comúnmente, a una variable que hace referencia a un objeto de matriz. Esto se conoce como <dfn>notación de corchete</dfn> .
|
||||
Por ejemplo, si queremos recuperar la <code>"a"</code> de <code>ourArray</code> y asignarla a una variable, podemos hacerlo con el siguiente código:
|
||||
<blockquote>let ourVariable = ourArray[0];<br>// ourVariable equals "a"</blockquote>
|
||||
Además de acceder al valor asociado a un índice, también puede <em>establecer</em> un índice en un valor usando la misma notación:
|
||||
<blockquote>ourArray[1] = "not b anymore";<br>// ourArray now equals ["a", "not b anymore", "c"];</blockquote>
|
||||
Usando la notación de corchetes, ahora hemos restablecido el elemento en el índice 1 de <code>"b"</code> , a <code>"not b anymore"</code> .
|
||||
</section>
|
||||
<section id="description"> La característica fundamental de cualquier estructura de datos es, por supuesto, la capacidad no solo de almacenar datos, sino también de poder recuperar esos datos en el comando. Entonces, ahora que hemos aprendido cómo crear una matriz, comencemos a pensar cómo podemos acceder a la información de esa matriz. Cuando definimos una matriz simple como se ve a continuación, hay 3 elementos en ella: <blockquote> deje que ourArray = ["a", "b", "c"]; </blockquote> En una matriz, cada elemento de la matriz tiene un <dfn>índice</dfn> . Este índice se duplica como la posición de ese elemento en la matriz y cómo se hace referencia a él. Sin embargo, es importante tener en cuenta que las matrices de JavaScript tienen <dfn>un índice de cero</dfn> , lo que significa que el primer elemento de una matriz está en realidad en la posición <em><strong>cero</strong></em> , no en el primero. Para recuperar un elemento de una matriz, podemos incluir un índice entre paréntesis y agregarlo al final de una matriz, o más comúnmente, a una variable que hace referencia a un objeto de matriz. Esto se conoce como <dfn>notación de corchete</dfn> . Por ejemplo, si queremos recuperar la <code>"a"</code> de <code>ourArray</code> y asignarla a una variable, podemos hacerlo con el siguiente código: <blockquote> deja que nuestra Variable = nuestroArray [0]; <br> // nuestra variable es igual a "a" </blockquote> Además de acceder al valor asociado a un índice, también puede <em>establecer</em> un índice en un valor utilizando la misma notación: <blockquote> ourArray [1] = "ya no b"; <br> // ourArray ahora es igual a ["a", "no b más", "c"]; </blockquote> Usando la notación de corchetes, ahora hemos restablecido el elemento en el índice 1 de <code>"b"</code> , a <code>"not b anymore"</code> . </section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
Para completar este desafío, establezca la segunda posición (índice <code>1</code> ) de <code>myArray</code> en cualquier cosa que desee, además de <code>"b"</code> .
|
||||
</section>
|
||||
<section id="instructions"> Para completar este desafío, establezca la segunda posición (índice <code>1</code> ) de <code>myArray</code> en cualquier cosa que desee, además de <code>"b"</code> . </section>
|
||||
|
||||
## Tests
|
||||
<section id='tests'>
|
||||
|
||||
```yml
|
||||
tests:
|
||||
- text: ' <code>myArray[0]</code> es igual a <code>"a"</code> '
|
||||
- text: '<code>myArray[0]</code> es igual a <code>"a"</code>'
|
||||
testString: 'assert.strictEqual(myArray[0], "a", "<code>myArray[0]</code> is equal to <code>"a"</code>");'
|
||||
- text: ' <code>myArray[1]</code> ya no está configurado en <code>"b"</code> '
|
||||
- text: '<code>myArray[1]</code> ya no está configurado en <code>"b"</code>'
|
||||
testString: 'assert.notStrictEqual(myArray[1], "b", "<code>myArray[1]</code> is no longer set to <code>"b"</code>");'
|
||||
- text: ' <code>myArray[2]</code> es igual a <code>"c"</code> '
|
||||
- text: '<code>myArray[2]</code> es igual a <code>"c"</code>'
|
||||
testString: 'assert.strictEqual(myArray[2], "c", "<code>myArray[2]</code> is equal to <code>"c"</code>");'
|
||||
- text: ' <code>myArray[3]</code> es igual a <code>"d"</code> '
|
||||
- text: '<code>myArray[3]</code> es igual a <code>"d"</code>'
|
||||
testString: 'assert.strictEqual(myArray[3], "d", "<code>myArray[3]</code> is equal to <code>"d"</code>");'
|
||||
|
||||
```
|
||||
@@ -53,6 +41,7 @@ let myArray = ["a", "b", "c", "d"];
|
||||
|
||||
//change code above this line
|
||||
console.log(myArray);
|
||||
|
||||
```
|
||||
|
||||
</div>
|
||||
|
||||
@@ -1,21 +1,16 @@
|
||||
---
|
||||
id: 587d7b7c367417b2b2512b1a
|
||||
title: Access Property Names with Bracket Notation
|
||||
localeTitle: Acceso a nombres de propiedades con notación de corchete
|
||||
challengeType: 1
|
||||
videoUrl: ''
|
||||
localeTitle: Acceso a nombres de propiedades con notación de corchete
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
En el primer desafío de objetos mencionamos el uso de la notación de corchetes como una forma de acceder a los valores de las propiedades mediante la evaluación de una variable. Por ejemplo, imagine que nuestro objeto de <code>foods</code> se está utilizando en un programa para una caja registradora de un supermercado. Tenemos alguna función que configura los <code>foods</code> <code>selectedFood</code> y queremos verificar el objeto de nuestros <code>foods</code> para detectar la presencia de ese alimento. Esto podría parecer:
|
||||
<blockquote>let selectedFood = getCurrentFood(scannedItem);<br>let inventory = foods[selectedFood];</blockquote>
|
||||
Este código evaluará el valor almacenado en la variable <code>selectedFood</code> y devolverá el valor de esa clave en el objeto de <code>foods</code> , o <code>undefined</code> si no está presente. La notación de corchetes es muy útil porque a veces las propiedades de los objetos no se conocen antes del tiempo de ejecución o necesitamos acceder a ellos de una manera más dinámica.
|
||||
</section>
|
||||
<section id="description"> En el primer desafío de objetos mencionamos el uso de la notación de corchetes como una forma de acceder a los valores de las propiedades mediante la evaluación de una variable. Por ejemplo, imagine que nuestro objeto de <code>foods</code> se está utilizando en un programa para una caja registradora de un supermercado. Tenemos alguna función que configura los <code>foods</code> <code>selectedFood</code> y queremos verificar el objeto de nuestros <code>foods</code> para detectar la presencia de ese alimento. Esto podría parecer: <blockquote> let selectedFood = getCurrentFood (scannedItem); <br> dejar inventario = alimentos [alimentos seleccionados]; </blockquote> Este código evaluará el valor almacenado en la variable <code>selectedFood</code> y devolverá el valor de esa clave en el objeto de <code>foods</code> , o <code>undefined</code> si no está presente. La notación de corchetes es muy útil porque a veces las propiedades de los objetos no se conocen antes del tiempo de ejecución o necesitamos acceder a ellos de una manera más dinámica. </section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
Hemos definido una función, <code>checkInventory</code> , que recibe un elemento escaneado como un argumento. Devuelve el valor actual de la clave <code>scannedItem</code> en el objeto de <code>foods</code> . Puede suponer que solo se proporcionarán claves válidas como argumento para <code>checkInventory</code> .
|
||||
</section>
|
||||
<section id="instructions"> Hemos definido una función, <code>checkInventory</code> , que recibe un elemento escaneado como un argumento. Devuelve el valor actual de la clave <code>scannedItem</code> en el objeto de <code>foods</code> . Puede suponer que solo se proporcionarán claves válidas como argumento para <code>checkInventory</code> . </section>
|
||||
|
||||
## Tests
|
||||
<section id='tests'>
|
||||
@@ -24,7 +19,7 @@ Hemos definido una función, <code>checkInventory</code> , que recibe un element
|
||||
tests:
|
||||
- text: <code>checkInventory</code> es una función
|
||||
testString: 'assert.strictEqual(typeof checkInventory, "function", "<code>checkInventory</code> is a function");'
|
||||
- text: 'El objeto de <code>foods</code> debe tener solo los siguientes pares clave-valor: <code>apples: 25</code> , <code>oranges: 32</code> , <code>plums: 28</code> , <code>bananas: 13</code> , <code>grapes: 35</code> , <code>strawberries: 27</code> '
|
||||
- text: 'El objeto de <code>foods</code> debe tener solo los siguientes pares clave-valor: <code>apples: 25</code> , <code>oranges: 32</code> , <code>plums: 28</code> , <code>bananas: 13</code> , <code>grapes: 35</code> , <code>strawberries: 27</code>'
|
||||
testString: 'assert.deepEqual(foods, {apples: 25, oranges: 32, plums: 28, bananas: 13, grapes: 35, strawberries: 27}, "The <code>foods</code> object should have only the following key-value pairs: <code>apples: 25</code>, <code>oranges: 32</code>, <code>plums: 28</code>, <code>bananas: 13</code>, <code>grapes: 35</code>, <code>strawberries: 27</code>");'
|
||||
- text: <code>checkInventory("apples")</code> debe devolver <code>25</code>
|
||||
testString: 'assert.strictEqual(checkInventory("apples"), 25, "<code>checkInventory("apples")</code> should return <code>25</code>");'
|
||||
@@ -60,6 +55,7 @@ function checkInventory(scannedItem) {
|
||||
|
||||
// change code below this line to test different cases:
|
||||
console.log(checkInventory("apples"));
|
||||
|
||||
```
|
||||
|
||||
</div>
|
||||
|
||||
@@ -1,29 +1,23 @@
|
||||
---
|
||||
id: 587d78b2367417b2b2512b0e
|
||||
title: Add Items to an Array with push() and unshift()
|
||||
localeTitle: Agregar elementos a una matriz con push () y unshift ()
|
||||
challengeType: 1
|
||||
videoUrl: ''
|
||||
localeTitle: Agregar elementos a una matriz con push () y unshift ()
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
La longitud de una matriz, como los tipos de datos que puede contener, no es fija. Las matrices se pueden definir con una longitud de cualquier número de elementos, y los elementos se pueden agregar o eliminar con el tiempo; en otras palabras, los arreglos son <dfn>mutables</dfn> . En este desafío, veremos dos métodos con los cuales podemos modificar mediante programación una matriz: <code>Array.push()</code> y <code>Array.unshift()</code> .
|
||||
Ambos métodos toman uno o más elementos como parámetros y agregan esos elementos a la matriz en la que se está utilizando el método; el método <code>push()</code> agrega elementos al final de una matriz, y <code>unshift()</code> agrega elementos al principio. Considera lo siguiente:
|
||||
<blockquote>let twentyThree = 'XXIII';<br>let romanNumerals = ['XXI', 'XXII'];<br><br>romanNumerals.unshift('XIX', 'XX');<br>// now equals ['XIX', 'XX', 'XXI', 'XXII']<br><br>romanNumerals.push(twentyThree);<br>// now equals ['XIX', 'XX', 'XXI', 'XXII', 'XXIII']
|
||||
Notice that we can also pass variables, which allows us even greater flexibility in dynamically modifying our array's data.
|
||||
</section>
|
||||
<section id="description"> La longitud de una matriz, como los tipos de datos que puede contener, no es fija. Las matrices se pueden definir con una longitud de cualquier número de elementos, y los elementos se pueden agregar o eliminar con el tiempo; en otras palabras, los arreglos son <dfn>mutables</dfn> . En este desafío, veremos dos métodos con los cuales podemos modificar mediante programación una matriz: <code>Array.push()</code> y <code>Array.unshift()</code> . Ambos métodos toman uno o más elementos como parámetros y agregan esos elementos a la matriz en la que se está utilizando el método; el método <code>push()</code> agrega elementos al final de una matriz, y <code>unshift()</code> agrega elementos al principio. Considera lo siguiente: <blockquote> dejemos veintitrés = 'XXIII'; <br> let romanNumerals = ['XXI', 'XXII']; <br><br> romanNumerals.unshift ('XIX', 'XX'); <br> // ahora es igual a ['XIX', 'XX', 'XXI', 'XXII'] <br><br> romanNumerals.push (veintitrés); <br> // ahora es igual a ['XIX', 'XX', 'XXI', 'XXII', 'XXIII'] Tenga en cuenta que también podemos pasar variables, lo que nos permite una mayor flexibilidad en la modificación dinámica de los datos de nuestra matriz. </blockquote></section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
Hemos definido una función, <code>mixedNumbers</code> , a la que le estamos pasando una matriz como argumento. Modifique la función utilizando <code>push()</code> y <code>unshift()</code> para agregar <code>'I', 2, 'three'</code> al principio de la matriz y <code>7, 'VIII', 9</code> al final para que la matriz devuelta contenga representaciones de los números 1-9 en orden.
|
||||
</section>
|
||||
<section id="instructions"> Hemos definido una función, <code>mixedNumbers</code> , a la que le estamos pasando una matriz como argumento. Modifique la función utilizando <code>push()</code> y <code>unshift()</code> para agregar <code>'I', 2, 'three'</code> al principio de la matriz y <code>7, 'VIII', 9</code> al final para que la matriz devuelta contenga representaciones de los números 1-9 en orden. </section>
|
||||
|
||||
## Tests
|
||||
<section id='tests'>
|
||||
|
||||
```yml
|
||||
tests:
|
||||
- text: ' <code>mixedNumbers(["IV", 5, "six"])</code> ahora debe devolver <code>["I", 2, "three", "IV", 5, "six", 7, "VIII", 9]</code> '
|
||||
- text: '<code>mixedNumbers(["IV", 5, "six"])</code> ahora deben devolver <code>["I", 2, "three", "IV", 5, "six", 7, "VIII", 9]</code>'
|
||||
testString: 'assert.deepEqual(mixedNumbers(["IV", 5, "six"]), ["I", 2, "three", "IV", 5, "six", 7, "VIII", 9], "<code>mixedNumbers(["IV", 5, "six"])</code> should now return <code>["I", 2, "three", "IV", 5, "six", 7, "VIII", 9]</code>");'
|
||||
- text: La función <code>mixedNumbers</code> debe utilizar el método <code>push()</code>
|
||||
testString: 'assert.notStrictEqual(mixedNumbers.toString().search(/\.push\(/), -1, "The <code>mixedNumbers</code> function should utilize the <code>push()</code> method");'
|
||||
@@ -49,6 +43,7 @@ function mixedNumbers(arr) {
|
||||
|
||||
// do not change code below this line
|
||||
console.log(mixedNumbers(['IV', 5, 'six']));
|
||||
|
||||
```
|
||||
|
||||
</div>
|
||||
|
||||
@@ -1,28 +1,23 @@
|
||||
---
|
||||
id: 587d78b3367417b2b2512b11
|
||||
title: Add Items Using splice()
|
||||
localeTitle: Agregar artículos usando splice ()
|
||||
challengeType: 1
|
||||
videoUrl: ''
|
||||
localeTitle: Agregar artículos usando splice ()
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
Recuerda que en el último desafío mencionamos que <code>splice()</code> puede tomar hasta tres parámetros? Bueno, podemos ir un paso más allá con <code>splice()</code> ; además de eliminar elementos, podemos usar ese tercer parámetro, que representa uno o más elementos, para <em>agregarlos</em> también. Esto puede ser increíblemente útil para cambiar rápidamente un elemento, o un conjunto de elementos, por otro. Por ejemplo, supongamos que está almacenando una combinación de colores para un conjunto de elementos DOM en una matriz, y desea cambiar dinámicamente un color en función de alguna acción:
|
||||
<blockquote>function colorChange(arr, index, newColor) {<br> arr.splice(index, 1, newColor);<br> return arr;<br>}<br><br>let colorScheme = ['#878787', '#a08794', '#bb7e8c', '#c9b6be', '#d1becf'];<br><br>colorScheme = colorChange(colorScheme, 2, '#332327');<br>// we have removed '#bb7e8c' and added '#332327' in its place<br>// colorScheme now equals ['#878787', '#a08794', '#332327', '#c9b6be', '#d1becf']</blockquote>
|
||||
Esta función toma una matriz de valores hexadecimales, un índice para eliminar un elemento y el nuevo color para reemplazar el elemento eliminado. El valor de retorno es una matriz que contiene un esquema de color recién modificado. Si bien este ejemplo está un poco simplificado, podemos ver el valor que puede tener el uso de <code>splice()</code> en su potencial máximo.
|
||||
</section>
|
||||
<section id="description"> ¿Recuerda que en el último desafío mencionamos que <code>splice()</code> puede tomar hasta tres parámetros? Bueno, podemos ir un paso más allá con <code>splice()</code> ; además de eliminar elementos, podemos usar ese tercer parámetro, que representa uno o más elementos, para <em>agregarlos</em> también. Esto puede ser increíblemente útil para cambiar rápidamente un elemento, o un conjunto de elementos, por otro. Por ejemplo, digamos que está almacenando una combinación de colores para un conjunto de elementos DOM en una matriz, y desea cambiar dinámicamente un color en función de alguna acción: <blockquote> función colorCambiar (arr, index, newColor) { <br> arr.splice (index, 1, newColor); <br> volver arr; <br> } <br><br> vamos colorScheme = ['# 878787', '# a08794', '# bb7e8c', '# c9b6be', '# d1becf']; <br><br> colorScheme = colorChange (colorScheme, 2, '# 332327'); <br> // eliminamos '# bb7e8c' y agregamos '# 332327' en su lugar <br> // colorScheme ahora es igual a ['# 878787', '# a08794', '# 332327', '# c9b6be', '# d1becf'] </blockquote> Esta función toma una matriz de valores hexadecimales, un índice para eliminar un elemento y el nuevo color para reemplazar el elemento eliminado. El valor de retorno es una matriz que contiene un esquema de color recién modificado. Si bien este ejemplo está un poco simplificado, podemos ver el valor que puede tener el uso de <code>splice()</code> en su potencial máximo. </section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
Hemos definido una función, <code>htmlColorNames</code> , que toma una matriz de colores HTML como argumento. Modifique la función utilizando <code>splice()</code> para eliminar los dos primeros elementos de la matriz y agregue <code>'DarkSalmon'</code> y <code>'BlanchedAlmond'</code> en sus respectivos lugares.
|
||||
</section>
|
||||
<section id="instructions"> Hemos definido una función, <code>htmlColorNames</code> , que toma una matriz de colores HTML como un argumento. Modifique la función utilizando <code>splice()</code> para eliminar los dos primeros elementos de la matriz y agregue <code>'DarkSalmon'</code> y <code>'BlanchedAlmond'</code> en sus respectivos lugares. </section>
|
||||
|
||||
## Tests
|
||||
<section id='tests'>
|
||||
|
||||
```yml
|
||||
tests:
|
||||
- text: ' <code>htmlColorNames</code> debería devolver <code>["DarkSalmon", "BlanchedAlmond", "LavenderBlush", "PaleTurqoise", "FireBrick"]</code> '
|
||||
- text: '<code>htmlColorNames</code> debería devolver <code>["DarkSalmon", "BlanchedAlmond", "LavenderBlush", "PaleTurqoise", "FireBrick"]</code>'
|
||||
testString: 'assert.deepEqual(htmlColorNames(["DarkGoldenRod", "WhiteSmoke", "LavenderBlush", "PaleTurqoise", "FireBrick"]), ["DarkSalmon", "BlanchedAlmond", "LavenderBlush", "PaleTurqoise", "FireBrick"], "<code>htmlColorNames</code> should return <code>["DarkSalmon", "BlanchedAlmond", "LavenderBlush", "PaleTurqoise", "FireBrick"]</code>");'
|
||||
- text: La función <code>htmlColorNames</code> debe utilizar el método <code>splice()</code>
|
||||
testString: 'assert(/.splice/.test(code), "The <code>htmlColorNames</code> function should utilize the <code>splice()</code> method");'
|
||||
@@ -50,6 +45,7 @@ function htmlColorNames(arr) {
|
||||
|
||||
// do not change code below this line
|
||||
console.log(htmlColorNames(['DarkGoldenRod', 'WhiteSmoke', 'LavenderBlush', 'PaleTurqoise', 'FireBrick']));
|
||||
|
||||
```
|
||||
|
||||
</div>
|
||||
|
||||
@@ -1,25 +1,16 @@
|
||||
---
|
||||
id: 587d7b7c367417b2b2512b18
|
||||
title: Add Key-Value Pairs to JavaScript Objects
|
||||
localeTitle: Agregue pares de valor-clave a los objetos de JavaScript
|
||||
challengeType: 1
|
||||
videoUrl: ''
|
||||
localeTitle: Agregue pares de valor-clave a los objetos de JavaScript
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
En su forma más básica, los objetos son solo colecciones de <dfn>pares clave-valor</dfn> , o, en otras palabras, fragmentos de datos asignados a identificadores únicos que llamamos <dfn>propiedades</dfn> o <dfn>claves</dfn> . Veamos un ejemplo muy simple:
|
||||
<blockquote>let FCC_User = {<br> username: 'awesome_coder',<br> followers: 572,<br> points: 1741,<br> completedProjects: 15<br>};</blockquote>
|
||||
El código anterior define un objeto llamado <code>FCC_User</code> que tiene cuatro <dfn>propiedades</dfn> , cada una de las cuales se <code>FCC_User</code> a un valor específico. Si quisiéramos saber el número de <code>followers</code> tiene <code>FCC_User</code> , podemos acceder a esa propiedad escribiendo:
|
||||
<blockquote>let userData = FCC_User.followers;<br>// userData equals 572</blockquote>
|
||||
Esto se llama <dfn>notación de puntos</dfn> . Alternativamente, también podemos acceder a la propiedad entre paréntesis, así:
|
||||
<blockquote>let userData = FCC_User['followers']<br>// userData equals 572</blockquote>
|
||||
Observe que con la <dfn>notación de corchetes</dfn> , incluimos a los <code>followers</code> entre comillas. Esto se debe a que los corchetes realmente nos permiten pasar una variable para que sea evaluada como un nombre de propiedad (sugerencia: ten esto en cuenta para más adelante). Si hubiéramos pasado a los <code>followers</code> sin las comillas, el motor de JavaScript habría intentado evaluarla como una variable, y un <code>ReferenceError: followers is not defined</code> .
|
||||
</section>
|
||||
<section id="description"> En su forma más básica, los objetos son solo colecciones de <dfn>pares clave-valor</dfn> , o, en otras palabras, fragmentos de datos asignados a identificadores únicos que llamamos <dfn>propiedades</dfn> o <dfn>claves</dfn> . Veamos un ejemplo muy simple: <blockquote> dejar FCC_User = { <br> nombre de usuario: 'awesome_coder', <br> seguidores: 572, <br> puntos: 1741, <br> Proyectos completados: 15 <br> }; </blockquote> El código anterior define un objeto llamado <code>FCC_User</code> que tiene cuatro <dfn>propiedades</dfn> , cada una de las cuales se <code>FCC_User</code> a un valor específico. Si quisiéramos saber la cantidad de <code>followers</code> tiene <code>FCC_User</code> , podemos acceder a esa propiedad escribiendo: <blockquote> deje userData = FCC_User.followers; <br> // userData es igual a 572 </blockquote> Esto se llama <dfn>notación de puntos</dfn> . Alternativamente, también podemos acceder a la propiedad entre paréntesis, así: <blockquote> deja userData = FCC_User ['followers'] <br> // userData es igual a 572 </blockquote> Tenga en cuenta que con la <dfn>notación de corchetes</dfn> , incluimos a los <code>followers</code> entre comillas. Esto se debe a que los corchetes realmente nos permiten pasar una variable para que sea evaluada como un nombre de propiedad (sugerencia: ten esto en cuenta para más adelante). Si hubiéramos pasado a los <code>followers</code> sin las comillas, el motor de JavaScript habría intentado evaluarla como una variable, y un <code>ReferenceError: followers is not defined</code> . </section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
Usando la misma sintaxis, también podemos <em><strong>agregar nuevos</strong></em> pares clave-valor a los objetos. Hemos creado un objeto de <code>foods</code> con tres entradas. Agregue tres entradas más: <code>bananas</code> con un valor de <code>13</code> , <code>grapes</code> con un valor de <code>35</code> y <code>strawberries</code> con un valor de <code>27</code> .
|
||||
</section>
|
||||
<section id="instructions"> Usando la misma sintaxis, también podemos <em><strong>agregar nuevos</strong></em> pares clave-valor a los objetos. Hemos creado un objeto de <code>foods</code> con tres entradas. Agregue tres entradas más: <code>bananas</code> con un valor de <code>13</code> , <code>grapes</code> con un valor de <code>35</code> y <code>strawberries</code> con un valor de <code>27</code> . </section>
|
||||
|
||||
## Tests
|
||||
<section id='tests'>
|
||||
@@ -58,6 +49,7 @@ let foods = {
|
||||
// change code above this line
|
||||
|
||||
console.log(foods);
|
||||
|
||||
```
|
||||
|
||||
</div>
|
||||
|
||||
@@ -1,34 +1,29 @@
|
||||
---
|
||||
id: 587d7b7b367417b2b2512b14
|
||||
title: Check For The Presence of an Element With indexOf()
|
||||
localeTitle: Comprobar la presencia de un elemento con indexOf ()
|
||||
challengeType: 1
|
||||
videoUrl: ''
|
||||
localeTitle: Comprobar la presencia de un elemento con indexOf ()
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
Dado que las matrices se pueden cambiar, o <em>mutar</em> , en cualquier momento, no hay ninguna garantía sobre dónde estará una determinada pieza de datos en una matriz determinada, o si ese elemento aún existe. Afortunadamente, JavaScript nos proporciona otro método <code>indexOf()</code> , <code>indexOf()</code> , que nos permite verificar rápida y fácilmente la presencia de un elemento en una matriz. <code>indexOf()</code> toma un elemento como parámetro y, cuando se le llama, devuelve la posición o el índice de ese elemento, o <code>-1</code> si el elemento no existe en la matriz.
|
||||
Por ejemplo:
|
||||
<blockquote>let fruits = ['apples', 'pears', 'oranges', 'peaches', 'pears'];<br><br>fruits.indexOf('dates') // returns -1<br>fruits.indexOf('oranges') // returns 2<br>fruits.indexOf('pears') // returns 1, the first index at which the element exists</blockquote>
|
||||
</section>
|
||||
<section id="description"> Dado que las matrices se pueden cambiar, o <em>mutar</em> , en cualquier momento, no hay garantía sobre dónde estará una determinada pieza de datos en una matriz determinada, o si ese elemento aún existe. Afortunadamente, JavaScript nos proporciona otro método <code>indexOf()</code> , <code>indexOf()</code> , que nos permite verificar rápida y fácilmente la presencia de un elemento en una matriz. <code>indexOf()</code> toma un elemento como parámetro y, cuando se le llama, devuelve la posición o el índice de ese elemento, o <code>-1</code> si el elemento no existe en la matriz. Por ejemplo: <blockquote> deja que las frutas = ['manzanas', 'peras', 'naranjas', 'melocotones', 'peras']; <br><br> fruits.indexOf ('dates') // devuelve -1 <br> fruits.indexOf ('naranjas') // devuelve 2 <br> fruits.indexOf ('pears') // devuelve 1, el primer índice en el que existe el elemento </blockquote></section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
<code>indexOf()</code> puede ser increíblemente útil para verificar rápidamente la presencia de un elemento en una matriz. Hemos definido una función, <code>quickCheck</code> , que toma una matriz y un elemento como argumentos. Modifique la función utilizando <code>indexOf()</code> para que devuelva <code>true</code> si el elemento pasado existe en la matriz, y <code>false</code> si no lo hace.
|
||||
</section>
|
||||
<section id="instructions"> <code>indexOf()</code> puede ser increíblemente útil para verificar rápidamente la presencia de un elemento en una matriz. Hemos definido una función, <code>quickCheck</code> , que toma una matriz y un elemento como argumentos. Modifique la función utilizando <code>indexOf()</code> para que devuelva <code>true</code> si el elemento pasado existe en la matriz, y <code>false</code> si no lo hace. </section>
|
||||
|
||||
## Tests
|
||||
<section id='tests'>
|
||||
|
||||
```yml
|
||||
tests:
|
||||
- text: ' <code>quickCheck(["squash", "onions", "shallots"], "mushrooms")</code> debe devolver <code>false</code> '
|
||||
- text: '<code>quickCheck(["squash", "onions", "shallots"], "mushrooms")</code> debe devolver <code>false</code>'
|
||||
testString: 'assert.strictEqual(quickCheck(["squash", "onions", "shallots"], "mushrooms"), false, "<code>quickCheck(["squash", "onions", "shallots"], "mushrooms")</code> should return <code>false</code>");'
|
||||
- text: ' <code>quickCheck(["squash", "onions", "shallots"], "onions")</code> debe devolver <code>true</code> "
|
||||
- text: '<code>quickCheck(["squash", "onions", "shallots"], "onions")</code> debe devolver <code>true</code>'
|
||||
testString: 'assert.strictEqual(quickCheck(["squash", "onions", "shallots"], "onions"), true, "<code>quickCheck(["squash", "onions", "shallots"], "onions")</code> should return <code>true</code>");'
|
||||
- text: ' <code>quickCheck([3, 5, 9, 125, 45, 2], 125)</code> debe devolver <code>true</code> '
|
||||
- text: '<code>quickCheck([3, 5, 9, 125, 45, 2], 125)</code> debe devolver <code>true</code>'
|
||||
testString: 'assert.strictEqual(quickCheck([3, 5, 9, 125, 45, 2], 125), true, "<code>quickCheck([3, 5, 9, 125, 45, 2], 125)</code> should return <code>true</code>");'
|
||||
- text: ' <code>quickCheck([true, false, false], undefined)</code> debe devolver <code>false</code> '
|
||||
- text: '<code>quickCheck([true, false, false], undefined)</code> debe devolver <code>false</code>'
|
||||
testString: 'assert.strictEqual(quickCheck([true, false, false], undefined), false, "<code>quickCheck([true, false, false], undefined)</code> should return <code>false</code>");'
|
||||
- text: La función <code>quickCheck</code> debe utilizar el método <code>indexOf()</code>
|
||||
testString: 'assert.notStrictEqual(quickCheck.toString().search(/\.indexOf\(/), -1, "The <code>quickCheck</code> function should utilize the <code>indexOf()</code> method");'
|
||||
@@ -51,6 +46,7 @@ function quickCheck(arr, elem) {
|
||||
|
||||
// change code here to test different cases:
|
||||
console.log(quickCheck(['squash', 'onions', 'shallots'], 'mushrooms'));
|
||||
|
||||
```
|
||||
|
||||
</div>
|
||||
|
||||
@@ -1,31 +1,27 @@
|
||||
---
|
||||
id: 587d7b7d367417b2b2512b1c
|
||||
title: Check if an Object has a Property
|
||||
localeTitle: Compruebe si un objeto tiene una propiedad
|
||||
challengeType: 1
|
||||
videoUrl: ''
|
||||
localeTitle: Compruebe si un objeto tiene una propiedad
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
Ahora podemos agregar, modificar y eliminar claves de objetos. Pero, ¿y si solo quisiéramos saber si un objeto tiene una propiedad específica? JavaScript nos proporciona dos formas diferentes de hacer esto. Uno usa el método <code>hasOwnProperty()</code> y el otro usa la palabra clave <code>in</code> . Si tenemos un objeto <code>users</code> con una propiedad de <code>Alan</code> , podríamos verificar su presencia de una de las siguientes maneras:
|
||||
<blockquote>users.hasOwnProperty('Alan');<br>'Alan' in users;<br>// both return true</blockquote>
|
||||
</section>
|
||||
<section id="description"> Ahora podemos agregar, modificar y eliminar claves de objetos. Pero, ¿y si solo quisiéramos saber si un objeto tiene una propiedad específica? JavaScript nos proporciona dos formas diferentes de hacer esto. Uno usa el método <code>hasOwnProperty()</code> y el otro usa la palabra clave <code>in</code> . Si tenemos un objeto <code>users</code> con una propiedad de <code>Alan</code> , podríamos verificar su presencia de una de las siguientes maneras: <blockquote> users.hasOwnProperty ('Alan'); <br> 'Alan' en los usuarios; <br> // ambos devuelven verdadero </blockquote></section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
Hemos creado un objeto, <code>users</code> , con algunos usuarios en él y una función <code>isEveryoneHere</code> , a la que pasamos el objeto de los <code>users</code> como un argumento. Termine de escribir esta función de modo que devuelva <code>true</code> solo si el objeto de los <code>users</code> contiene los cuatro nombres, <code>Alan</code> , <code>Jeff</code> , <code>Sarah</code> y <code>Ryan</code> , como claves, y en caso contrario, <code>false</code> .
|
||||
</section>
|
||||
<section id="instructions"> Hemos creado un objeto, <code>users</code> , con algunos usuarios en él y una función <code>isEveryoneHere</code> , a la que pasamos el objeto de los <code>users</code> como un argumento. Termine de escribir esta función de modo que devuelva <code>true</code> solo si el objeto de los <code>users</code> contiene los cuatro nombres, <code>Alan</code> , <code>Jeff</code> , <code>Sarah</code> y <code>Ryan</code> , como claves, y en caso contrario, <code>false</code> . </section>
|
||||
|
||||
## Tests
|
||||
<section id='tests'>
|
||||
|
||||
```yml
|
||||
tests:
|
||||
- text: 'El objeto de los <code>users</code> solo contiene las claves <code>Alan</code> , <code>Jeff</code> , <code>Sarah</code> y <code>Ryan</code> '
|
||||
- text: 'El objeto de los <code>users</code> solo contiene las claves <code>Alan</code> , <code>Jeff</code> , <code>Sarah</code> y <code>Ryan</code>'
|
||||
testString: 'assert("Alan" in users && "Jeff" in users && "Sarah" in users && "Ryan" in users && Object.keys(users).length === 4, "The <code>users</code> object only contains the keys <code>Alan</code>, <code>Jeff</code>, <code>Sarah</code>, and <code>Ryan</code>");'
|
||||
- text: 'La función <code>isEveryoneHere</code> devuelve <code>true</code> si <code>Alan</code> , <code>Jeff</code> , <code>Sarah</code> y <code>Ryan</code> son propiedades del objeto de los <code>users</code> '
|
||||
- text: 'La función <code>isEveryoneHere</code> devuelve <code>true</code> si <code>Alan</code> , <code>Jeff</code> , <code>Sarah</code> y <code>Ryan</code> son propiedades del objeto de los <code>users</code>'
|
||||
testString: 'assert(isEveryoneHere(users) === true, "The function <code>isEveryoneHere</code> returns <code>true</code> if <code>Alan</code>, <code>Jeff</code>, <code>Sarah</code>, and <code>Ryan</code> are properties on the <code>users</code> object");'
|
||||
- text: 'La función <code>isEveryoneHere</code> devuelve <code>false</code> si <code>Alan</code> , <code>Jeff</code> , <code>Sarah</code> y <code>Ryan</code> no son propiedades del objeto de los <code>users</code> '
|
||||
- text: 'La función <code>isEveryoneHere</code> devuelve <code>false</code> si <code>Alan</code> , <code>Jeff</code> , <code>Sarah</code> y <code>Ryan</code> no son propiedades en el objeto de los <code>users</code>'
|
||||
testString: 'assert((function() { delete users.Alan; delete users.Jeff; delete users.Sarah; delete users.Ryan; return isEveryoneHere(users) })() === false, "The function <code>isEveryoneHere</code> returns <code>false</code> if <code>Alan</code>, <code>Jeff</code>, <code>Sarah</code>, and <code>Ryan</code> are not properties on the <code>users</code> object");'
|
||||
|
||||
```
|
||||
@@ -64,6 +60,7 @@ function isEveryoneHere(obj) {
|
||||
}
|
||||
|
||||
console.log(isEveryoneHere(users));
|
||||
|
||||
```
|
||||
|
||||
</div>
|
||||
|
||||
@@ -1,28 +1,23 @@
|
||||
---
|
||||
id: 587d7b7b367417b2b2512b17
|
||||
title: Combine Arrays with the Spread Operator
|
||||
localeTitle: Combina matrices con el operador de propagación
|
||||
challengeType: 1
|
||||
videoUrl: ''
|
||||
localeTitle: Combina matrices con el operador de propagación
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
Otra gran ventaja del operador de <dfn>difusión</dfn> , es la capacidad de combinar arreglos, o de insertar todos los elementos de un arreglo en otro, en cualquier índice. Con sintaxis más tradicionales, podemos concatenar matrices, pero esto solo nos permite combinar matrices al final de una y al comienzo de otra. La sintaxis de propagación hace que la siguiente operación sea extremadamente simple:
|
||||
<blockquote>let thisArray = ['sage', 'rosemary', 'parsley', 'thyme'];<br><br>let thatArray = ['basil', 'cilantro', ...thisArray, 'coriander'];<br>// thatArray now equals ['basil', 'cilantro', 'sage', 'rosemary', 'parsley', 'thyme', 'coriander']</blockquote>
|
||||
Usando la sintaxis de propagación, acabamos de lograr una operación que hubiera sido más compleja y más detallada si hubiéramos usado métodos tradicionales.
|
||||
</section>
|
||||
<section id="description"> Otra gran ventaja del operador de <dfn>propagación</dfn> es la capacidad de combinar arreglos, o de insertar todos los elementos de un arreglo en otro, en cualquier índice. Con sintaxis más tradicionales, podemos concatenar matrices, pero esto solo nos permite combinar matrices al final de una y al comienzo de otra. La sintaxis de propagación hace que la siguiente operación sea extremadamente simple: <blockquote> dejar que este Array = ['sage', 'romero', 'perejil', 'tomillo']; <br><br> que thatArray = ['basil', 'cilantro', ... thisArray, 'coriander']; <br> // que Array ahora es igual a ['basil', 'cilantro', 'sage', 'romero', 'perejil', 'tomillo', 'cilantro'] </blockquote> Usando la sintaxis de propagación, acabamos de lograr una operación que hubiera sido más compleja y más detallada si hubiéramos usado métodos tradicionales. </section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
Hemos definido una función <code>spreadOut</code> que devuelve la <code>sentence</code> variable, modifique la función usando el operador de <dfn>propagación</dfn> para que devuelva la matriz <code>['learning', 'to', 'code', 'is', 'fun']</code> .
|
||||
</section>
|
||||
<section id="instructions"> Hemos definido una función <code>spreadOut</code> que devuelve la <code>sentence</code> variable, modifique la función usando el operador <dfn>spread</dfn> para que devuelva la matriz <code>['learning', 'to', 'code', 'is', 'fun']</code> . </section>
|
||||
|
||||
## Tests
|
||||
<section id='tests'>
|
||||
|
||||
```yml
|
||||
tests:
|
||||
- text: ' <code>spreadOut</code> debería devolver <code>["learning", "to", "code", "is", "fun"]</code> '
|
||||
- text: '<code>spreadOut</code> debería devolver <code>["learning", "to", "code", "is", "fun"]</code>'
|
||||
testString: 'assert.deepEqual(spreadOut(), ["learning", "to", "code", "is", "fun"], "<code>spreadOut</code> should return <code>["learning", "to", "code", "is", "fun"]</code>");'
|
||||
- text: La función <code>spreadOut</code> debe utilizar la sintaxis de difusión
|
||||
testString: 'assert.notStrictEqual(spreadOut.toString().search(/[...]/), -1, "The <code>spreadOut</code> function should utilize spread syntax");'
|
||||
@@ -45,6 +40,7 @@ function spreadOut() {
|
||||
|
||||
// do not change code below this line
|
||||
console.log(spreadOut());
|
||||
|
||||
```
|
||||
|
||||
</div>
|
||||
|
||||
@@ -1,34 +1,29 @@
|
||||
---
|
||||
id: 587d7b7b367417b2b2512b13
|
||||
title: Copy an Array with the Spread Operator
|
||||
localeTitle: Copiar una matriz con el operador de propagación
|
||||
challengeType: 1
|
||||
videoUrl: ''
|
||||
localeTitle: Copiar una matriz con el operador de propagación
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
Mientras <code>slice()</code> nos permite ser selectivos sobre qué elementos de una matriz copiar, entre otras muchas tareas útiles, el nuevo <dfn>operador de difusión de</dfn> ES6 nos permite copiar fácilmente <em>todos</em> los elementos de una matriz, en orden, con una sintaxis simple y altamente legible . La sintaxis de propagación simplemente se ve así: <code>...</code>
|
||||
En la práctica, podemos usar el operador de propagación para copiar una matriz de la siguiente manera:
|
||||
<blockquote>let thisArray = [true, true, undefined, false, null];<br>let thatArray = [...thisArray];<br>// thatArray equals [true, true, undefined, false, null]<br>// thisArray remains unchanged, and is identical to thatArray</blockquote>
|
||||
</section>
|
||||
<section id="description"> Si bien <code>slice()</code> nos permite ser selectivos sobre qué elementos de una matriz copiar, entre otras muchas tareas útiles, el nuevo <dfn>operador de difusión de</dfn> ES6 nos permite copiar fácilmente <em>todos</em> los elementos de una matriz, en orden, con una sintaxis simple y altamente legible. La sintaxis de propagación simplemente se ve así: <code>...</code> En la práctica, podemos usar el operador de propagación para copiar una matriz de esta manera: <blockquote> deje que esteArray = [verdadero, verdadero, indefinido, falso, nulo]; <br> que thatArray = [... thisArray]; <br> // thatArray es igual a [true, true, undefined, false, null] <br> // thisArray permanece sin cambios, y es idéntico a thatArray </blockquote></section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
Hemos definido una función, <code>copyMachine</code> que toma <code>arr</code> (una matriz) y <code>num</code> (un número) como argumentos. Se supone que la función devuelve una nueva matriz formada por <code>num</code> copias de <code>arr</code> . Hemos hecho la mayor parte del trabajo por usted, pero todavía no funciona del todo bien. Modifique la función utilizando la sintaxis de dispersión para que funcione correctamente (sugerencia: ¡otro método que ya hemos cubierto podría ser útil aquí!).
|
||||
</section>
|
||||
<section id="instructions"> Hemos definido una función, <code>copyMachine</code> que toma <code>arr</code> (una matriz) y <code>num</code> (un número) como argumentos. Se supone que la función devuelve una nueva matriz formada por <code>num</code> copias de <code>arr</code> . Hemos hecho la mayor parte del trabajo por usted, pero todavía no funciona del todo bien. Modifique la función utilizando la sintaxis de dispersión para que funcione correctamente (sugerencia: ¡otro método que ya hemos cubierto podría ser útil aquí!). </section>
|
||||
|
||||
## Tests
|
||||
<section id='tests'>
|
||||
|
||||
```yml
|
||||
tests:
|
||||
- text: ' <code>copyMachine([true, false, true], 2)</code> debe devolver <code>[[true, false, true], [true, false, true]]</code> '
|
||||
- text: '<code>copyMachine([true, false, true], 2)</code> debe devolver <code>[[true, false, true], [true, false, true]]</code>'
|
||||
testString: 'assert.deepEqual(copyMachine([true, false, true], 2), [[true, false, true], [true, false, true]], "<code>copyMachine([true, false, true], 2)</code> should return <code>[[true, false, true], [true, false, true]]</code>");'
|
||||
- text: ' <code>copyMachine([1, 2, 3], 5)</code> debe devolver <code>[[1, 2, 3], [1, 2, 3], [1, 2, 3], [1, 2, 3], [1, 2, 3]]</code> '
|
||||
- text: '<code>copyMachine([1, 2, 3], 5)</code> debe devolver <code>[[1, 2, 3], [1, 2, 3], [1, 2, 3], [1, 2, 3], [1, 2, 3]]</code>'
|
||||
testString: 'assert.deepEqual(copyMachine([1, 2, 3], 5), [[1, 2, 3], [1, 2, 3], [1, 2, 3], [1, 2, 3], [1, 2, 3]], "<code>copyMachine([1, 2, 3], 5)</code> should return <code>[[1, 2, 3], [1, 2, 3], [1, 2, 3], [1, 2, 3], [1, 2, 3]]</code>");'
|
||||
- text: ' <code>copyMachine([true, true, null], 1)</code> debe devolver <code>[[true, true, null]]</code> '
|
||||
- text: '<code>copyMachine([true, true, null], 1)</code> debe devolver <code>[[true, true, null]]</code>'
|
||||
testString: 'assert.deepEqual(copyMachine([true, true, null], 1), [[true, true, null]], "<code>copyMachine([true, true, null], 1)</code> should return <code>[[true, true, null]]</code>");'
|
||||
- text: ' <code>copyMachine(["it works"], 3)</code> debería devolver <code>[["it works"], ["it works"], ["it works"]]</code> '
|
||||
- text: '<code>copyMachine(["it works"], 3)</code> debe devolver <code>[["it works"], ["it works"], ["it works"]]</code>'
|
||||
testString: 'assert.deepEqual(copyMachine(["it works"], 3), [["it works"], ["it works"], ["it works"]], "<code>copyMachine(["it works"], 3)</code> should return <code>[["it works"], ["it works"], ["it works"]]</code>");'
|
||||
- text: La función <code>copyMachine</code> debe utilizar el <code>spread operator</code> con array <code>arr</code>
|
||||
testString: 'assert.notStrictEqual(copyMachine.toString().indexOf(".concat(_toConsumableArray(arr))"), -1, "The <code>copyMachine</code> function should utilize the <code>spread operator</code> with array <code>arr</code>");'
|
||||
@@ -56,6 +51,7 @@ function copyMachine(arr, num) {
|
||||
|
||||
// change code here to test different cases:
|
||||
console.log(copyMachine([true, false, true], 2));
|
||||
|
||||
```
|
||||
|
||||
</div>
|
||||
|
||||
@@ -1,28 +1,23 @@
|
||||
---
|
||||
id: 587d7b7a367417b2b2512b12
|
||||
title: Copy Array Items Using slice()
|
||||
localeTitle: Copiar elementos de matriz utilizando slice ()
|
||||
challengeType: 1
|
||||
videoUrl: ''
|
||||
localeTitle: Copiar elementos de matriz utilizando slice ()
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
El siguiente método que cubriremos es <code>slice()</code> . <code>slice()</code> , en lugar de modificar una matriz, copia o <em>extrae</em> , un número dado de elementos a una nueva matriz, dejando la matriz a la que se llama sin tocar. <code>slice()</code> toma solo 2 parámetros: el primero es el índice para comenzar la extracción y el segundo es el índice para detener la extracción (la extracción ocurrirá hasta, pero sin incluir el elemento en este índice). Considera esto:
|
||||
<blockquote>let weatherConditions = ['rain', 'snow', 'sleet', 'hail', 'clear'];<br><br>let todaysWeather = weatherConditions.slice(1, 3);<br>// todaysWeather equals ['snow', 'sleet'];<br>// weatherConditions still equals ['rain', 'snow', 'sleet', 'hail', 'clear']<br></blockquote>
|
||||
En efecto, hemos creado una nueva matriz extrayendo elementos de una matriz existente.
|
||||
</section>
|
||||
<section id="description"> El siguiente método que cubriremos es <code>slice()</code> . <code>slice()</code> , en lugar de modificar una matriz, copia o <em>extrae</em> , un número dado de elementos a una nueva matriz, dejando la matriz a la que se llama sin tocar. <code>slice()</code> toma solo 2 parámetros: el primero es el índice para comenzar la extracción y el segundo es el índice para detener la extracción (la extracción ocurrirá hasta, pero sin incluir el elemento en este índice). Considera esto: <blockquote> deja las condiciones climáticas = ['lluvia', 'nieve', 'aguanieve', 'granizo', 'claro']; <br><br> let todaysWeather = weatherConditions.slice (1, 3); <br> // todaysWeather es igual a ['snow', 'sleet']; <br> // weatherConditions aún es igual a ['rain', 'snow', 'sleet', 'hail', 'clear'] <br></blockquote> En efecto, hemos creado una nueva matriz extrayendo elementos de una matriz existente. </section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
Hemos definido una función, <code>forecast</code> , que toma una matriz como argumento. Modifique la función utilizando <code>slice()</code> para extraer información de la matriz de argumentos y devuelva una nueva matriz que contenga los elementos <code>'warm'</code> y <code>'sunny'</code> .
|
||||
</section>
|
||||
<section id="instructions"> Hemos definido una función, <code>forecast</code> , que toma una matriz como argumento. Modifique la función utilizando <code>slice()</code> para extraer información de la matriz de argumentos y devuelva una nueva matriz que contenga los elementos <code>'warm'</code> y <code>'sunny'</code> . </section>
|
||||
|
||||
## Tests
|
||||
<section id='tests'>
|
||||
|
||||
```yml
|
||||
tests:
|
||||
- text: ' <code>forecast</code> debería devolver <code>["warm", "sunny"]'</code>
|
||||
- text: '<code>forecast</code> debería devolver <code>["warm", "sunny"]</code>'
|
||||
testString: 'assert.deepEqual(forecast(["cold", "rainy", "warm", "sunny", "cool", "thunderstorms"]), ["warm", "sunny"], "<code>forecast</code> should return <code>["warm", "sunny"]");'
|
||||
- text: La función de <code>forecast</code> debe utilizar el método <code>slice()</code>
|
||||
testString: 'assert(/\.slice\(/.test(code), "The <code>forecast</code> function should utilize the <code>slice()</code> method");'
|
||||
@@ -45,6 +40,7 @@ function forecast(arr) {
|
||||
|
||||
// do not change code below this line
|
||||
console.log(forecast(['cold', 'rainy', 'warm', 'sunny', 'cool', 'thunderstorms']));
|
||||
|
||||
```
|
||||
|
||||
</div>
|
||||
|
||||
@@ -1,33 +1,23 @@
|
||||
---
|
||||
id: 587d7b7b367417b2b2512b16
|
||||
title: Create complex multi-dimensional arrays
|
||||
localeTitle: Crear complejos arreglos multidimensionales.
|
||||
challengeType: 1
|
||||
videoUrl: ''
|
||||
localeTitle: Crear complejos arreglos multidimensionales.
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
impresionante! ¡Acabas de aprender un montón de arreglos! Este ha sido un resumen de nivel bastante alto, y hay mucho más que aprender sobre el trabajo con matrices, muchas de las cuales veremos en secciones posteriores. Pero antes de pasar a mirar <dfn>Objetos</dfn> , echemos un vistazo más y veamos cómo los arreglos pueden volverse un poco más complejos de lo que hemos visto en desafíos anteriores.
|
||||
Una de las características más poderosas cuando se piensa en los arreglos como estructuras de datos, es que los arreglos pueden contener, o incluso estar completamente compuestos de otros arreglos. Hemos visto matrices que contienen matrices en desafíos anteriores, pero bastante simples. Sin embargo, las matrices pueden contener una profundidad infinita de matrices que pueden contener otras matrices, cada una con sus propios niveles arbitrarios de profundidad, y así sucesivamente. De esta manera, una matriz puede convertirse muy rápidamente en una estructura de datos muy compleja, conocida como una matriz <dfn>multidimensional</dfn> o anidada. Considera el siguiente ejemplo:
|
||||
<blockquote>let nestedArray = [ // top, or first level - the outer most array<br> ['deep'], // an array within an array, 2 levels of depth<br> [<br> ['deeper'], ['deeper'] // 2 arrays nested 3 levels deep<br> ],<br> [<br> [<br> ['deepest'], ['deepest'] // 2 arrays nested 4 levels deep<br> ],<br> [<br> [<br> ['deepest-est?'] // an array nested 5 levels deep<br> ]<br> ]<br> ]<br>];</blockquote>
|
||||
Si bien este ejemplo puede parecer complicado, este nivel de complejidad no es inaudito, o incluso inusual, cuando se trata de grandes cantidades de datos.
|
||||
Sin embargo, aún podemos acceder fácilmente a los niveles más profundos de una matriz de este complejo con notación de corchete:
|
||||
<blockquote>console.log(nestedArray[2][1][0][0][0]);<br>// logs: deepest-est?</blockquote>
|
||||
Y ahora que sabemos dónde está ese dato, podemos restablecerlo si necesitamos:
|
||||
<blockquote>nestedArray[2][1][0][0][0] = 'deeper still';<br><br>console.log(nestedArray[2][1][0][0][0]);<br>// now logs: deeper still</blockquote>
|
||||
</section>
|
||||
<section id="description"> ¡Increíble! ¡Acabas de aprender un montón de arreglos! Este ha sido un resumen de nivel bastante alto, y hay mucho más que aprender sobre el trabajo con matrices, muchas de las cuales veremos en secciones posteriores. Pero antes de pasar a mirar <dfn>Objetos</dfn> , echemos un vistazo más y veamos cómo los arreglos pueden volverse un poco más complejos de lo que hemos visto en desafíos anteriores. Una de las características más poderosas cuando se piensa en los arreglos como estructuras de datos, es que los arreglos pueden contener, o incluso estar completamente compuestos de otros arreglos. Hemos visto matrices que contienen matrices en desafíos anteriores, pero bastante simples. Sin embargo, las matrices pueden contener una profundidad infinita de matrices que pueden contener otras matrices, cada una con sus propios niveles arbitrarios de profundidad, y así sucesivamente. De esta manera, una matriz puede convertirse muy rápidamente en una estructura de datos muy compleja, conocida como una matriz <dfn>multidimensional</dfn> o anidada. Considere el siguiente ejemplo: <blockquote> Deje nestedArray = [// top, o primer nivel: la matriz más externa <br> ['deep'], // una matriz dentro de una matriz, 2 niveles de profundidad <br> El <br> ['deep'], ['deep'] // 2 arreglos anidados 3 niveles de profundidad <br> ] <br> El <br> El <br> ['deepest'], ['deepest'] // 2 arrays anidados 4 niveles de profundidad <br> ] <br> El <br> El <br> ['deepest-est?'] // una matriz anidada 5 niveles de profundidad <br> ] <br> ] <br> ] <br> ]; </blockquote> Si bien este ejemplo puede parecer complicado, este nivel de complejidad no es inaudito, o incluso inusual, cuando se trata de grandes cantidades de datos. Sin embargo, aún podemos acceder fácilmente a los niveles más profundos de una matriz de este complejo con notación de corchetes: <blockquote> console.log (nestedArray [2] [1] [0] [0] [0]); <br> // logs: deepest-est? </blockquote> Y ahora que sabemos dónde se encuentra ese dato, podemos restablecerlo si necesitamos: <blockquote> nestedArray [2] [1] [0] [0] [0] = 'deep still still'; <br><br> console.log (nestedArray [2] [1] [0] [0] [0]); <br> // ahora registra: aún más profundo </blockquote></section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
Hemos definido una variable, <code>myNestedArray</code> , igual a una matriz. Modifique <code>myNestedArray</code> , utilizando cualquier combinación de <dfn>cadenas</dfn> , <dfn>números</dfn> y <dfn>valores booleanos</dfn> para los elementos de datos, de modo que tenga exactamente cinco niveles de profundidad (recuerde, la matriz más externa es el nivel 1). En algún lugar en el tercer nivel, incluye la cadena <code>'deep'</code> , en el cuarto nivel, incluyen la cadena <code>'deeper'</code> , y en el quinto nivel, incluyen la cadena <code>'deepest'</code> .
|
||||
</section>
|
||||
<section id="instructions"> Hemos definido una variable, <code>myNestedArray</code> , igual a una matriz. Modifique <code>myNestedArray</code> , utilizando cualquier combinación de <dfn>cadenas</dfn> , <dfn>números</dfn> y <dfn>valores booleanos</dfn> para los elementos de datos, de modo que tenga exactamente cinco niveles de profundidad (recuerde, la matriz más externa es el nivel 1). En algún lugar en el tercer nivel, incluye la cadena <code>'deep'</code> , en el cuarto nivel, incluyen la cadena <code>'deeper'</code> , y en el quinto nivel, incluyen la cadena <code>'deepest'</code> . </section>
|
||||
|
||||
## Tests
|
||||
<section id='tests'>
|
||||
|
||||
```yml
|
||||
tests:
|
||||
- text: ' <code>myNestedArray</code> debe contener solo números, booleanos y cadenas como elementos de datos'
|
||||
- text: '<code>myNestedArray</code> debe contener solo números, booleanos y cadenas como elementos de datos'
|
||||
testString: 'assert.strictEqual((function(arr) { let flattened = (function flatten(arr) { const flat = [].concat(...arr); return flat.some (Array.isArray) ? flatten(flat) : flat; })(arr); for (let i = 0; i < flattened.length; i++) { if ( typeof flattened[i] !== "number" && typeof flattened[i] !== "string" && typeof flattened[i] !== "boolean") { return false } } return true })(myNestedArray), true, "<code>myNestedArray</code> should contain only numbers, booleans, and strings as data elements");'
|
||||
- text: <code>myNestedArray</code> debe tener exactamente 5 niveles de profundidad
|
||||
testString: 'assert.strictEqual((function(arr) {let depth = 0;function arrayDepth(array, i, d) { if (Array.isArray(array[i])) { arrayDepth(array[i], 0, d + 1);} else { depth = (d > depth) ? d : depth;}if (i < array.length) { arrayDepth(array, i + 1, d);} }arrayDepth(arr, 0, 0);return depth;})(myNestedArray), 4, "<code>myNestedArray</code> should have exactly 5 levels of depth");'
|
||||
@@ -35,7 +25,7 @@ tests:
|
||||
testString: 'assert((function howDeep(array, target, depth = 0) {return array.reduce((combined, current) => {if (Array.isArray(current)) { return combined.concat(howDeep(current, target, depth + 1));} else if (current === target) { return combined.concat(depth);} else { return combined;}}, []);})(myNestedArray, "deep").length === 1 && (function howDeep(array, target, depth = 0) {return array.reduce((combined, current) => {if (Array.isArray(current)) { return combined.concat(howDeep(current, target, depth + 1));} else if (current === target) { return combined.concat(depth);} else { return combined;}}, []);})(myNestedArray, "deep")[0] === 2, "<code>myNestedArray</code> should contain exactly one occurrence of the string <code>"deep"</code> on an array nested 3 levels deep");'
|
||||
- text: <code>myNestedArray</code> debe contener exactamente una aparición de la cadena <code>"deeper"</code> deep <code>"deeper"</code> en una matriz anidada con 4 niveles de profundidad
|
||||
testString: 'assert((function howDeep(array, target, depth = 0) {return array.reduce((combined, current) => {if (Array.isArray(current)) { return combined.concat(howDeep(current, target, depth + 1));} else if (current === target) { return combined.concat(depth);} else { return combined;}}, []);})(myNestedArray, "deeper").length === 1 && (function howDeep(array, target, depth = 0) {return array.reduce((combined, current) => {if (Array.isArray(current)) { return combined.concat(howDeep(current, target, depth + 1));} else if (current === target) { return combined.concat(depth);} else { return combined;}}, []);})(myNestedArray, "deeper")[0] === 3, "<code>myNestedArray</code> should contain exactly one occurrence of the string <code>"deeper"</code> on an array nested 4 levels deep");'
|
||||
- text: <code>myNestedArray</code> debe contener exactamente una aparición de la cadena <code>"deepest"</code> en una matriz anidada a 5 niveles de profundidad
|
||||
- text: <code>myNestedArray</code> debe contener exactamente una aparición de la cadena <code>"deepest"</code> en una matriz anidada con 5 niveles de profundidad
|
||||
testString: 'assert((function howDeep(array, target, depth = 0) {return array.reduce((combined, current) => {if (Array.isArray(current)) { return combined.concat(howDeep(current, target, depth + 1));} else if (current === target) { return combined.concat(depth);} else { return combined;}}, []);})(myNestedArray, "deepest").length === 1 && (function howDeep(array, target, depth = 0) {return array.reduce((combined, current) => {if (Array.isArray(current)) { return combined.concat(howDeep(current, target, depth + 1));} else if (current === target) { return combined.concat(depth);} else { return combined;}}, []);})(myNestedArray, "deepest")[0] === 4, "<code>myNestedArray</code> should contain exactly one occurrence of the string <code>"deepest"</code> on an array nested 5 levels deep");'
|
||||
|
||||
```
|
||||
@@ -57,6 +47,7 @@ let myNestedArray = [
|
||||
['iterate', 1.3849, 7, '8.4876', 'arbitrary', 'depth']
|
||||
// change code above this line
|
||||
];
|
||||
|
||||
```
|
||||
|
||||
</div>
|
||||
|
||||
@@ -1,26 +1,23 @@
|
||||
---
|
||||
id: 587d7b7d367417b2b2512b1e
|
||||
title: Generate an Array of All Object Keys with Object.keys()
|
||||
localeTitle: Generar una matriz de todas las claves de objeto con Object.keys ()
|
||||
challengeType: 1
|
||||
videoUrl: ''
|
||||
localeTitle: Generar una matriz de todas las claves de objeto con Object.keys ()
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
También podemos generar una matriz que contiene todas las claves almacenadas en un objeto usando el método <code>Object.keys()</code> y pasando un objeto como argumento. Esto devolverá una matriz con cadenas que representan cada propiedad en el objeto. Nuevamente, no habrá un orden específico para las entradas en la matriz.
|
||||
</section>
|
||||
<section id="description"> También podemos generar una matriz que contenga todas las claves almacenadas en un objeto usando el método <code>Object.keys()</code> y pasando un objeto como argumento. Esto devolverá una matriz con cadenas que representan cada propiedad en el objeto. Nuevamente, no habrá un orden específico para las entradas en la matriz. </section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
Termine de escribir la función <code>getArrayOfUsers</code> para que devuelva una matriz que contenga todas las propiedades en el objeto que recibe como argumento.
|
||||
</section>
|
||||
<section id="instructions"> Termine de escribir la función <code>getArrayOfUsers</code> para que devuelva una matriz que contenga todas las propiedades en el objeto que recibe como argumento. </section>
|
||||
|
||||
## Tests
|
||||
<section id='tests'>
|
||||
|
||||
```yml
|
||||
tests:
|
||||
- text: 'El objeto de los <code>users</code> solo contiene las claves <code>Alan</code> , <code>Jeff</code> , <code>Sarah</code> y <code>Ryan</code> '
|
||||
- text: 'El objeto de los <code>users</code> solo contiene las claves <code>Alan</code> , <code>Jeff</code> , <code>Sarah</code> y <code>Ryan</code>'
|
||||
testString: 'assert("Alan" in users && "Jeff" in users && "Sarah" in users && "Ryan" in users && Object.keys(users).length === 4, "The <code>users</code> object only contains the keys <code>Alan</code>, <code>Jeff</code>, <code>Sarah</code>, and <code>Ryan</code>");'
|
||||
- text: La función <code>getArrayOfUsers</code> devuelve una matriz que contiene todas las claves en el objeto de los <code>users</code>
|
||||
testString: 'assert((function() { users.Sam = {}; users.Lewis = {}; let R = getArrayOfUsers(users); return (R.indexOf("Alan") !== -1 && R.indexOf("Jeff") !== -1 && R.indexOf("Sarah") !== -1 && R.indexOf("Ryan") !== -1 && R.indexOf("Sam") !== -1 && R.indexOf("Lewis") !== -1); })() === true, "The <code>getArrayOfUsers</code> function returns an array which contains all the keys in the <code>users</code> object");'
|
||||
@@ -61,6 +58,7 @@ function getArrayOfUsers(obj) {
|
||||
}
|
||||
|
||||
console.log(getArrayOfUsers(users));
|
||||
|
||||
```
|
||||
|
||||
</div>
|
||||
|
||||
@@ -1,35 +1,29 @@
|
||||
---
|
||||
id: 587d7b7b367417b2b2512b15
|
||||
title: Iterate Through All an Array's Items Using For Loops
|
||||
localeTitle: Iterar a través de todos los elementos de una matriz utilizando bucles for
|
||||
challengeType: 1
|
||||
videoUrl: ''
|
||||
localeTitle: Iterar a través de todos los elementos de una matriz utilizando bucles for
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
A veces, cuando se trabaja con matrices, es muy útil poder recorrer cada elemento para encontrar uno o más elementos que podríamos necesitar, o manipular una matriz en función de qué elementos de datos cumplen un determinado conjunto de criterios. JavaScript ofrece varios métodos integrados que se repiten en matrices de maneras ligeramente diferentes para lograr resultados diferentes (como <code>every()</code> , para <code>forEach()</code> , <code>map()</code> , etc.), sin embargo, la técnica es más flexible y nos ofrece la mejor cantidad de control es un simple <code>for</code> bucle.
|
||||
Considera lo siguiente:
|
||||
<blockquote>function greaterThanTen(arr) {<br> let newArr = [];<br> for (let i = 0; i < arr.length; i++) {<br> if (arr[i] > 10) {<br> newArr.push(arr[i]);<br> }<br> }<br> return newArr;<br>}<br><br>greaterThanTen([2, 12, 8, 14, 80, 0, 1]);<br>// returns [12, 14, 80]</blockquote>
|
||||
Usando un bucle <code>for</code> , esta función recorre y accede a cada elemento de la matriz, y lo somete a una prueba simple que hemos creado. De esta manera, hemos determinado fácil y programáticamente qué elementos de datos son más grandes que <code>10</code> , y hemos devuelto una nueva matriz que contiene esos elementos.
|
||||
</section>
|
||||
<section id="description"> A veces, cuando se trabaja con matrices, es muy útil poder recorrer en iteración cada elemento para encontrar uno o más elementos que podríamos necesitar, o manipular una matriz en función de qué elementos de datos cumplen un determinado conjunto de criterios. JavaScript ofrece varios métodos integrados que se repiten en matrices de maneras ligeramente diferentes para lograr resultados diferentes (como <code>every()</code> , para <code>forEach()</code> , <code>map()</code> , etc.), sin embargo, la técnica es más flexible y nos ofrece la mejor cantidad de control es un simple <code>for</code> bucle. Considera lo siguiente: <blockquote> función mayorThanTen (arr) { <br> deja newArr = []; <br> para (sea i = 0; i <arr.length; i ++) { <br> si (arr [i]> 10) { <br> newArr.push (arr [i]); <br> } <br> } <br> devuelve newArr; <br> } <br><br> mayorThanTen ([2, 12, 8, 14, 80, 0, 1]); <br> // devoluciones [12, 14, 80] </blockquote> Usando un bucle <code>for</code> , esta función recorre y accede a cada elemento de la matriz y lo somete a una prueba simple que hemos creado. De esta manera, hemos determinado fácil y programáticamente qué elementos de datos son más grandes que <code>10</code> , y hemos devuelto una nueva matriz que contiene esos elementos. </section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
Hemos definido una función, <code>filteredArray</code> , que toma <code>arr</code> , una matriz anidada, y <code>elem</code> como argumentos, y devuelve una nueva matriz. <code>elem</code> representa un elemento que puede o no estar presente en una o más de las matrices anidadas dentro de <code>arr</code> . Modifique la función, utilizando un bucle <code>for</code> , para devolver una versión filtrada de la matriz pasada de manera que se haya eliminado cualquier matriz anidada dentro de <code>arr</code> contenga <code>elem</code> .
|
||||
</section>
|
||||
<section id="instructions"> Hemos definido una función, <code>filteredArray</code> , que toma <code>arr</code> , una matriz anidada, y <code>elem</code> como argumentos, y devuelve una nueva matriz. <code>elem</code> representa un elemento que puede o no estar presente en una o más de las matrices anidadas dentro de <code>arr</code> . Modifique la función, utilizando un bucle <code>for</code> , para devolver una versión filtrada de la matriz pasada de manera que se haya eliminado cualquier matriz anidada dentro de <code>arr</code> contenga <code>elem</code> . </section>
|
||||
|
||||
## Tests
|
||||
<section id='tests'>
|
||||
|
||||
```yml
|
||||
tests:
|
||||
- text: ' <code>filteredArray([[10, 8, 3], [14, 6, 23], [3, 18, 6]], 18)</code> debe devolver <code>[ [10, 8, 3], [14, 6, 23] ]</code> '
|
||||
- text: '<code>filteredArray([[10, 8, 3], [14, 6, 23], [3, 18, 6]], 18)</code> debe devolver <code>[ [10, 8, 3], [14, 6, 23] ]</code>'
|
||||
testString: 'assert.deepEqual(filteredArray([ [10, 8, 3], [14, 6, 23], [3, 18, 6] ], 18), [[10, 8, 3], [14, 6, 23]], "<code>filteredArray([[10, 8, 3], [14, 6, 23], [3, 18, 6]], 18)</code> should return <code>[ [10, 8, 3], [14, 6, 23] ]</code>");'
|
||||
- text: ' <code>filteredArray([ ["trumpets", 2], ["flutes", 4], ["saxophones", 2] ], 2)</code> debe devolver <code>[ ["flutes", 4] ]</code> '
|
||||
- text: '<code>filteredArray([ ["trumpets", 2], ["flutes", 4], ["saxophones", 2] ], 2)</code> debe devolver <code>[ ["flutes", 4] ]</code>'
|
||||
testString: 'assert.deepEqual(filteredArray([ ["trumpets", 2], ["flutes", 4], ["saxophones", 2] ], 2), [["flutes", 4]], "<code>filteredArray([ ["trumpets", 2], ["flutes", 4], ["saxophones", 2] ], 2)</code> should return <code>[ ["flutes", 4] ]</code>");'
|
||||
- text: ' <code>filteredArray([ ["amy", "beth", "sam"], ["dave", "sean", "peter"] ], "peter")</code> debe devolver <code>[ ["amy", "beth", "sam"] ]</code> '
|
||||
- text: '<code>filteredArray([ ["amy", "beth", "sam"], ["dave", "sean", "peter"] ], "peter")</code> debe devolver <code>[ ["amy", "beth", "sam"] ]</code>'
|
||||
testString: 'assert.deepEqual(filteredArray([["amy", "beth", "sam"], ["dave", "sean", "peter"]], "peter"), [["amy", "beth", "sam"]], "<code>filteredArray([ ["amy", "beth", "sam"], ["dave", "sean", "peter"] ], "peter")</code> should return <code>[ ["amy", "beth", "sam"] ]</code>");'
|
||||
- text: ' <code>filteredArray([[3, 2, 3], [1, 6, 3], [3, 13, 26], [19, 3, 9]], 3)</code> debe devolver <code>[ ]</code> '
|
||||
- text: '<code>filteredArray([[3, 2, 3], [1, 6, 3], [3, 13, 26], [19, 3, 9]], 3)</code> debe devolver <code>[ ]</code>'
|
||||
testString: 'assert.deepEqual(filteredArray([[3, 2, 3], [1, 6, 3], [3, 13, 26], [19, 3, 9]], 3), [], "<code>filteredArray([[3, 2, 3], [1, 6, 3], [3, 13, 26], [19, 3, 9]], 3)</code> should return <code>[ ]</code>");'
|
||||
- text: El <code>filteredArray</code> función debe utilizar un <code>for</code> bucle
|
||||
testString: 'assert.notStrictEqual(filteredArray.toString().search(/for/), -1, "The <code>filteredArray</code> function should utilize a <code>for</code> loop");'
|
||||
@@ -54,6 +48,7 @@ function filteredArray(arr, elem) {
|
||||
|
||||
// change code here to test different cases:
|
||||
console.log(filteredArray([[3, 2, 3], [1, 6, 3], [3, 13, 26], [19, 3, 9]], 3));
|
||||
|
||||
```
|
||||
|
||||
</div>
|
||||
|
||||
@@ -1,30 +1,27 @@
|
||||
---
|
||||
id: 587d7b7d367417b2b2512b1f
|
||||
title: Modify an Array Stored in an Object
|
||||
localeTitle: Modificar una matriz almacenada en un objeto
|
||||
challengeType: 1
|
||||
videoUrl: ''
|
||||
localeTitle: Modificar una matriz almacenada en un objeto
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
Ahora has visto todas las operaciones básicas para objetos JavaScript. Puede agregar, modificar y eliminar pares clave-valor, verificar si existen claves e iterar sobre todas las claves en un objeto. A medida que continúe aprendiendo JavaScript, verá aplicaciones de objetos aún más versátiles. Además, las lecciones opcionales de Estructuras de datos avanzadas más adelante en el plan de estudios también cubren los objetos <dfn>Map</dfn> y <dfn>Set de</dfn> ES6, los cuales son similares a los objetos comunes pero ofrecen algunas características adicionales. ¡Ahora que ha aprendido los conceptos básicos de matrices y objetos, está completamente preparado para comenzar a abordar problemas más complejos utilizando JavaScript!
|
||||
</section>
|
||||
<section id="description"> Ahora has visto todas las operaciones básicas para objetos JavaScript. Puede agregar, modificar y eliminar pares clave-valor, verificar si existen claves e iterar sobre todas las claves en un objeto. A medida que continúe aprendiendo JavaScript, verá aplicaciones de objetos aún más versátiles. Además, las lecciones opcionales de Estructuras de datos avanzadas más adelante en el plan de estudios también cubren los objetos <dfn>Map</dfn> y <dfn>Set de</dfn> ES6, los cuales son similares a los objetos comunes pero ofrecen algunas características adicionales. ¡Ahora que ha aprendido los conceptos básicos de matrices y objetos, está completamente preparado para comenzar a abordar problemas más complejos utilizando JavaScript! </section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
Eche un vistazo al objeto que hemos proporcionado en el editor de código. El objeto de <code>user</code> contiene tres claves. La clave de <code>data</code> contiene cinco claves, una de las cuales contiene una gran variedad de <code>friends</code> . A partir de esto, puede ver cómo los objetos flexibles son como estructuras de datos. Hemos empezado a escribir una función <code>addFriend</code> . Termine de escribirlo para que tome un objeto de <code>user</code> y agregue el nombre del argumento de <code>friend</code> a la matriz almacenada en <code>user.data.friends</code> y devuelva esa matriz.
|
||||
</section>
|
||||
<section id="instructions"> Eche un vistazo al objeto que hemos proporcionado en el editor de código. El objeto de <code>user</code> contiene tres claves. La clave de <code>data</code> contiene cinco claves, una de las cuales contiene una gran variedad de <code>friends</code> . A partir de esto, puede ver cómo los objetos flexibles son como estructuras de datos. Hemos empezado a escribir una función <code>addFriend</code> . Termine de escribirlo para que tome un objeto de <code>user</code> y agregue el nombre del argumento de <code>friend</code> a la matriz almacenada en <code>user.data.friends</code> y devuelva esa matriz. </section>
|
||||
|
||||
## Tests
|
||||
<section id='tests'>
|
||||
|
||||
```yml
|
||||
tests:
|
||||
- text: 'El objeto de <code>user</code> tiene <code>name</code> , <code>age</code> y claves de <code>data</code> '
|
||||
- text: 'El objeto de <code>user</code> tiene <code>name</code> , <code>age</code> y claves de <code>data</code>'
|
||||
testString: 'assert("name" in user && "age" in user && "data" in user, "The <code>user</code> object has <code>name</code>, <code>age</code>, and <code>data</code> keys");'
|
||||
- text: La función <code>addFriend</code> acepta un objeto de <code>user</code> y una cadena de <code>friend</code> como argumentos y agrega el amigo a la matriz de <code>friends</code> en el objeto de <code>user</code>
|
||||
testString: 'assert((function() { let L1 = user.data.friends.length; addFriend(user, "Sean"); let L2 = user.data.friends.length; return (L2 === L1 + 1); })(), "The <code>addFriend</code> function accepts a <code>user</code> object and a <code>friend</code> string as arguments and adds the friend to the array of <code>friends</code> in the <code>user</code> object");'
|
||||
- text: ' <code>addFriend(user, "Pete")</code> debe devolver <code>["Sam", "Kira", "Tomo", "Pete"]</code> '
|
||||
- text: '<code>addFriend(user, "Pete")</code> debe devolver <code>["Sam", "Kira", "Tomo", "Pete"]</code>'
|
||||
testString: 'assert.deepEqual((function() { delete user.data.friends; user.data.friends = ["Sam", "Kira", "Tomo"]; return addFriend(user, "Pete") })(), ["Sam", "Kira", "Tomo", "Pete"], "<code>addFriend(user, "Pete")</code> should return <code>["Sam", "Kira", "Tomo", "Pete"]</code>");'
|
||||
|
||||
```
|
||||
@@ -64,6 +61,7 @@ function addFriend(userObj, friend) {
|
||||
}
|
||||
|
||||
console.log(addFriend(user, 'Pete'));
|
||||
|
||||
```
|
||||
|
||||
</div>
|
||||
|
||||
@@ -1,28 +1,23 @@
|
||||
---
|
||||
id: 587d7b7c367417b2b2512b19
|
||||
title: Modify an Object Nested Within an Object
|
||||
localeTitle: Modificar un objeto anidado dentro de un objeto
|
||||
challengeType: 1
|
||||
videoUrl: ''
|
||||
localeTitle: Modificar un objeto anidado dentro de un objeto
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
Ahora veamos un objeto un poco más complejo. Las propiedades de los objetos se pueden anidar a una profundidad arbitraria, y sus valores pueden ser cualquier tipo de datos admitidos por JavaScript, incluidas las matrices e incluso otros objetos. Considera lo siguiente:
|
||||
<blockquote>let nestedObject = {<br> id: 28802695164,<br> date: 'December 31, 2016',<br> data: {<br> totalUsers: 99,<br> online: 80,<br> onlineStatus: {<br> active: 67,<br> away: 13<br> }<br> }<br>};</blockquote>
|
||||
<code>nestedObject</code> tiene tres claves únicas: <code>id</code> , cuyo valor es un número, la <code>date</code> cuyo valor es una cadena y los <code>data</code> , cuyo valor es un objeto que tiene otro objeto anidado dentro de él. Si bien las estructuras pueden volverse complejas rápidamente, aún podemos usar las mismas notaciones para acceder a la información que necesitamos.
|
||||
</section>
|
||||
<section id="description"> Ahora echemos un vistazo a un objeto un poco más complejo. Las propiedades de los objetos se pueden anidar a una profundidad arbitraria, y sus valores pueden ser cualquier tipo de datos admitidos por JavaScript, incluidas las matrices e incluso otros objetos. Considera lo siguiente: <blockquote> deja nestedObject = { <br> Identificación: 28802695164, <br> fecha: '31 de diciembre de 2016', <br> datos: { <br> totalUsuarios: 99, <br> en línea: 80, <br> Estado en línea: { <br> activo: 67, <br> lejos: 13 <br> } <br> } <br> }; </blockquote> <code>nestedObject</code> tiene tres claves únicas: <code>id</code> , cuyo valor es un número, la <code>date</code> cuyo valor es una cadena y los <code>data</code> , cuyo valor es un objeto que tiene otro objeto anidado dentro de él. Si bien las estructuras pueden volverse complejas rápidamente, aún podemos usar las mismas notaciones para acceder a la información que necesitamos. </section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
Aquí hemos definido un objeto, <code>userActivity</code> , que incluye otro objeto anidado dentro de él. Puede modificar las propiedades de este objeto anidado de la misma manera que modificó las propiedades en el último desafío. Establezca el valor de la clave en <code>online</code> en <code>45</code> .
|
||||
</section>
|
||||
<section id="instructions"> Aquí hemos definido un objeto, <code>userActivity</code> , que incluye otro objeto anidado dentro de él. Puede modificar las propiedades de este objeto anidado de la misma manera que modificó las propiedades en el último desafío. Establezca el valor de la clave en <code>online</code> en <code>45</code> . </section>
|
||||
|
||||
## Tests
|
||||
<section id='tests'>
|
||||
|
||||
```yml
|
||||
tests:
|
||||
- text: ' <code>userActivity</code> tiene <code>id</code> , <code>date</code> y propiedades de <code>data</code> '
|
||||
- text: '<code>userActivity</code> tiene <code>id</code> , <code>date</code> y propiedades de <code>data</code>'
|
||||
testString: 'assert("id" in userActivity && "date" in userActivity && "data" in userActivity, "<code>userActivity</code> has <code>id</code>, <code>date</code> and <code>data</code> properties");'
|
||||
- text: <code>userActivity</code> tiene una clave de <code>data</code> configurada para un objeto con las teclas <code>totalUsers</code> y en <code>online</code>
|
||||
testString: 'assert("totalUsers" in userActivity.data && "online" in userActivity.data, "<code>userActivity</code> has a <code>data</code> key set to an object with keys <code>totalUsers</code> and <code>online</code>");'
|
||||
@@ -55,6 +50,7 @@ let userActivity = {
|
||||
// change code above this line
|
||||
|
||||
console.log(userActivity);
|
||||
|
||||
```
|
||||
|
||||
</div>
|
||||
|
||||
@@ -1,30 +1,23 @@
|
||||
---
|
||||
id: 587d78b2367417b2b2512b0f
|
||||
title: Remove Items from an Array with pop() and shift()
|
||||
localeTitle: Eliminar elementos de una matriz con pop () y shift ()
|
||||
challengeType: 1
|
||||
videoUrl: ''
|
||||
localeTitle: Eliminar elementos de una matriz con pop () y shift ()
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
Tanto <code>push()</code> como <code>unshift()</code> tienen métodos correspondientes que son opuestos casi funcionales: <code>pop()</code> y <code>shift()</code> . Como ya habrá adivinado, en lugar de agregar, <code>pop()</code> <em>elimina</em> un elemento del final de una matriz, mientras que <code>shift()</code> elimina un elemento desde el principio. La diferencia clave entre <code>pop()</code> y <code>shift()</code> y sus primos <code>push()</code> y <code>unshift()</code> , es que ninguno de los dos métodos toma parámetros, y cada uno solo permite que una matriz sea modificada por un solo elemento a la vez.
|
||||
Echemos un vistazo:
|
||||
<blockquote>let greetings = ['whats up?', 'hello', 'see ya!'];<br><br>greetings.pop();<br>// now equals ['whats up?', 'hello']<br><br>greetings.shift();<br>// now equals ['hello']</blockquote>
|
||||
También podemos devolver el valor del elemento eliminado con uno de estos métodos:
|
||||
<blockquote>let popped = greetings.pop();<br>// returns 'hello'<br>// greetings now equals []</blockquote>
|
||||
</section>
|
||||
<section id="description"> Tanto <code>push()</code> como <code>unshift()</code> tienen métodos correspondientes que son opuestos casi funcionales: <code>pop()</code> y <code>shift()</code> . Como ya habrá adivinado, en lugar de agregar, <code>pop()</code> <em>elimina</em> un elemento del final de una matriz, mientras que <code>shift()</code> elimina un elemento desde el principio. La diferencia clave entre <code>pop()</code> y <code>shift()</code> y sus primos <code>push()</code> y <code>unshift()</code> , es que ninguno de los dos métodos toma parámetros, y cada uno solo permite que una matriz sea modificada por un solo elemento a la vez. Vamos a ver: <blockquote> dejar saludos = ['¿qué hay?', 'hola', 'nos vemos']; <br><br> greetings.pop (); <br> // ahora es igual a ['whats up?', 'hola'] <br><br> saludos. cambio (); <br> // ahora es igual a ['hola'] </blockquote> También podemos devolver el valor del elemento eliminado con uno de estos métodos: <blockquote> vamos a popped = greetings.pop (); <br> // devuelve 'hola' <br> // saludos ahora es igual a [] </blockquote></section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
Hemos definido una función, <code>popShift</code> , que toma una matriz como argumento y devuelve una nueva matriz. Modifique la función, utilizando <code>pop()</code> y <code>shift()</code> , para eliminar el primer y último elemento de la matriz de argumentos, y asigne los elementos eliminados a sus variables correspondientes, de modo que la matriz devuelta contenga sus valores.
|
||||
</section>
|
||||
<section id="instructions"> Hemos definido una función, <code>popShift</code> , que toma una matriz como argumento y devuelve una nueva matriz. Modifique la función, utilizando <code>pop()</code> y <code>shift()</code> , para eliminar el primer y último elemento de la matriz de argumentos, y asigne los elementos eliminados a sus variables correspondientes, de modo que la matriz devuelta contenga sus valores. </section>
|
||||
|
||||
## Tests
|
||||
<section id='tests'>
|
||||
|
||||
```yml
|
||||
tests:
|
||||
- text: ' <code>popShift(["challenge", "is", "not", "complete"])</code> debe devolver <code>["challenge", "complete"]</code> '
|
||||
- text: '<code>popShift(["challenge", "is", "not", "complete"])</code> debe devolver <code>["challenge", "complete"]</code>'
|
||||
testString: 'assert.deepEqual(popShift(["challenge", "is", "not", "complete"]), ["challenge", "complete"], "<code>popShift(["challenge", "is", "not", "complete"])</code> should return <code>["challenge", "complete"]</code>");'
|
||||
- text: La función <code>popShift</code> debería utilizar el método <code>pop()</code>
|
||||
testString: 'assert.notStrictEqual(popShift.toString().search(/\.pop\(/), -1, "The <code>popShift</code> function should utilize the <code>pop()</code> method");'
|
||||
@@ -49,6 +42,7 @@ function popShift(arr) {
|
||||
|
||||
// do not change code below this line
|
||||
console.log(popShift(['challenge', 'is', 'not', 'complete']));
|
||||
|
||||
```
|
||||
|
||||
</div>
|
||||
|
||||
@@ -1,23 +1,16 @@
|
||||
---
|
||||
id: 587d78b2367417b2b2512b10
|
||||
title: Remove Items Using splice()
|
||||
localeTitle: Quitar elementos utilizando empalme ()
|
||||
challengeType: 1
|
||||
videoUrl: ''
|
||||
localeTitle: Quitar elementos utilizando empalme ()
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
Bien, hemos aprendido cómo eliminar elementos del principio y el final de los arreglos usando <code>shift()</code> y <code>pop()</code> , pero ¿qué pasa si queremos eliminar un elemento de algún lugar en el medio? ¿O eliminar más de un elemento a la vez? Bueno, ahí es donde entra <code>splice()</code> . <code>splice()</code> nos permite hacer precisamente eso: <strong>eliminar cualquier número de elementos consecutivos</strong> de cualquier lugar en una matriz.
|
||||
<code>splice()</code> puede tomar hasta 3 parámetros, pero por ahora, nos enfocaremos solo en los primeros 2. Los primeros dos parámetros de <code>splice()</code> son enteros que representan índices, o posiciones, de la matriz que <code>splice()</code> es siendo llamado. Y recuerde, las matrices tienen <em>un índice de cero</em> , por lo que para indicar el primer elemento de una matriz, usaríamos <code>0</code> . El primer parámetro de <code>splice()</code> representa el índice en la matriz a partir de la cual comenzar a eliminar elementos, mientras que el segundo parámetro indica el número de elementos a eliminar. Por ejemplo:
|
||||
<blockquote>let array = ['today', 'was', 'not', 'so', 'great'];<br><br>array.splice(2, 2);<br>// remove 2 elements beginning with the 3rd element<br>// array now equals ['today', 'was', 'great']</blockquote>
|
||||
<code>splice()</code> no solo modifica la matriz en la que se llama, sino que también devuelve una nueva matriz que contiene el valor de los elementos eliminados:
|
||||
<blockquote>let array = ['I', 'am', 'feeling', 'really', 'happy'];<br><br>let newArray = array.splice(3, 2);<br>// newArray equals ['really', 'happy']</blockquote>
|
||||
</section>
|
||||
<section id="description"> Bien, hemos aprendido cómo eliminar elementos del principio y el final de las matrices con <code>shift()</code> y <code>pop()</code> , pero ¿qué pasa si queremos eliminar un elemento de algún lugar en el medio? ¿O eliminar más de un elemento a la vez? Bueno, ahí es donde entra <code>splice()</code> . <code>splice()</code> nos permite hacer precisamente eso: <strong>eliminar cualquier número de elementos consecutivos</strong> de cualquier lugar en una matriz. <code>splice()</code> puede tomar hasta 3 parámetros, pero por ahora, nos enfocaremos solo en los primeros 2. Los primeros dos parámetros de <code>splice()</code> son enteros que representan índices, o posiciones, de la matriz que <code>splice()</code> está siendo exhortó a. Y recuerde, las matrices tienen <em>un índice de cero</em> , por lo que para indicar el primer elemento de una matriz, usaríamos <code>0</code> . El primer parámetro de <code>splice()</code> representa el índice en la matriz a partir de la cual comenzar a eliminar elementos, mientras que el segundo parámetro indica el número de elementos a eliminar. Por ejemplo: <blockquote> let array = ['today', 'was', 'not', 'so', 'great']; <br><br> array.splice (2, 2); <br> // eliminar 2 elementos comenzando con el 3er elemento <br> // array ahora es igual a ['today', 'was', 'great'] </blockquote> <code>splice()</code> no solo modifica la matriz, sino que también devuelve una nueva matriz que contiene el valor de los elementos eliminados: <blockquote> dejar array = ['I', 'am', 'feeling', 'really', 'happy']; <br><br> deja newArray = array.splice (3, 2); <br> // newArray es igual a ['really', 'happy'] </blockquote></section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
Hemos definido una función, <code>sumOfTen</code> , que toma una matriz como argumento y devuelve la suma de los elementos de esa matriz. Modifique la función, usando <code>splice()</code> , para que devuelva un valor de <code>10</code> .
|
||||
</section>
|
||||
<section id="instructions"> Hemos definido una función, <code>sumOfTen</code> , que toma una matriz como argumento y devuelve la suma de los elementos de esa matriz. Modifique la función, usando <code>splice()</code> , para que devuelva un valor de <code>10</code> . </section>
|
||||
|
||||
## Tests
|
||||
<section id='tests'>
|
||||
@@ -48,6 +41,7 @@ function sumOfTen(arr) {
|
||||
|
||||
// do not change code below this line
|
||||
console.log(sumOfTen([2, 5, 1, 5, 2, 1]));
|
||||
|
||||
```
|
||||
|
||||
</div>
|
||||
|
||||
@@ -1,23 +1,16 @@
|
||||
---
|
||||
id: 587d7b7e367417b2b2512b20
|
||||
title: Use an Array to Store a Collection of Data
|
||||
localeTitle: Utilice una matriz para almacenar una colección de datos
|
||||
challengeType: 1
|
||||
videoUrl: ''
|
||||
localeTitle: Utilice una matriz para almacenar una colección de datos
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
A continuación se muestra un ejemplo de la implementación más simple de una estructura de datos de matriz. Esto se conoce como una <dfn>matriz unidimensional</dfn> , lo que significa que solo tiene un nivel, o que no tiene ninguna otra matriz anidada dentro de ella. Observe que contiene <dfn>valores booleanos</dfn> , <dfn>cadenas</dfn> y <dfn>números</dfn> , entre otros tipos de datos de JavaScript válidos:
|
||||
<blockquote>let simpleArray = ['one', 2, 'three’, true, false, undefined, null];<br>console.log(simpleArray.length);<br>// logs 7</blockquote>
|
||||
Todas las matrices tienen una propiedad de longitud que, como se muestra arriba, se puede acceder muy fácilmente con la sintaxis <code>Array.length</code> .
|
||||
Una implementación más compleja de una matriz se puede ver a continuación. Esto se conoce como una <dfn>matriz multidimensional</dfn> o una matriz que contiene otras matrices. Tenga en cuenta que esta matriz también contiene <dfn>objetos</dfn> JavaScript, que examinaremos detenidamente en nuestra próxima sección, pero por ahora, todo lo que necesita saber es que las matrices también son capaces de almacenar objetos complejos.
|
||||
<blockquote>let complexArray = [<br> [<br> {<br> one: 1,<br> two: 2<br> },<br> {<br> three: 3,<br> four: 4<br> }<br> ],<br> [<br> {<br> a: "a",<br> b: "b"<br> },<br> {<br> c: "c",<br> d: “d”<br> }<br> ]<br>];</blockquote>
|
||||
</section>
|
||||
<section id="description"> El siguiente es un ejemplo de la implementación más simple de una estructura de datos de matriz. Esto se conoce como una <dfn>matriz unidimensional</dfn> , lo que significa que solo tiene un nivel, o que no tiene ninguna otra matriz anidada dentro de ella. Observe que contiene <dfn>valores booleanos</dfn> , <dfn>cadenas</dfn> y <dfn>números</dfn> , entre otros tipos de datos de JavaScript válidos: <blockquote> deje simpleArray = ['uno', 2, 'tres', verdadero, falso, indefinido, nulo]; <br> console.log (simpleArray.length); <br> // logs 7 </blockquote> Todas las matrices tienen una propiedad de longitud, que, como se muestra arriba, se puede acceder muy fácilmente con la sintaxis <code>Array.length</code> . Una implementación más compleja de una matriz se puede ver a continuación. Esto se conoce como una <dfn>matriz multidimensional</dfn> o una matriz que contiene otras matrices. Tenga en cuenta que esta matriz también contiene <dfn>objetos</dfn> JavaScript, que examinaremos detenidamente en nuestra próxima sección, pero por ahora, todo lo que necesita saber es que las matrices también son capaces de almacenar objetos complejos. <blockquote> deja complexArray = [ <br> El <br> { <br> uno 1, <br> dos: 2 <br> } <br> { <br> tres: 3, <br> cuatro: 4 <br> } <br> ] <br> El <br> { <br> a: "a", <br> b: "b" <br> } <br> { <br> c: "c", <br> d: "d" <br> } <br> ] <br> ]; </blockquote></section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
Hemos definido una variable llamada <code>yourArray</code> . Complete la declaración asignando una matriz de al menos 5 elementos de longitud a la variable <code>yourArray</code> . Su matriz debe contener al menos una <dfn>cadena</dfn> , un <dfn>número</dfn> y un <dfn>booleano</dfn> .
|
||||
</section>
|
||||
<section id="instructions"> Hemos definido una variable llamada <code>yourArray</code> . Complete la declaración asignando una matriz de al menos 5 elementos de longitud a la variable <code>yourArray</code> . Su matriz debe contener al menos una <dfn>cadena</dfn> , un <dfn>número</dfn> y un <dfn>booleano</dfn> . </section>
|
||||
|
||||
## Tests
|
||||
<section id='tests'>
|
||||
@@ -26,13 +19,13 @@ Hemos definido una variable llamada <code>yourArray</code> . Complete la declara
|
||||
tests:
|
||||
- text: yourArray es una matriz
|
||||
testString: 'assert.strictEqual(Array.isArray(yourArray), true, "yourArray is an array");'
|
||||
- text: <code class = "notranslate"> yourArray </code> tiene al menos 5 elementos
|
||||
- text: <code>yourArray</code> tiene al menos 5 elementos de largo
|
||||
testString: 'assert.isAtLeast(yourArray.length, 5, "<code>yourArray</code> is at least 5 elements long");'
|
||||
- text: <code class = "notranslate"> yourArray </code> contiene al menos un <code class = "notranslate"> boolean </code>
|
||||
- text: <code>yourArray</code> contiene al menos un <code>boolean</code>
|
||||
testString: 'assert(yourArray.filter( el => typeof el === "boolean").length >= 1, "<code>yourArray</code> contains at least one <code>boolean</code>");'
|
||||
- text: <code class = "notranslate"> yourArray </code> contiene al menos un <code class = "notranslate"> number </code>
|
||||
- text: <code>yourArray</code> contiene al menos un <code>number</code>
|
||||
testString: 'assert(yourArray.filter( el => typeof el === "number").length >= 1, "<code>yourArray</code> contains at least one <code>number</code>");'
|
||||
- text: <code class = "notranslate"> yourArray </code> contiene al menos una <code class = "notranslate"> string </code>
|
||||
- text: <code>yourArray</code> contiene al menos una <code>string</code>
|
||||
testString: 'assert(yourArray.filter( el => typeof el === "string").length >= 1, "<code>yourArray</code> contains at least one <code>string</code>");'
|
||||
|
||||
```
|
||||
@@ -46,6 +39,7 @@ tests:
|
||||
|
||||
```js
|
||||
let yourArray; // change this line
|
||||
|
||||
```
|
||||
|
||||
</div>
|
||||
|
||||
@@ -1,31 +1,25 @@
|
||||
---
|
||||
id: 587d7b7c367417b2b2512b1b
|
||||
title: Use the delete Keyword to Remove Object Properties
|
||||
localeTitle: Utilice la palabra clave delete para eliminar las propiedades del objeto
|
||||
challengeType: 1
|
||||
videoUrl: ''
|
||||
localeTitle: Utilice la palabra clave delete para eliminar las propiedades del objeto
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
Ahora ya sabes qué son los objetos y sus características y ventajas básicas. En resumen, son tiendas de valor clave que proporcionan una forma flexible e intuitiva de estructurar los datos <strong><em>y</em></strong> proporcionan un tiempo de búsqueda muy rápido. A lo largo del resto de estos desafíos, describiremos varias operaciones comunes que puede realizar en objetos para que pueda sentirse cómodo aplicando estas estructuras de datos útiles en sus programas.
|
||||
En desafíos anteriores, hemos agregado y modificado los pares clave-valor de un objeto. Aquí veremos cómo podemos <em>eliminar</em> un par clave-valor de un objeto.
|
||||
Repasemos nuestro ejemplo de objeto de <code>foods</code> una última vez. Si quisiéramos eliminar la clave de las <code>apples</code> , podemos eliminarla usando la palabra clave <code>delete</code> así:
|
||||
<blockquote>delete foods.apples;</blockquote>
|
||||
</section>
|
||||
<section id="description"> Ahora sabes qué son los objetos y sus características y ventajas básicas. En resumen, son tiendas de valor clave que proporcionan una forma flexible e intuitiva de estructurar los datos <strong><em>y</em></strong> proporcionan un tiempo de búsqueda muy rápido. A lo largo del resto de estos desafíos, describiremos varias operaciones comunes que puede realizar en objetos para que pueda sentirse cómodo aplicando estas estructuras de datos útiles en sus programas. En desafíos anteriores, hemos agregado y modificado los pares clave-valor de un objeto. Aquí veremos cómo podemos <em>eliminar</em> un par clave-valor de un objeto. Repasemos nuestro ejemplo de objeto de <code>foods</code> una última vez. Si quisiéramos eliminar la clave de las <code>apples</code> , podemos eliminarla utilizando la palabra clave <code>delete</code> siguiente manera: <blockquote> eliminar foods.apples; </blockquote></section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
Use la palabra clave delete para eliminar las teclas de <code>oranges</code> , <code>plums</code> y <code>strawberries</code> del objeto de <code>foods</code> .
|
||||
</section>
|
||||
<section id="instructions"> Use la palabra clave delete para eliminar las teclas de <code>oranges</code> , <code>plums</code> y <code>strawberries</code> del objeto de <code>foods</code> . </section>
|
||||
|
||||
## Tests
|
||||
<section id='tests'>
|
||||
|
||||
```yml
|
||||
tests:
|
||||
- text: 'El objeto de <code>foods</code> solo tiene tres claves: <code>apples</code> , <code>grapes</code> y <code>bananas</code> '
|
||||
- text: 'El objeto de <code>foods</code> solo tiene tres claves: <code>apples</code> , <code>grapes</code> y <code>bananas</code>'
|
||||
testString: 'assert(!foods.hasOwnProperty("oranges") && !foods.hasOwnProperty("plums") && !foods.hasOwnProperty("strawberries") && Object.keys(foods).length === 3, "The <code>foods</code> object only has three keys: <code>apples</code>, <code>grapes</code>, and <code>bananas</code>");'
|
||||
- text: 'Las claves de <code>oranges</code> , <code>plums</code> y <code>strawberries</code> se eliminan usando <code>delete</code> '
|
||||
- text: 'Las claves de <code>oranges</code> , <code>plums</code> y <code>strawberries</code> se eliminan usando <code>delete</code>'
|
||||
testString: 'assert(code.search(/oranges:/) !== -1 && code.search(/plums:/) !== -1 && code.search(/strawberries:/) !== -1, "The <code>oranges</code>, <code>plums</code>, and <code>strawberries</code> keys are removed using <code>delete</code>");'
|
||||
|
||||
```
|
||||
@@ -52,6 +46,7 @@ let foods = {
|
||||
// change code above this line
|
||||
|
||||
console.log(foods);
|
||||
|
||||
```
|
||||
|
||||
</div>
|
||||
|
||||
@@ -1,24 +1,17 @@
|
||||
---
|
||||
id: 56bbb991ad1ed5201cd392ca
|
||||
title: Access Array Data with Indexes
|
||||
localeTitle: Acceso a datos de matriz con índices
|
||||
challengeType: 1
|
||||
guideUrl: 'https://spanish.freecodecamp.org/guide/certificates/access-array-data-with-indexes'
|
||||
videoUrl: ''
|
||||
localeTitle: Acceso a datos de matriz con índices
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
Podemos acceder a los datos dentro de las matrices utilizando <code>indexes</code> .
|
||||
índices de matriz se escriben en la misma notación de corchete que usan las cadenas, excepto que en lugar de especificar un carácter, están especificando una entrada en la matriz. Al igual que las cadenas, las matrices utilizan indización <dfn>basada en cero</dfn> , por lo que el primer elemento de una matriz es el elemento <code>0</code> .
|
||||
<strong>Ejemplo</strong>
|
||||
<blockquote>var array = [50,60,70];<br>array[0]; // equals 50<br>var data = array[1]; // equals 60</blockquote>
|
||||
<strong>Nota</strong> <br> No debe haber espacios entre el nombre de la matriz y los corchetes, como la <code>array [0]</code> . Aunque JavaScript puede procesar esto correctamente, esto puede confundir a otros programadores que leen su código.
|
||||
</section>
|
||||
<section id="description"> Podemos acceder a los datos dentro de las matrices utilizando <code>indexes</code> . Los índices de matriz se escriben en la misma notación de corchete que usan las cadenas, excepto que en lugar de especificar un carácter, están especificando una entrada en la matriz. Al igual que las cadenas, las matrices utilizan indización <dfn>basada en cero</dfn> , por lo que el primer elemento de una matriz es el elemento <code>0</code> . <strong>Ejemplo</strong> <blockquote> var array = [50,60,70]; <br> array [0]; // es igual a 50 <br> var data = array [1]; // es igual a 60 </blockquote> <strong>Nota</strong> <br> No debe haber espacios entre el nombre de la matriz y los corchetes, como la <code>array [0]</code> . Aunque JavaScript puede procesar esto correctamente, esto puede confundir a otros programadores que leen su código. </section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
Cree una variable llamada <code>myData</code> y <code>myArray</code> para que sea igual al primer valor de <code>myArray</code> usando notación de corchete.
|
||||
</section>
|
||||
<section id="instructions"> Cree una variable llamada <code>myData</code> y <code>myArray</code> para que sea igual al primer valor de <code>myArray</code> usando notación de corchetes. </section>
|
||||
|
||||
## Tests
|
||||
<section id='tests'>
|
||||
@@ -68,10 +61,7 @@ console.info('after the test');
|
||||
## Solution
|
||||
<section id='solution'>
|
||||
|
||||
|
||||
```js
|
||||
var myArray = [50,60,70];
|
||||
var myData = myArray[0];
|
||||
// solution required
|
||||
```
|
||||
|
||||
</section>
|
||||
|
||||
@@ -1,23 +1,17 @@
|
||||
---
|
||||
id: 56592a60ddddeae28f7aa8e1
|
||||
title: Access Multi-Dimensional Arrays With Indexes
|
||||
localeTitle: Acceder a matrices multidimensionales con índices
|
||||
challengeType: 1
|
||||
guideUrl: 'https://spanish.freecodecamp.org/guide/certificates/access-array-data-with-indexes'
|
||||
videoUrl: ''
|
||||
localeTitle: Acceder a matrices multidimensionales con índices
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
Una forma de pensar en una matriz <dfn>multidimensional</dfn> es como una <em>matriz de matrices</em> . Cuando usa corchetes para acceder a su matriz, el primer conjunto de corchetes se refiere a las entradas en la matriz más externa (el primer nivel), y cada par adicional de corchetes se refiere al siguiente nivel de entradas adentro.
|
||||
<strong>Ejemplo</strong>
|
||||
<blockquote>var arr = [<br> [1,2,3],<br> [4,5,6],<br> [7,8,9],<br> [[10,11,12], 13, 14]<br>];<br>arr[3]; // equals [[10,11,12], 13, 14]<br>arr[3][0]; // equals [10,11,12]<br>arr[3][0][1]; // equals 11</blockquote>
|
||||
<strong>Nota</strong> <br> No debe haber espacios entre el nombre de la matriz y los corchetes, como la <code>array [0][0]</code> e incluso esta <code>array [0] [0]</code> no está permitida. Aunque JavaScript puede procesar esto correctamente, esto puede confundir a otros programadores que leen su código.
|
||||
</section>
|
||||
<section id="description"> Una forma de pensar en una matriz <dfn>multidimensional</dfn> es como una <em>matriz de matrices</em> . Cuando usa corchetes para acceder a su matriz, el primer conjunto de corchetes se refiere a las entradas en la matriz más externa (el primer nivel), y cada par adicional de corchetes se refiere al siguiente nivel de entradas adentro. <strong>Ejemplo</strong> <blockquote> var arr = [ <br> [1,2,3], <br> [4,5,6], <br> [7,8,9], <br> [[10,11,12], 13, 14] <br> ]; <br> arr [3]; // es igual a [[10,11,12], 13, 14] <br> arr [3] [0]; // es igual a [10,11,12] <br> arr [3] [0] [1]; // es igual a 11 </blockquote> <strong>Nota</strong> <br> No debe haber espacios entre el nombre de la matriz y los corchetes, como la <code>array [0][0]</code> e incluso esta <code>array [0] [0]</code> no está permitida. Aunque JavaScript puede procesar esto correctamente, esto puede confundir a otros programadores que leen su código. </section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
Usando la notación de corchetes, seleccione un elemento de <code>myArray</code> para que <code>myData</code> sea igual a <code>8</code> .
|
||||
</section>
|
||||
<section id="instructions"> Usando la notación de corchetes, seleccione un elemento de <code>myArray</code> para que <code>myData</code> sea igual a <code>8</code> . </section>
|
||||
|
||||
## Tests
|
||||
<section id='tests'>
|
||||
@@ -64,10 +58,7 @@ console.info('after the test');
|
||||
## Solution
|
||||
<section id='solution'>
|
||||
|
||||
|
||||
```js
|
||||
var myArray = [[1,2,3],[4,5,6], [7,8,9], [[10,11,12], 13, 14]];
|
||||
var myData = myArray[2][1];
|
||||
// solution required
|
||||
```
|
||||
|
||||
</section>
|
||||
|
||||
@@ -1,22 +1,17 @@
|
||||
---
|
||||
id: 56533eb9ac21ba0edf2244cd
|
||||
title: Accessing Nested Arrays
|
||||
localeTitle: Acceso a matrices anidadas
|
||||
challengeType: 1
|
||||
guideUrl: 'https://spanish.freecodecamp.org/guide/certificates/access-array-data-with-indexes'
|
||||
videoUrl: ''
|
||||
localeTitle: Acceso a matrices anidadas
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
Como hemos visto en ejemplos anteriores, los objetos pueden contener tanto objetos anidados como matrices anidadas. Al igual que para acceder a objetos anidados, la notación de paréntesis de arrays se puede encadenar para acceder a arrays anidados.
|
||||
Aquí hay un ejemplo de cómo acceder a una matriz anidada:
|
||||
<blockquote>var ourPets = [<br> {<br> animalType: "cat",<br> names: [<br> "Meowzer",<br> "Fluffy",<br> "Kit-Cat"<br> ]<br> },<br> {<br> animalType: "dog",<br> names: [<br> "Spot",<br> "Bowser",<br> "Frankie"<br> ]<br> }<br>];<br>ourPets[0].names[1]; // "Fluffy"<br>ourPets[1].names[0]; // "Spot"</blockquote>
|
||||
</section>
|
||||
<section id="description"> Como hemos visto en ejemplos anteriores, los objetos pueden contener tanto objetos anidados como matrices anidadas. Al igual que para acceder a objetos anidados, la notación de paréntesis de arrays se puede encadenar para acceder a arrays anidados. Aquí hay un ejemplo de cómo acceder a una matriz anidada: <blockquote> var ourPets = [ <br> { <br> tipo de animal: "gato", <br> nombres: [ <br> "Meowzer", <br> "Mullido", <br> "Kit-Cat" <br> ] <br> } <br> { <br> tipo de animal: "perro", <br> nombres: [ <br> "Lugar", <br> "Bowser", <br> "Frankie" <br> ] <br> } <br> ]; <br> ourPets [0] .names [1]; // "Fluffy" <br> ourPets [1] .names [0]; // "Lugar" </blockquote></section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
Recupere el segundo árbol de la variable <code>myPlants</code> usando el punto de objeto y la notación de corchete de matriz.
|
||||
</section>
|
||||
<section id="instructions"> Recupere el segundo árbol de la variable <code>myPlants</code> usando el punto de objeto y la notación de corchete de matriz. </section>
|
||||
|
||||
## Tests
|
||||
<section id='tests'>
|
||||
@@ -81,30 +76,7 @@ console.info('after the test');
|
||||
## Solution
|
||||
<section id='solution'>
|
||||
|
||||
|
||||
```js
|
||||
var myPlants = [
|
||||
{
|
||||
type: "flowers",
|
||||
list: [
|
||||
"rose",
|
||||
"tulip",
|
||||
"dandelion"
|
||||
]
|
||||
},
|
||||
{
|
||||
type: "trees",
|
||||
list: [
|
||||
"fir",
|
||||
"pine",
|
||||
"birch"
|
||||
]
|
||||
}
|
||||
];
|
||||
|
||||
// Only change code below this line
|
||||
|
||||
var secondTree = myPlants[1].list[1];
|
||||
// solution required
|
||||
```
|
||||
|
||||
</section>
|
||||
|
||||
@@ -1,22 +1,17 @@
|
||||
---
|
||||
id: 56533eb9ac21ba0edf2244cc
|
||||
title: Accessing Nested Objects
|
||||
localeTitle: Accediendo a objetos anidados
|
||||
challengeType: 1
|
||||
guideUrl: 'https://spanish.freecodecamp.org/guide/certificates/accessing-nested-objects-in-json'
|
||||
videoUrl: ''
|
||||
localeTitle: Accediendo a objetos anidados
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
Se puede acceder a las sub-propiedades de los objetos encadenando la notación de punto o corchete.
|
||||
Aquí hay un objeto anidado:
|
||||
<blockquote>var ourStorage = {<br> "desk": {<br> "drawer": "stapler"<br> },<br> "cabinet": {<br> "top drawer": { <br> "folder1": "a file",<br> "folder2": "secrets"<br> },<br> "bottom drawer": "soda"<br> }<br>};<br>ourStorage.cabinet["top drawer"].folder2; // "secrets"<br>ourStorage.desk.drawer; // "stapler"</blockquote>
|
||||
</section>
|
||||
<section id="description"> Se puede acceder a las sub-propiedades de los objetos encadenando la notación de punto o corchete. Aquí hay un objeto anidado: <blockquote> var ourStorage = { <br> "escritorio": { <br> "cajón": "grapadora" <br> } <br> "gabinete": { <br> "cajón de arriba": { <br> "folder1": "un archivo", <br> "folder2": "secretos" <br> } <br> "cajón inferior": "soda" <br> } <br> }; <br> ourStorage.cabinet ["cajón superior"]. folder2; // "secretos" <br> ourStorage.desk.drawer; // "engrapadora" </blockquote></section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
Acceda al objeto <code>myStorage</code> y asigne el contenido de la propiedad de la <code>glove box</code> a la variable <code>gloveBoxContents</code> . Utilice la notación de corchete para las propiedades con un espacio en su nombre.
|
||||
</section>
|
||||
<section id="instructions"> Acceda al objeto <code>myStorage</code> y asigne el contenido de la propiedad <code>glove box</code> a la variable <code>gloveBoxContents</code> . Utilice la notación de corchete para las propiedades con un espacio en su nombre. </section>
|
||||
|
||||
## Tests
|
||||
<section id='tests'>
|
||||
@@ -72,20 +67,7 @@ console.info('after the test');
|
||||
## Solution
|
||||
<section id='solution'>
|
||||
|
||||
|
||||
```js
|
||||
var myStorage = {
|
||||
"car":{
|
||||
"inside":{
|
||||
"glove box":"maps",
|
||||
"passenger seat":"crumbs"
|
||||
},
|
||||
"outside":{
|
||||
"trunk":"jack"
|
||||
}
|
||||
}
|
||||
};
|
||||
var gloveBoxContents = myStorage.car.inside["glove box"];
|
||||
// solution required
|
||||
```
|
||||
|
||||
</section>
|
||||
|
||||
@@ -1,24 +1,17 @@
|
||||
---
|
||||
id: 56533eb9ac21ba0edf2244c8
|
||||
title: Accessing Object Properties with Bracket Notation
|
||||
localeTitle: Acceso a las propiedades del objeto con notación de corchete
|
||||
challengeType: 1
|
||||
guideUrl: 'https://spanish.freecodecamp.org/guide/certificates/accessing-objects-properties-with-bracket-notation'
|
||||
videoUrl: ''
|
||||
localeTitle: Acceso a las propiedades del objeto con notación de corchete
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
La segunda forma de acceder a las propiedades de un objeto es la notación de corchetes ( <code>[]</code> ). Si la propiedad del objeto al que intenta acceder tiene un espacio en su nombre, deberá utilizar la notación de corchetes.
|
||||
Sin embargo, aún puede usar la notación de corchete en las propiedades del objeto sin espacios.
|
||||
Aquí hay una muestra del uso de la notación de corchetes para leer la propiedad de un objeto:
|
||||
<blockquote>var myObj = {<br> "Space Name": "Kirk",<br> "More Space": "Spock",<br> "NoSpace": "USS Enterprise"<br>};<br>myObj["Space Name"]; // Kirk<br>myObj['More Space']; // Spock<br>myObj["NoSpace"]; // USS Enterprise</blockquote>
|
||||
Tenga en cuenta que los nombres de propiedades con espacios en ellos deben estar entre comillas (simple o doble).
|
||||
</section>
|
||||
<section id="description"> La segunda forma de acceder a las propiedades de un objeto es la notación de corchetes ( <code>[]</code> ). Si la propiedad del objeto al que intenta acceder tiene un espacio en su nombre, deberá utilizar la notación de corchetes. Sin embargo, aún puede usar la notación de corchete en las propiedades del objeto sin espacios. Aquí hay una muestra del uso de la notación de corchetes para leer la propiedad de un objeto: <blockquote> var myObj = { <br> "Nombre del espacio": "Kirk", <br> "Más espacio": "Spock", <br> "NoSpace": "USS Enterprise" <br> }; <br> myObj ["Nombre del espacio"]; // Kirk <br> myObj ['Más espacio']; // Spock <br> myObj ["NoSpace"]; // USS Enterprise </blockquote> Tenga en cuenta que los nombres de propiedades con espacios en ellos deben estar entre comillas (simple o doble). </section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
Lea los valores de las propiedades <code>"an entree"</code> y <code>"the drink"</code> de <code>testObj</code> utilizando la notación de corchetes y asignarlos a <code>entreeValue</code> y <code>drinkValue</code> respectivamente.
|
||||
</section>
|
||||
<section id="instructions"> Lea los valores de las propiedades <code>"an entree"</code> y <code>"the drink"</code> de <code>testObj</code> utilizando la notación de corchetes y asignarlos a <code>entreeValue</code> y <code>drinkValue</code> respectivamente. </section>
|
||||
|
||||
## Tests
|
||||
<section id='tests'>
|
||||
@@ -57,6 +50,7 @@ var testObj = {
|
||||
|
||||
var entreeValue = testObj; // Change this line
|
||||
var drinkValue = testObj; // Change this line
|
||||
|
||||
```
|
||||
|
||||
</div>
|
||||
@@ -76,15 +70,7 @@ console.info('after the test');
|
||||
## Solution
|
||||
<section id='solution'>
|
||||
|
||||
|
||||
```js
|
||||
var testObj = {
|
||||
"an entree": "hamburger",
|
||||
"my side": "veggies",
|
||||
"the drink": "water"
|
||||
};
|
||||
var entreeValue = testObj["an entree"];
|
||||
var drinkValue = testObj['the drink'];
|
||||
// solution required
|
||||
```
|
||||
|
||||
</section>
|
||||
|
||||
@@ -1,22 +1,16 @@
|
||||
---
|
||||
id: 56533eb9ac21ba0edf2244c7
|
||||
title: Accessing Object Properties with Dot Notation
|
||||
localeTitle: Acceso a las propiedades del objeto con notación de puntos
|
||||
challengeType: 1
|
||||
videoUrl: ''
|
||||
localeTitle: Acceso a las propiedades del objeto con notación de puntos
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
Hay dos formas de acceder a las propiedades de un objeto: notación de puntos ( <code>.</code> ) Y notación de corchetes ( <code>[]</code> ), similar a una matriz.
|
||||
notación de puntos es lo que usa cuando conoce el nombre de la propiedad a la que intenta acceder con anticipación.
|
||||
Aquí hay una muestra de cómo usar la notación de puntos ( <code>.</code> ) Para leer la propiedad de un objeto:
|
||||
<blockquote>var myObj = {<br> prop1: "val1",<br> prop2: "val2"<br>};<br>var prop1val = myObj.prop1; // val1<br>var prop2val = myObj.prop2; // val2</blockquote>
|
||||
</section>
|
||||
<section id="description"> Hay dos formas de acceder a las propiedades de un objeto: notación de puntos ( <code>.</code> ) Y notación de corchetes ( <code>[]</code> ), similar a una matriz. La notación de puntos es lo que usa cuando conoce el nombre de la propiedad a la que intenta acceder con anticipación. Aquí hay una muestra del uso de la notación de puntos ( <code>.</code> ) Para leer la propiedad de un objeto: <blockquote> var myObj = { <br> prop1: "val1", <br> prop2: "val2" <br> }; <br> var prop1val = myObj.prop1; // val1 <br> var prop2val = myObj.prop2; // val2 </blockquote></section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
Lea los valores de propiedad de <code>testObj</code> usando la notación de puntos. Establezca la variable <code>hatValue</code> igual al <code>hat</code> propiedad del objeto y establezca la variable <code>shirtValue</code> igual a la <code>shirt</code> propiedad del objeto.
|
||||
</section>
|
||||
<section id="instructions"> Lea los valores de propiedad de <code>testObj</code> usando la notación de puntos. Establezca la variable <code>hatValue</code> igual al <code>hat</code> propiedad del objeto y establezca la variable <code>shirtValue</code> igual a la <code>shirt</code> propiedad del objeto. </section>
|
||||
|
||||
## Tests
|
||||
<section id='tests'>
|
||||
@@ -55,6 +49,7 @@ var testObj = {
|
||||
|
||||
var hatValue = testObj; // Change this line
|
||||
var shirtValue = testObj; // Change this line
|
||||
|
||||
```
|
||||
|
||||
</div>
|
||||
@@ -74,16 +69,7 @@ console.info('after the test');
|
||||
## Solution
|
||||
<section id='solution'>
|
||||
|
||||
|
||||
```js
|
||||
var testObj = {
|
||||
"hat": "ballcap",
|
||||
"shirt": "jersey",
|
||||
"shoes": "cleats"
|
||||
};
|
||||
|
||||
var hatValue = testObj.hat;
|
||||
var shirtValue = testObj.shirt;
|
||||
// solution required
|
||||
```
|
||||
|
||||
</section>
|
||||
|
||||
@@ -1,27 +1,17 @@
|
||||
---
|
||||
id: 56533eb9ac21ba0edf2244c9
|
||||
title: Accessing Object Properties with Variables
|
||||
localeTitle: Accediendo a las propiedades del objeto con variables
|
||||
challengeType: 1
|
||||
guideUrl: 'https://spanish.freecodecamp.org/guide/certificates/accessing-objects-properties-with-variables'
|
||||
videoUrl: ''
|
||||
localeTitle: Accediendo a las propiedades del objeto con variables
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
Otro uso de la notación de corchetes en los objetos es acceder a una propiedad que se almacena como el valor de una variable. Esto puede ser muy útil para iterar a través de las propiedades de un objeto o al acceder a una tabla de búsqueda.
|
||||
Aquí hay un ejemplo del uso de una variable para acceder a una propiedad:
|
||||
<blockquote>var dogs = {<br> Fido: "Mutt",
|
||||
Hunter: "Doberman",
|
||||
Snoopie: "Beagle"<br>};<br>var myDog = "Hunter";<br>var myBreed = dogs[myDog];<br>console.log(myBreed); // "Doberman"</blockquote>
|
||||
Otra forma en que puede usar este concepto es cuando el nombre de la propiedad se recopila dinámicamente durante la ejecución del programa, de la siguiente manera:
|
||||
<blockquote>var someObj = {<br> propName: "John"<br>};<br>function propPrefix(str) {<br> var s = "prop";<br> return s + str;<br>}<br>var someProp = propPrefix("Name"); // someProp now holds the value 'propName'<br>console.log(someObj[someProp]); // "John"</blockquote>
|
||||
Tenga en cuenta que <em>no</em> usamos comillas alrededor del nombre de la variable cuando la usamos para acceder a la propiedad porque estamos usando el <em>valor</em> de la variable, no el <em>nombre</em> .
|
||||
</section>
|
||||
<section id="description"> Otro uso de la notación de corchetes en los objetos es acceder a una propiedad que se almacena como el valor de una variable. Esto puede ser muy útil para iterar a través de las propiedades de un objeto o al acceder a una tabla de búsqueda. Aquí hay un ejemplo del uso de una variable para acceder a una propiedad: <blockquote> perros var = { <br> Fido: "Mutt", Hunter: "Doberman", Snoopie: "Beagle" <br> }; <br> var myDog = "Cazador"; <br> var myBreed = perros [myDog]; <br> console.log (myBreed); // "Doberman" </blockquote> Otra forma en que puede usar este concepto es cuando el nombre de la propiedad se recopila dinámicamente durante la ejecución del programa, de la siguiente manera: <blockquote> var someObj = { <br> propName: "John" <br> }; <br> función propPrefix (str) { <br> var s = "prop"; <br> devuelve s + str; <br> } <br> var someProp = propPrefix ("Name"); // someProp ahora tiene el valor 'propName' <br> console.log (someObj [someProp]); // "John" </blockquote> Tenga en cuenta que <em>no</em> usamos comillas alrededor del nombre de la variable cuando la usamos para acceder a la propiedad porque estamos usando el <em>valor</em> de la variable, no el <em>nombre</em> . </section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
Use la variable <code>playerNumber</code> para buscar el jugador <code>16</code> en <code>testObj</code> usando la notación de corchete. Luego asigna ese nombre a la variable del <code>player</code> .
|
||||
</section>
|
||||
<section id="instructions"> Use la variable <code>playerNumber</code> para buscar el jugador <code>16</code> en <code>testObj</code> usando la notación de corchete. Luego asigna ese nombre a la variable del <code>player</code> . </section>
|
||||
|
||||
## Tests
|
||||
<section id='tests'>
|
||||
@@ -62,6 +52,7 @@ var testObj = {
|
||||
|
||||
var playerNumber; // Change this Line
|
||||
var player = testObj; // Change this Line
|
||||
|
||||
```
|
||||
|
||||
</div>
|
||||
@@ -81,15 +72,7 @@ console.info('after the test');
|
||||
## Solution
|
||||
<section id='solution'>
|
||||
|
||||
|
||||
```js
|
||||
var testObj = {
|
||||
12: "Namath",
|
||||
16: "Montana",
|
||||
19: "Unitas"
|
||||
};
|
||||
var playerNumber = 16;
|
||||
var player = testObj[playerNumber];
|
||||
// solution required
|
||||
```
|
||||
|
||||
</section>
|
||||
|
||||
@@ -1,24 +1,16 @@
|
||||
---
|
||||
id: 56bbb991ad1ed5201cd392d2
|
||||
title: Add New Properties to a JavaScript Object
|
||||
localeTitle: Agregar nuevas propiedades a un objeto de JavaScript
|
||||
challengeType: 1
|
||||
videoUrl: ''
|
||||
localeTitle: Agregar nuevas propiedades a un objeto de JavaScript
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
Puede agregar nuevas propiedades a los objetos JavaScript existentes de la misma manera que los modificaría.
|
||||
Así es como agregaríamos una propiedad de <code>"bark"</code> a <code>ourDog</code> :
|
||||
<code>ourDog.bark = "bow-wow";</code>
|
||||
o
|
||||
<code>ourDog["bark"] = "bow-wow";</code>
|
||||
Ahora, cuando evaluamos <code>ourDog.bark</code> , obtendremos su ladrido, "bow-wow".
|
||||
</section>
|
||||
<section id="description"> Puede agregar nuevas propiedades a los objetos JavaScript existentes de la misma manera que los modificaría. Así es como agregaríamos una propiedad de <code>"bark"</code> a <code>ourDog</code> : <code>ourDog.bark = "bow-wow";</code> o <code>ourDog["bark"] = "bow-wow";</code> Ahora, cuando evaluamos <code>ourDog.bark</code> , obtendremos su ladrido, "bow-wow". </section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
Agrega una propiedad de <code>"bark"</code> a <code>myDog</code> y <code>myDog</code> con un sonido de perro, como "woof". Puede usar la notación de punto o corchete.
|
||||
</section>
|
||||
<section id="instructions"> Agrega una propiedad de <code>"bark"</code> a <code>myDog</code> y <code>myDog</code> con un sonido de perro, como "woof". Puede usar la notación de punto o corchete. </section>
|
||||
|
||||
## Tests
|
||||
<section id='tests'>
|
||||
@@ -79,15 +71,7 @@ console.info('after the test');
|
||||
## Solution
|
||||
<section id='solution'>
|
||||
|
||||
|
||||
```js
|
||||
var myDog = {
|
||||
"name": "Happy Coder",
|
||||
"legs": 4,
|
||||
"tails": 1,
|
||||
"friends": ["freeCodeCamp Campers"]
|
||||
};
|
||||
myDog.bark = "Woof Woof";
|
||||
// solution required
|
||||
```
|
||||
|
||||
</section>
|
||||
|
||||
@@ -1,23 +1,16 @@
|
||||
---
|
||||
id: cf1111c1c11feddfaeb3bdef
|
||||
title: Add Two Numbers with JavaScript
|
||||
localeTitle: Añadir dos números con JavaScript
|
||||
challengeType: 1
|
||||
videoUrl: ''
|
||||
localeTitle: Añadir dos números con JavaScript
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
<code>Number</code> es un tipo de datos en JavaScript que representa datos numéricos.
|
||||
Ahora vamos a tratar de sumar dos números usando JavaScript.
|
||||
JavaScript usa el símbolo <code>+</code> como operación de suma cuando se coloca entre dos números.
|
||||
<strong>Ejemplo</strong>
|
||||
<blockquote>myVar = 5 + 10; // assigned 15</blockquote>
|
||||
</section>
|
||||
<section id="description"> <code>Number</code> es un tipo de datos en JavaScript que representa datos numéricos. Ahora intentemos agregar dos números usando JavaScript. JavaScript usa el símbolo <code>+</code> como operación de suma cuando se coloca entre dos números. <strong>Ejemplo</strong> <blockquote> myVar = 5 + 10; // asignado 15 </blockquote></section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
Cambia el <code>0</code> para que la suma sea igual a <code>20</code> .
|
||||
</section>
|
||||
<section id="instructions"> Cambia el <code>0</code> para que la suma sea igual a <code>20</code> . </section>
|
||||
|
||||
## Tests
|
||||
<section id='tests'>
|
||||
@@ -60,9 +53,7 @@ console.info('after the test');
|
||||
## Solution
|
||||
<section id='solution'>
|
||||
|
||||
|
||||
```js
|
||||
var sum = 10 + 10;
|
||||
// solution required
|
||||
```
|
||||
|
||||
</section>
|
||||
|
||||
@@ -1,22 +1,17 @@
|
||||
---
|
||||
id: 56533eb9ac21ba0edf2244de
|
||||
title: Adding a Default Option in Switch Statements
|
||||
localeTitle: Adición de una opción predeterminada en los estados de cambio
|
||||
challengeType: 1
|
||||
guideUrl: 'https://spanish.freecodecamp.org/guide/certificates/adding-a-default-option-in-switch-statements'
|
||||
videoUrl: ''
|
||||
localeTitle: Adición de una opción predeterminada en los estados de cambio
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
En una declaración de <code>switch</code> , es posible que no pueda especificar todos los valores posibles como declaraciones de <code>case</code> . En su lugar, puede agregar la declaración <code>default</code> que se ejecutará si no se encuentran declaraciones de <code>case</code> coincidentes. Piense en ello como la última instrucción <code>else</code> en una cadena <code>if/else</code> .
|
||||
Una declaración por <code>default</code> debe ser el último caso.
|
||||
<blockquote>switch (num) {<br> case value1:<br> statement1;<br> break;<br> case value2:<br> statement2;<br> break;<br>...<br> default:<br> defaultStatement;<br> break;<br>}</blockquote>
|
||||
</section>
|
||||
<section id="description"> En una declaración de <code>switch</code> , es posible que no pueda especificar todos los valores posibles como declaraciones de <code>case</code> . En su lugar, puede agregar la declaración <code>default</code> que se ejecutará si no se encuentran declaraciones de <code>case</code> coincidentes. Piense en ello como la última instrucción <code>else</code> en una cadena <code>if/else</code> . Una declaración por <code>default</code> debe ser el último caso. <blockquote> interruptor (núm) { <br> valor de caso1: <br> sentencia1; <br> descanso; <br> valor de caso2: <br> declaración2; <br> descanso; <br> ... <br> defecto: <br> declaración por defecto; <br> descanso; <br> } </blockquote></section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
Escriba una instrucción de cambio para establecer la <code>answer</code> para las siguientes condiciones: <br> <code>"a"</code> - "manzana" <br> <code>"b"</code> - "pájaro" <br> <code>"c"</code> - "gato" <br> <code>default</code> - "cosas"
|
||||
</section>
|
||||
<section id="instructions"> Escriba una instrucción de cambio para establecer la <code>answer</code> para las siguientes condiciones: <br> <code>"a"</code> - "manzana" <br> <code>"b"</code> - "pájaro" <br> <code>"c"</code> - "gato" <br> <code>default</code> - "cosas" </section>
|
||||
|
||||
## Tests
|
||||
<section id='tests'>
|
||||
@@ -74,26 +69,7 @@ switchOfStuff(1);
|
||||
## Solution
|
||||
<section id='solution'>
|
||||
|
||||
|
||||
```js
|
||||
function switchOfStuff(val) {
|
||||
var answer = "";
|
||||
|
||||
switch(val) {
|
||||
case "a":
|
||||
answer = "apple";
|
||||
break;
|
||||
case "b":
|
||||
answer = "bird";
|
||||
break;
|
||||
case "c":
|
||||
answer = "cat";
|
||||
break;
|
||||
default:
|
||||
answer = "stuff";
|
||||
}
|
||||
return answer;
|
||||
}
|
||||
// solution required
|
||||
```
|
||||
|
||||
</section>
|
||||
|
||||
@@ -1,20 +1,17 @@
|
||||
---
|
||||
id: 56533eb9ac21ba0edf2244ed
|
||||
title: Appending Variables to Strings
|
||||
localeTitle: Anexando Variables a las Cadenas
|
||||
challengeType: 1
|
||||
guideUrl: 'https://spanish.freecodecamp.org/guide/certificates/appending-variables-to-strings'
|
||||
videoUrl: ''
|
||||
localeTitle: Anexando Variables a las Cadenas
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
Al igual que podemos construir una cadena sobre varias líneas a partir de <dfn>literales</dfn> de cadena, también podemos agregar variables a una cadena usando el operador más es igual a ( <code>+=</code> ).
|
||||
</section>
|
||||
<section id="description"> Del mismo modo que podemos construir una cadena sobre varias líneas a partir de <dfn>literales</dfn> de cadena, también podemos agregar variables a una cadena utilizando el operador más es igual a ( <code>+=</code> ). </section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
Establezca <code>someAdjective</code> y <code>someAdjective</code> a <code>myStr</code> usando el operador <code>+=</code> .
|
||||
</section>
|
||||
<section id="instructions"> Configure <code>someAdjective</code> y <code>someAdjective</code> a <code>myStr</code> usando el operador <code>+=</code> . </section>
|
||||
|
||||
## Tests
|
||||
<section id='tests'>
|
||||
@@ -65,15 +62,7 @@ console.info('after the test');
|
||||
## Solution
|
||||
<section id='solution'>
|
||||
|
||||
|
||||
```js
|
||||
var anAdjective = "awesome!";
|
||||
var ourStr = "freeCodeCamp is ";
|
||||
ourStr += anAdjective;
|
||||
|
||||
var someAdjective = "neat";
|
||||
var myStr = "Learning to code is ";
|
||||
myStr += someAdjective;
|
||||
// solution required
|
||||
```
|
||||
|
||||
</section>
|
||||
|
||||
@@ -1,23 +1,17 @@
|
||||
---
|
||||
id: 56533eb9ac21ba0edf2244c3
|
||||
title: Assignment with a Returned Value
|
||||
localeTitle: Asignación con un valor devuelto
|
||||
challengeType: 1
|
||||
guideUrl: 'https://spanish.freecodecamp.org/guide/certificates/assignment-with-a-returned-value'
|
||||
videoUrl: ''
|
||||
localeTitle: Asignación con un valor devuelto
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
Si recordará de nuestra discusión sobre el <a href="javascript-algorithms-and-data-structures/basic-javascript/storing-values-with-the-assignment-operator" target="_blank">almacenamiento de valores con el operador de asignación</a> , todo a la derecha del signo igual se resuelve antes de que se asigne el valor. Esto significa que podemos tomar el valor de retorno de una función y asignarlo a una variable.
|
||||
Supongamos que hemos predefinido una <code>sum</code> función que suma dos números, luego:
|
||||
<code>ourSum = sum(5, 12);</code>
|
||||
llamará a la función <code>sum</code> , que devuelve un valor de <code>17</code> y lo asigna a <code>ourSum</code> variable <code>ourSum</code> .
|
||||
</section>
|
||||
<section id="description"> Si recuerda de nuestra discusión sobre el <a href="javascript-algorithms-and-data-structures/basic-javascript/storing-values-with-the-assignment-operator" target="_blank">almacenamiento de valores con el operador de asignación</a> , todo a la derecha del signo igual se resuelve antes de que se asigne el valor. Esto significa que podemos tomar el valor de retorno de una función y asignarlo a una variable. Supongamos que hemos predefinido una <code>sum</code> función que suma dos números, entonces: <code>ourSum = sum(5, 12);</code> <code>ourSum</code> a la función <code>sum</code> , que devuelve un valor de <code>17</code> y lo asigna a <code>ourSum</code> variable <code>ourSum</code> </section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
Llame a la función <code>processArg</code> con un argumento de <code>7</code> y asigne su valor de retorno a la variable <code>processed</code> .
|
||||
</section>
|
||||
<section id="instructions"> Llame a la función <code>processArg</code> con un argumento de <code>7</code> y asigne su valor de retorno a la variable <code>processed</code> . </section>
|
||||
|
||||
## Tests
|
||||
<section id='tests'>
|
||||
@@ -57,7 +51,6 @@ function processArg(num) {
|
||||
|
||||
// Only change code below this line
|
||||
|
||||
|
||||
```
|
||||
|
||||
</div>
|
||||
@@ -77,15 +70,7 @@ console.info('after the test');
|
||||
## Solution
|
||||
<section id='solution'>
|
||||
|
||||
|
||||
```js
|
||||
var processed = 0;
|
||||
|
||||
function processArg(num) {
|
||||
return (num + 3) / 5;
|
||||
}
|
||||
|
||||
processed = processArg(7);
|
||||
// solution required
|
||||
```
|
||||
|
||||
</section>
|
||||
|
||||
@@ -1,27 +1,16 @@
|
||||
---
|
||||
id: 56bbb991ad1ed5201cd392d0
|
||||
title: Build JavaScript Objects
|
||||
localeTitle: Construir objetos de JavaScript
|
||||
challengeType: 1
|
||||
videoUrl: ''
|
||||
localeTitle: Construir objetos de JavaScript
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
Es posible que hayas escuchado el término <code>object</code> antes.
|
||||
objetos son similares a las <code>arrays</code> , excepto que en lugar de utilizar índices para acceder y modificar sus datos, puede acceder a los datos en objetos a través de lo que se denomina <code>properties</code> .
|
||||
objetos son útiles para almacenar datos de manera estructurada y pueden representar objetos del mundo real, como un gato.
|
||||
Aquí hay una muestra de un objeto de gato:
|
||||
<blockquote>var cat = {<br> "name": "Whiskers",<br> "legs": 4,<br> "tails": 1,<br> "enemies": ["Water", "Dogs"]<br>};</blockquote>
|
||||
En este ejemplo, todas las propiedades se almacenan como cadenas, como <code>"name"</code> , <code>"legs"</code> y <code>"tails"</code> . Sin embargo, también puede utilizar los números como propiedades. Incluso puede omitir las comillas para las propiedades de cadena de una sola palabra, de la siguiente manera:
|
||||
<blockquote>var anotherObject = {<br> make: "Ford",<br> 5: "five",<br> "model": "focus"<br>};</blockquote>
|
||||
Sin embargo, si su objeto tiene propiedades que no son de cadena, JavaScript las encasillará automáticamente como cadenas.
|
||||
</section>
|
||||
<section id="description"> Es posible que haya escuchado el término <code>object</code> antes. Los objetos son similares a las <code>arrays</code> , excepto que, en lugar de utilizar índices para acceder y modificar sus datos, puede acceder a los datos de los objetos a través de lo que se denomina <code>properties</code> . Los objetos son útiles para almacenar datos de forma estructurada y pueden representar objetos del mundo real, como un gato. Aquí hay una muestra de un objeto cat: <blockquote> var cat = { <br> "nombre": "bigotes", <br> "piernas": 4, <br> "colas": 1, <br> "enemigos": ["Agua", "Perros"] <br> }; </blockquote> En este ejemplo, todas las propiedades se almacenan como cadenas, como <code>"name"</code> , <code>"legs"</code> y <code>"tails"</code> . Sin embargo, también puede utilizar los números como propiedades. Incluso puede omitir las citas de las propiedades de cadena de una sola palabra, de la siguiente manera: <blockquote> var anotherObject = { <br> hacer: "Ford", <br> 5: "cinco", <br> "modelo": "enfoque" <br> }; </blockquote> Sin embargo, si su objeto tiene propiedades que no son de cadena, JavaScript las encasilla automáticamente como cadenas. </section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
Haz un objeto que represente un perro llamado <code>myDog</code> que contenga las propiedades <code>"name"</code> (una cadena), <code>"legs"</code> , <code>"tails"</code> y <code>"friends"</code> .
|
||||
Puede establecer estas propiedades de objeto en los valores que desee, siempre que <code>"name"</code> sea una cadena, <code>"legs"</code> y <code>"tails"</code> sean números, y <code>"friends"</code> es una matriz.
|
||||
</section>
|
||||
<section id="instructions"> Haga un objeto que represente a un perro llamado <code>myDog</code> que contenga las propiedades <code>"name"</code> (una cadena), <code>"legs"</code> , <code>"tails"</code> y <code>"friends"</code> . Puede establecer estas propiedades de objeto en los valores que desee, siempre que <code>"name"</code> sea una cadena, <code>"legs"</code> y <code>"tails"</code> sean números, y <code>"friends"</code> es una matriz. </section>
|
||||
|
||||
## Tests
|
||||
<section id='tests'>
|
||||
@@ -65,6 +54,7 @@ var myDog = {
|
||||
|
||||
|
||||
};
|
||||
|
||||
```
|
||||
|
||||
</div>
|
||||
@@ -84,14 +74,7 @@ console.info('after the test');
|
||||
## Solution
|
||||
<section id='solution'>
|
||||
|
||||
|
||||
```js
|
||||
var myDog = {
|
||||
"name": "Camper",
|
||||
"legs": 4,
|
||||
"tails": 1,
|
||||
"friends": ["everything!"]
|
||||
};
|
||||
// solution required
|
||||
```
|
||||
|
||||
</section>
|
||||
|
||||
@@ -1,21 +1,16 @@
|
||||
---
|
||||
id: 56533eb9ac21ba0edf2244dc
|
||||
title: Chaining If Else Statements
|
||||
localeTitle: Encadenamiento en caso contrario
|
||||
challengeType: 1
|
||||
videoUrl: ''
|
||||
localeTitle: Encadenamiento en caso contrario
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
<code>if/else</code> sentencias pueden ser encadenadas juntas para lógica compleja. Aquí está el <dfn>pseudocódigo</dfn> de múltiples encadenadas <code>if</code> / <code>else if</code> enunciados:
|
||||
<blockquote>if ( <em>condition1</em> ) {<br> <em>statement1</em> <br>} else if ( <em>condition2</em> ) {<br> <em>statement2</em> <br>} else if ( <em>condition3</em> ) {<br> <em>statement3</em> <br>. . .<br>} else {<br> <em>statementN</em> <br>}</blockquote>
|
||||
</section>
|
||||
<section id="description"> <code>if/else</code> declaraciones <code>if/else</code> se pueden encadenar para una lógica compleja. Aquí está el <dfn>pseudocódigo</dfn> de múltiples encadenadas <code>if</code> / <code>else if</code> sentencias: <blockquote> if ( <em>condición1</em> ) { <br> <em>declaración1</em> <br> } else if ( <em>condition2</em> ) { <br> <em>declaración2</em> <br> } else if ( <em>condition3</em> ) { <br> <em>declaración3</em> <br> . . . <br> } else { <br> <em>declaraciónN</em> <br> } </blockquote></section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
Escribir en cadena <code>if</code> / <code>else if</code> sentencias para cumplir con las siguientes condiciones:
|
||||
<code>num < 5</code> - devolver "Tiny" <br> <code>num < 10</code> - devuelve "Small" <br> <code>num < 15</code> - devuelve "Medio" <br> <code>num < 20</code> - devuelve "Large" <br> <code>num >= 20</code> - devuelve "Enorme"
|
||||
</section>
|
||||
<section id="instructions"> Escriba en cadena las sentencias <code>if</code> / <code>else if</code> para cumplir las siguientes condiciones: <code>num < 5</code> - return "Tiny" <br> <code>num < 10</code> - devuelve "Small" <br> <code>num < 15</code> - devuelve "Medio" <br> <code>num < 20</code> - devuelve "Large" <br> <code>num >= 20</code> - devuelve "Enorme" </section>
|
||||
|
||||
## Tests
|
||||
<section id='tests'>
|
||||
@@ -69,6 +64,7 @@ function testSize(num) {
|
||||
|
||||
// Change this value to test
|
||||
testSize(7);
|
||||
|
||||
```
|
||||
|
||||
</div>
|
||||
@@ -80,21 +76,7 @@ testSize(7);
|
||||
## Solution
|
||||
<section id='solution'>
|
||||
|
||||
|
||||
```js
|
||||
function testSize(num) {
|
||||
if (num < 5) {
|
||||
return "Tiny";
|
||||
} else if (num < 10) {
|
||||
return "Small";
|
||||
} else if (num < 15) {
|
||||
return "Medium";
|
||||
} else if (num < 20) {
|
||||
return "Large";
|
||||
} else {
|
||||
return "Huge";
|
||||
}
|
||||
}
|
||||
// solution required
|
||||
```
|
||||
|
||||
</section>
|
||||
|
||||
@@ -1,25 +1,16 @@
|
||||
---
|
||||
id: bd7123c9c441eddfaeb4bdef
|
||||
title: Comment Your JavaScript Code
|
||||
localeTitle: Comenta tu código JavaScript
|
||||
challengeType: 1
|
||||
videoUrl: ''
|
||||
localeTitle: Comenta tu código JavaScript
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
comentarios son líneas de código que JavaScript ignorará intencionalmente. Los comentarios son una excelente manera de dejar notas para usted y para otras personas que más tarde necesitarán averiguar qué hace ese código.
|
||||
Hay dos formas de escribir comentarios en JavaScript:
|
||||
Al usar <code>//</code> le indicará a JavaScript que ignore el resto del texto en la línea actual:
|
||||
<blockquote>// This is an in-line comment.</blockquote>
|
||||
Puede hacer un comentario de varias líneas comenzando con <code>/*</code> y terminando con <code>*/</code> :
|
||||
<blockquote>/* This is a<br>multi-line comment */</blockquote>
|
||||
<strong>Mejores Prácticas</strong> <br> A medida que escribe el código, debe agregar comentarios regularmente para aclarar la función de partes de su código. Los buenos comentarios pueden ayudar a comunicar la intención de su código, tanto para los demás <em>como</em> para su futuro.
|
||||
</section>
|
||||
<section id="description"> Los comentarios son líneas de código que JavaScript ignorará intencionalmente. Los comentarios son una excelente manera de dejar notas para usted y para otras personas que más tarde necesitarán averiguar qué hace ese código. Hay dos formas de escribir comentarios en JavaScript: Usar <code>//</code> le dirá a JavaScript que ignore el resto del texto en la línea actual: <blockquote> // Este es un comentario en línea. </blockquote> Puede hacer un comentario de varias líneas comenzando con <code>/*</code> y terminando con <code>*/</code> : <blockquote> /* Esto es un <br> comentario multilínea * / </blockquote> <strong>Mejores prácticas</strong> <br> A medida que escribe el código, debe agregar comentarios regularmente para aclarar la función de partes de su código. Los buenos comentarios pueden ayudar a comunicar la intención de su código, tanto para los demás <em>como</em> para su futuro. </section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
Intenta crear uno de cada tipo de comentario.
|
||||
</section>
|
||||
<section id="instructions"> Intenta crear uno de cada tipo de comentario. </section>
|
||||
|
||||
## Tests
|
||||
<section id='tests'>
|
||||
@@ -53,10 +44,7 @@ tests:
|
||||
## Solution
|
||||
<section id='solution'>
|
||||
|
||||
|
||||
```js
|
||||
// Fake Comment
|
||||
/* Another Comment */
|
||||
// solution required
|
||||
```
|
||||
|
||||
</section>
|
||||
|
||||
@@ -1,24 +1,16 @@
|
||||
---
|
||||
id: 56533eb9ac21ba0edf2244d0
|
||||
title: Comparison with the Equality Operator
|
||||
localeTitle: Comparación con el operador de igualdad
|
||||
challengeType: 1
|
||||
videoUrl: ''
|
||||
localeTitle: Comparación con el operador de igualdad
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
Hay muchos <dfn>operadores de comparación</dfn> en JavaScript. Todos estos operadores devuelven un valor <code>true</code> o <code>false</code> booleano.
|
||||
El operador más básico es el operador de igualdad <code>==</code> . El operador de igualdad compara dos valores y devuelve <code>true</code> si son equivalentes o <code>false</code> si no lo son. Tenga en cuenta que la igualdad es diferente de la asignación ( <code>=</code> ), que asigna el valor a la derecha del operador a una variable en la izquierda.
|
||||
<blockquote>function equalityTest(myVal) {<br> if (myVal == 10) {<br> return "Equal";<br> }<br> return "Not Equal";<br>}</blockquote>
|
||||
Si <code>myVal</code> es igual a <code>10</code> , el operador de igualdad devuelve <code>true</code> , por lo que se ejecutará el código entre llaves y la función devolverá <code>"Equal"</code> . De lo contrario, la función devolverá <code>"Not Equal"</code> .
|
||||
Para que JavaScript pueda comparar dos <code>data types</code> (por ejemplo, <code>numbers</code> y <code>strings</code> ), debe convertir un tipo a otro. Esto se conoce como "Tipo de coerción". Una vez que lo hace, sin embargo, puede comparar los términos de la siguiente manera:
|
||||
<blockquote>1 == 1 // true<br>1 == 2 // false<br>1 == '1' // true<br>"3" == 3 // true</blockquote>
|
||||
</section>
|
||||
<section id="description"> Hay muchos <dfn>operadores de comparación</dfn> en JavaScript. Todos estos operadores devuelven un valor <code>true</code> o <code>false</code> booleano. El operador más básico es el operador de igualdad <code>==</code> . El operador de igualdad compara dos valores y devuelve <code>true</code> si son equivalentes o <code>false</code> si no lo son. Tenga en cuenta que la igualdad es diferente de la asignación ( <code>=</code> ), que asigna el valor a la derecha del operador a una variable en la izquierda. <blockquote> function equalTest (myVal) { <br> si (myVal == 10) { <br> devuelve "Igual"; <br> } <br> devuelve "No es igual"; <br> } </blockquote> Si <code>myVal</code> es igual a <code>10</code> , el operador de igualdad devuelve <code>true</code> , por lo que el código entre las llaves se ejecutará y la función devolverá <code>"Equal"</code> . De lo contrario, la función devolverá <code>"Not Equal"</code> . Para que JavaScript pueda comparar dos <code>data types</code> (por ejemplo, <code>numbers</code> y <code>strings</code> ), debe convertir un tipo a otro. Esto se conoce como "Tipo de coerción". Una vez que lo hace, sin embargo, puede comparar los términos de la siguiente manera: <blockquote> 1 == 1 // verdadero <br> 1 == 2 // falso <br> 1 == '1' // verdadero <br> "3" == 3 // verdadero </blockquote></section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
Agregue el <code>equality operator</code> a la línea indicada para que la función devuelva "Igual" cuando <code>val</code> sea equivalente a <code>12</code>
|
||||
</section>
|
||||
<section id="instructions"> Agregue el <code>equality operator</code> a la línea indicada para que la función devuelva "Igual" cuando <code>val</code> sea equivalente a <code>12</code> </section>
|
||||
|
||||
## Tests
|
||||
<section id='tests'>
|
||||
@@ -54,6 +46,7 @@ function testEqual(val) {
|
||||
|
||||
// Change this value to test
|
||||
testEqual(10);
|
||||
|
||||
```
|
||||
|
||||
</div>
|
||||
@@ -65,14 +58,7 @@ testEqual(10);
|
||||
## Solution
|
||||
<section id='solution'>
|
||||
|
||||
|
||||
```js
|
||||
function testEqual(val) {
|
||||
if (val == 12) {
|
||||
return "Equal";
|
||||
}
|
||||
return "Not Equal";
|
||||
}
|
||||
// solution required
|
||||
```
|
||||
|
||||
</section>
|
||||
|
||||
@@ -1,22 +1,16 @@
|
||||
---
|
||||
id: 56533eb9ac21ba0edf2244d4
|
||||
title: Comparison with the Greater Than Operator
|
||||
localeTitle: Comparación con el operador mayor que
|
||||
challengeType: 1
|
||||
videoUrl: ''
|
||||
localeTitle: Comparación con el operador mayor que
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
El operador mayor que ( <code>></code> ) compara los valores de dos números. Si el número a la izquierda es mayor que el número a la derecha, devuelve <code>true</code> . De lo contrario, devuelve <code>false</code> .
|
||||
Al igual que el operador de igualdad, el operador mayor que el convertirá los tipos de datos de valores al comparar.
|
||||
<strong>ejemplos</strong>
|
||||
<blockquote> 5 > 3 // true<br> 7 > '3' // true<br> 2 > 3 // false<br>'1' > 9 // false</blockquote>
|
||||
</section>
|
||||
<section id="description"> El operador mayor que ( <code>></code> ) compara los valores de dos números. Si el número a la izquierda es mayor que el número a la derecha, devuelve <code>true</code> . De lo contrario, devuelve <code>false</code> . Al igual que el operador de igualdad, el operador mayor que el convertirá los tipos de datos de valores al comparar. <strong>Ejemplos</strong> <blockquote> 5> 3 // verdadero <br> 7> '3' // verdadero <br> 2> 3 // falso <br> '1'> 9 // falso </blockquote></section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
Agregue el operador <code>greater than</code> a las líneas indicadas para que las declaraciones de devolución tengan sentido.
|
||||
</section>
|
||||
<section id="instructions"> Agregue el operador <code>greater than</code> a las líneas indicadas para que las declaraciones de devolución tengan sentido. </section>
|
||||
|
||||
## Tests
|
||||
<section id='tests'>
|
||||
@@ -64,6 +58,7 @@ function testGreaterThan(val) {
|
||||
|
||||
// Change this value to test
|
||||
testGreaterThan(10);
|
||||
|
||||
```
|
||||
|
||||
</div>
|
||||
@@ -75,17 +70,7 @@ testGreaterThan(10);
|
||||
## Solution
|
||||
<section id='solution'>
|
||||
|
||||
|
||||
```js
|
||||
function testGreaterThan(val) {
|
||||
if (val > 100) { // Change this line
|
||||
return "Over 100";
|
||||
}
|
||||
if (val > 10) { // Change this line
|
||||
return "Over 10";
|
||||
}
|
||||
return "10 or Under";
|
||||
}
|
||||
// solution required
|
||||
```
|
||||
|
||||
</section>
|
||||
|
||||
@@ -1,22 +1,16 @@
|
||||
---
|
||||
id: 56533eb9ac21ba0edf2244d5
|
||||
title: Comparison with the Greater Than Or Equal To Operator
|
||||
localeTitle: Comparación con el operador mayor o igual que el operador
|
||||
challengeType: 1
|
||||
videoUrl: ''
|
||||
localeTitle: Comparación con el operador mayor o igual que el operador
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
El operador <code>greater than or equal to</code> ( <code>>=</code> ) compara los valores de dos números. Si el número a la izquierda es mayor o igual que el número a la derecha, devuelve <code>true</code> . De lo contrario, devuelve <code>false</code> .
|
||||
Al igual que el operador de igualdad, <code>greater than or equal to</code> operador convertirá los tipos de datos al comparar.
|
||||
<strong>ejemplos</strong>
|
||||
<blockquote> 6 >= 6 // true<br> 7 >= '3' // true<br> 2 >= 3 // false<br>'7' >= 9 // false</blockquote>
|
||||
</section>
|
||||
<section id="description"> El operador <code>greater than or equal to</code> ( <code>>=</code> ) compara los valores de dos números. Si el número a la izquierda es mayor o igual que el número a la derecha, devuelve <code>true</code> . De lo contrario, devuelve <code>false</code> . Al igual que el operador de igualdad, <code>greater than or equal to</code> operador convertirá los tipos de datos al comparar. <strong>Ejemplos</strong> <blockquote> 6> = 6 // verdadero <br> 7> = '3' // verdadero <br> 2> = 3 // falso <br> '7'> = 9 // falso </blockquote></section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
Agregue el operador <code>greater than or equal to</code> las líneas indicadas para que las declaraciones de devolución tengan sentido.
|
||||
</section>
|
||||
<section id="instructions"> Agregue el operador <code>greater than or equal to</code> las líneas indicadas para que las declaraciones de devolución tengan sentido. </section>
|
||||
|
||||
## Tests
|
||||
<section id='tests'>
|
||||
@@ -64,6 +58,7 @@ function testGreaterOrEqual(val) {
|
||||
|
||||
// Change this value to test
|
||||
testGreaterOrEqual(10);
|
||||
|
||||
```
|
||||
|
||||
</div>
|
||||
@@ -75,19 +70,7 @@ testGreaterOrEqual(10);
|
||||
## Solution
|
||||
<section id='solution'>
|
||||
|
||||
|
||||
```js
|
||||
function testGreaterOrEqual(val) {
|
||||
if (val >= 20) { // Change this line
|
||||
return "20 or Over";
|
||||
}
|
||||
|
||||
if (val >= 10) { // Change this line
|
||||
return "10 or Over";
|
||||
}
|
||||
|
||||
return "Less than 10";
|
||||
}
|
||||
// solution required
|
||||
```
|
||||
|
||||
</section>
|
||||
|
||||
@@ -1,21 +1,16 @@
|
||||
---
|
||||
id: 56533eb9ac21ba0edf2244d2
|
||||
title: Comparison with the Inequality Operator
|
||||
localeTitle: Comparación con el operador de desigualdad
|
||||
challengeType: 1
|
||||
videoUrl: ''
|
||||
localeTitle: Comparación con el operador de desigualdad
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
El operador de desigualdad ( <code>!=</code> ) Es el opuesto del operador de igualdad. Significa "No es igual" y devuelve <code>false</code> donde la igualdad se volvería <code>true</code> y <em>viceversa</em> . Al igual que el operador de igualdad, el operador de desigualdad convertirá los tipos de datos de los valores al comparar.
|
||||
<strong>ejemplos</strong>
|
||||
<blockquote>1 != 2 // true<br>1 != "1" // false<br>1 != '1' // false<br>1 != true // false<br>0 != false // false</blockquote>
|
||||
</section>
|
||||
<section id="description"> El operador de desigualdad ( <code>!=</code> ) Es lo opuesto al operador de igualdad. Significa "No es igual" y devuelve <code>false</code> donde la igualdad se volvería <code>true</code> y <em>viceversa</em> . Al igual que el operador de igualdad, el operador de desigualdad convertirá los tipos de datos de los valores al comparar. <strong>Ejemplos</strong> <blockquote> 1! = 2 // verdadero <br> 1! = "1" // falso <br> 1! = '1' // falso <br> 1! = Verdadero // falso <br> 0! = Falso // falso </blockquote></section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
Agregue el operador de desigualdad <code>!=</code> En la instrucción <code>if</code> para que la función devuelva "No igual" cuando <code>val</code> no es equivalente a <code>99</code>
|
||||
</section>
|
||||
<section id="instructions"> Agregue el operador de desigualdad <code>!=</code> En la instrucción <code>if</code> para que la función devuelva "No igual" cuando <code>val</code> no es equivalente a <code>99</code> </section>
|
||||
|
||||
## Tests
|
||||
<section id='tests'>
|
||||
@@ -55,6 +50,7 @@ function testNotEqual(val) {
|
||||
|
||||
// Change this value to test
|
||||
testNotEqual(10);
|
||||
|
||||
```
|
||||
|
||||
</div>
|
||||
@@ -66,14 +62,7 @@ testNotEqual(10);
|
||||
## Solution
|
||||
<section id='solution'>
|
||||
|
||||
|
||||
```js
|
||||
function testNotEqual(val) {
|
||||
if (val != 99) {
|
||||
return "Not Equal";
|
||||
}
|
||||
return "Equal";
|
||||
}
|
||||
// solution required
|
||||
```
|
||||
|
||||
</section>
|
||||
|
||||
@@ -1,21 +1,16 @@
|
||||
---
|
||||
id: 56533eb9ac21ba0edf2244d6
|
||||
title: Comparison with the Less Than Operator
|
||||
localeTitle: Comparación con el operador menor que
|
||||
challengeType: 1
|
||||
videoUrl: ''
|
||||
localeTitle: Comparación con el operador menor que
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
El operador <dfn>menor que</dfn> ( <code><</code> ) compara los valores de dos números. Si el número a la izquierda es menor que el número a la derecha, devuelve <code>true</code> . De lo contrario, devuelve <code>false</code> . Al igual que el operador de igualdad, <dfn>menos que el</dfn> operador convierte los tipos de datos al comparar.
|
||||
<strong>ejemplos</strong>
|
||||
<blockquote>2 < 5 // true<br>'3' < 7 // true<br>5 < 5 // false<br>3 < 2 // false<br>'8' < 4 // false</blockquote>
|
||||
</section>
|
||||
<section id="description"> El operador <dfn>menor que</dfn> ( <code><</code> ) compara los valores de dos números. Si el número a la izquierda es menor que el número a la derecha, devuelve <code>true</code> . De lo contrario, devuelve <code>false</code> . Al igual que el operador de igualdad, <dfn>menos que el</dfn> operador convierte los tipos de datos al comparar. <strong>Ejemplos</strong> <blockquote> 2 <5 // verdadero <br> '3' <7 // verdadero <br> 5 <5 // falso <br> 3 <2 // falso <br> '8' <4 // falso </blockquote></section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
Agregue el operador <code>less than</code> a las líneas indicadas para que las declaraciones de devolución tengan sentido.
|
||||
</section>
|
||||
<section id="instructions"> Agregue el operador <code>less than</code> a las líneas indicadas para que las declaraciones de devolución tengan sentido. </section>
|
||||
|
||||
## Tests
|
||||
<section id='tests'>
|
||||
@@ -61,6 +56,7 @@ function testLessThan(val) {
|
||||
|
||||
// Change this value to test
|
||||
testLessThan(10);
|
||||
|
||||
```
|
||||
|
||||
</div>
|
||||
@@ -72,19 +68,7 @@ testLessThan(10);
|
||||
## Solution
|
||||
<section id='solution'>
|
||||
|
||||
|
||||
```js
|
||||
function testLessThan(val) {
|
||||
if (val < 25) { // Change this line
|
||||
return "Under 25";
|
||||
}
|
||||
|
||||
if (val < 55) { // Change this line
|
||||
return "Under 55";
|
||||
}
|
||||
|
||||
return "55 or Over";
|
||||
}
|
||||
// solution required
|
||||
```
|
||||
|
||||
</section>
|
||||
|
||||
@@ -1,21 +1,16 @@
|
||||
---
|
||||
id: 56533eb9ac21ba0edf2244d7
|
||||
title: Comparison with the Less Than Or Equal To Operator
|
||||
localeTitle: Comparación con el operador menor o igual que
|
||||
challengeType: 1
|
||||
videoUrl: ''
|
||||
localeTitle: Comparación con el operador menor o igual que
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
El operador <code>less than or equal to</code> ( <code><=</code> ) compara los valores de dos números. Si el número a la izquierda es menor o igual que el número a la derecha, devuelve <code>true</code> . Si el número de la izquierda es mayor que el de la derecha, devuelve <code>false</code> . Al igual que el operador de igualdad, <code>less than or equal to</code> convierte los tipos de datos.
|
||||
<strong>ejemplos</strong>
|
||||
<blockquote>4 <= 5 // true<br>'7' <= 7 // true<br>5 <= 5 // true<br>3 <= 2 // false<br>'8' <= 4 // false</blockquote>
|
||||
</section>
|
||||
<section id="description"> El operador <code>less than or equal to</code> ( <code><=</code> ) compara los valores de dos números. Si el número a la izquierda es menor o igual que el número a la derecha, devuelve <code>true</code> . Si el número de la izquierda es mayor que el de la derecha, devuelve <code>false</code> . Al igual que el operador de igualdad, <code>less than or equal to</code> convierte los tipos de datos. <strong>Ejemplos</strong> <blockquote> 4 <= 5 // verdadero <br> '7' <= 7 // verdadero <br> 5 <= 5 // verdadero <br> 3 <= 2 // falso <br> '8' <= 4 // falso </blockquote></section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
Agregue el operador <code>less than or equal to</code> las líneas indicadas para que las declaraciones de devolución tengan sentido.
|
||||
</section>
|
||||
<section id="instructions"> Agregue el operador <code>less than or equal to</code> las líneas indicadas para que las declaraciones de devolución tengan sentido. </section>
|
||||
|
||||
## Tests
|
||||
<section id='tests'>
|
||||
@@ -75,19 +70,7 @@ testLessOrEqual(10);
|
||||
## Solution
|
||||
<section id='solution'>
|
||||
|
||||
|
||||
```js
|
||||
function testLessOrEqual(val) {
|
||||
if (val <= 12) { // Change this line
|
||||
return "Smaller Than or Equal to 12";
|
||||
}
|
||||
|
||||
if (val <= 24) { // Change this line
|
||||
return "Smaller Than or Equal to 24";
|
||||
}
|
||||
|
||||
return "More Than 24";
|
||||
}
|
||||
// solution required
|
||||
```
|
||||
|
||||
</section>
|
||||
|
||||
@@ -1,23 +1,16 @@
|
||||
---
|
||||
id: 56533eb9ac21ba0edf2244d1
|
||||
title: Comparison with the Strict Equality Operator
|
||||
localeTitle: Comparación con el operador de igualdad estricta
|
||||
challengeType: 1
|
||||
videoUrl: ''
|
||||
localeTitle: Comparación con el operador de igualdad estricta
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
Igualdad estricta ( <code>===</code> ) es la contraparte del operador de igualdad ( <code>==</code> ). Sin embargo, a diferencia del operador de igualdad, que intenta convertir ambos valores en comparación con un tipo común, el operador de igualdad estricta no realiza una conversión de tipo.
|
||||
Si los valores que se comparan tienen tipos diferentes, se consideran desiguales y el operador de igualdad estricta devolverá el valor falso.
|
||||
<strong>ejemplos</strong>
|
||||
<blockquote>3 === 3 // true<br>3 === '3' // false</blockquote>
|
||||
En el segundo ejemplo, <code>3</code> es un tipo de <code>Number</code> y <code>'3'</code> es un tipo de <code>String</code> .
|
||||
</section>
|
||||
<section id="description"> La igualdad estricta ( <code>===</code> ) es la contraparte del operador de igualdad ( <code>==</code> ). Sin embargo, a diferencia del operador de igualdad, que intenta convertir ambos valores en comparación con un tipo común, el operador de igualdad estricta no realiza una conversión de tipo. Si los valores que se comparan tienen tipos diferentes, se consideran desiguales y el operador de igualdad estricta devolverá el valor falso. <strong>Ejemplos</strong> <blockquote> 3 === 3 // verdadero <br> 3 === '3' // falso </blockquote> En el segundo ejemplo, <code>3</code> es un tipo de <code>Number</code> y <code>'3'</code> es un tipo de <code>String</code> . </section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
Use el operador de igualdad estricta en la instrucción <code>if</code> para que la función devuelva "Igual" cuando <code>val</code> sea estrictamente igual a <code>7</code>
|
||||
</section>
|
||||
<section id="instructions"> Use el operador de igualdad estricta en la instrucción <code>if</code> para que la función devuelva "Igual" cuando <code>val</code> sea estrictamente igual a <code>7</code> </section>
|
||||
|
||||
## Tests
|
||||
<section id='tests'>
|
||||
@@ -53,6 +46,7 @@ function testStrict(val) {
|
||||
|
||||
// Change this value to test
|
||||
testStrict(10);
|
||||
|
||||
```
|
||||
|
||||
</div>
|
||||
@@ -64,14 +58,7 @@ testStrict(10);
|
||||
## Solution
|
||||
<section id='solution'>
|
||||
|
||||
|
||||
```js
|
||||
function testStrict(val) {
|
||||
if (val === 7) {
|
||||
return "Equal";
|
||||
}
|
||||
return "Not Equal";
|
||||
}
|
||||
// solution required
|
||||
```
|
||||
|
||||
</section>
|
||||
|
||||
@@ -1,21 +1,16 @@
|
||||
---
|
||||
id: 56533eb9ac21ba0edf2244d3
|
||||
title: Comparison with the Strict Inequality Operator
|
||||
localeTitle: Comparación con el operador de desigualdad estricta
|
||||
challengeType: 1
|
||||
videoUrl: ''
|
||||
localeTitle: Comparación con el operador de desigualdad estricta
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
El operador de desigualdad estricta ( <code>!==</code> ) es el opuesto lógico del operador de igualdad estricta. Significa "Estrictamente no es igual" y devuelve <code>false</code> donde la igualdad estricta sería <code>true</code> y <em>viceversa</em> . La desigualdad estricta no convertirá los tipos de datos.
|
||||
<strong>ejemplos</strong>
|
||||
<blockquote>3 !== 3 // false<br>3 !== '3' // true<br>4 !== 3 // true</blockquote>
|
||||
</section>
|
||||
<section id="description"> El operador de desigualdad estricta ( <code>!==</code> ) es el opuesto lógico del operador de igualdad estricta. Significa "Estrictamente no es igual" y devuelve <code>false</code> donde la igualdad estricta sería <code>true</code> y <em>viceversa</em> . La desigualdad estricta no convertirá los tipos de datos. <strong>Ejemplos</strong> <blockquote> 3! == 3 // falso <br> 3! == '3' // verdadero <br> 4! == 3 // verdadero </blockquote></section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
Agregue el <code>strict inequality operator</code> a la sentencia <code>if</code> para que la función devuelva "No igual" cuando <code>val</code> no sea estrictamente igual a <code>17</code>
|
||||
</section>
|
||||
<section id="instructions"> Agregue el <code>strict inequality operator</code> a la instrucción <code>if</code> para que la función devuelva "No igual" cuando <code>val</code> no es estrictamente igual a <code>17</code> </section>
|
||||
|
||||
## Tests
|
||||
<section id='tests'>
|
||||
@@ -58,6 +53,7 @@ function testStrictNotEqual(val) {
|
||||
|
||||
// Change this value to test
|
||||
testStrictNotEqual(10);
|
||||
|
||||
```
|
||||
|
||||
</div>
|
||||
@@ -69,14 +65,7 @@ testStrictNotEqual(10);
|
||||
## Solution
|
||||
<section id='solution'>
|
||||
|
||||
|
||||
```js
|
||||
function testStrictNotEqual(val) {
|
||||
if (val !== 17) {
|
||||
return "Not Equal";
|
||||
}
|
||||
return "Equal";
|
||||
}
|
||||
// solution required
|
||||
```
|
||||
|
||||
</section>
|
||||
|
||||
@@ -1,23 +1,16 @@
|
||||
---
|
||||
id: 56533eb9ac21ba0edf2244d8
|
||||
title: Comparisons with the Logical And Operator
|
||||
localeTitle: Comparaciones con lo lógico y el operador.
|
||||
challengeType: 1
|
||||
videoUrl: ''
|
||||
localeTitle: Comparaciones con lo lógico y el operador.
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
A veces necesitará probar más de una cosa a la vez. La <dfn>lógica y el</dfn> operador ( <code>&&</code> ) devuelven <code>true</code> si y solo si los <dfn>operandos</dfn> a su izquierda y derecha son verdaderos.
|
||||
El mismo efecto podría lograrse anidando una instrucción if dentro de otra if:
|
||||
<blockquote>if (num > 5) {<br> if (num < 10) {<br> return "Yes";<br> }<br>}<br>return "No";</blockquote>
|
||||
solo devolverá "Sí" si <code>num</code> es mayor que <code>5</code> y menor que <code>10</code> . La misma lógica se puede escribir como:
|
||||
<blockquote>if (num > 5 && num < 10) {<br> return "Yes";<br>}<br>return "No";</blockquote>
|
||||
</section>
|
||||
<section id="description"> A veces necesitará probar más de una cosa a la vez. La <dfn>lógica y el</dfn> operador ( <code>&&</code> ) devuelven <code>true</code> si y solo si los <dfn>operandos</dfn> a su izquierda y derecha son verdaderos. El mismo efecto podría lograrse anidando una instrucción if dentro de otra si: <blockquote> if (num> 5) { <br> si (num <10) { <br> devuelve "Sí"; <br> } <br> } <br> devuelve "No"; </blockquote> solo devolverá "Sí" si <code>num</code> es mayor que <code>5</code> y menor que <code>10</code> . La misma lógica se puede escribir como: <blockquote> if (num> 5 && num <10) { <br> devuelve "Sí"; <br> } <br> devuelve "No"; </blockquote></section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
Combine las dos declaraciones if en una declaración que devolverá <code>"Yes"</code> si <code>val</code> es menor o igual a <code>50</code> y mayor o igual a <code>25</code> . De lo contrario, devolverá <code>"No"</code> .
|
||||
</section>
|
||||
<section id="instructions"> Combine las dos declaraciones if en una declaración que devolverá <code>"Yes"</code> si <code>val</code> es menor o igual a <code>50</code> y mayor o igual a <code>25</code> . De lo contrario, devolverá <code>"No"</code> . </section>
|
||||
|
||||
## Tests
|
||||
<section id='tests'>
|
||||
@@ -70,6 +63,7 @@ function testLogicalAnd(val) {
|
||||
|
||||
// Change this value to test
|
||||
testLogicalAnd(10);
|
||||
|
||||
```
|
||||
|
||||
</div>
|
||||
@@ -81,14 +75,7 @@ testLogicalAnd(10);
|
||||
## Solution
|
||||
<section id='solution'>
|
||||
|
||||
|
||||
```js
|
||||
function testLogicalAnd(val) {
|
||||
if (val >= 25 && val <= 50) {
|
||||
return "Yes";
|
||||
}
|
||||
return "No";
|
||||
}
|
||||
// solution required
|
||||
```
|
||||
|
||||
</section>
|
||||
|
||||
@@ -1,24 +1,16 @@
|
||||
---
|
||||
id: 56533eb9ac21ba0edf2244d9
|
||||
title: Comparisons with the Logical Or Operator
|
||||
localeTitle: Comparaciones con el operador lógico o
|
||||
challengeType: 1
|
||||
videoUrl: ''
|
||||
localeTitle: Comparaciones con el operador lógico o
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
El <dfn>lógico u</dfn> operador ( <code>||</code> ) devuelve <code>true</code> si cualquiera de los <dfn>operandos</dfn> es <code>true</code> . De lo contrario, devuelve <code>false</code> .
|
||||
El operador <dfn>lógico</dfn> está compuesto de dos símbolos de tubería ( <code>|</code> ). Normalmente, esto se puede encontrar entre las teclas Retroceso e Intro.
|
||||
El patrón a continuación debe parecer familiar de los puntos de paso anteriores:
|
||||
<blockquote>if (num > 10) {<br> return "No";<br>}<br>if (num < 5) {<br> return "No";<br>}<br>return "Yes";</blockquote>
|
||||
devolverá "Sí" solo si el <code>num</code> está entre <code>5</code> y <code>10</code> (5 y 10 incluidos). La misma lógica se puede escribir como:
|
||||
<blockquote>if (num > 10 || num < 5) {<br> return "No";<br>}<br>return "Yes";</blockquote>
|
||||
</section>
|
||||
<section id="description"> El <dfn>lógico u</dfn> operador ( <code>||</code> ) devuelve <code>true</code> si cualquiera de los <dfn>operandos</dfn> es <code>true</code> . De lo contrario, devuelve <code>false</code> . El operador <dfn>lógico o</dfn> está compuesto por dos símbolos de tubería ( <code>|</code> ). Normalmente, esto se puede encontrar entre las teclas Retroceso e Intro. El patrón a continuación debe parecer familiar de los puntos de paso anteriores: <blockquote> if (num> 10) { <br> devuelve "No"; <br> } <br> si (num <5) { <br> devuelve "No"; <br> } <br> devuelve "Sí"; </blockquote> devolverá "Sí" solo si el <code>num</code> está entre <code>5</code> y <code>10</code> (5 y 10 incluidos). La misma lógica se puede escribir como: <blockquote> if (num> 10 || num <5) { <br> devuelve "No"; <br> } <br> devuelve "Sí"; </blockquote></section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
Combine las dos declaraciones <code>if</code> en una declaración que devuelva <code>"Outside"</code> si <code>val</code> no está entre <code>10</code> y <code>20</code> , inclusive. De lo contrario, devuelve <code>"Inside"</code> .
|
||||
</section>
|
||||
<section id="instructions"> Combine las dos declaraciones <code>if</code> en una sola declaración que devuelva <code>"Outside"</code> si <code>val</code> no está entre <code>10</code> y <code>20</code> , inclusive. De lo contrario, devuelve <code>"Inside"</code> . </section>
|
||||
|
||||
## Tests
|
||||
<section id='tests'>
|
||||
@@ -73,6 +65,7 @@ function testLogicalOr(val) {
|
||||
|
||||
// Change this value to test
|
||||
testLogicalOr(15);
|
||||
|
||||
```
|
||||
|
||||
</div>
|
||||
@@ -84,14 +77,7 @@ testLogicalOr(15);
|
||||
## Solution
|
||||
<section id='solution'>
|
||||
|
||||
|
||||
```js
|
||||
function testLogicalOr(val) {
|
||||
if (val < 10 || val > 20) {
|
||||
return "Outside";
|
||||
}
|
||||
return "Inside";
|
||||
}
|
||||
// solution required
|
||||
```
|
||||
|
||||
</section>
|
||||
|
||||
@@ -1,23 +1,16 @@
|
||||
---
|
||||
id: 56533eb9ac21ba0edf2244af
|
||||
title: Compound Assignment With Augmented Addition
|
||||
localeTitle: Asignación compuesta con adición aumentada
|
||||
challengeType: 1
|
||||
videoUrl: ''
|
||||
localeTitle: Asignación compuesta con adición aumentada
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
En la programación, es común usar asignaciones para modificar el contenido de una variable. Recuerde que todo a la derecha del signo igual se evalúa primero, por lo que podemos decir:
|
||||
<code>myVar = myVar + 5;</code>
|
||||
para agregar <code>5</code> a <code>myVar</code> . Dado que este es un patrón tan común, hay operadores que realizan tanto una operación matemática como una asignación en un solo paso.
|
||||
Uno de tales operadores es el operador <code>+=</code> .
|
||||
<blockquote>var myVar = 1;<br>myVar += 5;<br>console.log(myVar); // Returns 6</blockquote>
|
||||
</section>
|
||||
<section id="description"> En programación, es común usar asignaciones para modificar el contenido de una variable. Recuerde que todo a la derecha del signo igual se evalúa primero, por lo que podemos decir: <code>myVar = myVar + 5;</code> para agregar <code>5</code> a <code>myVar</code> . Dado que este es un patrón tan común, hay operadores que realizan tanto una operación matemática como una asignación en un solo paso. Uno de tales operadores es el operador <code>+=</code> . <blockquote> var myVar = 1; <br> myVar + = 5; <br> console.log (myVar); // Devoluciones 6 </blockquote></section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
Convierta las asignaciones para <code>a</code> , <code>b</code> y <code>c</code> para usar el operador <code>+=</code> .
|
||||
</section>
|
||||
<section id="instructions"> Convierta las asignaciones para <code>a</code> , <code>b</code> y <code>c</code> para usar el operador <code>+=</code> . </section>
|
||||
|
||||
## Tests
|
||||
<section id='tests'>
|
||||
@@ -74,15 +67,7 @@ console.info('after the test');
|
||||
## Solution
|
||||
<section id='solution'>
|
||||
|
||||
|
||||
```js
|
||||
var a = 3;
|
||||
var b = 17;
|
||||
var c = 12;
|
||||
|
||||
a += 12;
|
||||
b += 9;
|
||||
c += 7;
|
||||
// solution required
|
||||
```
|
||||
|
||||
</section>
|
||||
|
||||
@@ -1,22 +1,16 @@
|
||||
---
|
||||
id: 56533eb9ac21ba0edf2244b2
|
||||
title: Compound Assignment With Augmented Division
|
||||
localeTitle: Asignación compuesta con división aumentada
|
||||
challengeType: 1
|
||||
videoUrl: ''
|
||||
localeTitle: Asignación compuesta con división aumentada
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
El operador <code>/=</code> divide una variable por otro número.
|
||||
<code>myVar = myVar / 5;</code>
|
||||
<code>myVar</code> por <code>5</code> . Esto se puede reescribir como:
|
||||
<code>myVar /= 5;</code>
|
||||
</section>
|
||||
<section id="description"> El operador <code>/=</code> divide una variable por otro número. <code>myVar = myVar / 5;</code> <code>myVar</code> por <code>5</code> . Esto se puede reescribir como: <code>myVar /= 5;</code> </section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
Convierta las asignaciones para <code>a</code> , <code>b</code> y <code>c</code> para usar el operador <code>/=</code> .
|
||||
</section>
|
||||
<section id="instructions"> Convierta las asignaciones para <code>a</code> , <code>b</code> y <code>c</code> para usar el operador <code>/=</code> . </section>
|
||||
|
||||
## Tests
|
||||
<section id='tests'>
|
||||
@@ -73,15 +67,7 @@ console.info('after the test');
|
||||
## Solution
|
||||
<section id='solution'>
|
||||
|
||||
|
||||
```js
|
||||
var a = 48;
|
||||
var b = 108;
|
||||
var c = 33;
|
||||
|
||||
a /= 12;
|
||||
b /= 4;
|
||||
c /= 11;
|
||||
// solution required
|
||||
```
|
||||
|
||||
</section>
|
||||
|
||||
@@ -1,22 +1,16 @@
|
||||
---
|
||||
id: 56533eb9ac21ba0edf2244b1
|
||||
title: Compound Assignment With Augmented Multiplication
|
||||
localeTitle: Asignación compuesta con multiplicación aumentada
|
||||
challengeType: 1
|
||||
videoUrl: ''
|
||||
localeTitle: Asignación compuesta con multiplicación aumentada
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
El operador <code>*=</code> multiplica una variable por un número.
|
||||
<code>myVar = myVar * 5;</code>
|
||||
multiplicará <code>myVar</code> por <code>5</code> . Esto se puede reescribir como:
|
||||
<code>myVar *= 5;</code>
|
||||
</section>
|
||||
<section id="description"> El operador <code>*=</code> multiplica una variable por un número. <code>myVar = myVar * 5;</code> multiplicará <code>myVar</code> por <code>5</code> . Esto se puede reescribir como: <code>myVar *= 5;</code> </section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
Convierta las asignaciones para <code>a</code> , <code>b</code> y <code>c</code> para usar el operador <code>*=</code> .
|
||||
</section>
|
||||
<section id="instructions"> Convierta las asignaciones para <code>a</code> , <code>b</code> y <code>c</code> para usar el operador <code>*=</code> . </section>
|
||||
|
||||
## Tests
|
||||
<section id='tests'>
|
||||
@@ -54,7 +48,6 @@ a = a * 5;
|
||||
b = 3 * b;
|
||||
c = c * 10;
|
||||
|
||||
|
||||
```
|
||||
|
||||
</div>
|
||||
@@ -74,15 +67,7 @@ console.info('after the test');
|
||||
## Solution
|
||||
<section id='solution'>
|
||||
|
||||
|
||||
```js
|
||||
var a = 5;
|
||||
var b = 12;
|
||||
var c = 4.6;
|
||||
|
||||
a *= 5;
|
||||
b *= 3;
|
||||
c *= 10;
|
||||
// solution required
|
||||
```
|
||||
|
||||
</section>
|
||||
|
||||
@@ -1,22 +1,16 @@
|
||||
---
|
||||
id: 56533eb9ac21ba0edf2244b0
|
||||
title: Compound Assignment With Augmented Subtraction
|
||||
localeTitle: Asignación compuesta con resta aumentada
|
||||
challengeType: 1
|
||||
videoUrl: ''
|
||||
localeTitle: Asignación compuesta con resta aumentada
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
Al igual que el operador <code>+=</code> , <code>-=</code> resta un número de una variable.
|
||||
<code>myVar = myVar - 5;</code>
|
||||
restará <code>5</code> de <code>myVar</code> . Esto se puede reescribir como:
|
||||
<code>myVar -= 5;</code>
|
||||
</section>
|
||||
<section id="description"> Al igual que el operador <code>+=</code> , <code>-=</code> resta un número de una variable. <code>myVar = myVar - 5;</code> restará <code>5</code> de <code>myVar</code> . Esto se puede reescribir como: <code>myVar -= 5;</code> </section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
Convierta las asignaciones para <code>a</code> , <code>b</code> y <code>c</code> para usar el operador <code>-=</code> .
|
||||
</section>
|
||||
<section id="instructions"> Convierta las asignaciones para <code>a</code> , <code>b</code> y <code>c</code> para usar el operador <code>-=</code> . </section>
|
||||
|
||||
## Tests
|
||||
<section id='tests'>
|
||||
@@ -54,7 +48,6 @@ a = a - 6;
|
||||
b = b - 15;
|
||||
c = c - 1;
|
||||
|
||||
|
||||
```
|
||||
|
||||
</div>
|
||||
@@ -74,17 +67,7 @@ console.info('after the test');
|
||||
## Solution
|
||||
<section id='solution'>
|
||||
|
||||
|
||||
```js
|
||||
var a = 11;
|
||||
var b = 9;
|
||||
var c = 3;
|
||||
|
||||
a -= 6;
|
||||
b -= 15;
|
||||
c -= 1;
|
||||
|
||||
|
||||
// solution required
|
||||
```
|
||||
|
||||
</section>
|
||||
|
||||
@@ -1,22 +1,16 @@
|
||||
---
|
||||
id: 56533eb9ac21ba0edf2244b7
|
||||
title: Concatenating Strings with Plus Operator
|
||||
localeTitle: Concatenando cuerdas con el operador Plus
|
||||
challengeType: 1
|
||||
videoUrl: ''
|
||||
localeTitle: Concatenando cuerdas con el operador Plus
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
En JavaScript, cuando el operador <code>+</code> se usa con un valor de <code>String</code> , se llama operador de <dfn>concatenación</dfn> . Puede construir una nueva cadena a partir de otras cadenas <dfn>concatenándolas</dfn> juntas.
|
||||
<strong>Ejemplo</strong>
|
||||
<blockquote>'My name is Alan,' + ' I concatenate.'</blockquote>
|
||||
<strong>Nota</strong> <br> Cuidado con los espacios. La concatenación no agrega espacios entre las cadenas concatenadas, por lo que deberá agregarlas usted mismo.
|
||||
</section>
|
||||
<section id="description"> En JavaScript, cuando el operador <code>+</code> se usa con un valor de <code>String</code> , se llama operador de <dfn>concatenación</dfn> . Puede construir una nueva cadena a partir de otras cadenas <dfn>concatenándolas</dfn> juntas. <strong>Ejemplo</strong> <blockquote> 'Mi nombre es Alan,' + 'Concatené'. </blockquote> <strong>Nota</strong> <br> Cuidado con los espacios. La concatenación no agrega espacios entre las cadenas concatenadas, por lo que deberá agregarlas usted mismo. </section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
Construye <code>myStr</code> partir de las cadenas <code>"This is the start. "</code> y <code>"This is the end."</code> utilizando el operador <code>+</code> .
|
||||
</section>
|
||||
<section id="instructions"> Construye <code>myStr</code> partir de las cadenas <code>"This is the start. "</code> y <code>"This is the end."</code> utilizando el operador <code>+</code> . </section>
|
||||
|
||||
## Tests
|
||||
<section id='tests'>
|
||||
@@ -49,7 +43,6 @@ var ourStr = "I come first. " + "I come second.";
|
||||
|
||||
var myStr;
|
||||
|
||||
|
||||
```
|
||||
|
||||
</div>
|
||||
@@ -69,10 +62,7 @@ console.info('after the test');
|
||||
## Solution
|
||||
<section id='solution'>
|
||||
|
||||
|
||||
```js
|
||||
var ourStr = "I come first. " + "I come second.";
|
||||
var myStr = "This is the start. " + "This is the end.";
|
||||
// solution required
|
||||
```
|
||||
|
||||
</section>
|
||||
|
||||
@@ -1,20 +1,16 @@
|
||||
---
|
||||
id: 56533eb9ac21ba0edf2244b8
|
||||
title: Concatenating Strings with the Plus Equals Operator
|
||||
localeTitle: Concatenando cadenas con el operador Plus Equals
|
||||
challengeType: 1
|
||||
videoUrl: ''
|
||||
localeTitle: Concatenando cadenas con el operador Plus Equals
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
También podemos usar el operador <code>+=</code> para <dfn>concatenar</dfn> una cadena al final de una variable de cadena existente. Esto puede ser muy útil para romper una cadena larga en varias líneas.
|
||||
<strong>Nota</strong> <br> Cuidado con los espacios. La concatenación no agrega espacios entre las cadenas concatenadas, por lo que deberá agregarlas usted mismo.
|
||||
</section>
|
||||
<section id="description"> También podemos usar el operador <code>+=</code> para <dfn>concatenar</dfn> una cadena al final de una variable de cadena existente. Esto puede ser muy útil para romper una cadena larga en varias líneas. <strong>Nota</strong> <br> Cuidado con los espacios. La concatenación no agrega espacios entre las cadenas concatenadas, por lo que deberá agregarlas usted mismo. </section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
Construya <code>myStr</code> en varias líneas concatenando estas dos cadenas: <code>"This is the first sentence. "</code> y <code>"This is the second sentence."</code> utilizando el operador <code>+=</code> . Utilice el operador <code>+=</code> similar a como se muestra en el editor. Comience por asignar la primera cadena a <code>myStr</code> , luego agregue la segunda cadena.
|
||||
</section>
|
||||
<section id="instructions"> Construya <code>myStr</code> en varias líneas concatenando estas dos cadenas: <code>"This is the first sentence. "</code> y <code>"This is the second sentence."</code> utilizando el operador <code>+=</code> . Utilice el operador <code>+=</code> similar a como se muestra en el editor. Comience por asignar la primera cadena a <code>myStr</code> , luego agregue la segunda cadena. </section>
|
||||
|
||||
## Tests
|
||||
<section id='tests'>
|
||||
@@ -44,7 +40,6 @@ ourStr += "I come second.";
|
||||
|
||||
var myStr;
|
||||
|
||||
|
||||
```
|
||||
|
||||
</div>
|
||||
@@ -64,13 +59,7 @@ console.info('after the test');
|
||||
## Solution
|
||||
<section id='solution'>
|
||||
|
||||
|
||||
```js
|
||||
var ourStr = "I come first. ";
|
||||
ourStr += "I come second.";
|
||||
|
||||
var myStr = "This is the first sentence. ";
|
||||
myStr += "This is the second sentence.";
|
||||
// solution required
|
||||
```
|
||||
|
||||
</section>
|
||||
|
||||
@@ -1,19 +1,16 @@
|
||||
---
|
||||
id: 56533eb9ac21ba0edf2244b9
|
||||
title: Constructing Strings with Variables
|
||||
localeTitle: Construyendo cuerdas con variables
|
||||
challengeType: 1
|
||||
videoUrl: ''
|
||||
localeTitle: Construyendo cuerdas con variables
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
A veces necesitarás construir una cadena, al estilo de <a href="https://en.wikipedia.org/wiki/Mad_Libs" target="_blank">Mad Libs</a> . Al utilizar el operador de concatenación ( <code>+</code> ), puede insertar una o más variables en una cadena que está creando.
|
||||
</section>
|
||||
<section id="description"> A veces necesitarás construir una cadena, al estilo de <a href="https://en.wikipedia.org/wiki/Mad_Libs" target="_blank">Mad Libs</a> . Al utilizar el operador de concatenación ( <code>+</code> ), puede insertar una o más variables en una cadena que está creando. </section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
Establezca <code>myName</code> en una cadena igual a su nombre y compile <code>myStr</code> con <code>myName</code> entre las cadenas <code>"My name is "</code> y <code>" and I am well!"</code>
|
||||
</section>
|
||||
<section id="instructions"> Establezca <code>myName</code> en una cadena igual a su nombre y compile <code>myStr</code> con <code>myName</code> entre las cadenas <code>"My name is "</code> y <code>" and I am well!"</code> </section>
|
||||
|
||||
## Tests
|
||||
<section id='tests'>
|
||||
@@ -43,7 +40,6 @@ var ourStr = "Hello, our name is " + ourName + ", how are you?";
|
||||
var myName;
|
||||
var myStr;
|
||||
|
||||
|
||||
```
|
||||
|
||||
</div>
|
||||
@@ -63,10 +59,7 @@ console.info('after the test');
|
||||
## Solution
|
||||
<section id='solution'>
|
||||
|
||||
|
||||
```js
|
||||
var myName = "Bob";
|
||||
var myStr = "My name is " + myName + " and I am well!";
|
||||
// solution required
|
||||
```
|
||||
|
||||
</section>
|
||||
|
||||
@@ -1,24 +1,16 @@
|
||||
---
|
||||
id: 56105e7b514f539506016a5e
|
||||
title: Count Backwards With a For Loop
|
||||
localeTitle: Contar hacia atrás con un bucle for
|
||||
challengeType: 1
|
||||
videoUrl: ''
|
||||
localeTitle: Contar hacia atrás con un bucle for
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
A for loop también puede contar hacia atrás, siempre que podamos definir las condiciones correctas.
|
||||
Para contar hacia atrás de dos en dos, necesitaremos cambiar nuestra <code>initialization</code> , <code>condition</code> y <code>final-expression</code> .
|
||||
Comenzaremos en <code>i = 10</code> y haremos un bucle mientras <code>i > 0</code> . Disminuiremos <code>i</code> en 2 cada bucle con <code>i -= 2</code> .
|
||||
<blockquote>var ourArray = [];<br>for (var i=10; i > 0; i-=2) {<br> ourArray.push(i);<br>}</blockquote>
|
||||
<code>ourArray</code> ahora contendrá <code>[10,8,6,4,2]</code> .
|
||||
Cambiemos nuestra <code>initialization</code> y <code>final-expression</code> para que podamos contar hacia atrás de dos en dos con números impares.
|
||||
</section>
|
||||
<section id="description"> Un bucle for también puede contar hacia atrás, siempre que podamos definir las condiciones correctas. Para contar hacia atrás de dos en dos, necesitaremos cambiar nuestra <code>initialization</code> , <code>condition</code> y <code>final-expression</code> . Comenzaremos en <code>i = 10</code> y haremos un bucle mientras <code>i > 0</code> . Disminuiremos <code>i</code> en 2 cada bucle con <code>i -= 2</code> . <blockquote> var ourArray = []; <br> para (var i = 10; i> 0; i- = 2) { <br> nuestroArray.push (i); <br> } </blockquote> <code>ourArray</code> ahora contendrá <code>[10,8,6,4,2]</code> . Cambiemos nuestra <code>initialization</code> y <code>final-expression</code> para que podamos contar hacia atrás de dos en dos por números impares. </section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
Empuje los números impares del 9 al 1 a <code>myArray</code> usando un bucle <code>for</code> .
|
||||
</section>
|
||||
<section id="instructions"> Empuje los números impares del 9 al 1 a <code>myArray</code> usando un bucle <code>for</code> . </section>
|
||||
|
||||
## Tests
|
||||
<section id='tests'>
|
||||
@@ -29,7 +21,7 @@ tests:
|
||||
testString: 'assert(code.match(/for\s*\(/g).length > 1, "You should be using a <code>for</code> loop for this.");'
|
||||
- text: Deberías estar usando el método de matriz <code>push</code> .
|
||||
testString: 'assert(code.match(/myArray.push/), "You should be using the array method <code>push</code>.");'
|
||||
- text: ' <code>myArray</code> debe ser igual a <code>[9,7,5,3,1]</code> .'
|
||||
- text: '<code>myArray</code> debe ser igual a <code>[9,7,5,3,1]</code> .'
|
||||
testString: 'assert.deepEqual(myArray, [9,7,5,3,1], "<code>myArray</code> should equal <code>[9,7,5,3,1]</code>.");'
|
||||
|
||||
```
|
||||
@@ -54,7 +46,6 @@ var myArray = [];
|
||||
|
||||
// Only change code below this line.
|
||||
|
||||
|
||||
```
|
||||
|
||||
</div>
|
||||
@@ -74,16 +65,7 @@ console.info('after the test');
|
||||
## Solution
|
||||
<section id='solution'>
|
||||
|
||||
|
||||
```js
|
||||
var ourArray = [];
|
||||
for (var i = 10; i > 0; i -= 2) {
|
||||
ourArray.push(i);
|
||||
}
|
||||
var myArray = [];
|
||||
for (var i = 9; i > 0; i -= 2) {
|
||||
myArray.push(i);
|
||||
}
|
||||
// solution required
|
||||
```
|
||||
|
||||
</section>
|
||||
|
||||
@@ -1,23 +1,16 @@
|
||||
---
|
||||
id: 565bbe00e9cc8ac0725390f4
|
||||
title: Counting Cards
|
||||
localeTitle: Tarjetas de conteo
|
||||
challengeType: 1
|
||||
videoUrl: ''
|
||||
localeTitle: Tarjetas de conteo
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
En el juego de casino Blackjack, un jugador puede obtener una ventaja sobre la casa al hacer un seguimiento del número relativo de cartas altas y bajas que quedan en el mazo. Esto se llama <a href='https://en.wikipedia.org/wiki/Card_counting' target='_blank'>conteo de cartas</a> .
|
||||
Tener más cartas altas en el mazo favorece al jugador. A cada tarjeta se le asigna un valor de acuerdo con la siguiente tabla. Cuando el conteo es positivo, el jugador debe apostar alto. Cuando el conteo es cero o negativo, el jugador debe apostar bajo.
|
||||
<table class="table table-striped"><thead><tr><th> Cambio de cuenta </th><th> Tarjetas </th></tr></thead><tbody><tr><td> +1 </td><td> 2, 3, 4, 5, 6 </td></tr><tr><td> 0 </td><td> 7, 8, 9 </td></tr><tr><td> -1 </td><td> 10, 'J', 'Q', 'K', 'A' </td></tr></tbody></table>
|
||||
Escribirás una función de conteo de cartas. Recibirá un parámetro de <code>card</code> , que puede ser un número o una cadena, y aumentará o disminuirá la variable de <code>count</code> global según el valor de la tarjeta (consulte la tabla). La función devolverá una cadena con el recuento actual y la cadena <code>Bet</code> si el recuento es positivo, o <code>Hold</code> si el recuento es cero o negativo. El conteo actual y la decisión del jugador ( <code>Bet</code> o <code>Hold</code> ) deben estar separados por un solo espacio.
|
||||
<strong>Ejemplo de salida</strong> <br> <code>-3 Hold</code> <br> <code>5 Bet</code>
|
||||
<strong>Sugerencia</strong> <br> NO reinicie el <code>count</code> a 0 cuando el valor sea 7, 8 o 9. <br> NO devuelva una matriz. <br> NO incluya comillas (simples o dobles) en la salida.
|
||||
</section>
|
||||
<section id="description"> En el juego de casino Blackjack, un jugador puede obtener una ventaja sobre la casa al hacer un seguimiento del número relativo de cartas altas y bajas que quedan en el mazo. Esto se llama <a href="https://en.wikipedia.org/wiki/Card_counting" target="_blank">conteo de cartas</a> . Tener más cartas altas en el mazo favorece al jugador. A cada tarjeta se le asigna un valor de acuerdo con la siguiente tabla. Cuando el conteo es positivo, el jugador debe apostar alto. Cuando el conteo es cero o negativo, el jugador debe apostar bajo. <table class="table table-striped"><thead><tr><th> Cambio de cuenta </th><th> Tarjetas </th></tr></thead><tbody><tr><td> +1 </td><td> 2, 3, 4, 5, 6 </td></tr><tr><td> 0 </td><td> 7, 8, 9 </td></tr><tr><td> -1 </td><td> 10, 'J', 'Q', 'K', 'A' </td></tr></tbody></table> Escribirás una función de conteo de cartas. Recibirá un parámetro de <code>card</code> , que puede ser un número o una cadena, y aumentará o disminuirá la variable de <code>count</code> global según el valor de la tarjeta (consulte la tabla). La función devolverá una cadena con el recuento actual y la cadena <code>Bet</code> si el recuento es positivo, o <code>Hold</code> si el recuento es cero o negativo. El conteo actual y la decisión del jugador ( <code>Bet</code> o <code>Hold</code> ) deben estar separados por un solo espacio. <strong>Ejemplo de salida</strong> <br> <code>-3 Hold</code> <br> <code>5 Bet</code> <strong>Consejo de</strong> <code>5 Bet</code> <br> NO reinicie el <code>count</code> a 0 cuando el valor sea 7, 8 o 9. <br> NO devuelva una matriz. <br> NO incluya comillas (simples o dobles) en la salida. </section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
|
||||
<section id="instructions">
|
||||
</section>
|
||||
|
||||
## Tests
|
||||
@@ -25,19 +18,19 @@ Escribirás una función de conteo de cartas. Recibirá un parámetro de <code>c
|
||||
|
||||
```yml
|
||||
tests:
|
||||
- text: 'Las secuencias de cartas 2, 3, 4, 5, 6 deben devolver <code>5 Bet</code> '
|
||||
- text: 'Las secuencias de cartas 2, 3, 4, 5, 6 deben devolver <code>5 Bet</code>'
|
||||
testString: 'assert((function(){ count = 0; cc(2);cc(3);cc(4);cc(5);var out = cc(6); if(out === "5 Bet") {return true;} return false; })(), "Cards Sequence 2, 3, 4, 5, 6 should return <code>5 Bet</code>");'
|
||||
- text: 'Las secuencias de cartas 7, 8, 9 deben devolver <code>0 Hold</code> '
|
||||
- text: 'Las secuencias de cartas 7, 8, 9 deberían devolver <code>0 Hold</code>'
|
||||
testString: 'assert((function(){ count = 0; cc(7);cc(8);var out = cc(9); if(out === "0 Hold") {return true;} return false; })(), "Cards Sequence 7, 8, 9 should return <code>0 Hold</code>");'
|
||||
- text: 'La secuencia de cartas 10, J, Q, K, A debería devolver <code>-5 Hold</code> '
|
||||
- text: 'La secuencia de tarjetas 10, J, Q, K, A debe devolver <code>-5 Hold</code>'
|
||||
testString: 'assert((function(){ count = 0; cc(10);cc("J");cc("Q");cc("K");var out = cc("A"); if(out === "-5 Hold") {return true;} return false; })(), "Cards Sequence 10, J, Q, K, A should return <code>-5 Hold</code>");'
|
||||
- text: 'Las secuencias de cartas 3, 7, Q, 8, A deben devolver <code>-1 Hold</code> '
|
||||
- text: 'Las secuencias de tarjetas 3, 7, Q, 8, A deben devolver <code>-1 Hold</code>'
|
||||
testString: 'assert((function(){ count = 0; cc(3);cc(7);cc("Q");cc(8);var out = cc("A"); if(out === "-1 Hold") {return true;} return false; })(), "Cards Sequence 3, 7, Q, 8, A should return <code>-1 Hold</code>");'
|
||||
- text: 'Las secuencias de cartas 2, J, 9, 2, 7 deben devolver <code>1 Bet</code> '
|
||||
- text: 'La secuencia de cartas 2, J, 9, 2, 7 debe devolver <code>1 Bet</code>'
|
||||
testString: 'assert((function(){ count = 0; cc(2);cc("J");cc(9);cc(2);var out = cc(7); if(out === "1 Bet") {return true;} return false; })(), "Cards Sequence 2, J, 9, 2, 7 should return <code>1 Bet</code>");'
|
||||
- text: 'Las secuencias de cartas 2, 2, 10 deben devolver <code>1 Bet</code> '
|
||||
- text: 'Secuencia de cartas 2, 2, 10 debe devolver <code>1 Bet</code>'
|
||||
testString: 'assert((function(){ count = 0; cc(2);cc(2);var out = cc(10); if(out === "1 Bet") {return true;} return false; })(), "Cards Sequence 2, 2, 10 should return <code>1 Bet</code>");'
|
||||
- text: 'Secuencia de cartas 3, 2, A, 10, K debería devolver <code>-1 Hold</code> '
|
||||
- text: 'Secuencia de tarjetas 3, 2, A, 10, K debería devolver <code>-1 Hold</code>'
|
||||
testString: 'assert((function(){ count = 0; cc(3);cc(2);cc("A");cc(10);var out = cc("K"); if(out === "-1 Hold") {return true;} return false; })(), "Cards Sequence 3, 2, A, 10, K should return <code>-1 Hold</code>");'
|
||||
|
||||
```
|
||||
@@ -63,6 +56,7 @@ function cc(card) {
|
||||
// Add/remove calls to test your function.
|
||||
// Note: Only the last will display
|
||||
cc(2); cc(3); cc(7); cc('K'); cc('A');
|
||||
|
||||
```
|
||||
|
||||
</div>
|
||||
@@ -74,31 +68,7 @@ cc(2); cc(3); cc(7); cc('K'); cc('A');
|
||||
## Solution
|
||||
<section id='solution'>
|
||||
|
||||
|
||||
```js
|
||||
var count = 0;
|
||||
function cc(card) {
|
||||
switch(card) {
|
||||
case 2:
|
||||
case 3:
|
||||
case 4:
|
||||
case 5:
|
||||
case 6:
|
||||
count++;
|
||||
break;
|
||||
case 10:
|
||||
case 'J':
|
||||
case 'Q':
|
||||
case 'K':
|
||||
case 'A':
|
||||
count--;
|
||||
}
|
||||
if(count > 0) {
|
||||
return count + " Bet";
|
||||
} else {
|
||||
return count + " Hold";
|
||||
}
|
||||
}
|
||||
// solution required
|
||||
```
|
||||
|
||||
</section>
|
||||
|
||||
@@ -1,20 +1,16 @@
|
||||
---
|
||||
id: cf1391c1c11feddfaeb4bdef
|
||||
title: Create Decimal Numbers with JavaScript
|
||||
localeTitle: Crea números decimales con JavaScript
|
||||
challengeType: 1
|
||||
videoUrl: ''
|
||||
localeTitle: Crea números decimales con JavaScript
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
Podemos almacenar números decimales en variables también. Los números decimales a veces se denominan números de <dfn>punto flotante</dfn> o <dfn>flotantes</dfn> .
|
||||
<strong>Nota</strong> <br> No todos los números reales se pueden representar con precisión en <dfn>coma flotante</dfn> . Esto puede llevar a errores de redondeo. <a href="https://en.wikipedia.org/wiki/Floating_point#Accuracy_problems" target="_blank">Detalles aquí</a> .
|
||||
</section>
|
||||
<section id="description"> Podemos almacenar números decimales en variables también. Los números decimales a veces se denominan números de <dfn>punto flotante</dfn> o <dfn>flotantes</dfn> . <strong>Nota</strong> <br> No todos los números reales se pueden representar con precisión en <dfn>coma flotante</dfn> . Esto puede llevar a errores de redondeo. <a href="https://en.wikipedia.org/wiki/Floating_point#Accuracy_problems" target="_blank">Detalles aquí</a> . </section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
Crea una variable <code>myDecimal</code> y dale un valor decimal con una parte fraccionaria (por ejemplo, <code>5.7</code> ).
|
||||
</section>
|
||||
<section id="instructions"> Cree una variable <code>myDecimal</code> y <code>myDecimal</code> un valor decimal con una parte fraccionaria (por ejemplo, <code>5.7</code> ). </section>
|
||||
|
||||
## Tests
|
||||
<section id='tests'>
|
||||
@@ -40,7 +36,6 @@ var ourDecimal = 5.7;
|
||||
|
||||
// Only change code below this line
|
||||
|
||||
|
||||
```
|
||||
|
||||
</div>
|
||||
@@ -60,9 +55,7 @@ console.info('after the test');
|
||||
## Solution
|
||||
<section id='solution'>
|
||||
|
||||
|
||||
```js
|
||||
var myDecimal = 9.9;
|
||||
// solution required
|
||||
```
|
||||
|
||||
</section>
|
||||
|
||||
@@ -1,34 +1,23 @@
|
||||
---
|
||||
id: bd7123c9c443eddfaeb5bdef
|
||||
title: Declare JavaScript Variables
|
||||
localeTitle: Declarar las variables de JavaScript
|
||||
challengeType: 1
|
||||
videoUrl: ''
|
||||
localeTitle: Declarar las variables de JavaScript
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
En informática, los <dfn>datos</dfn> son cualquier cosa que sea significativa para la computadora. JavaScript proporciona siete <dfn>tipos de datos diferentes</dfn> que son <code>undefined</code> , <code>null</code> , <code>boolean</code> , <code>string</code> , <code>symbol</code> , <code>number</code> y <code>object</code> .
|
||||
Por ejemplo, las computadoras distinguen entre los números, como el número <code>12</code> , y las <code>strings</code> , como <code>"12"</code> , <code>"dog"</code> o <code>"123 cats"</code> , que son colecciones de caracteres. Las computadoras pueden realizar operaciones matemáticas en un número, pero no en una cadena.
|
||||
<dfn>Las variables</dfn> permiten que las computadoras almacenen y manipulen datos de una manera dinámica. Hacen esto usando una "etiqueta" para señalar los datos en lugar de usar los datos en sí. Cualquiera de los siete tipos de datos puede almacenarse en una variable.
|
||||
<code>Variables</code> son similares a las variables x e y que usa en matemáticas, lo que significa que son un nombre simple para representar los datos a los que queremos referirnos. Las <code>variables</code> computadora difieren de las variables matemáticas en que pueden almacenar diferentes valores en diferentes momentos.
|
||||
Le pedimos a JavaScript que cree o <dfn>declare</dfn> una variable poniendo la palabra clave <code>var</code> delante de ella, así:
|
||||
<blockquote>var ourName;</blockquote>
|
||||
crea una <code>variable</code> llamada <code>ourName</code> . En JavaScript terminamos las frases con punto y coma.
|
||||
<code>Variable</code> nombres de las <code>Variable</code> pueden estar formados por números, letras y <code>$</code> o <code>_</code> , pero no pueden contener espacios ni comenzar con un número.
|
||||
</section>
|
||||
<section id="description"> En informática, los <dfn>datos</dfn> son cualquier cosa que sea significativa para la computadora. JavaScript proporciona siete <dfn>tipos de datos diferentes</dfn> que son <code>undefined</code> , <code>null</code> , <code>boolean</code> , <code>string</code> , <code>symbol</code> , <code>number</code> y <code>object</code> . Por ejemplo, las computadoras distinguen entre los números, como el número <code>12</code> , y las <code>strings</code> , como <code>"12"</code> , <code>"dog"</code> o <code>"123 cats"</code> , que son colecciones de caracteres. Las computadoras pueden realizar operaciones matemáticas en un número, pero no en una cadena. <dfn>Las variables</dfn> permiten que las computadoras almacenen y manipulen datos de una manera dinámica. Hacen esto usando una "etiqueta" para señalar los datos en lugar de usar los datos en sí. Cualquiera de los siete tipos de datos puede almacenarse en una variable. <code>Variables</code> son similares a las variables x e y que usas en matemáticas, lo que significa que son un nombre simple para representar los datos a los que queremos referirnos. Las <code>variables</code> computadora difieren de las variables matemáticas en que pueden almacenar diferentes valores en diferentes momentos. Le pedimos a JavaScript que cree o <dfn>declare</dfn> una variable colocando la palabra clave <code>var</code> delante de ella, así: <blockquote> var ourName; </blockquote> crea una <code>variable</code> llamada <code>ourName</code> . En JavaScript terminamos las frases con punto y coma. <code>Variable</code> nombres de las <code>Variable</code> pueden estar formados por números, letras y <code>$</code> o <code>_</code> , pero no pueden contener espacios ni comenzar con un número. </section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
Use la palabra clave <code>var</code> para crear una variable llamada <code>myName</code> .
|
||||
<strong>Pista</strong> <br> Mira el ejemplo de <code>ourName</code> si te quedas atascado.
|
||||
</section>
|
||||
<section id="instructions"> Use la palabra clave <code>var</code> para crear una variable llamada <code>myName</code> . <strong>Insinuación</strong> <br> Mira el ejemplo de <code>ourName</code> si te quedas atascado. </section>
|
||||
|
||||
## Tests
|
||||
<section id='tests'>
|
||||
|
||||
```yml
|
||||
tests:
|
||||
- text: 'Debes declarar <code>myName</code> con la palabra clave <code>var</code> , que termina con un punto y coma'
|
||||
- text: 'Debe declarar <code>myName</code> con la palabra clave <code>var</code> , que termina con un punto y coma'
|
||||
testString: 'assert(/var\s+myName\s*;/.test(code), "You should declare <code>myName</code> with the <code>var</code> keyword, ending with a semicolon");'
|
||||
|
||||
```
|
||||
@@ -65,9 +54,7 @@ console.info('after the test');
|
||||
## Solution
|
||||
<section id='solution'>
|
||||
|
||||
|
||||
```js
|
||||
var myName;
|
||||
// solution required
|
||||
```
|
||||
|
||||
</section>
|
||||
|
||||
@@ -1,21 +1,16 @@
|
||||
---
|
||||
id: bd7123c9c444eddfaeb5bdef
|
||||
title: Declare String Variables
|
||||
localeTitle: Declarar variables de cadena
|
||||
challengeType: 1
|
||||
videoUrl: ''
|
||||
localeTitle: Declarar variables de cadena
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
Anteriormente hemos utilizado el código
|
||||
<code>var myName = "your name";</code>
|
||||
<code>"your name"</code> se llama una <dfn>cadena</dfn> <dfn>literal</dfn> . Es una cadena porque es una serie de cero o más caracteres entre comillas simples o dobles.
|
||||
</section>
|
||||
<section id="description"> Anteriormente hemos utilizado el código <code>var myName = "your name";</code> <code>"your name"</code> se llama una <dfn>cadena</dfn> <dfn>literal</dfn> . Es una cadena porque es una serie de cero o más caracteres entre comillas simples o dobles. </section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
Crea dos nuevas variables de <code>string</code> : <code>myFirstName</code> y <code>myLastName</code> y asigna los valores de tu nombre y apellido, respectivamente.
|
||||
</section>
|
||||
<section id="instructions"> Cree dos nuevas variables de <code>string</code> : <code>myFirstName</code> y <code>myLastName</code> y asigne los valores de su nombre y apellido, respectivamente. </section>
|
||||
|
||||
## Tests
|
||||
<section id='tests'>
|
||||
@@ -43,7 +38,6 @@ var lastName = "Turing";
|
||||
|
||||
// Only change code below this line
|
||||
|
||||
|
||||
```
|
||||
|
||||
</div>
|
||||
@@ -63,10 +57,7 @@ console.info('after the test');
|
||||
## Solution
|
||||
<section id='solution'>
|
||||
|
||||
|
||||
```js
|
||||
var myFirstName = "Alan";
|
||||
var myLastName = "Turing";
|
||||
// solution required
|
||||
```
|
||||
|
||||
</section>
|
||||
|
||||
@@ -1,23 +1,16 @@
|
||||
---
|
||||
id: 56533eb9ac21ba0edf2244ad
|
||||
title: Decrement a Number with JavaScript
|
||||
localeTitle: Disminuir un número con JavaScript
|
||||
challengeType: 1
|
||||
videoUrl: ''
|
||||
localeTitle: Disminuir un número con JavaScript
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
Puede <dfn>disminuir</dfn> o disminuir fácilmente una variable por una con el operador <code>--</code> .
|
||||
<code>i--;</code>
|
||||
es el equivalente de
|
||||
<code>i = i - 1;</code>
|
||||
<strong>Nota</strong> <br> La línea entera se convierte en <code>i--;</code> , eliminando la necesidad del signo igual.
|
||||
</section>
|
||||
<section id="description"> Puede <dfn>disminuir</dfn> o disminuir fácilmente una variable por una con el operador <code>--</code> . <code>i--;</code> es el equivalente de <code>i = i - 1;</code> <strong>Nota</strong> <br> La línea entera se convierte en <code>i--;</code> , eliminando la necesidad del signo igual. </section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
Cambie el código para usar el operador <code>--</code> en <code>myVar</code> .
|
||||
</section>
|
||||
<section id="instructions"> Cambie el código para usar el operador <code>--</code> en <code>myVar</code> . </section>
|
||||
|
||||
## Tests
|
||||
<section id='tests'>
|
||||
@@ -67,10 +60,7 @@ console.info('after the test');
|
||||
## Solution
|
||||
<section id='solution'>
|
||||
|
||||
|
||||
```js
|
||||
var myVar = 11;
|
||||
myVar--;
|
||||
// solution required
|
||||
```
|
||||
|
||||
</section>
|
||||
|
||||
@@ -1,20 +1,16 @@
|
||||
---
|
||||
id: 56bbb991ad1ed5201cd392d3
|
||||
title: Delete Properties from a JavaScript Object
|
||||
localeTitle: Eliminar propiedades de un objeto de JavaScript
|
||||
challengeType: 1
|
||||
videoUrl: ''
|
||||
localeTitle: Eliminar propiedades de un objeto de JavaScript
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
También podemos eliminar propiedades de objetos como este:
|
||||
<code>delete ourDog.bark;</code>
|
||||
</section>
|
||||
<section id="description"> También podemos eliminar propiedades de objetos como este: <code>delete ourDog.bark;</code> </section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
Eliminar la propiedad <code>"tails"</code> de <code>myDog</code> . Puede usar la notación de punto o corchete.
|
||||
</section>
|
||||
<section id="instructions"> Eliminar la propiedad <code>"tails"</code> de <code>myDog</code> . Puede usar la notación de punto o corchete. </section>
|
||||
|
||||
## Tests
|
||||
<section id='tests'>
|
||||
@@ -58,7 +54,6 @@ var myDog = {
|
||||
|
||||
// Only change code below this line.
|
||||
|
||||
|
||||
```
|
||||
|
||||
</div>
|
||||
@@ -78,23 +73,7 @@ console.info('after the test');
|
||||
## Solution
|
||||
<section id='solution'>
|
||||
|
||||
|
||||
```js
|
||||
var ourDog = {
|
||||
"name": "Camper",
|
||||
"legs": 4,
|
||||
"tails": 1,
|
||||
"friends": ["everything!"],
|
||||
"bark": "bow-wow"
|
||||
};
|
||||
var myDog = {
|
||||
"name": "Happy Coder",
|
||||
"legs": 4,
|
||||
"tails": 1,
|
||||
"friends": ["freeCodeCamp Campers"],
|
||||
"bark": "woof"
|
||||
};
|
||||
delete myDog.tails;
|
||||
// solution required
|
||||
```
|
||||
|
||||
</section>
|
||||
|
||||
@@ -1,19 +1,16 @@
|
||||
---
|
||||
id: bd7993c9ca9feddfaeb7bdef
|
||||
title: Divide One Decimal by Another with JavaScript
|
||||
localeTitle: Divide un decimal por otro con JavaScript
|
||||
challengeType: 1
|
||||
videoUrl: ''
|
||||
localeTitle: Divide un decimal por otro con JavaScript
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
Ahora dividamos un decimal por otro.
|
||||
</section>
|
||||
<section id="description"> Ahora dividamos un decimal por otro. </section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
Cambie el <code>0.0</code> para que el <code>quotient</code> sea igual a <code>2.2</code> .
|
||||
</section>
|
||||
<section id="instructions"> Cambia el <code>0.0</code> para que el <code>quotient</code> sea igual a <code>2.2</code> . </section>
|
||||
|
||||
## Tests
|
||||
<section id='tests'>
|
||||
@@ -39,7 +36,6 @@ tests:
|
||||
```js
|
||||
var quotient = 0.0 / 2.0; // Fix this line
|
||||
|
||||
|
||||
```
|
||||
|
||||
</div>
|
||||
|
||||
@@ -1,24 +1,16 @@
|
||||
---
|
||||
id: cf1111c1c11feddfaeb6bdef
|
||||
title: Divide One Number by Another with JavaScript
|
||||
localeTitle: Divide un número por otro con JavaScript
|
||||
challengeType: 1
|
||||
videoUrl: ''
|
||||
localeTitle: Divide un número por otro con JavaScript
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
También podemos dividir un número por otro.
|
||||
JavaScript usa el símbolo <code>/</code> para la división.
|
||||
|
||||
<strong>Ejemplo</strong>
|
||||
<blockquote>myVar = 16 / 2; // assigned 8</blockquote>
|
||||
|
||||
</section>
|
||||
<section id="description"> También podemos dividir un número por otro. JavaScript usa el símbolo <code>/</code> para la división. <p> <strong>Ejemplo</strong> </p><blockquote> myVar = 16/2; // asignado 8 </blockquote></section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
Cambia el <code>0</code> para que el <code>quotient</code> sea igual a <code>2</code> .
|
||||
</section>
|
||||
<section id="instructions"> Cambia el <code>0</code> para que el <code>quotient</code> sea igual a <code>2</code> . </section>
|
||||
|
||||
## Tests
|
||||
<section id='tests'>
|
||||
@@ -42,7 +34,6 @@ tests:
|
||||
```js
|
||||
var quotient = 66 / 0;
|
||||
|
||||
|
||||
```
|
||||
|
||||
</div>
|
||||
@@ -62,9 +53,7 @@ console.info('after the test');
|
||||
## Solution
|
||||
<section id='solution'>
|
||||
|
||||
|
||||
```js
|
||||
var quotient = 66 / 33;
|
||||
// solution required
|
||||
```
|
||||
|
||||
</section>
|
||||
|
||||
@@ -1,25 +1,16 @@
|
||||
---
|
||||
id: 56533eb9ac21ba0edf2244b6
|
||||
title: Escape Sequences in Strings
|
||||
localeTitle: Secuencias de escape en cuerdas
|
||||
challengeType: 1
|
||||
videoUrl: ''
|
||||
localeTitle: Secuencias de escape en cuerdas
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
comillas no son los únicos caracteres que pueden <dfn>escaparse</dfn> dentro de una cadena. Hay dos razones para usar caracteres que se escapan: primero es permitirle usar caracteres que de otra forma no podría escribir, como un retroceso. El segundo es permitirte representar múltiples citas en una cadena sin que JavaScript interprete mal lo que quieres decir. Aprendimos esto en el reto anterior.
|
||||
<table class="table table-striped"><thead><tr><th> Código </th><th> Salida </th></tr></thead><tbody><tr><td> <code>\'</code> </td> <td> una frase </td></tr><tr><td> <code>\"</code> </td> <td> doble cita </td></tr><tr><td> <code>\\</code> </td> <td> barra invertida </td></tr><tr><td> <code>\n</code> </td> <td> nueva línea </td></tr><tr><td> <code>\r</code> </td> <td> retorno de carro </td></tr><tr><td> <code>\t</code> </td> <td> lengüeta </td></tr><tr><td> <code>\b</code> </td> <td> retroceso </td></tr><tr><td> <code>\f</code> </td> <td> form feed </td></tr></tbody></table>
|
||||
<em>Tenga en cuenta que la barra invertida debe escaparse para que se muestre como una barra invertida.</em>
|
||||
</section>
|
||||
<section id="description"> Las comillas no son los únicos caracteres que pueden <dfn>escaparse</dfn> dentro de una cadena. Hay dos razones para usar caracteres que se escapan: primero es permitirle usar caracteres que de otra forma no podría escribir, como un retroceso. El segundo es permitirte representar múltiples citas en una cadena sin que JavaScript interprete mal lo que quieres decir. Aprendimos esto en el reto anterior. <table class="table table-striped"><thead><tr><th> Código </th><th> Salida </th></tr></thead><tbody><tr><td> <code>\'</code> </td> <td> una frase </td></tr><tr><td> <code>\"</code> </td> <td> doble cita </td></tr><tr><td> <code>\\</code> </td> <td> barra invertida </td></tr><tr><td> <code>\n</code> </td> <td> nueva línea </td></tr><tr><td> <code>\r</code> </td> <td> retorno de carro </td></tr><tr><td> <code>\t</code> </td> <td> lengüeta </td></tr><tr><td> <code>\b</code> </td> <td> retroceso </td></tr><tr><td> <code>\f</code> </td> <td> form feed </td></tr></tbody></table> <em>Tenga en cuenta que la barra invertida debe escaparse para mostrarse como una barra invertida.</em> </section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
Asigne las siguientes tres líneas de texto a la única variable <code>myStr</code> usando secuencias de escape.
|
||||
<blockquote>FirstLine<br/> \SecondLine<br/>ThirdLine</blockquote>
|
||||
Necesitará usar secuencias de escape para insertar caracteres especiales correctamente. También deberá seguir el espaciado como se ve arriba, sin espacios entre las secuencias de escape o las palabras.
|
||||
Aquí está el texto con las secuencias de escape escritas.
|
||||
<q>FirstLine <code>newline</code> <code>tab</code> <code>backslash</code> SecondLine <code>newline</code> ThirdLine</q>
|
||||
</section>
|
||||
<section id="instructions"> Asigne las siguientes tres líneas de texto a la única variable <code>myStr</code> usando secuencias de escape. <blockquote> Primera linea <br> \Segunda linea <br> Tercera linea </blockquote> Deberá usar secuencias de escape para insertar caracteres especiales correctamente. También deberá seguir el espaciado como se ve arriba, sin espacios entre las secuencias de escape o las palabras. Aquí está el texto con las secuencias de escape escritas. <q>FirstLine <code>newline</code> <code>tab</code> <code>backslash</code> SecondLine <code>newline</code> ThirdLine</q> </section>
|
||||
|
||||
## Tests
|
||||
<section id='tests'>
|
||||
@@ -28,7 +19,7 @@ Aquí está el texto con las secuencias de escape escritas.
|
||||
tests:
|
||||
- text: <code>myStr</code> no debe contener espacios
|
||||
testString: 'assert(!/ /.test(myStr), "<code>myStr</code> should not contain any spaces");'
|
||||
- text: ' <code>myStr</code> debe contener las cadenas <code>FirstLine</code> , <code>SecondLine</code> y <code>ThirdLine</code> (recuerda la sensibilidad a los casos)'
|
||||
- text: '<code>myStr</code> debe contener las cadenas <code>FirstLine</code> , <code>SecondLine</code> y <code>ThirdLine</code> (recuerde la sensibilidad a mayúsculas)'
|
||||
testString: 'assert(/FirstLine/.test(myStr) && /SecondLine/.test(myStr) && /ThirdLine/.test(myStr), "<code>myStr</code> should contain the strings <code>FirstLine</code>, <code>SecondLine</code> and <code>ThirdLine</code> (remember case sensitivity)");'
|
||||
- text: <code>FirstLine</code> debe ir seguido del carácter de nueva línea <code>\n</code>
|
||||
testString: 'assert(/FirstLine\n/.test(myStr), "<code>FirstLine</code> should be followed by the newline character <code>\n</code>");'
|
||||
@@ -51,7 +42,6 @@ tests:
|
||||
```js
|
||||
var myStr; // Change this line
|
||||
|
||||
|
||||
```
|
||||
|
||||
</div>
|
||||
@@ -71,9 +61,7 @@ console.info('after the test');
|
||||
## Solution
|
||||
<section id='solution'>
|
||||
|
||||
|
||||
```js
|
||||
var myStr = "FirstLine\n\t\\SecondLine\nThirdLine";
|
||||
// solution required
|
||||
```
|
||||
|
||||
</section>
|
||||
|
||||
@@ -1,33 +1,25 @@
|
||||
---
|
||||
id: 56533eb9ac21ba0edf2244b5
|
||||
title: Escaping Literal Quotes in Strings
|
||||
localeTitle: Escapar de citas literales en cuerdas
|
||||
challengeType: 1
|
||||
videoUrl: ''
|
||||
localeTitle: Escapar de citas literales en cuerdas
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
Cuando está definiendo una cadena, debe comenzar y terminar con una comilla simple o doble. ¿Qué sucede cuando necesita una cita literal: <code>"</code> o <code>'</code> dentro de su cadena?
|
||||
En JavaScript, puede <dfn>evitar que</dfn> una cita la considere como un final de cadena de la cadena colocando una <dfn>barra invertida</dfn> ( <code>\</code> ) delante de la cita.
|
||||
<code>var sampleStr = "Alan said, \"Peter is learning JavaScript\".";</code>
|
||||
Esto indica a JavaScript que la siguiente cita no es el final de la cadena, sino que debería aparecer dentro de la cadena. Por lo tanto, si imprimiera esto en En la consola, obtendrías:
|
||||
<code>Alan said, "Peter is learning JavaScript".</code>
|
||||
</section>
|
||||
<section id="description"> Cuando está definiendo una cadena, debe comenzar y terminar con una comilla simple o doble. ¿Qué sucede cuando necesita una cita literal: <code>"</code> o <code>'</code> dentro de su cadena? En JavaScript, puede <dfn>evitar que</dfn> una cita la considere como un final de la cadena de la cadena colocando una <dfn>barra invertida</dfn> ( <code>\</code> ) delante de la cita. <code>var sampleStr = "Alan said, \"Peter is learning JavaScript\".";</code> Esto indica a JavaScript que la siguiente cita no es el final de la cadena, sino que debería aparecer dentro de la cadena. Así que si imprimiera esto en la consola, obtendría: <code>Alan said, "Peter is learning JavaScript".</code> </section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
Use <dfn>barras diagonales inversas</dfn> para asignar una cadena a la variable <code>myStr</code> modo que si tuviera que imprimirla en la consola, verá:
|
||||
<code>I am a "double quoted" string inside "double quotes".</code>
|
||||
</section>
|
||||
<section id="instructions"> Utilice las <dfn>barras invertidas</dfn> para asignar una cadena a la variable <code>myStr</code> modo que si tuviera que imprimirla en la consola, verá: <code>I am a "double quoted" string inside "double quotes".</code> </section>
|
||||
|
||||
## Tests
|
||||
<section id='tests'>
|
||||
|
||||
```yml
|
||||
tests:
|
||||
- text: 'Debería usar dos comillas dobles ( <code>"</code> ) y cuatro comillas dobles escapadas ( <code>\"</code> ).'
|
||||
- text: Debe usar dos comillas dobles ( <code>"</code> ) y cuatro comillas dobles escapadas ( <code>\"</code> ).
|
||||
testString: 'assert(code.match(/\\"/g).length === 4 && code.match(/[^\\]"/g).length === 2, "You should use two double quotes (<code>"</code>) and four escaped double quotes (<code>\"</code>).");'
|
||||
- text: 'Variable myStr debe contener la cadena: <code>I am a "double quoted" string inside "double quotes".</code> comilla <code>I am a "double quoted" string inside "double quotes".</code> '
|
||||
- text: 'La variable myStr debe contener la cadena: <code>I am a "double quoted" string inside "double quotes".</code>'
|
||||
testString: 'assert(myStr === "I am a \"double quoted\" string inside \"double quotes\".", "Variable myStr should contain the string: <code>I am a "double quoted" string inside "double quotes".</code>");'
|
||||
|
||||
```
|
||||
@@ -42,7 +34,6 @@ tests:
|
||||
```js
|
||||
var myStr = ""; // Change this line
|
||||
|
||||
|
||||
```
|
||||
|
||||
</div>
|
||||
@@ -62,9 +53,7 @@ console.info('after the test');
|
||||
## Solution
|
||||
<section id='solution'>
|
||||
|
||||
|
||||
```js
|
||||
var myStr = "I am a \"double quoted\" string inside \"double quotes\".";
|
||||
// solution required
|
||||
```
|
||||
|
||||
</section>
|
||||
|
||||
@@ -1,21 +1,16 @@
|
||||
---
|
||||
id: bd7123c9c448eddfaeb5bdef
|
||||
title: Find the Length of a String
|
||||
localeTitle: Encuentra la longitud de una cuerda
|
||||
challengeType: 1
|
||||
videoUrl: ''
|
||||
localeTitle: Encuentra la longitud de una cuerda
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
Puede encontrar la longitud de un valor de <code>String</code> escribiendo <code>.length</code> después de la variable de cadena o el literal de cadena.
|
||||
<code>"Alan Peter".length; // 10</code>
|
||||
Por ejemplo, si creamos una variable <code>var firstName = "Charles"</code> , podríamos averiguar cuánto tiempo dura la cadena <code>"Charles"</code> utilizando la propiedad <code>firstName.length</code> .
|
||||
</section>
|
||||
<section id="description"> Puede encontrar la longitud de un valor de <code>String</code> escribiendo <code>.length</code> después de la variable de cadena o el literal de cadena. <code>"Alan Peter".length; // 10</code> Por ejemplo, si creamos una variable <code>var firstName = "Charles"</code> , podríamos averiguar cuánto tiempo dura la cadena <code>"Charles"</code> utilizando la propiedad <code>firstName.length</code> . </section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
Use la propiedad <code>.length</code> para contar el número de caracteres en la variable <code>lastName</code> y asignarla a <code>lastNameLength</code> .
|
||||
</section>
|
||||
<section id="instructions"> Utilice la propiedad <code>.length</code> para contar el número de caracteres en la variable <code>lastName</code> y asignarla a <code>lastNameLength</code> . </section>
|
||||
|
||||
## Tests
|
||||
<section id='tests'>
|
||||
@@ -24,7 +19,7 @@ Use la propiedad <code>.length</code> para contar el número de caracteres en la
|
||||
tests:
|
||||
- text: <code>lastNameLength</code> debe ser igual a ocho.
|
||||
testString: 'assert((function(){if(typeof lastNameLength !== "undefined" && typeof lastNameLength === "number" && lastNameLength === 8){return true;}else{return false;}})(), "<code>lastNameLength</code> should be equal to eight.");'
|
||||
- text: 'Deberías obtener la longitud del <code>lastName</code> al usar <code>.length</code> esta manera: <code>lastName.length</code> '
|
||||
- text: 'Que debería estar recibiendo la longitud de <code>lastName</code> utilizando <code>.length</code> así: <code>lastName.length</code> .'
|
||||
testString: 'assert((function(){if(code.match(/\.length/gi) && code.match(/\.length/gi).length >= 2 && code.match(/var lastNameLength \= 0;/gi) && code.match(/var lastNameLength \= 0;/gi).length >= 1){return true;}else{return false;}})(), "You should be getting the length of <code>lastName</code> by using <code>.length</code> like this: <code>lastName.length</code>.");'
|
||||
|
||||
```
|
||||
@@ -51,7 +46,6 @@ var lastName = "Lovelace";
|
||||
|
||||
lastNameLength = lastName;
|
||||
|
||||
|
||||
```
|
||||
|
||||
</div>
|
||||
@@ -71,15 +65,7 @@ console.info('after the test');
|
||||
## Solution
|
||||
<section id='solution'>
|
||||
|
||||
|
||||
```js
|
||||
var firstNameLength = 0;
|
||||
var firstName = "Ada";
|
||||
firstNameLength = firstName.length;
|
||||
|
||||
var lastNameLength = 0;
|
||||
var lastName = "Lovelace";
|
||||
lastNameLength = lastName.length;
|
||||
// solution required
|
||||
```
|
||||
|
||||
</section>
|
||||
|
||||
@@ -1,24 +1,16 @@
|
||||
---
|
||||
id: 56533eb9ac21ba0edf2244ae
|
||||
title: Finding a Remainder in JavaScript
|
||||
localeTitle: Encontrar un resto en JavaScript
|
||||
challengeType: 1
|
||||
videoUrl: ''
|
||||
localeTitle: Encontrar un resto en JavaScript
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
El operador <dfn>restante</dfn> <code>%</code> da el resto de la división de dos números.
|
||||
<strong>Ejemplo</strong>
|
||||
<blockquote>5 % 2 = 1 because<br>Math.floor(5 / 2) = 2 (Quotient)<br>2 * 2 = 4<br>5 - 4 = 1 (Remainder)</blockquote>
|
||||
<strong>Usage</strong> <br> En matemáticas, se puede verificar que un número sea par o impar verificando el resto de la división del número entre <code>2</code> .
|
||||
<blockquote>17 % 2 = 1 (17 is Odd)<br>48 % 2 = 0 (48 is Even)</blockquote>
|
||||
<strong>Nota</strong> <br> El operador del <dfn>resto a</dfn> veces se denomina incorrectamente operador del "módulo". Es muy similar al módulo, pero no funciona correctamente con números negativos.
|
||||
</section>
|
||||
<section id="description"> El operador <dfn>restante</dfn> <code>%</code> da el resto de la división de dos números. <strong>Ejemplo</strong> <blockquote> 5% 2 = 1 porque <br> Math.floor (5/2) = 2 (Cociente) <br> 2 * 2 = 4 <br> 5 - 4 = 1 (resto) </blockquote> <strong>Uso</strong> <br> En matemáticas, se puede verificar que un número sea par o impar verificando el resto de la división del número entre <code>2</code> . <blockquote> 17% 2 = 1 (17 es impar) <br> 48% 2 = 0 (48 es par) </blockquote> <strong>Nota</strong> <br> El operador del <dfn>resto a</dfn> veces se denomina incorrectamente operador del "módulo". Es muy similar al módulo, pero no funciona correctamente con números negativos. </section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
Establezca el <code>remainder</code> igual al resto de <code>11</code> dividido por <code>3</code> usando el operador <dfn>resto</dfn> ( <code>%</code> ).
|
||||
</section>
|
||||
<section id="instructions"> Establezca el <code>remainder</code> igual al resto de <code>11</code> dividido por <code>3</code> usando el operador <dfn>resto</dfn> ( <code>%</code> ). </section>
|
||||
|
||||
## Tests
|
||||
<section id='tests'>
|
||||
@@ -65,9 +57,7 @@ console.info('after the test');
|
||||
## Solution
|
||||
<section id='solution'>
|
||||
|
||||
|
||||
```js
|
||||
var remainder = 11 % 3;
|
||||
// solution required
|
||||
```
|
||||
|
||||
</section>
|
||||
|
||||
@@ -1,21 +1,16 @@
|
||||
---
|
||||
id: cf1111c1c11feddfaeb9bdef
|
||||
title: Generate Random Fractions with JavaScript
|
||||
localeTitle: Generar fracciones aleatorias con JavaScript
|
||||
challengeType: 1
|
||||
videoUrl: ''
|
||||
localeTitle: Generar fracciones aleatorias con JavaScript
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
Los números aleatorios son útiles para crear un comportamiento aleatorio.
|
||||
JavaScript tiene una función <code>Math.random()</code> que genera un número decimal aleatorio entre <code>0</code> (incluido) y no hasta <code>1</code> (exclusivo). Por <code>Math.random()</code> tanto, <code>Math.random()</code> puede devolver un <code>0</code> pero nunca devolver completamente una <strong>Nota de</strong> <code>1</code>
|
||||
<br> Al igual que el <a href='storing-values-with-the-assignment-operator' target='_blank'>almacenamiento de valores con el operador igual</a> , todas las llamadas de función se resolverán antes de que se ejecute la <code>return</code> , por lo que podemos <code>return</code> el valor de la función <code>Math.random()</code> .
|
||||
</section>
|
||||
<section id="description"> Los números aleatorios son útiles para crear un comportamiento aleatorio. JavaScript tiene una función <code>Math.random()</code> que genera un número decimal aleatorio entre <code>0</code> (incluido) y no hasta <code>1</code> (exclusivo). Por <code>Math.random()</code> tanto, <code>Math.random()</code> puede devolver un <code>0</code> pero nunca devolver una <code>1</code> <strong>Nota</strong> <br> Al igual que el <a href="storing-values-with-the-assignment-operator" target="_blank">almacenamiento de valores con el operador igual</a> , todas las llamadas de función se resolverán antes de que se ejecute la <code>return</code> , por lo que podemos <code>return</code> el valor de la función <code>Math.random()</code> . </section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
Cambie <code>randomFraction</code> para devolver un número aleatorio en lugar de devolver <code>0</code> .
|
||||
</section>
|
||||
<section id="instructions"> Cambie <code>randomFraction</code> para devolver un número aleatorio en lugar de devolver <code>0</code> . </section>
|
||||
|
||||
## Tests
|
||||
<section id='tests'>
|
||||
@@ -47,6 +42,7 @@ function randomFraction() {
|
||||
|
||||
// Only change code above this line.
|
||||
}
|
||||
|
||||
```
|
||||
|
||||
</div>
|
||||
@@ -66,11 +62,7 @@ console.info('after the test');
|
||||
## Solution
|
||||
<section id='solution'>
|
||||
|
||||
|
||||
```js
|
||||
function randomFraction() {
|
||||
return Math.random();
|
||||
}
|
||||
// solution required
|
||||
```
|
||||
|
||||
</section>
|
||||
|
||||
@@ -1,24 +1,16 @@
|
||||
---
|
||||
id: cf1111c1c12feddfaeb1bdef
|
||||
title: Generate Random Whole Numbers with JavaScript
|
||||
localeTitle: Generar números enteros al azar con JavaScript
|
||||
challengeType: 1
|
||||
videoUrl: ''
|
||||
localeTitle: Generar números enteros al azar con JavaScript
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
Es genial que podamos generar números decimales aleatorios, pero es aún más útil si lo usamos para generar números enteros aleatorios.
|
||||
<ol><li> Usa <code>Math.random()</code> para generar un decimal aleatorio. </li><li> Multiplica ese decimal aleatorio por <code>20</code> . </li><li> Use otra función, <code>Math.floor()</code> para redondear el número a su número entero más cercano. </li></ol>
|
||||
Recuerda que <code>Math.random()</code> nunca puede devolver un <code>1</code> y, porque estamos redondeando, es imposible obtener <code>20</code> . Esta técnica nos dará un número entero entre <code>0</code> y <code>19</code> .
|
||||
Poniendo todo junto, así es como se ve nuestro código:
|
||||
<code>Math.floor(Math.random() * 20);</code>
|
||||
Estamos llamando a <code>Math.random()</code> , multiplicamos el resultado por 20 y luego <code>Math.floor()</code> el valor a la función <code>Math.floor()</code> para redondear el valor al número entero más cercano.
|
||||
</section>
|
||||
<section id="description"> Es genial que podamos generar números decimales aleatorios, pero es aún más útil si lo usamos para generar números enteros aleatorios. <ol><li> Usa <code>Math.random()</code> para generar un decimal aleatorio. </li><li> Multiplica ese decimal aleatorio por <code>20</code> . </li><li> Use otra función, <code>Math.floor()</code> para redondear el número a su número entero más cercano. </li></ol> Recuerda que <code>Math.random()</code> nunca puede devolver un <code>1</code> y, como estamos redondeando, es imposible obtener <code>20</code> . Esta técnica nos dará un número entero entre <code>0</code> y <code>19</code> . Poniendo todo junto, así es como se ve nuestro código: <code>Math.floor(Math.random() * 20);</code> Llamamos a <code>Math.random()</code> , multiplicamos el resultado por 20 y luego <code>Math.floor()</code> el valor a la función <code>Math.floor()</code> para redondear el valor al número entero más cercano. </section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
Use esta técnica para generar y devolver un número entero aleatorio entre <code>0</code> y <code>9</code> .
|
||||
</section>
|
||||
<section id="instructions"> Utilice esta técnica para generar y devolver un número entero aleatorio entre <code>0</code> y <code>9</code> . </section>
|
||||
|
||||
## Tests
|
||||
<section id='tests'>
|
||||
@@ -52,6 +44,7 @@ function randomWholeNum() {
|
||||
|
||||
return Math.random();
|
||||
}
|
||||
|
||||
```
|
||||
|
||||
</div>
|
||||
@@ -71,12 +64,7 @@ console.info('after the test');
|
||||
## Solution
|
||||
<section id='solution'>
|
||||
|
||||
|
||||
```js
|
||||
var randomNumberBetween0and19 = Math.floor(Math.random() * 20);
|
||||
function randomWholeNum() {
|
||||
return Math.floor(Math.random() * 10);
|
||||
}
|
||||
// solution required
|
||||
```
|
||||
|
||||
</section>
|
||||
|
||||
@@ -1,35 +1,29 @@
|
||||
---
|
||||
id: cf1111c1c12feddfaeb2bdef
|
||||
title: Generate Random Whole Numbers within a Range
|
||||
localeTitle: Generar números enteros al azar dentro de un rango
|
||||
challengeType: 1
|
||||
videoUrl: ''
|
||||
localeTitle: Generar números enteros al azar dentro de un rango
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
En lugar de generar un número aleatorio entre cero y un número dado como hicimos antes, podemos generar un número aleatorio que se encuentre dentro de un rango de dos números específicos.
|
||||
Para hacer esto, definiremos un número mínimo <code>min</code> y un máximo número <code>max</code> .
|
||||
Aquí está la fórmula que usaremos. Tómese un momento para leerlo e intente entender lo que hace este código:
|
||||
<code>Math.floor(Math.random() * (max - min + 1)) + min</code>
|
||||
</section>
|
||||
<section id="description"> En lugar de generar un número aleatorio entre cero y un número dado como hicimos antes, podemos generar un número aleatorio que se encuentre dentro de un rango de dos números específicos. Para hacer esto, definiremos un número mínimo <code>min</code> y un máximo número <code>max</code> . Aquí está la fórmula que usaremos. Tómese un momento para leerlo e intente comprender lo que hace este código: <code>Math.floor(Math.random() * (max - min + 1)) + min</code> </section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
Cree una función llamada <code>randomRange</code> que tome un rango <code>myMin</code> y <code>myMax</code> y devuelva un número aleatorio que sea mayor o igual que <code>myMin</code> , y que sea menor o igual que <code>myMax</code> , inclusive.
|
||||
</section>
|
||||
<section id="instructions"> Cree una función llamada <code>randomRange</code> que tome un rango <code>myMin</code> y <code>myMax</code> y devuelva un número aleatorio que sea mayor o igual que <code>myMin</code> , y que sea menor o igual que <code>myMax</code> , inclusive. </section>
|
||||
|
||||
## Tests
|
||||
<section id='tests'>
|
||||
|
||||
```yml
|
||||
tests:
|
||||
- text: 'El número aleatorio más bajo que puede ser generado por <code>randomRange</code> debería ser igual a tu número mínimo, <code>myMin</code> '
|
||||
- text: 'El número aleatorio más bajo que puede ser generado por <code>randomRange</code> debe ser igual a tu número mínimo, <code>myMin</code> .'
|
||||
testString: 'assert(calcMin === 5, "The lowest random number that can be generated by <code>randomRange</code> should be equal to your minimum number, <code>myMin</code>.");'
|
||||
- text: "El número aleatorio más alto que puede ser generado por <code>randomRange</code> debería ser igual a tu número máximo, <code>myMax</code> ".
|
||||
- text: 'El número aleatorio más alto que puede ser generado por <code>randomRange</code> debe ser igual a tu número máximo, <code>myMax</code> .'
|
||||
testString: 'assert(calcMax === 15, "The highest random number that can be generated by <code>randomRange</code> should be equal to your maximum number, <code>myMax</code>.");'
|
||||
- text: 'El número aleatorio generado por <code>randomRange</code> debe ser un número entero, no un decimal'
|
||||
- text: 'El número aleatorio generado por <code>randomRange</code> debe ser un número entero, no un decimal.'
|
||||
testString: 'assert(randomRange(0,1) % 1 === 0 , "The random number generated by <code>randomRange</code> should be an integer, not a decimal.");'
|
||||
- text: ' <code>randomRange</code> debe usar <code>myMax</code> y <code>myMin</code> , y devolver un número aleatorio en tu rango'
|
||||
- text: '<code>randomRange</code> debe usar <code>myMax</code> y <code>myMin</code> , y devolver un número aleatorio en su rango.'
|
||||
testString: 'assert((function(){if(code.match(/myMax/g).length > 1 && code.match(/myMin/g).length > 2 && code.match(/Math.floor/g) && code.match(/Math.random/g)){return true;}else{return false;}})(), "<code>randomRange</code> should use both <code>myMax</code> and <code>myMin</code>, and return a random number in your range.");'
|
||||
|
||||
```
|
||||
@@ -60,6 +54,7 @@ function randomRange(myMin, myMax) {
|
||||
|
||||
// Change these values to test your function
|
||||
var myRandom = randomRange(5, 15);
|
||||
|
||||
```
|
||||
|
||||
</div>
|
||||
@@ -79,11 +74,7 @@ console.info('after the test');
|
||||
## Solution
|
||||
<section id='solution'>
|
||||
|
||||
|
||||
```js
|
||||
function randomRange(myMin, myMax) {
|
||||
return Math.floor(Math.random() * (myMax - myMin + 1)) + myMin;
|
||||
}
|
||||
// solution required
|
||||
```
|
||||
|
||||
</section>
|
||||
|
||||
@@ -1,21 +1,16 @@
|
||||
---
|
||||
id: 56533eb9ac21ba0edf2244be
|
||||
title: Global Scope and Functions
|
||||
localeTitle: Ámbito global y funciones
|
||||
challengeType: 1
|
||||
videoUrl: ''
|
||||
localeTitle: Ámbito global y funciones
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
En JavaScript, el <dfn>alcance se</dfn> refiere a la visibilidad de las variables. Las variables que se definen fuera de un bloque de función tienen alcance <dfn>global</dfn> . Esto significa que pueden verse en todas partes en su código JavaScript.
|
||||
Las variables que se utilizan sin la palabra clave <code>var</code> se crean automáticamente en el ámbito <code>global</code> . Esto puede crear consecuencias no deseadas en otra parte de su código o al ejecutar una función nuevamente. Siempre debes declarar tus variables con <code>var</code> .
|
||||
</section>
|
||||
<section id="description"> En JavaScript, el <dfn>alcance se</dfn> refiere a la visibilidad de las variables. Las variables que se definen fuera de un bloque de función tienen alcance <dfn>global</dfn> . Esto significa que pueden verse en todas partes en su código JavaScript. Las variables que se utilizan sin la palabra clave <code>var</code> se crean automáticamente en el ámbito <code>global</code> . Esto puede crear consecuencias no deseadas en otra parte de su código o al ejecutar una función nuevamente. Siempre debes declarar tus variables con <code>var</code> . </section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
Usando <code>var</code> , declare una variable <code>global</code> <code>myGlobal</code> fuera de cualquier función. Inicialízalo con un valor de <code>10</code> .
|
||||
Dentro de la función <code>fun1</code> , asigne <code>5</code> a <code>oopsGlobal</code> <strong><em>sin</em></strong> usar la palabra clave <code>var</code> .
|
||||
</section>
|
||||
<section id="instructions"> Usando <code>var</code> , declare una variable <code>global</code> <code>myGlobal</code> fuera de cualquier función. Inicialízalo con un valor de <code>10</code> . Dentro de la función <code>fun1</code> , asigne <code>5</code> a <code>oopsGlobal</code> <strong><em>sin</em></strong> usar la palabra clave <code>var</code> . </section>
|
||||
|
||||
## Tests
|
||||
<section id='tests'>
|
||||
@@ -60,6 +55,7 @@ function fun2() {
|
||||
}
|
||||
console.log(output);
|
||||
}
|
||||
|
||||
```
|
||||
|
||||
</div>
|
||||
@@ -88,6 +84,7 @@ function uncapture() {
|
||||
}
|
||||
var oopsGlobal;
|
||||
capture();
|
||||
|
||||
```
|
||||
|
||||
</div>
|
||||
@@ -106,27 +103,7 @@ console.info('after the test');
|
||||
## Solution
|
||||
<section id='solution'>
|
||||
|
||||
|
||||
```js
|
||||
// Declare your variable here
|
||||
var myGlobal = 10;
|
||||
|
||||
function fun1() {
|
||||
// Assign 5 to oopsGlobal Here
|
||||
oopsGlobal = 5;
|
||||
}
|
||||
|
||||
// Only change code above this line
|
||||
function fun2() {
|
||||
var output = "";
|
||||
if(typeof myGlobal != "undefined") {
|
||||
output += "myGlobal: " + myGlobal;
|
||||
}
|
||||
if(typeof oopsGlobal != "undefined") {
|
||||
output += " oopsGlobal: " + oopsGlobal;
|
||||
}
|
||||
console.log(output);
|
||||
}
|
||||
// solution required
|
||||
```
|
||||
|
||||
</section>
|
||||
|
||||
@@ -1,22 +1,16 @@
|
||||
---
|
||||
id: 56533eb9ac21ba0edf2244c0
|
||||
title: Global vs. Local Scope in Functions
|
||||
localeTitle: Ámbito global vs. local en funciones
|
||||
challengeType: 1
|
||||
videoUrl: ''
|
||||
localeTitle: Ámbito global vs. local en funciones
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
Es posible tener variables <dfn>locales</dfn> y <dfn>globales</dfn> con el mismo nombre. Cuando haces esto, la variable <code>local</code> tiene prioridad sobre la variable <code>global</code> .
|
||||
En este ejemplo:
|
||||
<blockquote>var someVar = "Hat";<br>function myFun() {<br> var someVar = "Head";<br> return someVar;<br>}</blockquote>
|
||||
La función <code>myFun</code> devolverá <code>"Head"</code> porque la versión <code>local</code> de la variable está presente.
|
||||
</section>
|
||||
<section id="description"> Es posible tener variables <dfn>locales</dfn> y <dfn>globales</dfn> con el mismo nombre. Cuando haces esto, la variable <code>local</code> tiene prioridad sobre la variable <code>global</code> . En este ejemplo: <blockquote> var someVar = "Hat"; <br> función myFun () { <br> var someVar = "Head"; <br> devuelve someVar; <br> } </blockquote> La función <code>myFun</code> devolverá <code>"Head"</code> porque la versión <code>local</code> de la variable está presente. </section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
Agregue una variable local a la función <code>myOutfit</code> para anular el valor de <code>outerWear</code> con <code>"sweater"</code> .
|
||||
</section>
|
||||
<section id="instructions"> Agregue una variable local a la función <code>myOutfit</code> para anular el valor de <code>outerWear</code> con <code>"sweater"</code> . </section>
|
||||
|
||||
## Tests
|
||||
<section id='tests'>
|
||||
@@ -53,6 +47,7 @@ function myOutfit() {
|
||||
}
|
||||
|
||||
myOutfit();
|
||||
|
||||
```
|
||||
|
||||
</div>
|
||||
@@ -64,13 +59,7 @@ myOutfit();
|
||||
## Solution
|
||||
<section id='solution'>
|
||||
|
||||
|
||||
```js
|
||||
var outerWear = "T-Shirt";
|
||||
function myOutfit() {
|
||||
var outerWear = "sweater";
|
||||
return outerWear;
|
||||
}
|
||||
// solution required
|
||||
```
|
||||
|
||||
</section>
|
||||
|
||||
@@ -1,21 +1,16 @@
|
||||
---
|
||||
id: 5664820f61c48e80c9fa476c
|
||||
title: Golf Code
|
||||
localeTitle: Codigo de golf
|
||||
challengeType: 1
|
||||
videoUrl: ''
|
||||
localeTitle: Codigo de golf
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
En el juego de <a href="https://en.wikipedia.org/wiki/Golf" target="_blank">golf,</a> cada hoyo tiene un <code>par</code> significa el número promedio de <code>strokes</code> que se espera que un golfista realice para hundir la bola en un hoyo para completar el juego. Dependiendo de qué tan por encima o <code>par</code> debajo de tus <code>strokes</code> , hay un apodo diferente.
|
||||
Su función se pasará <code>par</code> y <code>strokes</code> argumentos. Devuelva la cadena correcta de acuerdo con esta tabla que enumera los trazos en orden de prioridad; arriba (más alto) a abajo (más bajo):
|
||||
<table class="table table-striped"><thead><tr><th> Trazos </th><th> Regreso </th></tr></thead><tbody><tr><td> 1 </td><td> "¡Hoyo en uno!" </td></tr><tr><td> <= par - 2 </td><td> "Águila" </td></tr><tr><td> par - 1 </td><td> "Pajarito" </td></tr><tr><td> par </td><td> "Par" </td></tr><tr><td> par + 1 </td><td> "Espectro" </td></tr><tr><td> par + 2 </td><td> "Doble Bogey" </td></tr><tr><td> > = par + 3 </td><td> "¡Vete a casa!" </td></tr></tbody></table>
|
||||
<code>par</code> y <code>strokes</code> siempre serán numéricos y positivos. Hemos agregado una matriz de todos los nombres para su conveniencia.
|
||||
</section>
|
||||
<section id="description"> En el juego de <a href="https://en.wikipedia.org/wiki/Golf" target="_blank">golf,</a> cada hoyo tiene un <code>par</code> significa el número promedio de <code>strokes</code> que se espera que un golfista realice para hundir la bola en un hoyo para completar el juego. Dependiendo de qué tan por encima o <code>par</code> debajo de tus <code>strokes</code> , hay un apodo diferente. Su función se pasará <code>par</code> y <code>strokes</code> argumentos. Devuelva la cadena correcta de acuerdo con esta tabla que enumera los trazos en orden de prioridad; arriba (más alto) a abajo (más bajo): <table class="table table-striped"><thead><tr><th> Trazos </th><th> Regreso </th></tr></thead><tbody><tr><td> 1 </td><td> "¡Hoyo en uno!" </td></tr><tr><td> <= par - 2 </td><td> "Águila" </td></tr><tr><td> par - 1 </td><td> "Pajarito" </td></tr><tr><td> par </td><td> "Par" </td></tr><tr><td> par + 1 </td><td> "Espectro" </td></tr><tr><td> par + 2 </td><td> "Doble Bogey" </td></tr><tr><td> > = par + 3 </td><td> "¡Vete a casa!" </td></tr></tbody></table> <code>par</code> y <code>strokes</code> siempre serán numéricos y positivos. Hemos agregado una matriz de todos los nombres para su conveniencia. </section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
|
||||
<section id="instructions">
|
||||
</section>
|
||||
|
||||
## Tests
|
||||
@@ -23,27 +18,27 @@ Su función se pasará <code>par</code> y <code>strokes</code> argumentos. Devue
|
||||
|
||||
```yml
|
||||
tests:
|
||||
- text: ' <code>golfScore(4, 1)</code> debe devolver "Hole-in-one!"'
|
||||
- text: '<code>golfScore(4, 1)</code> debe devolver "Hole-in-one!"'
|
||||
testString: 'assert(golfScore(4, 1) === "Hole-in-one!", "<code>golfScore(4, 1)</code> should return "Hole-in-one!"");'
|
||||
- text: ' <code>golfScore(4, 2)</code> debe devolver "Eagle"'
|
||||
- text: '<code>golfScore(4, 2)</code> debe devolver "Eagle"'
|
||||
testString: 'assert(golfScore(4, 2) === "Eagle", "<code>golfScore(4, 2)</code> should return "Eagle"");'
|
||||
- text: ' <code>golfScore(5, 2)</code> debe devolver "Eagle"'
|
||||
- text: '<code>golfScore(5, 2)</code> debe devolver "Eagle"'
|
||||
testString: 'assert(golfScore(5, 2) === "Eagle", "<code>golfScore(5, 2)</code> should return "Eagle"");'
|
||||
- text: ' <code>golfScore(4, 3)</code> debe devolver "Birdie"'
|
||||
- text: '<code>golfScore(4, 3)</code> debe devolver "Birdie"'
|
||||
testString: 'assert(golfScore(4, 3) === "Birdie", "<code>golfScore(4, 3)</code> should return "Birdie"");'
|
||||
- text: ' <code>golfScore(4, 4)</code> debe devolver "Par"
|
||||
- text: '<code>golfScore(4, 4)</code> debe devolver "Par"'
|
||||
testString: 'assert(golfScore(4, 4) === "Par", "<code>golfScore(4, 4)</code> should return "Par"");'
|
||||
- text: ' <code>golfScore(1, 1)</code> debe devolver "Hole-in-one!"'
|
||||
- text: '<code>golfScore(1, 1)</code> debe devolver "Hole-in-one!"'
|
||||
testString: 'assert(golfScore(1, 1) === "Hole-in-one!", "<code>golfScore(1, 1)</code> should return "Hole-in-one!"");'
|
||||
- text: ' <code>golfScore(5, 5)</code> debe devolver "Par"
|
||||
- text: '<code>golfScore(5, 5)</code> debe devolver "Par"'
|
||||
testString: 'assert(golfScore(5, 5) === "Par", "<code>golfScore(5, 5)</code> should return "Par"");'
|
||||
- text: ' <code>golfScore(4, 5)</code> debería devolver "Bogey"'
|
||||
- text: '<code>golfScore(4, 5)</code> debe devolver "Bogey"'
|
||||
testString: 'assert(golfScore(4, 5) === "Bogey", "<code>golfScore(4, 5)</code> should return "Bogey"");'
|
||||
- text: ' <code>golfScore(4, 6)</code> debería devolver "Double Bogey"'
|
||||
- text: '<code>golfScore(4, 6)</code> debe devolver "Double Bogey"'
|
||||
testString: 'assert(golfScore(4, 6) === "Double Bogey", "<code>golfScore(4, 6)</code> should return "Double Bogey"");'
|
||||
- text: ' <code>golfScore(4, 7)</code> debe devolver "Go Home!"'
|
||||
- text: '<code>golfScore(4, 7)</code> debe devolver "Go Home!"'
|
||||
testString: 'assert(golfScore(4, 7) === "Go Home!", "<code>golfScore(4, 7)</code> should return "Go Home!"");'
|
||||
- text: ' <code>golfScore(5, 9)</code> debe devolver "Go Home!"'
|
||||
- text: '<code>golfScore(5, 9)</code> debe devolver "Go Home!"'
|
||||
testString: 'assert(golfScore(5, 9) === "Go Home!", "<code>golfScore(5, 9)</code> should return "Go Home!"");'
|
||||
|
||||
```
|
||||
@@ -67,6 +62,7 @@ function golfScore(par, strokes) {
|
||||
|
||||
// Change these values to test
|
||||
golfScore(5, 4);
|
||||
|
||||
```
|
||||
|
||||
</div>
|
||||
@@ -78,35 +74,7 @@ golfScore(5, 4);
|
||||
## Solution
|
||||
<section id='solution'>
|
||||
|
||||
|
||||
```js
|
||||
function golfScore(par, strokes) {
|
||||
if (strokes === 1) {
|
||||
return "Hole-in-one!";
|
||||
}
|
||||
|
||||
if (strokes <= par - 2) {
|
||||
return "Eagle";
|
||||
}
|
||||
|
||||
if (strokes === par - 1) {
|
||||
return "Birdie";
|
||||
}
|
||||
|
||||
if (strokes === par) {
|
||||
return "Par";
|
||||
}
|
||||
|
||||
if (strokes === par + 1) {
|
||||
return "Bogey";
|
||||
}
|
||||
|
||||
if(strokes === par + 2) {
|
||||
return "Double Bogey";
|
||||
}
|
||||
|
||||
return "Go Home!";
|
||||
}
|
||||
// solution required
|
||||
```
|
||||
|
||||
</section>
|
||||
|
||||
@@ -1,24 +1,16 @@
|
||||
---
|
||||
id: 56533eb9ac21ba0edf2244ac
|
||||
title: Increment a Number with JavaScript
|
||||
localeTitle: Incrementar un número con JavaScript
|
||||
challengeType: 1
|
||||
videoUrl: ''
|
||||
localeTitle: Incrementar un número con JavaScript
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
Puede <dfn>incrementar</dfn> o agregar fácilmente uno a una variable con el operador <code>++</code> .
|
||||
<code>i++;</code>
|
||||
es el equivalente de
|
||||
<code>i = i + 1;</code>
|
||||
<strong>Nota</strong> <br> La línea entera se convierte en <code>i++;</code> , eliminando la necesidad del signo igual.
|
||||
</section>
|
||||
<section id="description"> Puede <dfn>incrementar</dfn> o agregar fácilmente uno a una variable con el operador <code>++</code> . <code>i++;</code> es el equivalente de <code>i = i + 1;</code> <strong>Nota</strong> <br> La línea entera se convierte en <code>i++;</code> , eliminando la necesidad del signo igual. </section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
Cambie el código para usar el operador <code>++</code> en <code>myVar</code> .
|
||||
<strong>Pista</strong> <br> Obtenga más información sobre los <a href="https://developer.mozilla.org/en/docs/Web/JavaScript/Reference/Operators/Arithmetic_Operators#Increment_()" target="_blank">operadores aritméticos - Incremento (++)</a> .
|
||||
</section>
|
||||
<section id="instructions"> Cambie el código para usar el operador <code>++</code> en <code>myVar</code> . <strong>Insinuación</strong> <br> Obtenga más información sobre los <a href="https://developer.mozilla.org/en/docs/Web/JavaScript/Reference/Operators/Arithmetic_Operators#Increment_()" target="_blank">operadores aritméticos - Incremento (++)</a> . </section>
|
||||
|
||||
## Tests
|
||||
<section id='tests'>
|
||||
@@ -68,10 +60,7 @@ console.info('after the test');
|
||||
## Solution
|
||||
<section id='solution'>
|
||||
|
||||
|
||||
```js
|
||||
var myVar = 87;
|
||||
myVar++;
|
||||
// solution required
|
||||
```
|
||||
|
||||
</section>
|
||||
|
||||
@@ -1,21 +1,16 @@
|
||||
---
|
||||
id: 56533eb9ac21ba0edf2244a9
|
||||
title: Initializing Variables with the Assignment Operator
|
||||
localeTitle: Inicializando variables con el operador de asignación
|
||||
challengeType: 1
|
||||
videoUrl: ''
|
||||
localeTitle: Inicializando variables con el operador de asignación
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
Es común <dfn>inicializar</dfn> una variable a un valor inicial en la misma línea que se declara.
|
||||
<code>var myVar = 0;</code>
|
||||
Crea una nueva variable llamada <code>myVar</code> y le asigna un valor inicial de <code>0</code> .
|
||||
</section>
|
||||
<section id="description"> Es común <dfn>inicializar</dfn> una variable a un valor inicial en la misma línea que se declara. <code>var myVar = 0;</code> Crea una nueva variable llamada <code>myVar</code> y le asigna un valor inicial de <code>0</code> . </section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
Defina una variable <code>a</code> con <code>var</code> e inicialícela a un valor de <code>9</code> .
|
||||
</section>
|
||||
<section id="instructions"> Defina una variable <code>a</code> con <code>var</code> e inicialícela a un valor de <code>9</code> . </section>
|
||||
|
||||
## Tests
|
||||
<section id='tests'>
|
||||
@@ -59,9 +54,7 @@ console.info('after the test');
|
||||
## Solution
|
||||
<section id='solution'>
|
||||
|
||||
|
||||
```js
|
||||
var a = 9;
|
||||
// solution required
|
||||
```
|
||||
|
||||
</section>
|
||||
|
||||
@@ -1,20 +1,16 @@
|
||||
---
|
||||
id: 56533eb9ac21ba0edf2244db
|
||||
title: Introducing Else If Statements
|
||||
localeTitle: Introduciendo Else If Sentencias
|
||||
challengeType: 1
|
||||
videoUrl: ''
|
||||
localeTitle: Introduciendo Else If Sentencias
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
Si tiene varias condiciones que deben abordarse, puede encadenar <code>if</code> sentencias junto con <code>else if</code> sent.
|
||||
<blockquote>if (num > 15) {<br> return "Bigger than 15";<br>} else if (num < 5) {<br> return "Smaller than 5";<br>} else {<br> return "Between 5 and 15";<br>}</blockquote>
|
||||
</section>
|
||||
<section id="description"> Si tiene múltiples condiciones que deben abordarse, puede encadenar <code>if</code> sentencias junto con <code>else if</code> sent. <blockquote> if (num> 15) { <br> devuelve "Más grande que 15"; <br> } else if (num <5) { <br> devuelve "Menor de 5"; <br> } else { <br> volver "Entre 5 y 15"; <br> } </blockquote></section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
Convertir la lógica para usar <code>else if</code> instrucciones.
|
||||
</section>
|
||||
<section id="instructions"> Convierte la lógica para usar <code>else if</code> . </section>
|
||||
|
||||
## Tests
|
||||
<section id='tests'>
|
||||
@@ -74,17 +70,7 @@ testElseIf(7);
|
||||
## Solution
|
||||
<section id='solution'>
|
||||
|
||||
|
||||
```js
|
||||
function testElseIf(val) {
|
||||
if(val > 10) {
|
||||
return "Greater than 10";
|
||||
} else if(val < 5) {
|
||||
return "Smaller than 5";
|
||||
} else {
|
||||
return "Between 5 and 10";
|
||||
}
|
||||
}
|
||||
// solution required
|
||||
```
|
||||
|
||||
</section>
|
||||
|
||||
@@ -1,20 +1,16 @@
|
||||
---
|
||||
id: 56533eb9ac21ba0edf2244da
|
||||
title: Introducing Else Statements
|
||||
localeTitle: Introduciendo otras declaraciones
|
||||
challengeType: 1
|
||||
videoUrl: ''
|
||||
localeTitle: Introduciendo otras declaraciones
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
Cuando una condición para una sentencia <code>if</code> es verdadera, se ejecuta el bloque de código siguiente. ¿Qué pasa cuando esa condición es falsa? Normalmente no pasaría nada. Con una sentencia <code>else</code> , se puede ejecutar un bloque de código alternativo.
|
||||
<blockquote>if (num > 10) {<br> return "Bigger than 10";<br>} else {<br> return "10 or Less";<br>}</blockquote>
|
||||
</section>
|
||||
<section id="description"> Cuando una condición para una sentencia <code>if</code> es verdadera, se ejecuta el bloque de código siguiente. ¿Qué pasa cuando esa condición es falsa? Normalmente no pasaría nada. Con una sentencia <code>else</code> , se puede ejecutar un bloque de código alternativo. <blockquote> if (num> 10) { <br> devuelve "Más grande que 10"; <br> } else { <br> devuelve "10 o menos"; <br> } </blockquote></section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
Combine las sentencias <code>if</code> en una sola sentencia <code>if/else</code> .
|
||||
</section>
|
||||
<section id="instructions"> Combine las declaraciones <code>if</code> en una sola instrucción <code>if/else</code> . </section>
|
||||
|
||||
## Tests
|
||||
<section id='tests'>
|
||||
@@ -76,17 +72,7 @@ testElse(4);
|
||||
## Solution
|
||||
<section id='solution'>
|
||||
|
||||
|
||||
```js
|
||||
function testElse(val) {
|
||||
var result = "";
|
||||
if(val > 5) {
|
||||
result = "Bigger than 5";
|
||||
} else {
|
||||
result = "5 or Smaller";
|
||||
}
|
||||
return result;
|
||||
}
|
||||
// solution required
|
||||
```
|
||||
|
||||
</section>
|
||||
|
||||
@@ -1,23 +1,16 @@
|
||||
---
|
||||
id: 56104e9e514f539506016a5c
|
||||
title: Iterate Odd Numbers With a For Loop
|
||||
localeTitle: Iterar números impares con un bucle for
|
||||
challengeType: 1
|
||||
videoUrl: ''
|
||||
localeTitle: Iterar números impares con un bucle for
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
Para que los bucles no tengan que iterar uno a la vez. Al cambiar nuestra <code>final-expression</code> , podemos contar por números pares.
|
||||
Comenzaremos en <code>i = 0</code> y haremos un bucle mientras que <code>i < 10</code> . Incrementaremos <code>i</code> en 2 en cada bucle con <code>i += 2</code> .
|
||||
<blockquote>var ourArray = [];<br>for (var i = 0; i < 10; i += 2) {<br> ourArray.push(i);<br>}</blockquote>
|
||||
<code>ourArray</code> ahora contendrá <code>[0,2,4,6,8]</code> .
|
||||
Cambiemos nuestra <code>initialization</code> para que podamos contar por números impares.
|
||||
</section>
|
||||
<section id="description"> Para que los bucles no tengan que iterar uno a la vez. Al cambiar nuestra <code>final-expression</code> , podemos contar por números pares. Comenzaremos en <code>i = 0</code> y haremos un bucle mientras <code>i < 10</code> . Incrementaremos <code>i</code> en 2 en cada bucle con <code>i += 2</code> . <blockquote> var ourArray = []; <br> para (var i = 0; i <10; i + = 2) { <br> nuestroArray.push (i); <br> } </blockquote> <code>ourArray</code> ahora contendrá <code>[0,2,4,6,8]</code> . Cambiemos nuestra <code>initialization</code> para que podamos contar por números impares. </section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
Empuje los números impares del 1 al 9 a <code>myArray</code> usando un bucle <code>for</code> .
|
||||
</section>
|
||||
<section id="instructions"> Empuje los números impares del 1 al 9 a <code>myArray</code> usando un bucle <code>for</code> . </section>
|
||||
|
||||
## Tests
|
||||
<section id='tests'>
|
||||
@@ -26,7 +19,7 @@ Empuje los números impares del 1 al 9 a <code>myArray</code> usando un bucle <c
|
||||
tests:
|
||||
- text: Usted debe estar usando una <code>for</code> bucle para esto.
|
||||
testString: 'assert(code.match(/for\s*\(/g).length > 1, "You should be using a <code>for</code> loop for this.");'
|
||||
- text: ' <code>myArray</code> debería ser igual a <code>[1,3,5,7,9]</code> .'
|
||||
- text: '<code>myArray</code> debe ser igual a <code>[1,3,5,7,9]</code> .'
|
||||
testString: 'assert.deepEqual(myArray, [1,3,5,7,9], "<code>myArray</code> should equal <code>[1,3,5,7,9]</code>.");'
|
||||
|
||||
```
|
||||
@@ -51,7 +44,6 @@ var myArray = [];
|
||||
|
||||
// Only change code below this line.
|
||||
|
||||
|
||||
```
|
||||
|
||||
</div>
|
||||
@@ -71,16 +63,7 @@ console.info('after the test');
|
||||
## Solution
|
||||
<section id='solution'>
|
||||
|
||||
|
||||
```js
|
||||
var ourArray = [];
|
||||
for (var i = 0; i < 10; i += 2) {
|
||||
ourArray.push(i);
|
||||
}
|
||||
var myArray = [];
|
||||
for (var i = 1; i < 10; i += 2) {
|
||||
myArray.push(i);
|
||||
}
|
||||
// solution required
|
||||
```
|
||||
|
||||
</section>
|
||||
|
||||
@@ -1,21 +1,16 @@
|
||||
---
|
||||
id: 5675e877dbd60be8ad28edc6
|
||||
title: Iterate Through an Array with a For Loop
|
||||
localeTitle: Iterar a través de una matriz con un bucle For
|
||||
challengeType: 1
|
||||
videoUrl: ''
|
||||
localeTitle: Iterar a través de una matriz con un bucle For
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
Una tarea común en JavaScript es iterar a través del contenido de una matriz. Una forma de hacerlo es con un bucle <code>for</code> . Este código dará salida a cada elemento de la matriz <code>arr</code> a la consola:
|
||||
<blockquote>var arr = [10,9,8,7,6];<br>for (var i = 0; i < arr.length; i++) {<br> console.log(arr[i]);<br>}</blockquote>
|
||||
Recuerde que las matrices tienen numeración basada en cero, lo que significa que el último índice de la matriz es la longitud - 1. Nuestra <dfn>condición</dfn> para este bucle es <code>i < arr.length</code> , que se detiene cuando <code>i</code> tiene la longitud - 1.
|
||||
</section>
|
||||
<section id="description"> Una tarea común en JavaScript es iterar a través del contenido de una matriz. Una forma de hacerlo es con un bucle <code>for</code> . Este código dará salida a cada elemento de la matriz <code>arr</code> a la consola: <blockquote> var arr = [10,9,8,7,6]; <br> para (var i = 0; i <arr.length; i ++) { <br> console.log (arr [i]); <br> } </blockquote> Recuerde que las matrices tienen numeración basada en cero, lo que significa que el último índice de la matriz es la longitud - 1. Nuestra <dfn>condición</dfn> para este bucle es <code>i < arr.length</code> , que se detiene cuando <code>i</code> tiene la longitud - 1. </section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
Declarar e inicializar una variable <code>total</code> a <code>0</code> . Use un bucle <code>for</code> para agregar el valor de cada elemento de la matriz <code>myArr</code> al <code>total</code> .
|
||||
</section>
|
||||
<section id="instructions"> Declarar e inicializar una variable <code>total</code> a <code>0</code> . Use un bucle <code>for</code> para agregar el valor de cada elemento de la matriz <code>myArr</code> al <code>total</code> . </section>
|
||||
|
||||
## Tests
|
||||
<section id='tests'>
|
||||
@@ -54,7 +49,6 @@ var myArr = [ 2, 3, 4, 5, 6];
|
||||
|
||||
// Only change code below this line
|
||||
|
||||
|
||||
```
|
||||
|
||||
</div>
|
||||
@@ -74,21 +68,7 @@ console.info('after the test');
|
||||
## Solution
|
||||
<section id='solution'>
|
||||
|
||||
|
||||
```js
|
||||
var ourArr = [ 9, 10, 11, 12];
|
||||
var ourTotal = 0;
|
||||
|
||||
for (var i = 0; i < ourArr.length; i++) {
|
||||
ourTotal += ourArr[i];
|
||||
}
|
||||
|
||||
var myArr = [ 2, 3, 4, 5, 6];
|
||||
var total = 0;
|
||||
|
||||
for (var i = 0; i < myArr.length; i++) {
|
||||
total += myArr[i];
|
||||
}
|
||||
// solution required
|
||||
```
|
||||
|
||||
</section>
|
||||
|
||||
@@ -1,30 +1,16 @@
|
||||
---
|
||||
id: 5a2efd662fb457916e1fe604
|
||||
title: Iterate with JavaScript Do...While Loops
|
||||
localeTitle: Iterar con JavaScript Do ... While Loops
|
||||
challengeType: 1
|
||||
videoUrl: ''
|
||||
localeTitle: Iterar con JavaScript Do ... While Loops
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
Puede ejecutar el mismo código varias veces utilizando un bucle.
|
||||
El siguiente tipo de bucle que aprenderá se llama bucle " <code>do...while</code> " porque primero " <code>do</code> " una pasada del código dentro del bucle sin importar qué, y luego se ejecuta " <code>while</code> " una condición específica es verdadero y se detiene una vez que esa condición ya no es verdadera. Veamos un ejemplo.
|
||||
<blockquote>var ourArray = [];<br>var i = 0;<br>do {<br> ourArray.push(i);<br> i++;<br>} while (i < 5);</blockquote>
|
||||
Esto se comporta como se esperaría con cualquier otro tipo de bucle, y la matriz resultante se verá como <code>[0, 1, 2, 3, 4]</code> . Sin embargo, lo que hace <code>do...while</code> diferente de otros bucles es cómo se comporta cuando la condición falla en la primera comprobación. Veamos esto en acción.
|
||||
Aquí hay un bucle while común que ejecutará el código en el bucle siempre y cuando <code>i < 5</code> .
|
||||
<blockquote>var ourArray = []; <br>var i = 5;<br>while (i < 5) {<br> ourArray.push(i);<br> i++;<br>}</blockquote>
|
||||
Observe que inicializamos el valor de <code>i</code> en 5. Cuando ejecutamos la siguiente línea, notamos que <code>i</code> no es menor que 5. Por lo tanto, no ejecutamos el código dentro del bucle. El resultado es que <code>ourArray</code> no agregará nada, por lo que aún se verá así <code>[]</code> cuando todo el código del ejemplo anterior termine de ejecutarse.
|
||||
Ahora, eche un vistazo a un <code>do...while</code> loop.
|
||||
<blockquote>var ourArray = []; <br>var i = 5;<br>do {<br> ourArray.push(i);<br> i++;<br>} while (i < 5);</blockquote>
|
||||
En este caso, inicializamos el valor de <code>i</code> como 5, como hicimos con el bucle while. Cuando llegamos a la siguiente línea, no hay comprobación del valor de <code>i</code> , por lo que vamos al código dentro de las llaves y lo ejecutamos. Agregaremos un elemento a la matriz e incrementaremos <code>i</code> antes de llegar a la verificación de condición. Entonces, cuando se llega a comprobar si <code>i < 5</code> ver que <code>i</code> es ahora de 6 años, que no pasa la comprobación condicional. Así que salimos del bucle y estamos listos. Al final del ejemplo anterior, el valor de <code>ourArray</code> es <code>[5]</code> .
|
||||
Esencialmente, un bucle <code>do...while</code> while garantiza que el código dentro del bucle se ejecute al menos una vez.
|
||||
Intentemos obtener un ciclo <code>do...while</code> while para que funcione presionando los valores en una matriz.
|
||||
</section>
|
||||
<section id="description"> Puede ejecutar el mismo código varias veces utilizando un bucle. El siguiente tipo de bucle que aprenderá se denomina bucle " <code>do...while</code> " porque primero " <code>do</code> " una pasada del código dentro del bucle sin importar qué, y luego se ejecuta " <code>while</code> " se cumple una condición específica y se detiene una vez que esa condición ya no es verdadera. Veamos un ejemplo. <blockquote> var ourArray = []; <br> var i = 0; <br> hacer { <br> nuestroArray.push (i); <br> i ++; <br> } while (i <5); </blockquote> Esto se comporta como se esperaría con cualquier otro tipo de bucle, y la matriz resultante se verá como <code>[0, 1, 2, 3, 4]</code> . Sin embargo, lo que hace <code>do...while</code> diferente de otros bucles es cómo se comporta cuando la condición falla en la primera comprobación. Veamos esto en acción. Aquí hay un bucle while común que ejecutará el código en el bucle siempre y cuando <code>i < 5</code> . <blockquote> var ourArray = []; <br> var i = 5; <br> mientras (i <5) { <br> nuestroArray.push (i); <br> i ++; <br> } </blockquote> Observe que inicializamos el valor de <code>i</code> en 5. Cuando ejecutamos la siguiente línea, notamos que <code>i</code> no es menor que 5. Por lo tanto, no ejecutamos el código dentro del bucle. El resultado es que <code>ourArray</code> no agregará nada, por lo que aún se verá así <code>[]</code> cuando todo el código del ejemplo anterior termine de ejecutarse. Ahora, eche un vistazo a un <code>do...while</code> loop. <blockquote> var ourArray = []; <br> var i = 5; <br> hacer { <br> nuestroArray.push (i); <br> i ++; <br> } while (i <5); </blockquote> En este caso, inicializamos el valor de <code>i</code> como 5, tal como hicimos con el bucle while. Cuando llegamos a la siguiente línea, no hay comprobación del valor de <code>i</code> , por lo que vamos al código dentro de las llaves y lo ejecutamos. Agregaremos un elemento a la matriz e incrementaremos <code>i</code> antes de llegar a la verificación de condición. Entonces, cuando se llega a comprobar si <code>i < 5</code> ver que <code>i</code> es ahora de 6 años, que no pasa la comprobación condicional. Así que salimos del bucle y estamos listos. Al final del ejemplo anterior, el valor de <code>ourArray</code> es <code>[5]</code> . Esencialmente, un bucle <code>do...while</code> while garantiza que el código dentro del bucle se ejecute al menos una vez. Intentemos obtener un bucle <code>do...while</code> while para que funcione presionando valores en una matriz. </section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
Cambiar el <code>while</code> de bucle en el código a un <code>do...while</code> bucle de modo que el bucle empujará el número 10 a <code>myArray</code> , y <code>i</code> será igual a <code>11</code> cuando el código termina de ejecutarse.
|
||||
</section>
|
||||
<section id="instructions"> Cambiar el <code>while</code> de bucle en el código a un <code>do...while</code> bucle de modo que el bucle empujará el número 10 a <code>myArray</code> , y <code>i</code> será igual a <code>11</code> cuando el código termina de ejecutarse. </section>
|
||||
|
||||
## Tests
|
||||
<section id='tests'>
|
||||
@@ -33,7 +19,7 @@ Cambiar el <code>while</code> de bucle en el código a un <code>do...while</code
|
||||
tests:
|
||||
- text: Deberías usar un bucle <code>do...while</code> while para esto.
|
||||
testString: 'assert(code.match(/do/g), "You should be using a <code>do...while</code> loop for this.");'
|
||||
- text: ' <code>myArray</code> debería ser igual a <code>[10]</code> '
|
||||
- text: '<code>myArray</code> debe ser igual a <code>[10]</code> .'
|
||||
testString: 'assert.deepEqual(myArray, [10], "<code>myArray</code> should equal <code>[10]</code>.");'
|
||||
- text: <code>i</code> debe ser igual a <code>11</code>
|
||||
testString: 'assert.deepEqual(i, 11, "<code>i</code> should equal <code>11</code>");'
|
||||
@@ -78,14 +64,7 @@ console.info('after the test');
|
||||
## Solution
|
||||
<section id='solution'>
|
||||
|
||||
|
||||
```js
|
||||
var myArray = [];
|
||||
var i = 10;
|
||||
do {
|
||||
myArray.push(i);
|
||||
i++;
|
||||
} while (i < 5)
|
||||
// solution required
|
||||
```
|
||||
|
||||
</section>
|
||||
|
||||
@@ -1,28 +1,16 @@
|
||||
---
|
||||
id: cf1111c1c11feddfaeb5bdef
|
||||
title: Iterate with JavaScript For Loops
|
||||
localeTitle: Iterar con JavaScript para bucles
|
||||
challengeType: 1
|
||||
videoUrl: ''
|
||||
localeTitle: Iterar con JavaScript para bucles
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
Puede ejecutar el mismo código varias veces utilizando un bucle.
|
||||
El tipo más común de bucle de JavaScript se llama " <code>for loop</code> " porque se ejecuta "por" un número específico de veces.
|
||||
Para los bucles se declaran con tres expresiones opcionales separadas por punto y coma:
|
||||
<code>for ([initialization]; [condition]; [final-expression])</code>
|
||||
La instrucción de <code>initialization</code> se ejecuta una sola vez antes de que comience el bucle. Normalmente se utiliza para definir y configurar su variable de bucle.
|
||||
La declaración de <code>condition</code> se evalúa al comienzo de cada iteración de bucle y continuará mientras se evalúe como <code>true</code> . Cuando la <code>condition</code> es <code>false</code> al inicio de la iteración, el bucle dejará de ejecutarse. Esto significa que si la <code>condition</code> comienza como <code>false</code> , su bucle nunca se ejecutará.
|
||||
La <code>final-expression</code> se ejecuta al final de cada iteración de bucle, antes de la siguiente verificación de <code>condition</code> y generalmente se usa para aumentar o disminuir su contador de bucle.
|
||||
En el siguiente ejemplo, inicializamos con <code>i = 0</code> e iteramos mientras nuestra condición <code>i < 5</code> es verdadera. Incrementaremos <code>i</code> en <code>1</code> en cada iteración de bucle con <code>i++</code> como nuestra <code>final-expression</code> .
|
||||
<blockquote>var ourArray = [];<br>for (var i = 0; i < 5; i++) {<br> ourArray.push(i);<br>}</blockquote>
|
||||
<code>ourArray</code> ahora contendrá <code>[0,1,2,3,4]</code> .
|
||||
</section>
|
||||
<section id="description"> Puede ejecutar el mismo código varias veces utilizando un bucle. El tipo más común de bucle de JavaScript se llama " <code>for loop</code> " porque se ejecuta "por" un número específico de veces. Para los bucles se declaran con tres expresiones opcionales separadas por punto y coma: <code>for ([initialization]; [condition]; [final-expression])</code> La instrucción de <code>initialization</code> se ejecuta una sola vez antes de que comience el bucle. Normalmente se utiliza para definir y configurar su variable de bucle. La declaración de <code>condition</code> se evalúa al comienzo de cada iteración de bucle y continuará mientras se evalúe como <code>true</code> . Cuando la <code>condition</code> es <code>false</code> al inicio de la iteración, el bucle dejará de ejecutarse. Esto significa que si la <code>condition</code> comienza como <code>false</code> , su bucle nunca se ejecutará. La <code>final-expression</code> se ejecuta al final de cada iteración de bucle, antes de la siguiente verificación de <code>condition</code> y generalmente se usa para incrementar o disminuir su contador de bucle. En el siguiente ejemplo, iniciamos con <code>i = 0</code> e iteramos mientras nuestra condición <code>i < 5</code> es verdadera. Incrementaremos <code>i</code> en <code>1</code> en cada iteración de bucle con <code>i++</code> como nuestra <code>final-expression</code> . <blockquote> var ourArray = []; <br> para (var i = 0; i <5; i ++) { <br> nuestroArray.push (i); <br> } </blockquote> <code>ourArray</code> ahora contendrá <code>[0,1,2,3,4]</code> . </section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
Use un bucle <code>for</code> para trabajar y empujar los valores del 1 al 5 en <code>myArray</code> .
|
||||
</section>
|
||||
<section id="instructions"> Use un bucle <code>for</code> para trabajar y empujar los valores del 1 al 5 en <code>myArray</code> . </section>
|
||||
|
||||
## Tests
|
||||
<section id='tests'>
|
||||
@@ -31,7 +19,7 @@ Use un bucle <code>for</code> para trabajar y empujar los valores del 1 al 5 en
|
||||
tests:
|
||||
- text: Usted debe estar usando una <code>for</code> bucle para esto.
|
||||
testString: 'assert(code.match(/for\s*\(/g).length > 1, "You should be using a <code>for</code> loop for this.");'
|
||||
- text: ' <code>myArray</code> debe ser igual a <code>[1,2,3,4,5]</code> .'
|
||||
- text: '<code>myArray</code> debe ser igual a <code>[1,2,3,4,5]</code> .'
|
||||
testString: 'assert.deepEqual(myArray, [1,2,3,4,5], "<code>myArray</code> should equal <code>[1,2,3,4,5]</code>.");'
|
||||
|
||||
```
|
||||
@@ -56,7 +44,6 @@ var myArray = [];
|
||||
|
||||
// Only change code below this line.
|
||||
|
||||
|
||||
```
|
||||
|
||||
</div>
|
||||
@@ -76,16 +63,7 @@ console.info('after the test');
|
||||
## Solution
|
||||
<section id='solution'>
|
||||
|
||||
|
||||
```js
|
||||
var ourArray = [];
|
||||
for (var i = 0; i < 5; i++) {
|
||||
ourArray.push(i);
|
||||
}
|
||||
var myArray = [];
|
||||
for (var i = 1; i < 6; i++) {
|
||||
myArray.push(i);
|
||||
}
|
||||
// solution required
|
||||
```
|
||||
|
||||
</section>
|
||||
|
||||
@@ -1,22 +1,16 @@
|
||||
---
|
||||
id: cf1111c1c11feddfaeb1bdef
|
||||
title: Iterate with JavaScript While Loops
|
||||
localeTitle: Iterar con JavaScript mientras bucles
|
||||
challengeType: 1
|
||||
videoUrl: ''
|
||||
localeTitle: Iterar con JavaScript mientras bucles
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
Puede ejecutar el mismo código varias veces utilizando un bucle.
|
||||
El primer tipo de bucle vamos a aprender se llama un " <code>while</code> " bucle porque funciona "mientras que" una condición especificada es verdadera y se detiene una vez que la condición ya no es cierto.
|
||||
<blockquote>var ourArray = [];<br>var i = 0;<br>while(i < 5) {<br> ourArray.push(i);<br> i++;<br>}</blockquote>
|
||||
Intentemos que funcione un bucle while empujando los valores a una matriz.
|
||||
</section>
|
||||
<section id="description"> Puede ejecutar el mismo código varias veces utilizando un bucle. El primer tipo de bucle vamos a aprender se llama un " <code>while</code> " bucle porque funciona "mientras que" una condición especificada es verdadera y se detiene una vez que la condición ya no es cierto. <blockquote> var ourArray = []; <br> var i = 0; <br> mientras (i <5) { <br> nuestroArray.push (i); <br> i ++; <br> } </blockquote> Intentemos que funcione un bucle while empujando los valores a una matriz. </section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
Empuje los números de 0 a 4 para <code>myArray</code> usando un <code>while</code> de bucle.
|
||||
</section>
|
||||
<section id="instructions"> Empuje los números de 0 a 4 para <code>myArray</code> usando un <code>while</code> de bucle. </section>
|
||||
|
||||
## Tests
|
||||
<section id='tests'>
|
||||
@@ -25,7 +19,7 @@ Empuje los números de 0 a 4 para <code>myArray</code> usando un <code>while</co
|
||||
tests:
|
||||
- text: Usted debe utilizar un <code>while</code> de bucle para esto.
|
||||
testString: 'assert(code.match(/while/g), "You should be using a <code>while</code> loop for this.");'
|
||||
- text: ' <code>myArray</code> debe ser igual a <code>[0,1,2,3,4]</code> .'
|
||||
- text: '<code>myArray</code> debe ser igual a <code>[0,1,2,3,4]</code> .'
|
||||
testString: 'assert.deepEqual(myArray, [0,1,2,3,4], "<code>myArray</code> should equal <code>[0,1,2,3,4]</code>.");'
|
||||
|
||||
```
|
||||
@@ -43,7 +37,6 @@ var myArray = [];
|
||||
|
||||
// Only change code below this line.
|
||||
|
||||
|
||||
```
|
||||
|
||||
</div>
|
||||
@@ -63,14 +56,7 @@ console.info('after the test');
|
||||
## Solution
|
||||
<section id='solution'>
|
||||
|
||||
|
||||
```js
|
||||
var myArray = [];
|
||||
var i = 0;
|
||||
while(i < 5) {
|
||||
myArray.push(i);
|
||||
i++;
|
||||
}
|
||||
// solution required
|
||||
```
|
||||
|
||||
</section>
|
||||
|
||||
@@ -1,23 +1,16 @@
|
||||
---
|
||||
id: 56533eb9ac21ba0edf2244bf
|
||||
title: Local Scope and Functions
|
||||
localeTitle: Ámbito local y funciones
|
||||
challengeType: 1
|
||||
videoUrl: ''
|
||||
localeTitle: Ámbito local y funciones
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
Las variables que se declaran dentro de una función, así como los parámetros de la función tienen alcance <dfn>local</dfn> . Eso significa que, sólo son visibles dentro de esa función.
|
||||
Aquí hay una función <code>myTest</code> con una variable local llamada <code>loc</code> .
|
||||
<blockquote>function myTest() {<br> var loc = "foo";<br> console.log(loc);<br>}<br>myTest(); // logs "foo"<br>console.log(loc); // loc is not defined</blockquote>
|
||||
<code>loc</code> no está definido fuera de la función.
|
||||
</section>
|
||||
<section id="description"> Las variables que se declaran dentro de una función, así como los parámetros de la función tienen alcance <dfn>local</dfn> . Eso significa que, sólo son visibles dentro de esa función. Aquí hay una función <code>myTest</code> con una variable local llamada <code>loc</code> . <blockquote> función myTest () { <br> var loc = "foo"; <br> console.log (loc); <br> } <br> mi prueba(); // logs "foo" <br> console.log (loc); // loc no esta definido </blockquote> <code>loc</code> no está definido fuera de la función. </section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
Declare una variable local <code>myVar</code> dentro de <code>myLocalScope</code> . Ejecute las pruebas y luego siga las instrucciones comentadas en el editor.
|
||||
<strong>Pista</strong> <br> Actualizar la página puede ayudar si te quedas atascado.
|
||||
</section>
|
||||
<section id="instructions"> Declarar una variable local <code>myVar</code> dentro de <code>myLocalScope</code> . Ejecute las pruebas y luego siga las instrucciones comentadas en el editor. <strong>Insinuación</strong> <br> Actualizar la página puede ayudar si te quedas atascado. </section>
|
||||
|
||||
## Tests
|
||||
<section id='tests'>
|
||||
@@ -97,15 +90,7 @@ console.info('after the test');
|
||||
## Solution
|
||||
<section id='solution'>
|
||||
|
||||
|
||||
```js
|
||||
function myLocalScope() {
|
||||
'use strict';
|
||||
|
||||
var myVar;
|
||||
console.log(myVar);
|
||||
}
|
||||
myLocalScope();
|
||||
// solution required
|
||||
```
|
||||
|
||||
</section>
|
||||
|
||||
@@ -1,27 +1,16 @@
|
||||
---
|
||||
id: 5690307fddb111c6084545d7
|
||||
title: Logical Order in If Else Statements
|
||||
localeTitle: Orden lógico en si otras declaraciones
|
||||
challengeType: 1
|
||||
videoUrl: ''
|
||||
localeTitle: Orden lógico en si otras declaraciones
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
orden es importante en <code>if</code> , <code>else if</code> declaraciones.
|
||||
La función se ejecuta de arriba a abajo, por lo que deberá tener cuidado con la afirmación que aparece primero.
|
||||
Toma estas dos funciones como ejemplo.
|
||||
Aquí está el primero:
|
||||
<blockquote>function foo(x) {<br> if (x < 1) {<br> return "Less than one";<br> } else if (x < 2) {<br> return "Less than two";<br> } else {<br> return "Greater than or equal to two";<br> }<br>}</blockquote>
|
||||
Y el segundo solo cambia el orden de las declaraciones:
|
||||
<blockquote>function bar(x) {<br> if (x < 2) {<br> return "Less than two";<br> } else if (x < 1) {<br> return "Less than one";<br> } else {<br> return "Greater than or equal to two";<br> }<br>}</blockquote>
|
||||
Si bien estas dos funciones parecen casi idénticas, si pasamos un número a ambas obtenemos diferentes salidas.
|
||||
<blockquote>foo(0) // "Less than one"<br>bar(0) // "Less than two"</blockquote>
|
||||
</section>
|
||||
<section id="description"> El orden es importante en <code>if</code> , <code>else if</code> declaraciones. La función se ejecuta de arriba a abajo, por lo que deberá tener cuidado con la afirmación que aparece primero. Tomemos estas dos funciones como ejemplo. Aquí está el primero: <blockquote> función foo (x) { <br> si (x <1) { <br> devuelve "Menos de uno"; <br> } else if (x <2) { <br> devuelve "Menos de dos"; <br> } else { <br> devuelve "Mayor o igual a dos"; <br> } <br> } </blockquote> Y el segundo simplemente cambia el orden de las declaraciones: <blockquote> barra de funciones (x) { <br> si (x <2) { <br> devuelve "Menos de dos"; <br> } else if (x <1) { <br> devuelve "Menos de uno"; <br> } else { <br> devuelve "Mayor o igual a dos"; <br> } <br> } </blockquote> Si bien estas dos funciones parecen casi idénticas, si pasamos un número a ambas obtenemos diferentes salidas. <blockquote> foo (0) // "Menos de uno" <br> barra (0) // "Menos de dos" </blockquote></section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
Cambie el orden de la lógica en la función para que devuelva las declaraciones correctas en todos los casos.
|
||||
</section>
|
||||
<section id="instructions"> Cambie el orden de la lógica en la función para que devuelva las declaraciones correctas en todos los casos. </section>
|
||||
|
||||
## Tests
|
||||
<section id='tests'>
|
||||
@@ -57,6 +46,7 @@ function orderMyLogic(val) {
|
||||
|
||||
// Change this value to test
|
||||
orderMyLogic(7);
|
||||
|
||||
```
|
||||
|
||||
</div>
|
||||
@@ -68,17 +58,7 @@ orderMyLogic(7);
|
||||
## Solution
|
||||
<section id='solution'>
|
||||
|
||||
|
||||
```js
|
||||
function orderMyLogic(val) {
|
||||
if(val < 5) {
|
||||
return "Less than 5";
|
||||
} else if (val < 10) {
|
||||
return "Less than 10";
|
||||
} else {
|
||||
return "Greater than or equal to 10";
|
||||
}
|
||||
}
|
||||
// solution required
|
||||
```
|
||||
|
||||
</section>
|
||||
|
||||
@@ -1,33 +1,27 @@
|
||||
---
|
||||
id: 56bbb991ad1ed5201cd392cc
|
||||
title: Manipulate Arrays With pop()
|
||||
localeTitle: Manipular matrices con pop ()
|
||||
challengeType: 1
|
||||
videoUrl: ''
|
||||
localeTitle: Manipular matrices con pop ()
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
Otra forma de cambiar los datos en una matriz es con la función <code>.pop()</code> .
|
||||
<code>.pop()</code> se usa para " <code>.pop()</code> " un valor del final de una matriz. Podemos almacenar este valor "extraído" asignándolo a una variable. En otras palabras, <code>.pop()</code> elimina el último elemento de una matriz y devuelve ese elemento.
|
||||
Cualquier tipo de entrada se puede "extraer" de una matriz: números, cadenas, incluso matrices anidadas.
|
||||
<blockquote> <code>var threeArr = [1, 4, 6];<br> var oneDown = threeArr.pop();<br> console.log(oneDown); // Returns 6<br> console.log(threeArr); // Returns [1, 4]</code> </blockquote>
|
||||
</section>
|
||||
<section id="description"> Otra forma de cambiar los datos en una matriz es con la función <code>.pop()</code> . <code>.pop()</code> se utiliza para " <code>.pop()</code> " un valor del final de una matriz. Podemos almacenar este valor "extraído" asignándolo a una variable. En otras palabras, <code>.pop()</code> elimina el último elemento de una matriz y devuelve ese elemento. Cualquier tipo de entrada se puede "extraer" de una matriz: números, cadenas, incluso matrices anidadas. <blockquote> <code>var threeArr = [1, 4, 6]; <br> var oneDown = threeArr.pop(); <br> console.log(oneDown); // Returns 6 <br> console.log(threeArr); // Returns [1, 4]</code> </blockquote> </section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
Use la función <code>.pop()</code> para eliminar el último elemento de <code>myArray</code> , asignando el valor de "desprendimiento de" a <code>removedFromMyArray</code> .
|
||||
</section>
|
||||
<section id="instructions"> Use la función <code>.pop()</code> para eliminar el último elemento de <code>myArray</code> , asignando el valor " <code>removedFromMyArray</code> " a <code>removedFromMyArray</code> . </section>
|
||||
|
||||
## Tests
|
||||
<section id='tests'>
|
||||
|
||||
```yml
|
||||
tests:
|
||||
- text: ' <code>myArray</code> solo debe contener <code>[["John", 23]]</code> .'
|
||||
- text: '<code>myArray</code> solo debe contener <code>[["John", 23]]</code> .'
|
||||
testString: 'assert((function(d){if(d[0][0] == "John" && d[0][1] === 23 && d[1] == undefined){return true;}else{return false;}})(myArray), "<code>myArray</code> should only contain <code>[["John", 23]]</code>.");'
|
||||
- text: Usa <code>pop()</code> en <code>myArray</code>
|
||||
testString: 'assert(/removedFromMyArray\s*=\s*myArray\s*.\s*pop\s*(\s*)/.test(code), "Use <code>pop()</code> on <code>myArray</code>");'
|
||||
- text: ' <code>removedFromMyArray</code> solo debe contener <code>["cat", 2]</code> .'
|
||||
- text: '<code>removedFromMyArray</code> solo debe contener <code>["cat", 2]</code> .'
|
||||
testString: 'assert((function(d){if(d[0] == "cat" && d[1] === 2 && d[2] == undefined){return true;}else{return false;}})(removedFromMyArray), "<code>removedFromMyArray</code> should only contain <code>["cat", 2]</code>.");'
|
||||
|
||||
```
|
||||
@@ -51,7 +45,6 @@ var myArray = [["John", 23], ["cat", 2]];
|
||||
// Only change code below this line.
|
||||
var removedFromMyArray;
|
||||
|
||||
|
||||
```
|
||||
|
||||
</div>
|
||||
@@ -71,10 +64,7 @@ console.info('after the test');
|
||||
## Solution
|
||||
<section id='solution'>
|
||||
|
||||
|
||||
```js
|
||||
var myArray = [["John", 23], ["cat", 2]];
|
||||
var removedFromMyArray = myArray.pop();
|
||||
// solution required
|
||||
```
|
||||
|
||||
</section>
|
||||
|
||||
@@ -1,28 +1,23 @@
|
||||
---
|
||||
id: 56bbb991ad1ed5201cd392cb
|
||||
title: Manipulate Arrays With push()
|
||||
localeTitle: Manipular matrices con empuje ()
|
||||
challengeType: 1
|
||||
videoUrl: ''
|
||||
localeTitle: Manipular matrices con empuje ()
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
Una forma fácil de agregar datos al final de una matriz es a través de la función <code>push()</code> .
|
||||
<code>.push()</code> toma uno o más <dfn>parámetros</dfn> y los "empuja" al final de la matriz.
|
||||
<blockquote>var arr = [1,2,3];<br>arr.push(4);<br>// arr is now [1,2,3,4]</blockquote>
|
||||
</section>
|
||||
<section id="description"> Una forma fácil de agregar datos al final de una matriz es a través de la función <code>push()</code> . <code>.push()</code> toma uno o más <dfn>parámetros</dfn> y los "empuja" al final de la matriz. <blockquote> var arr = [1,2,3]; <br> arr.push (4); <br> // arr es ahora [1,2,3,4] </blockquote></section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
Presione <code>["dog", 3]</code> en el extremo de la variable <code>myArray</code> .
|
||||
</section>
|
||||
<section id="instructions"> Presione <code>["dog", 3]</code> sobre el final de la variable <code>myArray</code> . </section>
|
||||
|
||||
## Tests
|
||||
<section id='tests'>
|
||||
|
||||
```yml
|
||||
tests:
|
||||
- text: ' <code>myArray</code> ahora debe ser igual a <code>[["John", 23], ["cat", 2], ["dog", 3]]</code> .'
|
||||
- text: '<code>myArray</code> ahora debe ser igual a <code>[["John", 23], ["cat", 2], ["dog", 3]]</code> .'
|
||||
testString: 'assert((function(d){if(d[2] != undefined && d[0][0] == "John" && d[0][1] === 23 && d[2][0] == "dog" && d[2][1] === 3 && d[2].length == 2){return true;}else{return false;}})(myArray), "<code>myArray</code> should now equal <code>[["John", 23], ["cat", 2], ["dog", 3]]</code>.");'
|
||||
|
||||
```
|
||||
@@ -45,7 +40,6 @@ var myArray = [["John", 23], ["cat", 2]];
|
||||
|
||||
// Only change code below this line.
|
||||
|
||||
|
||||
```
|
||||
|
||||
</div>
|
||||
@@ -65,10 +59,7 @@ console.info('after the test');
|
||||
## Solution
|
||||
<section id='solution'>
|
||||
|
||||
|
||||
```js
|
||||
var myArray = [["John", 23], ["cat", 2]];
|
||||
myArray.push(["dog",3]);
|
||||
// solution required
|
||||
```
|
||||
|
||||
</section>
|
||||
|
||||
Some files were not shown because too many files have changed in this diff Show More
Reference in New Issue
Block a user