fix(spanish-md): Address some formatting issues for Spanish md
This commit is contained in:
Bouncey
committed by
mrugesh mohapatra
mrugesh mohapatra
parent
ee9f6b2d72
commit
c2a45b58be
@@ -7,14 +7,14 @@ challengeType: 5
|
||||
---
|
||||
|
||||
## 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 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>
|
||||
|
||||
@@ -27,11 +27,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.");'
|
||||
|
||||
@@ -7,13 +7,13 @@ challengeType: 5
|
||||
---
|
||||
|
||||
## 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 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>
|
||||
|
||||
@@ -22,19 +22,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>.");'
|
||||
|
||||
```
|
||||
|
||||
@@ -7,14 +7,14 @@ challengeType: 5
|
||||
---
|
||||
|
||||
## 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 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>
|
||||
|
||||
@@ -23,25 +23,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 verdadero.'
|
||||
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.");'
|
||||
|
||||
@@ -7,15 +7,15 @@ challengeType: 5
|
||||
---
|
||||
|
||||
## 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 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>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
<section id='instructions'>
|
||||
|
||||
</section>
|
||||
|
||||
@@ -24,13 +24,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>.");'
|
||||
|
||||
```
|
||||
|
||||
@@ -7,13 +7,13 @@ challengeType: 5
|
||||
---
|
||||
|
||||
## 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 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>
|
||||
|
||||
@@ -22,9 +22,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.");'
|
||||
|
||||
```
|
||||
|
||||
@@ -7,16 +7,16 @@ challengeType: 5
|
||||
---
|
||||
|
||||
## 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 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>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
<section id='instructions'>
|
||||
|
||||
</section>
|
||||
|
||||
@@ -25,23 +25,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: 'la <code>mutation(["Mary", "Army"])</code> debería 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: 'la <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.");'
|
||||
|
||||
```
|
||||
|
||||
@@ -7,13 +7,13 @@ challengeType: 5
|
||||
---
|
||||
|
||||
## 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 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>
|
||||
|
||||
@@ -22,17 +22,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");'
|
||||
|
||||
@@ -7,14 +7,14 @@ challengeType: 5
|
||||
---
|
||||
|
||||
## 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 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>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
<section id='instructions'>
|
||||
|
||||
</section>
|
||||
|
||||
@@ -23,13 +23,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 devolver <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>.");'
|
||||
|
||||
```
|
||||
|
||||
@@ -8,16 +8,16 @@ challengeType: 5
|
||||
---
|
||||
|
||||
## 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 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>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
<section id='instructions'>
|
||||
|
||||
</section>
|
||||
|
||||
@@ -26,11 +26,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.");'
|
||||
|
||||
@@ -7,14 +7,14 @@ challengeType: 5
|
||||
---
|
||||
|
||||
## 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 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>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
<section id='instructions'>
|
||||
|
||||
</section>
|
||||
|
||||
@@ -23,9 +23,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>.");'
|
||||
|
||||
@@ -7,13 +7,13 @@ challengeType: 5
|
||||
---
|
||||
|
||||
## 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 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>
|
||||
|
||||
@@ -22,17 +22,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> debería 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...".");'
|
||||
|
||||
```
|
||||
|
||||
@@ -7,15 +7,15 @@ challengeType: 5
|
||||
---
|
||||
|
||||
## 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 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>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
<section id='instructions'>
|
||||
|
||||
</section>
|
||||
|
||||
@@ -24,37 +24,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.");'
|
||||
|
||||
```
|
||||
|
||||
@@ -6,22 +6,22 @@ challengeType: 1
|
||||
---
|
||||
|
||||
## 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 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>
|
||||
|
||||
## 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 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
|
||||
@@ -29,13 +29,13 @@ Para completar este desafío, establezca la segunda posición (índice <code>1</
|
||||
|
||||
```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>");'
|
||||
|
||||
```
|
||||
|
||||
@@ -6,15 +6,15 @@ challengeType: 1
|
||||
---
|
||||
|
||||
## 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 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>
|
||||
|
||||
## 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 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
|
||||
@@ -24,7 +24,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>");'
|
||||
|
||||
@@ -6,16 +6,16 @@ challengeType: 1
|
||||
---
|
||||
|
||||
## 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 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>
|
||||
|
||||
## 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 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
|
||||
@@ -23,7 +23,7 @@ Hemos definido una función, <code>mixedNumbers</code> , a la que le estamos pas
|
||||
|
||||
```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 debe 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");'
|
||||
|
||||
@@ -6,15 +6,15 @@ challengeType: 1
|
||||
---
|
||||
|
||||
## 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 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>
|
||||
|
||||
## 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 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>
|
||||
|
||||
## Tests
|
||||
@@ -22,7 +22,7 @@ Hemos definido una función, <code>htmlColorNames</code> , que toma una matriz d
|
||||
|
||||
```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");'
|
||||
|
||||
@@ -6,15 +6,15 @@ challengeType: 1
|
||||
---
|
||||
|
||||
## 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 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>
|
||||
|
||||
## 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 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
|
||||
@@ -22,13 +22,13 @@ Por ejemplo:
|
||||
|
||||
```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");'
|
||||
|
||||
@@ -6,14 +6,14 @@ challengeType: 1
|
||||
---
|
||||
|
||||
## 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 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>
|
||||
|
||||
## 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 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
|
||||
@@ -21,11 +21,11 @@ Hemos creado un objeto, <code>users</code> , con algunos usuarios en él y una f
|
||||
|
||||
```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 del 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");'
|
||||
|
||||
```
|
||||
|
||||
@@ -6,15 +6,15 @@ challengeType: 1
|
||||
---
|
||||
|
||||
## 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 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>
|
||||
|
||||
## 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 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>
|
||||
|
||||
## Tests
|
||||
@@ -22,7 +22,7 @@ Hemos definido una función <code>spreadOut</code> que devuelve la <code>sentenc
|
||||
|
||||
```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");'
|
||||
|
||||
@@ -6,15 +6,15 @@ challengeType: 1
|
||||
---
|
||||
|
||||
## 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 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>
|
||||
|
||||
## 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 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
|
||||
@@ -22,13 +22,13 @@ Hemos definido una función, <code>copyMachine</code> que toma <code>arr</code>
|
||||
|
||||
```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> debería 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>");'
|
||||
|
||||
@@ -6,15 +6,15 @@ challengeType: 1
|
||||
---
|
||||
|
||||
## 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 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>
|
||||
|
||||
## 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 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
|
||||
@@ -22,7 +22,7 @@ Hemos definido una función, <code>forecast</code> , que toma una matriz como ar
|
||||
|
||||
```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");'
|
||||
|
||||
@@ -6,20 +6,20 @@ challengeType: 1
|
||||
---
|
||||
|
||||
## 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 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>
|
||||
|
||||
## 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 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
|
||||
@@ -27,7 +27,7 @@ Hemos definido una variable, <code>myNestedArray</code> , igual a una matriz. Mo
|
||||
|
||||
```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");'
|
||||
|
||||
@@ -6,13 +6,13 @@ challengeType: 1
|
||||
---
|
||||
|
||||
## 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 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>
|
||||
|
||||
## 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 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
|
||||
@@ -20,7 +20,7 @@ Termine de escribir la función <code>getArrayOfUsers</code> para que devuelva u
|
||||
|
||||
```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");'
|
||||
|
||||
@@ -6,16 +6,16 @@ challengeType: 1
|
||||
---
|
||||
|
||||
## 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 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>
|
||||
|
||||
## 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 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
|
||||
@@ -23,13 +23,13 @@ Hemos definido una función, <code>filteredArray</code> , que toma <code>arr</co
|
||||
|
||||
```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");'
|
||||
|
||||
@@ -6,13 +6,13 @@ challengeType: 1
|
||||
---
|
||||
|
||||
## 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 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 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
|
||||
@@ -20,11 +20,11 @@ Eche un vistazo al objeto que hemos proporcionado en el editor de código. El ob
|
||||
|
||||
```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>");'
|
||||
|
||||
```
|
||||
|
||||
@@ -6,15 +6,15 @@ challengeType: 1
|
||||
---
|
||||
|
||||
## 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 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>
|
||||
|
||||
## 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 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
|
||||
@@ -22,7 +22,7 @@ Aquí hemos definido un objeto, <code>userActivity</code> , que incluye otro obj
|
||||
|
||||
```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>");'
|
||||
|
||||
@@ -6,17 +6,17 @@ challengeType: 1
|
||||
---
|
||||
|
||||
## 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 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>
|
||||
|
||||
## 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 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
|
||||
@@ -24,7 +24,7 @@ Hemos definido una función, <code>popShift</code> , que toma una matriz como ar
|
||||
|
||||
```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");'
|
||||
|
||||
@@ -6,16 +6,16 @@ challengeType: 1
|
||||
---
|
||||
|
||||
## 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 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>
|
||||
|
||||
## 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 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
|
||||
@@ -23,9 +23,9 @@ Use la palabra clave delete para eliminar las teclas de <code>oranges</code> , <
|
||||
|
||||
```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>");'
|
||||
|
||||
```
|
||||
|
||||
@@ -6,18 +6,18 @@ challengeType: 1
|
||||
---
|
||||
|
||||
## 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 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>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
Empuje los números impares del 9 al 1 a <code>myArray</code> usando un bucle <code>for</code> .
|
||||
<section id='instructions'>
|
||||
Empuje los números impares del 9 al 1 a <code>myArray</code> usando un bucle <code>for</code> .
|
||||
</section>
|
||||
|
||||
## Tests
|
||||
@@ -29,7 +29,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>.");'
|
||||
|
||||
```
|
||||
|
||||
@@ -6,17 +6,17 @@ challengeType: 1
|
||||
---
|
||||
|
||||
## 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 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>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
<section id='instructions'>
|
||||
|
||||
</section>
|
||||
|
||||
@@ -25,19 +25,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 deben 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 cartas 10, J, Q, K, A debería 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 cartas 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: 'Las secuencias de cartas 2, J, 9, 2, 7 deben 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: 'Las secuencias de cartas 2, 2, 10 deben 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 cartas 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>");'
|
||||
|
||||
```
|
||||
|
||||
@@ -6,21 +6,21 @@ challengeType: 1
|
||||
---
|
||||
|
||||
## 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 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>
|
||||
|
||||
## 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 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>
|
||||
|
||||
## Tests
|
||||
@@ -28,7 +28,7 @@ Use la palabra clave <code>var</code> para crear una variable llamada <code>myNa
|
||||
|
||||
```yml
|
||||
tests:
|
||||
- text: 'Debes declarar <code>myName</code> con la palabra clave <code>var</code> , que termina con un punto y coma'
|
||||
- text: 'Debes 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");'
|
||||
|
||||
```
|
||||
|
||||
@@ -6,19 +6,19 @@ challengeType: 1
|
||||
---
|
||||
|
||||
## 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 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>
|
||||
|
||||
## 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 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>
|
||||
|
||||
## Tests
|
||||
@@ -28,7 +28,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> (recuerda la sensibilidad a los casos)'
|
||||
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>");'
|
||||
|
||||
@@ -6,18 +6,18 @@ challengeType: 1
|
||||
---
|
||||
|
||||
## 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 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>
|
||||
|
||||
## 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 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>
|
||||
|
||||
## Tests
|
||||
@@ -25,9 +25,9 @@ Use <dfn>barras diagonales inversas</dfn> para asignar una cadena a la variable
|
||||
|
||||
```yml
|
||||
tests:
|
||||
- text: 'Debería usar dos comillas dobles ( <code>"</code> ) y cuatro comillas dobles escapadas ( <code>\"</code> ).'
|
||||
- text: 'Debería 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: '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> '
|
||||
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>");'
|
||||
|
||||
```
|
||||
|
||||
@@ -6,15 +6,15 @@ challengeType: 1
|
||||
---
|
||||
|
||||
## 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 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 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>
|
||||
|
||||
## Tests
|
||||
@@ -24,7 +24,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: 'Deberías obtener la longitud del <code>lastName</code> al usar <code>.length</code> esta manera: <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>.");'
|
||||
|
||||
```
|
||||
|
||||
@@ -6,16 +6,16 @@ challengeType: 1
|
||||
---
|
||||
|
||||
## 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 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>
|
||||
|
||||
## 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 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
|
||||
@@ -23,13 +23,13 @@ Cree una función llamada <code>randomRange</code> que tome un rango <code>myMin
|
||||
|
||||
```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> debería 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> ".
|
||||
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 tu 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.");'
|
||||
|
||||
```
|
||||
|
||||
@@ -6,15 +6,15 @@ challengeType: 1
|
||||
---
|
||||
|
||||
## 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 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>
|
||||
|
||||
@@ -23,27 +23,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> debería 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> debería 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!"");'
|
||||
|
||||
```
|
||||
|
||||
@@ -6,17 +6,17 @@ challengeType: 1
|
||||
---
|
||||
|
||||
## 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 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>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
Empuje los números impares del 1 al 9 a <code>myArray</code> usando un bucle <code>for</code> .
|
||||
<section id='instructions'>
|
||||
Empuje los números impares del 1 al 9 a <code>myArray</code> usando un bucle <code>for</code> .
|
||||
</section>
|
||||
|
||||
## Tests
|
||||
@@ -26,7 +26,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> debería 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>.");'
|
||||
|
||||
```
|
||||
|
||||
@@ -6,24 +6,24 @@ challengeType: 1
|
||||
---
|
||||
|
||||
## 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 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>
|
||||
|
||||
## 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 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
|
||||
@@ -33,7 +33,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> debería 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>");'
|
||||
|
||||
@@ -6,22 +6,22 @@ challengeType: 1
|
||||
---
|
||||
|
||||
## 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 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>
|
||||
|
||||
## 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 id='instructions'>
|
||||
Use un bucle <code>for</code> para trabajar y empujar los valores del 1 al 5 en <code>myArray</code> .
|
||||
</section>
|
||||
|
||||
## Tests
|
||||
@@ -31,7 +31,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>.");'
|
||||
|
||||
```
|
||||
|
||||
@@ -6,16 +6,16 @@ challengeType: 1
|
||||
---
|
||||
|
||||
## 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 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>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
Empuje los números de 0 a 4 para <code>myArray</code> usando un <code>while</code> de bucle.
|
||||
<section id='instructions'>
|
||||
Empuje los números de 0 a 4 para <code>myArray</code> usando un <code>while</code> de bucle.
|
||||
</section>
|
||||
|
||||
## Tests
|
||||
@@ -25,7 +25,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>.");'
|
||||
|
||||
```
|
||||
|
||||
@@ -6,16 +6,16 @@ challengeType: 1
|
||||
---
|
||||
|
||||
## 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 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>
|
||||
|
||||
## 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 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>
|
||||
|
||||
## Tests
|
||||
@@ -23,11 +23,11 @@ Use la función <code>.pop()</code> para eliminar el último elemento de <code>m
|
||||
|
||||
```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>.");'
|
||||
|
||||
```
|
||||
|
||||
@@ -6,15 +6,15 @@ challengeType: 1
|
||||
---
|
||||
|
||||
## 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 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>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
Presione <code>["dog", 3]</code> en el extremo de la variable <code>myArray</code> .
|
||||
<section id='instructions'>
|
||||
Presione <code>["dog", 3]</code> en el extremo de la variable <code>myArray</code> .
|
||||
</section>
|
||||
|
||||
## Tests
|
||||
@@ -22,7 +22,7 @@ Presione <code>["dog", 3]</code> en el extremo de la variable <code>my
|
||||
|
||||
```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>.");'
|
||||
|
||||
```
|
||||
|
||||
@@ -6,14 +6,14 @@ challengeType: 1
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
<code>pop()</code> siempre elimina el último elemento de una matriz. ¿Qué pasa si quieres eliminar el primero?
|
||||
Ahí es donde <code>.shift()</code> en <code>.shift()</code> . Funciona igual que <code>.pop()</code> , excepto que elimina el primer elemento en lugar del último.
|
||||
<section id='description'>
|
||||
<code>pop()</code> siempre elimina el último elemento de una matriz. ¿Qué pasa si quieres eliminar el primero?
|
||||
Ahí es donde <code>.shift()</code> en <code>.shift()</code> . Funciona igual que <code>.pop()</code> , excepto que elimina el primer elemento en lugar del último.
|
||||
</section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
Use la función <code>.shift()</code> para eliminar el primer elemento de <code>myArray</code> , asignando el valor "desviado" a <code>removedFromMyArray</code> .
|
||||
<section id='instructions'>
|
||||
Use la función <code>.shift()</code> para eliminar el primer elemento de <code>myArray</code> , asignando el valor "desviado" a <code>removedFromMyArray</code> .
|
||||
</section>
|
||||
|
||||
## Tests
|
||||
@@ -21,9 +21,9 @@ Use la función <code>.shift()</code> para eliminar el primer elemento de <code>
|
||||
|
||||
```yml
|
||||
tests:
|
||||
- text: ' <code>myArray</code> ahora debe ser igual a <code>[["dog", 3]]</code> .'
|
||||
- text: ' <code>myArray</code> ahora debe ser igual a <code>[["dog", 3]]</code> .'
|
||||
testString: 'assert((function(d){if(d[0][0] == "dog" && d[0][1] === 3 && d[1] == undefined){return true;}else{return false;}})(myArray), "<code>myArray</code> should now equal <code>[["dog", 3]]</code>.");'
|
||||
- text: ' <code>removedFromMyArray</code> debe contener <code>["John", 23]</code> .'
|
||||
- text: ' <code>removedFromMyArray</code> debe contener <code>["John", 23]</code> .'
|
||||
testString: 'assert((function(d){if(d[0] == "John" && d[1] === 23 && typeof removedFromMyArray === "object"){return true;}else{return false;}})(removedFromMyArray), "<code>removedFromMyArray</code> should contain <code>["John", 23]</code>.");'
|
||||
|
||||
```
|
||||
|
||||
@@ -6,14 +6,14 @@ challengeType: 1
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
No solo puede <code>shift</code> elementos del principio de una matriz, <code>unshift</code> también puede <code>unshift</code> elementos al principio de una matriz, es decir, agregar elementos delante de la matriz.
|
||||
<code>.unshift()</code> funciona exactamente como <code>.push()</code> , pero en lugar de agregar el elemento al final de la matriz, <code>unshift()</code> agrega el elemento al principio de la matriz.
|
||||
<section id='description'>
|
||||
No solo puede <code>shift</code> elementos del principio de una matriz, <code>unshift</code> también puede <code>unshift</code> elementos al principio de una matriz, es decir, agregar elementos delante de la matriz.
|
||||
<code>.unshift()</code> funciona exactamente como <code>.push()</code> , pero en lugar de agregar el elemento al final de la matriz, <code>unshift()</code> agrega el elemento al principio de la matriz.
|
||||
</section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
Añadir <code>["Paul",35]</code> para el inicio de la <code>myArray</code> variable usando <code>unshift()</code> .
|
||||
<section id='instructions'>
|
||||
Añadir <code>["Paul",35]</code> para el inicio de la <code>myArray</code> variable usando <code>unshift()</code> .
|
||||
</section>
|
||||
|
||||
## Tests
|
||||
@@ -21,7 +21,7 @@ Añadir <code>["Paul",35]</code> para el inicio de la <code>myArray</c
|
||||
|
||||
```yml
|
||||
tests:
|
||||
- text: ' <code>myArray</code> debería tener ahora [["Paul", 35], ["dog", 3]].'
|
||||
- text: ' <code>myArray</code> debería tener ahora [["Paul", 35], ["dog", 3]].'
|
||||
testString: 'assert((function(d){if(typeof d[0] === "object" && d[0][0] == "Paul" && d[0][1] === 35 && d[1][0] != undefined && d[1][0] == "dog" && d[1][1] != undefined && d[1][1] == 3){return true;}else{return false;}})(myArray), "<code>myArray</code> should now have [["Paul", 35], ["dog", 3]].");'
|
||||
|
||||
```
|
||||
|
||||
@@ -6,20 +6,20 @@ challengeType: 1
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
A veces es posible que desee almacenar datos en una <dfn>estructura de datos</dfn> flexible. Un objeto JavaScript es una forma de manejar datos flexibles. Permiten combinaciones arbitrarias de <dfn>cadenas</dfn> , <dfn>números</dfn> , <dfn>booleanos</dfn> , <dfn>matrices</dfn> , <dfn>funciones</dfn> y <dfn>objetos</dfn> .
|
||||
Aquí hay un ejemplo de una estructura de datos compleja:
|
||||
<blockquote>var ourMusic = [<br> {<br> "artist": "Daft Punk",<br> "title": "Homework",<br> "release_year": 1997,<br> "formats": [ <br> "CD", <br> "Cassette", <br> "LP"<br> ],<br> "gold": true<br> }<br>];</blockquote>
|
||||
Esta es una matriz que contiene un objeto dentro. El objeto tiene varias piezas de <dfn>metadatos</dfn> sobre un álbum. También tiene una matriz de <code>"formats"</code> anidados. Si desea agregar más registros de álbum, puede hacerlo agregando registros a la matriz de nivel superior.
|
||||
objetos contienen datos en una propiedad, que tiene un formato de clave-valor. En el ejemplo anterior, <code>"artist": "Daft Punk"</code> es una propiedad que tiene una clave de <code>"artist"</code> y un valor de <code>"Daft Punk"</code> .
|
||||
<a href='http://www.json.org/' target=_blank>JavaScript Object Notation</a> o <code>JSON</code> es un formato de intercambio de datos relacionado que se utiliza para almacenar datos.
|
||||
<blockquote>{<br> "artist": "Daft Punk",<br> "title": "Homework",<br> "release_year": 1997,<br> "formats": [ <br> "CD",<br> "Cassette",<br> "LP"<br> ],<br> "gold": true<br>}</blockquote>
|
||||
<strong>Nota</strong> <br> Deberá colocar una coma después de cada objeto de la matriz, a menos que sea el último objeto de la matriz.
|
||||
<section id='description'>
|
||||
A veces es posible que desee almacenar datos en una <dfn>estructura de datos</dfn> flexible. Un objeto JavaScript es una forma de manejar datos flexibles. Permiten combinaciones arbitrarias de <dfn>cadenas</dfn> , <dfn>números</dfn> , <dfn>booleanos</dfn> , <dfn>matrices</dfn> , <dfn>funciones</dfn> y <dfn>objetos</dfn> .
|
||||
Aquí hay un ejemplo de una estructura de datos compleja:
|
||||
<blockquote>var ourMusic = [<br> {<br> "artist": "Daft Punk",<br> "title": "Homework",<br> "release_year": 1997,<br> "formats": [ <br> "CD", <br> "Cassette", <br> "LP"<br> ],<br> "gold": true<br> }<br>];</blockquote>
|
||||
Esta es una matriz que contiene un objeto dentro. El objeto tiene varias piezas de <dfn>metadatos</dfn> sobre un álbum. También tiene una matriz de <code>"formats"</code> anidados. Si desea agregar más registros de álbum, puede hacerlo agregando registros a la matriz de nivel superior.
|
||||
objetos contienen datos en una propiedad, que tiene un formato de clave-valor. En el ejemplo anterior, <code>"artist": "Daft Punk"</code> es una propiedad que tiene una clave de <code>"artist"</code> y un valor de <code>"Daft Punk"</code> .
|
||||
<a href='http://www.json.org/' target=_blank>JavaScript Object Notation</a> o <code>JSON</code> es un formato de intercambio de datos relacionado que se utiliza para almacenar datos.
|
||||
<blockquote>{<br> "artist": "Daft Punk",<br> "title": "Homework",<br> "release_year": 1997,<br> "formats": [ <br> "CD",<br> "Cassette",<br> "LP"<br> ],<br> "gold": true<br>}</blockquote>
|
||||
<strong>Nota</strong> <br> Deberá colocar una coma después de cada objeto de la matriz, a menos que sea el último objeto de la matriz.
|
||||
</section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
Agrega un nuevo álbum a la matriz <code>myMusic</code> . Agregue cadenas de <code>artist</code> y <code>title</code> , número de año de <code>release_year</code> y una matriz de <code>formats</code> de cadenas.
|
||||
<section id='instructions'>
|
||||
Agrega un nuevo álbum a la matriz <code>myMusic</code> . Agregue cadenas de <code>artist</code> y <code>title</code> , número de año de <code>release_year</code> y una matriz de <code>formats</code> de cadenas.
|
||||
</section>
|
||||
|
||||
## Tests
|
||||
@@ -31,17 +31,17 @@ tests:
|
||||
testString: 'assert(Array.isArray(myMusic), "<code>myMusic</code> should be an array");'
|
||||
- text: <code>myMusic</code> debería tener al menos dos elementos
|
||||
testString: 'assert(myMusic.length > 1, "<code>myMusic</code> should have at least two elements");'
|
||||
- text: ' <code>myMusic[1]</code> debería ser un objeto'
|
||||
- text: ' <code>myMusic[1]</code> debería ser un objeto'
|
||||
testString: 'assert(typeof myMusic[1] === "object", "<code>myMusic[1]</code> should be an object");'
|
||||
- text: ' <code>myMusic[1]</code> debería tener al menos 4 propiedades'
|
||||
- text: ' <code>myMusic[1]</code> debería tener al menos 4 propiedades'
|
||||
testString: 'assert(Object.keys(myMusic[1]).length > 3, "<code>myMusic[1]</code> should have at least 4 properties");'
|
||||
- text: ' <code>myMusic[1]</code> debe contener una propiedad de <code>artist</code> que es una cadena'
|
||||
- text: ' <code>myMusic[1]</code> debe contener una propiedad de <code>artist</code> que es una cadena'
|
||||
testString: 'assert(myMusic[1].hasOwnProperty("artist") && typeof myMusic[1].artist === "string", "<code>myMusic[1]</code> should contain an <code>artist</code> property which is a string");'
|
||||
- text: ' <code>myMusic[1]</code> debe contener una propiedad de <code>title</code> que es una cadena'
|
||||
- text: ' <code>myMusic[1]</code> debe contener una propiedad de <code>title</code> que es una cadena'
|
||||
testString: 'assert(myMusic[1].hasOwnProperty("title") && typeof myMusic[1].title === "string", "<code>myMusic[1]</code> should contain a <code>title</code> property which is a string");'
|
||||
- text: ' <code>myMusic[1]</code> debe contener una propiedad <code>release_year</code> que es un número'
|
||||
- text: ' <code>myMusic[1]</code> debe contener una propiedad <code>release_year</code> que es un número'
|
||||
testString: 'assert(myMusic[1].hasOwnProperty("release_year") && typeof myMusic[1].release_year === "number", "<code>myMusic[1]</code> should contain a <code>release_year</code> property which is a number");'
|
||||
- text: ' <code>myMusic[1]</code> debe contener una propiedad de <code>formats</code> que es una matriz'
|
||||
- text: ' <code>myMusic[1]</code> debe contener una propiedad de <code>formats</code> que es una matriz'
|
||||
testString: 'assert(myMusic[1].hasOwnProperty("formats") && Array.isArray(myMusic[1].formats), "<code>myMusic[1]</code> should contain a <code>formats</code> property which is an array");'
|
||||
- text: <code>formats</code> deben ser una matriz de cadenas con al menos dos elementos.
|
||||
testString: 'assert(myMusic[1].formats.every(function(item) { return (typeof item === "string")}) && myMusic[1].formats.length > 1, "<code>formats</code> should be an array of strings with at least two elements");'
|
||||
|
||||
@@ -6,16 +6,16 @@ challengeType: 1
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
A diferencia de las cadenas, las entradas de matrices son <dfn>mutables</dfn> y se pueden cambiar libremente.
|
||||
<strong>Ejemplo</strong>
|
||||
<blockquote>var ourArray = [50,40,30];<br>ourArray[0] = 15; // equals [15,40,30]</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 id='description'>
|
||||
A diferencia de las cadenas, las entradas de matrices son <dfn>mutables</dfn> y se pueden cambiar libremente.
|
||||
<strong>Ejemplo</strong>
|
||||
<blockquote>var ourArray = [50,40,30];<br>ourArray[0] = 15; // equals [15,40,30]</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'>
|
||||
Modifique los datos almacenados en el índice <code>0</code> de <code>myArray</code> a un valor de <code>45</code> .
|
||||
<section id='instructions'>
|
||||
Modifique los datos almacenados en el índice <code>0</code> de <code>myArray</code> a un valor de <code>45</code> .
|
||||
</section>
|
||||
|
||||
## Tests
|
||||
@@ -23,7 +23,7 @@ Modifique los datos almacenados en el índice <code>0</code> de <code>myArray</c
|
||||
|
||||
```yml
|
||||
tests:
|
||||
- text: ' <code>myArray</code> ahora debería ser [45,64,99].'
|
||||
- text: ' <code>myArray</code> ahora debería ser [45,64,99].'
|
||||
testString: 'assert((function(){if(typeof myArray != "undefined" && myArray[0] == 45 && myArray[1] == 64 && myArray[2] == 99){return true;}else{return false;}})(), "<code>myArray</code> should now be [45,64,99].");'
|
||||
- text: Debe utilizar el índice correcto para modificar el valor en <code>myArray</code> .
|
||||
testString: 'assert((function(){if(code.match(/myArray\[0\]\s*=\s*/g)){return true;}else{return false;}})(), "You should be using correct index to modify the value in <code>myArray</code>.");'
|
||||
|
||||
@@ -6,15 +6,15 @@ challengeType: 1
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
Si tiene una matriz multidimensional, puede usar la misma lógica que el punto de ruta anterior para recorrer tanto la matriz como cualquier subarreglo. Aquí hay un ejemplo:
|
||||
<blockquote>var arr = [<br> [1,2], [3,4], [5,6]<br>];<br>for (var i=0; i < arr.length; i++) {<br> for (var j=0; j < arr[i].length; j++) {<br> console.log(arr[i][j]);<br> }<br>}</blockquote>
|
||||
Esto genera cada subelemento en <code>arr</code> uno a la vez. Tenga en cuenta que para el bucle interno, estamos comprobando la <code>.length</code> de <code>arr[i]</code> , ya que <code>arr[i]</code> es en sí misma una matriz.
|
||||
<section id='description'>
|
||||
Si tiene una matriz multidimensional, puede usar la misma lógica que el punto de ruta anterior para recorrer tanto la matriz como cualquier subarreglo. Aquí hay un ejemplo:
|
||||
<blockquote>var arr = [<br> [1,2], [3,4], [5,6]<br>];<br>for (var i=0; i < arr.length; i++) {<br> for (var j=0; j < arr[i].length; j++) {<br> console.log(arr[i][j]);<br> }<br>}</blockquote>
|
||||
Esto genera cada subelemento en <code>arr</code> uno a la vez. Tenga en cuenta que para el bucle interno, estamos comprobando la <code>.length</code> de <code>arr[i]</code> , ya que <code>arr[i]</code> es en sí misma una matriz.
|
||||
</section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
Modificar la función <code>multiplyAll</code> para que multiplique la variable del <code>product</code> por cada número en las subarreglas de <code>arr</code>
|
||||
<section id='instructions'>
|
||||
Modificar la función <code>multiplyAll</code> para que multiplique la variable del <code>product</code> por cada número en las subarreglas de <code>arr</code>
|
||||
</section>
|
||||
|
||||
## Tests
|
||||
@@ -22,11 +22,11 @@ Modificar la función <code>multiplyAll</code> para que multiplique la variable
|
||||
|
||||
```yml
|
||||
tests:
|
||||
- text: ' <code>multiplyAll([[1],[2],[3]])</code> debe devolver <code>6</code> '
|
||||
- text: ' <code>multiplyAll([[1],[2],[3]])</code> debe devolver <code>6</code> '
|
||||
testString: 'assert(multiplyAll([[1],[2],[3]]) === 6, "<code>multiplyAll([[1],[2],[3]])</code> should return <code>6</code>");'
|
||||
- text: ' <code>multiplyAll([[1,2],[3,4],[5,6,7]])</code> debe devolver <code>5040</code> '
|
||||
- text: ' <code>multiplyAll([[1,2],[3,4],[5,6,7]])</code> debe devolver <code>5040</code> '
|
||||
testString: 'assert(multiplyAll([[1,2],[3,4],[5,6,7]]) === 5040, "<code>multiplyAll([[1,2],[3,4],[5,6,7]])</code> should return <code>5040</code>");'
|
||||
- text: ' <code>multiplyAll([[5,1],[0.2, 4, 0.5],[3, 9]])</code> debe devolver <code>54</code> '
|
||||
- text: ' <code>multiplyAll([[5,1],[0.2, 4, 0.5],[3, 9]])</code> debe devolver <code>54</code> '
|
||||
testString: 'assert(multiplyAll([[5,1],[0.2, 4, 0.5],[3, 9]]) === 54, "<code>multiplyAll([[5,1],[0.2, 4, 0.5],[3, 9]])</code> should return <code>54</code>");'
|
||||
|
||||
```
|
||||
|
||||
@@ -6,18 +6,18 @@ challengeType: 1
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
<dfn>parámetros</dfn> son variables que actúan como marcadores de posición para los valores que deben ingresarse en una función cuando se llama. Cuando se define una función, normalmente se define junto con uno o más parámetros. Los valores reales que se ingresan (o <dfn>"pasan"</dfn> ) en una función cuando se llama se conocen como <dfn>argumentos</dfn> .
|
||||
Aquí hay una función con dos parámetros, <code>param1</code> y <code>param2</code> :
|
||||
<blockquote>function testFun(param1, param2) {<br> console.log(param1, param2);<br>}</blockquote>
|
||||
Entonces podemos llamar a <code>testFun</code> :
|
||||
<code>testFun("Hello", "World");</code>
|
||||
Hemos pasado dos argumentos, <code>"Hello"</code> y <code>"World"</code> . Dentro de la función, <code>param1</code> será igual a "Hello" y <code>param2</code> será igual a "World". Tenga en cuenta que podría <code>testFun</code> llamar a <code>testFun</code> con diferentes argumentos y los parámetros tomarían el valor de los nuevos argumentos.
|
||||
<section id='description'>
|
||||
<dfn>parámetros</dfn> son variables que actúan como marcadores de posición para los valores que deben ingresarse en una función cuando se llama. Cuando se define una función, normalmente se define junto con uno o más parámetros. Los valores reales que se ingresan (o <dfn>"pasan"</dfn> ) en una función cuando se llama se conocen como <dfn>argumentos</dfn> .
|
||||
Aquí hay una función con dos parámetros, <code>param1</code> y <code>param2</code> :
|
||||
<blockquote>function testFun(param1, param2) {<br> console.log(param1, param2);<br>}</blockquote>
|
||||
Entonces podemos llamar a <code>testFun</code> :
|
||||
<code>testFun("Hello", "World");</code>
|
||||
Hemos pasado dos argumentos, <code>"Hello"</code> y <code>"World"</code> . Dentro de la función, <code>param1</code> será igual a "Hello" y <code>param2</code> será igual a "World". Tenga en cuenta que podría <code>testFun</code> llamar a <code>testFun</code> con diferentes argumentos y los parámetros tomarían el valor de los nuevos argumentos.
|
||||
</section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
<ol> <li> Cree una función llamada <code>functionWithArgs</code> que acepte dos argumentos y envíe su suma a la consola dev. </li><li> Llame a la función con dos números como argumentos. </li></ol>
|
||||
<section id='instructions'>
|
||||
<ol> <li> Cree una función llamada <code>functionWithArgs</code> que acepte dos argumentos y envíe su suma a la consola dev. </li><li> Llame a la función con dos números como argumentos. </li></ol>
|
||||
</section>
|
||||
|
||||
## Tests
|
||||
@@ -27,9 +27,9 @@ Hemos pasado dos argumentos, <code>"Hello"</code> y <code>"World&
|
||||
tests:
|
||||
- text: <code>functionWithArgs</code> debería ser una función
|
||||
testString: 'assert(typeof functionWithArgs === "function", "<code>functionWithArgs</code> should be a function");'
|
||||
- text: ' <code>functionWithArgs(1,2)</code> debe generar <code>3</code> '
|
||||
- text: ' <code>functionWithArgs(1,2)</code> debe generar <code>3</code> '
|
||||
testString: 'if(typeof functionWithArgs === "function") { capture(); functionWithArgs(1,2); uncapture(); } assert(logOutput == 3, "<code>functionWithArgs(1,2)</code> should output <code>3</code>");'
|
||||
- text: ' <code>functionWithArgs(7,9)</code> debe generar <code>16</code> '
|
||||
- text: ' <code>functionWithArgs(7,9)</code> debe generar <code>16</code> '
|
||||
testString: 'if(typeof functionWithArgs === "function") { capture(); functionWithArgs(7,9); uncapture(); } assert(logOutput == 16, "<code>functionWithArgs(7,9)</code> should output <code>16</code>");'
|
||||
- text: Llame a <code>functionWithArgs</code> con dos números después de definirlo.
|
||||
testString: 'assert(/^\s*functionWithArgs\s*\(\s*\d+\s*,\s*\d+\s*\)\s*;/m.test(code), "Call <code>functionWithArgs</code> with two numbers after you define it.");'
|
||||
|
||||
@@ -6,18 +6,18 @@ challengeType: 1
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
En los últimos dos desafíos, aprendimos sobre el operador de igualdad ( <code>==</code> ) y el operador de igualdad estricta ( <code>===</code> ). Hagamos una revisión rápida y practiquemos el uso de estos operadores un poco más.
|
||||
Si los valores que se comparan no son del mismo tipo, el operador de igualdad realizará una conversión de tipo y luego evaluará los valores. Sin embargo, el operador de igualdad estricta comparará tanto el tipo de datos como el valor tal como está, sin convertir un tipo en otro.
|
||||
<strong>ejemplos</strong>
|
||||
<blockquote>3 == '3' // returns true because JavaScript performs type conversion from string to number<br>3 === '3' // returns false because the types are different and type conversion is not performed</blockquote>
|
||||
<strong>Nota</strong> <br> En JavaScript, puede determinar el tipo de una variable o un valor con el operador <code>typeof</code> , de la siguiente manera:
|
||||
<blockquote>typeof 3 // returns 'number'<br>typeof '3' // returns 'string'</blockquote>
|
||||
<section id='description'>
|
||||
En los últimos dos desafíos, aprendimos sobre el operador de igualdad ( <code>==</code> ) y el operador de igualdad estricta ( <code>===</code> ). Hagamos una revisión rápida y practiquemos el uso de estos operadores un poco más.
|
||||
Si los valores que se comparan no son del mismo tipo, el operador de igualdad realizará una conversión de tipo y luego evaluará los valores. Sin embargo, el operador de igualdad estricta comparará tanto el tipo de datos como el valor tal como está, sin convertir un tipo en otro.
|
||||
<strong>ejemplos</strong>
|
||||
<blockquote>3 == '3' // returns true because JavaScript performs type conversion from string to number<br>3 === '3' // returns false because the types are different and type conversion is not performed</blockquote>
|
||||
<strong>Nota</strong> <br> En JavaScript, puede determinar el tipo de una variable o un valor con el operador <code>typeof</code> , de la siguiente manera:
|
||||
<blockquote>typeof 3 // returns 'number'<br>typeof '3' // returns 'string'</blockquote>
|
||||
</section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
La función <code>compareEquality</code> en el editor compara dos valores utilizando el <code>equality operator</code> . Modifique la función de modo que devuelva "Igual" solo cuando los valores sean estrictamente iguales.
|
||||
<section id='instructions'>
|
||||
La función <code>compareEquality</code> en el editor compara dos valores utilizando el <code>equality operator</code> . Modifique la función de modo que devuelva "Igual" solo cuando los valores sean estrictamente iguales.
|
||||
</section>
|
||||
|
||||
## Tests
|
||||
@@ -25,9 +25,9 @@ La función <code>compareEquality</code> en el editor compara dos valores utiliz
|
||||
|
||||
```yml
|
||||
tests:
|
||||
- text: ' <code>compareEquality(10, "10")</code> debe devolver "Not Equal"'
|
||||
- text: ' <code>compareEquality(10, "10")</code> debe devolver "Not Equal"'
|
||||
testString: 'assert(compareEquality(10, "10") === "Not Equal", "<code>compareEquality(10, "10")</code> should return "Not Equal"");'
|
||||
- text: ' <code>compareEquality("20", 20)</code> debe devolver "Not Equal"'
|
||||
- text: ' <code>compareEquality("20", 20)</code> debe devolver "Not Equal"'
|
||||
testString: 'assert(compareEquality("20", 20) === "Not Equal", "<code>compareEquality("20", 20)</code> should return "Not Equal"");'
|
||||
- text: Debes usar el operador <code>===</code>
|
||||
testString: 'assert(code.match(/===/g), "You should use the <code>===</code> operator");'
|
||||
|
||||
@@ -6,17 +6,17 @@ challengeType: 1
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
Tenemos una variedad de objetos que representan a diferentes personas en nuestras listas de contactos.
|
||||
Se ha <code>lookUpProfile</code> función <code>lookUpProfile</code> que toma el <code>name</code> y una propiedad ( <code>prop</code> ) como argumentos.
|
||||
La función debe comprobar si <code>name</code> es de un contacto real <code>firstName</code> y la propiedad dada ( <code>prop</code> ) es una propiedad de ese contacto.
|
||||
Si ambos son verdaderos, devuelva el "valor" de esa propiedad.
|
||||
Si el <code>name</code> no corresponde a ningún contacto, devuelva <code>"No such contact"</code>
|
||||
Si la <code>prop</code> no corresponde a ninguna propiedad válida de un contacto encontrado para coincidir con el <code>name</code> entonces devuelva <code>"No such property"</code> existe <code>"No such property"</code>
|
||||
<section id='description'>
|
||||
Tenemos una variedad de objetos que representan a diferentes personas en nuestras listas de contactos.
|
||||
Se ha <code>lookUpProfile</code> función <code>lookUpProfile</code> que toma el <code>name</code> y una propiedad ( <code>prop</code> ) como argumentos.
|
||||
La función debe comprobar si <code>name</code> es de un contacto real <code>firstName</code> y la propiedad dada ( <code>prop</code> ) es una propiedad de ese contacto.
|
||||
Si ambos son verdaderos, devuelva el "valor" de esa propiedad.
|
||||
Si el <code>name</code> no corresponde a ningún contacto, devuelva <code>"No such contact"</code>
|
||||
Si la <code>prop</code> no corresponde a ninguna propiedad válida de un contacto encontrado para coincidir con el <code>name</code> entonces devuelva <code>"No such property"</code> existe <code>"No such property"</code>
|
||||
</section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
<section id='instructions'>
|
||||
|
||||
</section>
|
||||
|
||||
@@ -25,17 +25,17 @@ Si la <code>prop</code> no corresponde a ninguna propiedad válida de un contact
|
||||
|
||||
```yml
|
||||
tests:
|
||||
- text: ' <code>"Kristian", "lastName"</code> debería devolver <code>"Vos"</code> '
|
||||
- text: ' <code>"Kristian", "lastName"</code> debería devolver <code>"Vos"</code> '
|
||||
testString: 'assert(lookUpProfile("Kristian","lastName") === "Vos", "<code>"Kristian", "lastName"</code> should return <code>"Vos"</code>");'
|
||||
- text: ' <code>"Sherlock", "likes"</code> debería devolver <code>["Intriguing Cases", "Violin"]</code> '
|
||||
- text: ' <code>"Sherlock", "likes"</code> debería devolver <code>["Intriguing Cases", "Violin"]</code> '
|
||||
testString: 'assert.deepEqual(lookUpProfile("Sherlock", "likes"), ["Intriguing Cases", "Violin"], "<code>"Sherlock", "likes"</code> should return <code>["Intriguing Cases", "Violin"]</code>");'
|
||||
- text: ' <code>"Harry","likes"</code> debería devolver una matriz'
|
||||
- text: ' <code>"Harry","likes"</code> debería devolver una matriz'
|
||||
testString: 'assert(typeof lookUpProfile("Harry", "likes") === "object", "<code>"Harry","likes"</code> should return an array");'
|
||||
- text: ' <code>"Bob", "number"</code> debe devolver "No existe tal contacto"'
|
||||
- text: ' <code>"Bob", "number"</code> debe devolver "No existe tal contacto"'
|
||||
testString: 'assert(lookUpProfile("Bob", "number") === "No such contact", "<code>"Bob", "number"</code> should return "No such contact"");'
|
||||
- text: ' <code>"Bob", "potato"</code> debe devolver "No hay tal contacto"'
|
||||
- text: ' <code>"Bob", "potato"</code> debe devolver "No hay tal contacto"'
|
||||
testString: 'assert(lookUpProfile("Bob", "potato") === "No such contact", "<code>"Bob", "potato"</code> should return "No such contact"");'
|
||||
- text: ' <code>"Akira", "address"</code> debe devolver "No existe tal propiedad"
|
||||
- text: ' <code>"Akira", "address"</code> debe devolver "No existe tal propiedad"
|
||||
testString: 'assert(lookUpProfile("Akira", "address") === "No such property", "<code>"Akira", "address"</code> should return "No such property"");'
|
||||
|
||||
```
|
||||
|
||||
@@ -6,21 +6,21 @@ challengeType: 1
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
<dfn>Los</dfn> valores de <dfn>cadena</dfn> en JavaScript se pueden escribir con comillas simples o dobles, siempre y cuando comience y termine con el mismo tipo de comillas. A diferencia de otros lenguajes de programación, las comillas simples y dobles funcionan de la misma manera en JavaScript.
|
||||
<blockquote>doubleQuoteStr = "This is a string"; <br/>singleQuoteStr = 'This is also a string';</blockquote>
|
||||
La razón por la que podría querer usar un tipo de cita sobre la otra es si quiere usar ambos en una cadena. Esto puede suceder si desea guardar una conversación en una cadena y tener la conversación entre comillas. Otro uso sería guardar una etiqueta <code><a></code> con varios atributos entre comillas, todo dentro de una cadena.
|
||||
<blockquote>conversation = 'Finn exclaims to Jake, "Algebraic!"';</blockquote>
|
||||
Sin embargo, esto se convierte en un problema si necesita usar las citas más externas dentro de él. Recuerde, una cadena tiene el mismo tipo de cita al principio y al final. Pero si tiene la misma cita en algún punto intermedio, la cadena se detendrá antes y arrojará un error.
|
||||
<blockquote>goodStr = 'Jake asks Finn, "Hey, let\'s go on an adventure?"'; <br/>badStr = 'Finn responds, "Let's go!"'; // Throws an error</blockquote>
|
||||
En el <dfn>goodStr</dfn> anterior, puede usar ambas comillas de forma segura usando la barra invertida <code>\</code> como un carácter de escape.
|
||||
<strong>Nota</strong> <br/> La barra invertida <code>\</code> no debe confundirse con la barra inclinada <code>/</code> . No hacen lo mismo.
|
||||
<section id='description'>
|
||||
<dfn>Los</dfn> valores de <dfn>cadena</dfn> en JavaScript se pueden escribir con comillas simples o dobles, siempre y cuando comience y termine con el mismo tipo de comillas. A diferencia de otros lenguajes de programación, las comillas simples y dobles funcionan de la misma manera en JavaScript.
|
||||
<blockquote>doubleQuoteStr = "This is a string"; <br/>singleQuoteStr = 'This is also a string';</blockquote>
|
||||
La razón por la que podría querer usar un tipo de cita sobre la otra es si quiere usar ambos en una cadena. Esto puede suceder si desea guardar una conversación en una cadena y tener la conversación entre comillas. Otro uso sería guardar una etiqueta <code><a></code> con varios atributos entre comillas, todo dentro de una cadena.
|
||||
<blockquote>conversation = 'Finn exclaims to Jake, "Algebraic!"';</blockquote>
|
||||
Sin embargo, esto se convierte en un problema si necesita usar las citas más externas dentro de él. Recuerde, una cadena tiene el mismo tipo de cita al principio y al final. Pero si tiene la misma cita en algún punto intermedio, la cadena se detendrá antes y arrojará un error.
|
||||
<blockquote>goodStr = 'Jake asks Finn, "Hey, let\'s go on an adventure?"'; <br/>badStr = 'Finn responds, "Let's go!"'; // Throws an error</blockquote>
|
||||
En el <dfn>goodStr</dfn> anterior, puede usar ambas comillas de forma segura usando la barra invertida <code>\</code> como un carácter de escape.
|
||||
<strong>Nota</strong> <br/> La barra invertida <code>\</code> no debe confundirse con la barra inclinada <code>/</code> . No hacen lo mismo.
|
||||
</section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
Cambie la cadena proporcionada por una cadena con comillas simples al principio y al final y sin caracteres de escape.
|
||||
En este momento, la etiqueta <code><a></code> en la cadena usa comillas dobles en todas partes. Deberá cambiar las comillas externas a comillas simples para poder eliminar los caracteres de escape.
|
||||
<section id='instructions'>
|
||||
Cambie la cadena proporcionada por una cadena con comillas simples al principio y al final y sin caracteres de escape.
|
||||
En este momento, la etiqueta <code><a></code> en la cadena usa comillas dobles en todas partes. Deberá cambiar las comillas externas a comillas simples para poder eliminar los caracteres de escape.
|
||||
</section>
|
||||
|
||||
## Tests
|
||||
@@ -30,7 +30,7 @@ En este momento, la etiqueta <code><a></code> en la cadena usa comillas do
|
||||
tests:
|
||||
- text: Eliminar todas las <code>backslashes</code> ( <code>\</code> )
|
||||
testString: 'assert(!/\\/g.test(code) && myStr.match("\\s*<a href\\s*=\\s*"http://www.example.com"\\s*target\\s*=\\s*"_blank">\\s*Link\\s*</a>\\s*"), "Remove all the <code>backslashes</code> (<code>\</code>)");'
|
||||
- text: 'Debería tener dos comillas simples <code>'</code> y cuatro comillas dobles <code>"</code> '
|
||||
- text: 'Debería tener dos comillas simples <code>'</code> y cuatro comillas dobles <code>"</code> '
|
||||
testString: 'assert(code.match(/"/g).length === 4 && code.match(/"/g).length === 2, "You should have two single quotes <code>'</code> and four double quotes <code>"</code>");'
|
||||
|
||||
```
|
||||
|
||||
@@ -6,22 +6,22 @@ challengeType: 1
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
Se le asigna un objeto JSON que representa una parte de su colección de álbumes musicales. Cada álbum tiene varias propiedades y un número de identificación único como clave. No todos los álbumes tienen información completa.
|
||||
Escriba una función que tome la <code>id</code> un álbum (como <code>2548</code> ), una propiedad <code>prop</code> (como <code>"artist"</code> o <code>"tracks"</code> ), y un <code>value</code> (como <code>"Addicted to Love"</code> ) para modificar los datos de esta colección.
|
||||
Si la <code>prop</code> no es <code>"tracks"</code> y el <code>value</code> no está vacío ( <code>""</code> ), actualice o establezca el <code>value</code> para la propiedad del álbum de grabación.
|
||||
Su función debe devolver siempre el objeto de colección completo.
|
||||
Existen varias reglas para manejar datos incompletos:
|
||||
Si <code>prop</code> es <code>"tracks"</code> pero el álbum no tiene una propiedad de <code>"tracks"</code> , cree una matriz vacía antes de agregar el nuevo valor a la propiedad correspondiente del álbum.
|
||||
Si <code>prop</code> es <code>"tracks"</code> y el <code>value</code> no está vacío ( <code>""</code> ), presione el <code>value</code> sobre el final de la matriz de <code>tracks</code> existente del <code>tracks</code> .
|
||||
Si el <code>value</code> está vacío ( <code>""</code> ), elimine la propiedad de <code>prop</code> determinada del álbum.
|
||||
<strong>Consejos</strong> <br> Utilice la <code>bracket notation</code> cuando <a href="javascript-algorithms-and-data-structures/basic-javascript/accessing-object-properties-with-variables" target="_blank">acceda a las propiedades de objetos con variables</a> .
|
||||
Push es un método de matriz que puede leer sobre <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/push" target="_blank">Mozilla Developer Network</a> .
|
||||
Puede volver a consultar <a href="javascript-algorithms-and-data-structures/basic-javascript/manipulating-complex-objects" target="_blank">Manipular objetos complejos</a> Presentando la notación de objetos de JavaScript (JSON) para obtener una actualización.
|
||||
<section id='description'>
|
||||
Se le asigna un objeto JSON que representa una parte de su colección de álbumes musicales. Cada álbum tiene varias propiedades y un número de identificación único como clave. No todos los álbumes tienen información completa.
|
||||
Escriba una función que tome la <code>id</code> un álbum (como <code>2548</code> ), una propiedad <code>prop</code> (como <code>"artist"</code> o <code>"tracks"</code> ), y un <code>value</code> (como <code>"Addicted to Love"</code> ) para modificar los datos de esta colección.
|
||||
Si la <code>prop</code> no es <code>"tracks"</code> y el <code>value</code> no está vacío ( <code>""</code> ), actualice o establezca el <code>value</code> para la propiedad del álbum de grabación.
|
||||
Su función debe devolver siempre el objeto de colección completo.
|
||||
Existen varias reglas para manejar datos incompletos:
|
||||
Si <code>prop</code> es <code>"tracks"</code> pero el álbum no tiene una propiedad de <code>"tracks"</code> , cree una matriz vacía antes de agregar el nuevo valor a la propiedad correspondiente del álbum.
|
||||
Si <code>prop</code> es <code>"tracks"</code> y el <code>value</code> no está vacío ( <code>""</code> ), presione el <code>value</code> sobre el final de la matriz de <code>tracks</code> existente del <code>tracks</code> .
|
||||
Si el <code>value</code> está vacío ( <code>""</code> ), elimine la propiedad de <code>prop</code> determinada del álbum.
|
||||
<strong>Consejos</strong> <br> Utilice la <code>bracket notation</code> cuando <a href="javascript-algorithms-and-data-structures/basic-javascript/accessing-object-properties-with-variables" target="_blank">acceda a las propiedades de objetos con variables</a> .
|
||||
Push es un método de matriz que puede leer sobre <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/push" target="_blank">Mozilla Developer Network</a> .
|
||||
Puede volver a consultar <a href="javascript-algorithms-and-data-structures/basic-javascript/manipulating-complex-objects" target="_blank">Manipular objetos complejos</a> Presentando la notación de objetos de JavaScript (JSON) para obtener una actualización.
|
||||
</section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
<section id='instructions'>
|
||||
|
||||
</section>
|
||||
|
||||
@@ -30,19 +30,19 @@ Puede volver a consultar <a href="javascript-algorithms-and-data-structures/basi
|
||||
|
||||
```yml
|
||||
tests:
|
||||
- text: 'Después de <code>updateRecords(5439, "artist", "ABBA")</code> , el <code>artist</code> debe ser <code>"ABBA"</code> '
|
||||
- text: 'Después de <code>updateRecords(5439, "artist", "ABBA")</code> , el <code>artist</code> debe ser <code>"ABBA"</code> '
|
||||
testString: 'collection = collectionCopy; assert(updateRecords(5439, "artist", "ABBA")[5439]["artist"] === "ABBA", "After <code>updateRecords(5439, "artist", "ABBA")</code>, <code>artist</code> should be <code>"ABBA"</code>");'
|
||||
- text: 'Después de <code>updateRecords(5439, "tracks", "Take a Chance on Me")</code> , los <code>tracks</code> deberían tener <code>"Take a Chance on Me"</code> como el último elemento.'
|
||||
- text: 'Después de <code>updateRecords(5439, "tracks", "Take a Chance on Me")</code> , los <code>tracks</code> deberían tener <code>"Take a Chance on Me"</code> como el último elemento.'
|
||||
testString: 'assert(updateRecords(5439, "tracks", "Take a Chance on Me")[5439]["tracks"].pop() === "Take a Chance on Me", "After <code>updateRecords(5439, "tracks", "Take a Chance on Me")</code>, <code>tracks</code> should have <code>"Take a Chance on Me"</code> as the last element.");'
|
||||
- text: 'Después de <code>updateRecords(2548, "artist", "")</code> , el <code>artist</code> no debe configurarse'
|
||||
- text: 'Después de <code>updateRecords(2548, "artist", "")</code> , el <code>artist</code> no debe configurarse'
|
||||
testString: 'updateRecords(2548, "artist", ""); assert(!collection[2548].hasOwnProperty("artist"), "After <code>updateRecords(2548, "artist", "")</code>, <code>artist</code> should not be set");'
|
||||
- text: 'Después de <code>updateRecords(1245, "tracks", "Addicted to Love")</code> , las <code>tracks</code> deberían tener <code>"Addicted to Love"</code> como último elemento.'
|
||||
- text: 'Después de <code>updateRecords(1245, "tracks", "Addicted to Love")</code> , las <code>tracks</code> deberían tener <code>"Addicted to Love"</code> como último elemento.'
|
||||
testString: 'assert(updateRecords(1245, "tracks", "Addicted to Love")[1245]["tracks"].pop() === "Addicted to Love", "After <code>updateRecords(1245, "tracks", "Addicted to Love")</code>, <code>tracks</code> should have <code>"Addicted to Love"</code> as the last element.");'
|
||||
- text: 'Después de <code>updateRecords(2468, "tracks", "Free")</code> , los <code>tracks</code> deberían tener <code>"1999"</code> como primer elemento.'
|
||||
- text: 'Después de <code>updateRecords(2468, "tracks", "Free")</code> , los <code>tracks</code> deberían tener <code>"1999"</code> como primer elemento.'
|
||||
testString: 'assert(updateRecords(2468, "tracks", "Free")[2468]["tracks"][0] === "1999", "After <code>updateRecords(2468, "tracks", "Free")</code>, <code>tracks</code> should have <code>"1999"</code> as the first element.");'
|
||||
- text: 'Después de <code>updateRecords(2548, "tracks", "")</code> , no se deben establecer <code>tracks</code> '
|
||||
- text: 'Después de <code>updateRecords(2548, "tracks", "")</code> , no se deben establecer <code>tracks</code> '
|
||||
testString: 'updateRecords(2548, "tracks", ""); assert(!collection[2548].hasOwnProperty("tracks"), "After <code>updateRecords(2548, "tracks", "")</code>, <code>tracks</code> should not be set");'
|
||||
- text: 'Después de <code>updateRecords(1245, "album", "Riptide")</code> , el <code>album</code> debería ser <code>"Riptide"</code> '
|
||||
- text: 'Después de <code>updateRecords(1245, "album", "Riptide")</code> , el <code>album</code> debería ser <code>"Riptide"</code> '
|
||||
testString: 'assert(updateRecords(1245, "album", "Riptide")[1245]["album"] === "Riptide", "After <code>updateRecords(1245, "album", "Riptide")</code>, <code>album</code> should be <code>"Riptide"</code>");'
|
||||
|
||||
```
|
||||
|
||||
@@ -6,16 +6,16 @@ challengeType: 1
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
Si tiene muchas opciones para elegir, una instrucción <code>switch</code> puede ser más fácil de escribir que muchas instrucciones encadenadas <code>if</code> / <code>else if</code> . Lo siguiente:
|
||||
<blockquote>if (val === 1) {<br> answer = "a";<br>} else if (val === 2) {<br> answer = "b";<br>} else {<br> answer = "c";<br>}</blockquote>
|
||||
puede ser reemplazado por:
|
||||
<blockquote>switch(val) {<br> case 1:<br> answer = "a";<br> break;<br> case 2:<br> answer = "b";<br> break;<br> default:<br> answer = "c";<br>}</blockquote>
|
||||
<section id='description'>
|
||||
Si tiene muchas opciones para elegir, una instrucción <code>switch</code> puede ser más fácil de escribir que muchas instrucciones encadenadas <code>if</code> / <code>else if</code> . Lo siguiente:
|
||||
<blockquote>if (val === 1) {<br> answer = "a";<br>} else if (val === 2) {<br> answer = "b";<br>} else {<br> answer = "c";<br>}</blockquote>
|
||||
puede ser reemplazado por:
|
||||
<blockquote>switch(val) {<br> case 1:<br> answer = "a";<br> break;<br> case 2:<br> answer = "b";<br> break;<br> default:<br> answer = "c";<br>}</blockquote>
|
||||
</section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
Cambie las sentencias <code>if</code> / <code>else if</code> encadenadas en una sentencia <code>switch</code> .
|
||||
<section id='instructions'>
|
||||
Cambie las sentencias <code>if</code> / <code>else if</code> encadenadas en una sentencia <code>switch</code> .
|
||||
</section>
|
||||
|
||||
## Tests
|
||||
@@ -33,7 +33,7 @@ tests:
|
||||
testString: 'assert(chainToSwitch("bob") === "Marley", "<code>chainToSwitch("bob")</code> should be "Marley"");'
|
||||
- text: <code>chainToSwitch(42)</code> debe ser "La Respuesta"
|
||||
testString: 'assert(chainToSwitch(42) === "The Answer", "<code>chainToSwitch(42)</code> should be "The Answer"");'
|
||||
- text: ' <code>chainToSwitch(1)</code> debe ser "No hay # 1"'
|
||||
- text: ' <code>chainToSwitch(1)</code> debe ser "No hay # 1"'
|
||||
testString: 'assert(chainToSwitch(1) === "There is no #1", "<code>chainToSwitch(1)</code> should be "There is no #1"");'
|
||||
- text: <code>chainToSwitch(99)</code> debería ser "¡Me <code>chainToSwitch(99)</code> por esto!"
|
||||
testString: 'assert(chainToSwitch(99) === "Missed me by this much!", "<code>chainToSwitch(99)</code> should be "Missed me by this much!"");'
|
||||
|
||||
@@ -6,17 +6,17 @@ challengeType: 1
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
Cuando se alcanza una declaración de <code>return</code> , la ejecución de la función actual se detiene y el control vuelve a la ubicación de la llamada.
|
||||
<strong>Ejemplo</strong>
|
||||
<blockquote>function myFun() {<br> console.log("Hello");<br> return "World";<br> console.log("byebye")<br>}<br>myFun();</blockquote>
|
||||
Lo anterior muestra "Hola" a la consola, devuelve "Mundo", pero <code>"byebye"</code> nunca se <code>"byebye"</code> , porque la función sale de la instrucción de <code>return</code> .
|
||||
<section id='description'>
|
||||
Cuando se alcanza una declaración de <code>return</code> , la ejecución de la función actual se detiene y el control vuelve a la ubicación de la llamada.
|
||||
<strong>Ejemplo</strong>
|
||||
<blockquote>function myFun() {<br> console.log("Hello");<br> return "World";<br> console.log("byebye")<br>}<br>myFun();</blockquote>
|
||||
Lo anterior muestra "Hola" a la consola, devuelve "Mundo", pero <code>"byebye"</code> nunca se <code>"byebye"</code> , porque la función sale de la instrucción de <code>return</code> .
|
||||
</section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
Modifique la función <code>abTest</code> para que si <code>a</code> o <code>b</code> sean menores que <code>0</code> la función saldrá inmediatamente con un valor <code>undefined</code> .
|
||||
<strong>Pista</strong> <br> Recuerde que <a href='http://www.freecodecamp.org/challenges/understanding-uninitialized-variables' target='_blank'><code>undefined</code> es una palabra clave</a> , no una cadena.
|
||||
<section id='instructions'>
|
||||
Modifique la función <code>abTest</code> para que si <code>a</code> o <code>b</code> sean menores que <code>0</code> la función saldrá inmediatamente con un valor <code>undefined</code> .
|
||||
<strong>Pista</strong> <br> Recuerde que <a href='http://www.freecodecamp.org/challenges/understanding-uninitialized-variables' target='_blank'><code>undefined</code> es una palabra clave</a> , no una cadena.
|
||||
</section>
|
||||
|
||||
## Tests
|
||||
@@ -24,17 +24,17 @@ Modifique la función <code>abTest</code> para que si <code>a</code> o <code>b</
|
||||
|
||||
```yml
|
||||
tests:
|
||||
- text: ' <code>abTest(2,2)</code> debe devolver un número'
|
||||
- text: ' <code>abTest(2,2)</code> debe devolver un número'
|
||||
testString: 'assert(typeof abTest(2,2) === "number" , "<code>abTest(2,2)</code> should return a number");'
|
||||
- text: ' <code>abTest(2,2)</code> debe devolver <code>8</code> '
|
||||
- text: ' <code>abTest(2,2)</code> debe devolver <code>8</code> '
|
||||
testString: 'assert(abTest(2,2) === 8 , "<code>abTest(2,2)</code> should return <code>8</code>");'
|
||||
- text: ' <code>abTest(-2,2)</code> debe devolver <code>undefined</code> '
|
||||
- text: ' <code>abTest(-2,2)</code> debe devolver <code>undefined</code> '
|
||||
testString: 'assert(abTest(-2,2) === undefined , "<code>abTest(-2,2)</code> should return <code>undefined</code>");'
|
||||
- text: ' <code>abTest(2,-2)</code> debe devolver <code>undefined</code> '
|
||||
- text: ' <code>abTest(2,-2)</code> debe devolver <code>undefined</code> '
|
||||
testString: 'assert(abTest(2,-2) === undefined , "<code>abTest(2,-2)</code> should return <code>undefined</code>");'
|
||||
- text: ' <code>abTest(2,8)</code> debe devolver <code>18</code> '
|
||||
- text: ' <code>abTest(2,8)</code> debe devolver <code>18</code> '
|
||||
testString: 'assert(abTest(2,8) === 18 , "<code>abTest(2,8)</code> should return <code>18</code>");'
|
||||
- text: ' <code>abTest(3,3)</code> debe devolver <code>12</code> '
|
||||
- text: ' <code>abTest(3,3)</code> debe devolver <code>12</code> '
|
||||
testString: 'assert(abTest(3,3) === 12 , "<code>abTest(3,3)</code> should return <code>12</code>");'
|
||||
|
||||
```
|
||||
|
||||
@@ -6,17 +6,17 @@ challengeType: 1
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
Puede recordar de la <a href="waypoint-comparison-with-the-equality-operator" target="_blank">comparación con el operador de igualdad</a> que todos los operadores de comparación devuelven un valor booleano <code>true</code> o <code>false</code> .
|
||||
Algunas veces las personas usan una sentencia if / else para hacer una comparación, como esta:
|
||||
<blockquote>function isEqual(a,b) {<br> if (a === b) {<br> return true;<br> } else {<br> return false;<br> }<br>}</blockquote>
|
||||
Pero hay una mejor manera de hacer esto. Como <code>===</code> devuelve <code>true</code> o <code>false</code> , podemos devolver el resultado de la comparación:
|
||||
<blockquote>function isEqual(a,b) {<br> return a === b;<br>}</blockquote>
|
||||
<section id='description'>
|
||||
Puede recordar de la <a href="waypoint-comparison-with-the-equality-operator" target="_blank">comparación con el operador de igualdad</a> que todos los operadores de comparación devuelven un valor booleano <code>true</code> o <code>false</code> .
|
||||
Algunas veces las personas usan una sentencia if / else para hacer una comparación, como esta:
|
||||
<blockquote>function isEqual(a,b) {<br> if (a === b) {<br> return true;<br> } else {<br> return false;<br> }<br>}</blockquote>
|
||||
Pero hay una mejor manera de hacer esto. Como <code>===</code> devuelve <code>true</code> o <code>false</code> , podemos devolver el resultado de la comparación:
|
||||
<blockquote>function isEqual(a,b) {<br> return a === b;<br>}</blockquote>
|
||||
</section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
Arreglar la función <code>isLess</code> permite eliminar las sentencias <code>if/else</code> .
|
||||
<section id='instructions'>
|
||||
Arreglar la función <code>isLess</code> permite eliminar las sentencias <code>if/else</code> .
|
||||
</section>
|
||||
|
||||
## Tests
|
||||
@@ -24,9 +24,9 @@ Arreglar la función <code>isLess</code> permite eliminar las sentencias <code>i
|
||||
|
||||
```yml
|
||||
tests:
|
||||
- text: ' <code>isLess(10,15)</code> debe devolver <code>true</code> '
|
||||
- text: ' <code>isLess(10,15)</code> debe devolver <code>true</code> '
|
||||
testString: 'assert(isLess(10,15) === true, "<code>isLess(10,15)</code> should return <code>true</code>");'
|
||||
- text: ' <code>isLess(15,10)</code> debe devolver <code>false</code> '
|
||||
- text: ' <code>isLess(15,10)</code> debe devolver <code>false</code> '
|
||||
testString: 'assert(isLess(15, 10) === false, "<code>isLess(15,10)</code> should return <code>false</code>");'
|
||||
- text: No debes usar ninguna declaración <code>if</code> o <code>else</code>
|
||||
testString: 'assert(!/if|else/g.test(code), "You should not use any <code>if</code> or <code>else</code> statements");'
|
||||
|
||||
@@ -6,15 +6,15 @@ challengeType: 1
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
En informática, una <dfn>cola</dfn> es una <dfn>estructura de datos</dfn> abstracta donde los elementos se mantienen en orden. Los nuevos elementos se pueden agregar al final de la <code>queue</code> y los elementos antiguos se quitan de la parte delantera de la <code>queue</code> .
|
||||
Escriba una función <code>nextInLine</code> que tome una matriz ( <code>arr</code> ) y un número ( <code>item</code> ) como argumentos.
|
||||
Agregue el número al final de la matriz, luego elimine el primer elemento de la matriz.
|
||||
La función <code>nextInLine</code> debe devolver el elemento que se eliminó.
|
||||
<section id='description'>
|
||||
En informática, una <dfn>cola</dfn> es una <dfn>estructura de datos</dfn> abstracta donde los elementos se mantienen en orden. Los nuevos elementos se pueden agregar al final de la <code>queue</code> y los elementos antiguos se quitan de la parte delantera de la <code>queue</code> .
|
||||
Escriba una función <code>nextInLine</code> que tome una matriz ( <code>arr</code> ) y un número ( <code>item</code> ) como argumentos.
|
||||
Agregue el número al final de la matriz, luego elimine el primer elemento de la matriz.
|
||||
La función <code>nextInLine</code> debe devolver el elemento que se eliminó.
|
||||
</section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
<section id='instructions'>
|
||||
|
||||
</section>
|
||||
|
||||
@@ -23,15 +23,15 @@ La función <code>nextInLine</code> debe devolver el elemento que se eliminó.
|
||||
|
||||
```yml
|
||||
tests:
|
||||
- text: ' <code>nextInLine([], 5)</code> debe devolver un número'.
|
||||
- text: ' <code>nextInLine([], 5)</code> debe devolver un número'
|
||||
testString: 'assert.isNumber(nextInLine([],5), "<code>nextInLine([], 5)</code> should return a number.");'
|
||||
- text: ' <code>nextInLine([], 1)</code> debe devolver <code>1</code> '
|
||||
- text: ' <code>nextInLine([], 1)</code> debe devolver <code>1</code> '
|
||||
testString: 'assert(nextInLine([],1) === 1, "<code>nextInLine([], 1)</code> should return <code>1</code>");'
|
||||
- text: ' <code>nextInLine([2], 1)</code> debe devolver <code>2</code> '
|
||||
- text: ' <code>nextInLine([2], 1)</code> debe devolver <code>2</code> '
|
||||
testString: 'assert(nextInLine([2],1) === 2, "<code>nextInLine([2], 1)</code> should return <code>2</code>");'
|
||||
- text: ' <code>nextInLine([5,6,7,8,9], 1)</code> debe devolver <code>5</code> '
|
||||
- text: ' <code>nextInLine([5,6,7,8,9], 1)</code> debe devolver <code>5</code> '
|
||||
testString: 'assert(nextInLine([5,6,7,8,9],1) === 5, "<code>nextInLine([5,6,7,8,9], 1)</code> should return <code>5</code>");'
|
||||
- text: 'Después de <code>nextInLine(testArr, 10)</code> , <code>testArr[4]</code> debería ser <code>10</code> '
|
||||
- text: 'Después de <code>nextInLine(testArr, 10)</code> , <code>testArr[4]</code> debería ser <code>10</code> '
|
||||
testString: 'nextInLine(testArr, 10); assert(testArr[4] === 10, "After <code>nextInLine(testArr, 10)</code>, <code>testArr[4]</code> should be <code>10</code>");'
|
||||
|
||||
```
|
||||
|
||||
@@ -6,14 +6,14 @@ challengeType: 1
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
Otro tipo de datos es el <dfn>booleano</dfn> . <code>Booleans</code> solo pueden ser uno de dos valores: <code>true</code> o <code>false</code> . Básicamente son pequeños interruptores de encendido y apagado, donde <code>true</code> está "encendido" y <code>false</code> está "apagado". Estos dos estados son mutuamente excluyentes.
|
||||
<strong>Nota</strong> <br> <code>Boolean</code> valores <code>Boolean</code> nunca se escriben entre comillas. Las <code>strings</code> <code>"true"</code> y <code>"false"</code> no son <code>Boolean</code> y no tienen un significado especial en JavaScript.
|
||||
<section id='description'>
|
||||
Otro tipo de datos es el <dfn>booleano</dfn> . <code>Booleans</code> solo pueden ser uno de dos valores: <code>true</code> o <code>false</code> . Básicamente son pequeños interruptores de encendido y apagado, donde <code>true</code> está "encendido" y <code>false</code> está "apagado". Estos dos estados son mutuamente excluyentes.
|
||||
<strong>Nota</strong> <br> <code>Boolean</code> valores <code>Boolean</code> nunca se escriben entre comillas. Las <code>strings</code> <code>"true"</code> y <code>"false"</code> no son <code>Boolean</code> y no tienen un significado especial en JavaScript.
|
||||
</section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
Modifique la función <code>welcomeToBooleans</code> para que devuelva <code>true</code> lugar de <code>false</code> cuando se haga clic en el botón Ejecutar.
|
||||
<section id='instructions'>
|
||||
Modifique la función <code>welcomeToBooleans</code> para que devuelva <code>true</code> lugar de <code>false</code> cuando se haga clic en el botón Ejecutar.
|
||||
</section>
|
||||
|
||||
## Tests
|
||||
@@ -21,7 +21,7 @@ Modifique la función <code>welcomeToBooleans</code> para que devuelva <code>tru
|
||||
|
||||
```yml
|
||||
tests:
|
||||
- text: 'La función <code>welcomeToBooleans()</code> debería devolver un valor booleano (verdadero / falso).'
|
||||
- text: 'La función <code>welcomeToBooleans()</code> debería devolver un valor booleano (verdadero / falso).'
|
||||
testString: 'assert(typeof welcomeToBooleans() === "boolean", "The <code>welcomeToBooleans()</code> function should return a boolean (true/false) value.");'
|
||||
- text: <code>welcomeToBooleans()</code> debe devolver true.
|
||||
testString: 'assert(welcomeToBooleans() === true, "<code>welcomeToBooleans()</code> should return true.");'
|
||||
|
||||
@@ -6,16 +6,16 @@ challengeType: 1
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
Una función puede incluir la declaración de <code>return</code> , pero no tiene que hacerlo. En el caso de que la función no tenga una declaración de <code>return</code> , cuando la llame, la función procesa el código interno pero el valor devuelto <code>undefined</code> está <code>undefined</code> .
|
||||
<strong>Ejemplo</strong>
|
||||
<blockquote>var sum = 0;<br>function addSum(num) {<br> sum = sum + num;<br>}<br>var returnedValue = addSum(3); // sum will be modified but returned value is undefined</blockquote>
|
||||
<code>addSum</code> es una función sin una declaración de <code>return</code> . La función cambiará la variable de <code>sum</code> global, pero el valor devuelto de la función es <code>undefined</code>
|
||||
<section id='description'>
|
||||
Una función puede incluir la declaración de <code>return</code> , pero no tiene que hacerlo. En el caso de que la función no tenga una declaración de <code>return</code> , cuando la llame, la función procesa el código interno pero el valor devuelto <code>undefined</code> está <code>undefined</code> .
|
||||
<strong>Ejemplo</strong>
|
||||
<blockquote>var sum = 0;<br>function addSum(num) {<br> sum = sum + num;<br>}<br>var returnedValue = addSum(3); // sum will be modified but returned value is undefined</blockquote>
|
||||
<code>addSum</code> es una función sin una declaración de <code>return</code> . La función cambiará la variable de <code>sum</code> global, pero el valor devuelto de la función es <code>undefined</code>
|
||||
</section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
Crear una función <code>addFive</code> sin ningún argumento. Esta función agrega 5 a la variable de <code>sum</code> , pero su valor devuelto <code>undefined</code> está <code>undefined</code> .
|
||||
<section id='instructions'>
|
||||
Crear una función <code>addFive</code> sin ningún argumento. Esta función agrega 5 a la variable de <code>sum</code> , pero su valor devuelto <code>undefined</code> está <code>undefined</code> .
|
||||
</section>
|
||||
|
||||
## Tests
|
||||
@@ -29,7 +29,7 @@ tests:
|
||||
testString: 'assert(sum === 8, "<code>sum</code> should be equal to 8");'
|
||||
- text: El valor devuelto de <code>addFive</code> debe estar <code>undefined</code>
|
||||
testString: 'assert(addFive() === undefined, "Returned value from <code>addFive</code> should be <code>undefined</code>");'
|
||||
- text: 'Dentro de tus funciones, suma 5 a la variable de <code>sum</code> '
|
||||
- text: 'Dentro de tus funciones, suma 5 a la variable de <code>sum</code> '
|
||||
testString: 'assert(code.match(/(sum\s*\=\s*sum\s*\+\s*5)|(sum\s*\+\=\s*5)/g).length === 1, "Inside of your functions, add 5 to the <code>sum</code> variable");'
|
||||
|
||||
```
|
||||
|
||||
@@ -6,19 +6,19 @@ challengeType: 1
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
<code>If</code> se usan sentencias para tomar decisiones en código. La palabra clave <code>if</code> le dice a JavaScript que ejecute el código entre llaves en ciertas condiciones, definidas entre paréntesis. Estas condiciones se conocen como condiciones <code>Boolean</code> y solo pueden ser <code>true</code> o <code>false</code> .
|
||||
Cuando la condición se evalúa como <code>true</code> , el programa ejecuta la instrucción dentro de las llaves. Cuando la condición booleana se evalúa como <code>false</code> , la instrucción dentro de las llaves no se ejecutará.
|
||||
<strong>pseudocódigo</strong>
|
||||
<blockquote>if ( <i>condition is true</i> ) {<br> <i>statement is executed</i> <br>}</blockquote>
|
||||
<strong>Ejemplo</strong>
|
||||
<blockquote>function test (myCondition) {<br> if (myCondition) {<br> return "It was true";<br> }<br> return "It was false";<br>}<br>test(true); // returns "It was true"<br>test(false); // returns "It was false"</blockquote>
|
||||
Cuando se llama a la <code>test</code> con un valor <code>true</code> , la sentencia <code>if</code> evalúa <code>myCondition</code> para ver si es <code>true</code> o no. Dado que es <code>true</code> , la función devuelve <code>"It was true"</code> . Cuando llamamos a <code>test</code> con un valor de <code>false</code> , <code>myCondition</code> <em>no</em> es <code>true</code> y la instrucción entre llaves no se ejecuta y la función devuelve <code>"It was false"</code> .
|
||||
<section id='description'>
|
||||
<code>If</code> se usan sentencias para tomar decisiones en código. La palabra clave <code>if</code> le dice a JavaScript que ejecute el código entre llaves en ciertas condiciones, definidas entre paréntesis. Estas condiciones se conocen como condiciones <code>Boolean</code> y solo pueden ser <code>true</code> o <code>false</code> .
|
||||
Cuando la condición se evalúa como <code>true</code> , el programa ejecuta la instrucción dentro de las llaves. Cuando la condición booleana se evalúa como <code>false</code> , la instrucción dentro de las llaves no se ejecutará.
|
||||
<strong>pseudocódigo</strong>
|
||||
<blockquote>if ( <i>condition is true</i> ) {<br> <i>statement is executed</i> <br>}</blockquote>
|
||||
<strong>Ejemplo</strong>
|
||||
<blockquote>function test (myCondition) {<br> if (myCondition) {<br> return "It was true";<br> }<br> return "It was false";<br>}<br>test(true); // returns "It was true"<br>test(false); // returns "It was false"</blockquote>
|
||||
Cuando se llama a la <code>test</code> con un valor <code>true</code> , la sentencia <code>if</code> evalúa <code>myCondition</code> para ver si es <code>true</code> o no. Dado que es <code>true</code> , la función devuelve <code>"It was true"</code> . Cuando llamamos a <code>test</code> con un valor de <code>false</code> , <code>myCondition</code> <em>no</em> es <code>true</code> y la instrucción entre llaves no se ejecuta y la función devuelve <code>"It was false"</code> .
|
||||
</section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
Cree una instrucción <code>if</code> dentro de la función para devolver <code>"Yes, that was true"</code> si el parámetro <code>wasThatTrue</code> es <code>true</code> y devuelva <code>"No, that was false"</code> contrario.
|
||||
<section id='instructions'>
|
||||
Cree una instrucción <code>if</code> dentro de la función para devolver <code>"Yes, that was true"</code> si el parámetro <code>wasThatTrue</code> es <code>true</code> y devuelva <code>"No, that was false"</code> contrario.
|
||||
</section>
|
||||
|
||||
## Tests
|
||||
@@ -32,9 +32,9 @@ tests:
|
||||
testString: 'assert(typeof trueOrFalse(true) === "string", "<code>trueOrFalse(true)</code> should return a string");'
|
||||
- text: <code>trueOrFalse(false)</code> debe devolver una cadena
|
||||
testString: 'assert(typeof trueOrFalse(false) === "string", "<code>trueOrFalse(false)</code> should return a string");'
|
||||
- text: ' <code>trueOrFalse(true)</code> debe devolver "Sí, eso fue cierto"'
|
||||
- text: ' <code>trueOrFalse(true)</code> debe devolver "Sí, eso fue cierto"'
|
||||
testString: 'assert(trueOrFalse(true) === "Yes, that was true", "<code>trueOrFalse(true)</code> should return "Yes, that was true"");'
|
||||
- text: ' <code>trueOrFalse(false)</code> debe devolver "No, eso fue falso"'
|
||||
- text: ' <code>trueOrFalse(false)</code> debe devolver "No, eso fue falso"'
|
||||
testString: 'assert(trueOrFalse(false) === "No, that was false", "<code>trueOrFalse(false)</code> should return "No, that was false"");'
|
||||
|
||||
```
|
||||
|
||||
@@ -6,19 +6,19 @@ challengeType: 1
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
El <dfn>operador condicional</dfn> , también llamado <dfn>operador ternario</dfn> , se puede usar como una expresión de una línea si-else.
|
||||
La sintaxis es:
|
||||
<code>condition ? statement-if-true : statement-if-false;</code>
|
||||
La siguiente función utiliza una instrucción if-else para verificar una condición:
|
||||
<blockquote>function findGreater(a, b) {<br> if(a > b) {<br> return "a is greater";<br> }<br> else {<br> return "b is greater";<br> }<br>}</blockquote>
|
||||
Esto se puede reescribir usando el <code>conditional operator</code> :
|
||||
<blockquote>function findGreater(a, b) {<br> return a > b ? "a is greater" : "b is greater";<br>}</blockquote>
|
||||
<section id='description'>
|
||||
El <dfn>operador condicional</dfn> , también llamado <dfn>operador ternario</dfn> , se puede usar como una expresión de una línea si-else.
|
||||
La sintaxis es:
|
||||
<code>condition ? statement-if-true : statement-if-false;</code>
|
||||
La siguiente función utiliza una instrucción if-else para verificar una condición:
|
||||
<blockquote>function findGreater(a, b) {<br> if(a > b) {<br> return "a is greater";<br> }<br> else {<br> return "b is greater";<br> }<br>}</blockquote>
|
||||
Esto se puede reescribir usando el <code>conditional operator</code> :
|
||||
<blockquote>function findGreater(a, b) {<br> return a > b ? "a is greater" : "b is greater";<br>}</blockquote>
|
||||
</section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
Use el <code>conditional operator</code> en la función <code>checkEqual</code> para verificar si dos números son iguales o no. La función debe devolver verdadero o falso.
|
||||
<section id='instructions'>
|
||||
Use el <code>conditional operator</code> en la función <code>checkEqual</code> para verificar si dos números son iguales o no. La función debe devolver verdadero o falso.
|
||||
</section>
|
||||
|
||||
## Tests
|
||||
@@ -28,11 +28,11 @@ Use el <code>conditional operator</code> en la función <code>checkEqual</code>
|
||||
tests:
|
||||
- text: <code>checkEqual</code> debe usar el <code>conditional operator</code>
|
||||
testString: 'assert(/.+?\s*?\?\s*?.+?\s*?:\s*?.+?/gi.test(code), "<code>checkEqual</code> should use the <code>conditional operator</code>");'
|
||||
- text: ' <code>checkEqual(1, 2)</code> debe devolver falso'
|
||||
- text: ' <code>checkEqual(1, 2)</code> debe devolver falso'
|
||||
testString: 'assert(checkEqual(1, 2) === false, "<code>checkEqual(1, 2)</code> should return false");'
|
||||
- text: ' <code>checkEqual(1, 1)</code> debe devolver verdadero'
|
||||
- text: ' <code>checkEqual(1, 1)</code> debe devolver verdadero'
|
||||
testString: 'assert(checkEqual(1, 1) === true, "<code>checkEqual(1, 1)</code> should return true");'
|
||||
- text: ' <code>checkEqual(1, -1)</code> debe devolver falso'
|
||||
- text: ' <code>checkEqual(1, -1)</code> debe devolver falso'
|
||||
testString: 'assert(checkEqual(1, -1) === false, "<code>checkEqual(1, -1)</code> should return false");'
|
||||
|
||||
```
|
||||
|
||||
@@ -6,15 +6,15 @@ challengeType: 1
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
objetos pueden considerarse como un almacenamiento de clave / valor, como un diccionario. Si tiene datos tabulares, puede usar un objeto para "buscar" valores en lugar de una instrucción <code>switch</code> o una cadena <code>if/else</code> . Esto es más útil cuando sabe que sus datos de entrada están limitados a un cierto rango.
|
||||
Aquí hay un ejemplo de una búsqueda de alfabeto inversa simple:
|
||||
<blockquote>var alpha = {<br> 1:"Z",<br> 2:"Y",<br> 3:"X",<br> 4:"W",<br> ...<br> 24:"C",<br> 25:"B",<br> 26:"A"<br>};<br>alpha[2]; // "Y"<br>alpha[24]; // "C"<br><br>var value = 2;<br>alpha[value]; // "Y"</blockquote>
|
||||
<section id='description'>
|
||||
objetos pueden considerarse como un almacenamiento de clave / valor, como un diccionario. Si tiene datos tabulares, puede usar un objeto para "buscar" valores en lugar de una instrucción <code>switch</code> o una cadena <code>if/else</code> . Esto es más útil cuando sabe que sus datos de entrada están limitados a un cierto rango.
|
||||
Aquí hay un ejemplo de una búsqueda de alfabeto inversa simple:
|
||||
<blockquote>var alpha = {<br> 1:"Z",<br> 2:"Y",<br> 3:"X",<br> 4:"W",<br> ...<br> 24:"C",<br> 25:"B",<br> 26:"A"<br>};<br>alpha[2]; // "Y"<br>alpha[24]; // "C"<br><br>var value = 2;<br>alpha[value]; // "Y"</blockquote>
|
||||
</section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
Convertir la instrucción switch en un objeto llamado <code>lookup</code> . Úselo para buscar <code>val</code> y asignar la cadena asociada a la variable de <code>result</code> .
|
||||
<section id='instructions'>
|
||||
Convertir la instrucción switch en un objeto llamado <code>lookup</code> . Úselo para buscar <code>val</code> y asignar la cadena asociada a la variable de <code>result</code> .
|
||||
</section>
|
||||
|
||||
## Tests
|
||||
@@ -38,7 +38,7 @@ tests:
|
||||
testString: 'assert(typeof phoneticLookup("") === "undefined", "<code>phoneticLookup("")</code> should equal <code>undefined</code>");'
|
||||
- text: No debes modificar la declaración de <code>return</code> .
|
||||
testString: 'assert(code.match(/return\sresult;/), "You should not modify the <code>return</code> statement");'
|
||||
- text: 'No debe usar <code>case</code> , <code>switch</code> , o <code>if</code> declaraciones'
|
||||
- text: 'No debe usar <code>case</code> , <code>switch</code> , o <code>if</code> declaraciones'
|
||||
testString: 'assert(!/case|switch|if/g.test(code.replace(/([/]{2}.*)|([/][*][^/*]*[*][/])/g,"")), "You should not use <code>case</code>, <code>switch</code>, or <code>if</code> statements"); '
|
||||
|
||||
```
|
||||
|
||||
@@ -6,18 +6,18 @@ challengeType: 1
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
Ahora usaremos nuestro conocimiento de cuerdas para construir un juego de palabras al estilo de " <a href='https://en.wikipedia.org/wiki/Mad_Libs' target='_blank'>Mad Libs</a> " que llamamos "Word Blanks". Creará una oración estilo "Rellene los espacios en blanco" (opcionalmente humorística).
|
||||
En un juego de "Mad Libs", se te proporcionan frases con algunas palabras faltantes, como sustantivos, verbos, adjetivos y adverbios. Luego, completa las piezas faltantes con las palabras que elijas de manera que la oración completa tenga sentido.
|
||||
Considere esta oración: "Fue realmente <strong>____</strong> , y nosotros <strong>____</strong> nosotros <strong>____</strong> ". Esta oración tiene tres partes faltantes: un adjetivo, un verbo y un adverbio, y podemos agregar palabras de nuestra elección para completarla. Luego podemos asignar la oración completa a una variable de la siguiente manera:
|
||||
<blockquote>var sentence = "It was really" + "hot" + ", and we" + "laughed" + "ourselves" + "silly.";</blockquote>
|
||||
<section id='description'>
|
||||
Ahora usaremos nuestro conocimiento de cuerdas para construir un juego de palabras al estilo de " <a href='https://en.wikipedia.org/wiki/Mad_Libs' target='_blank'>Mad Libs</a> " que llamamos "Word Blanks". Creará una oración estilo "Rellene los espacios en blanco" (opcionalmente humorística).
|
||||
En un juego de "Mad Libs", se te proporcionan frases con algunas palabras faltantes, como sustantivos, verbos, adjetivos y adverbios. Luego, completa las piezas faltantes con las palabras que elijas de manera que la oración completa tenga sentido.
|
||||
Considere esta oración: "Fue realmente <strong>____</strong> , y nosotros <strong>____</strong> nosotros <strong>____</strong> ". Esta oración tiene tres partes faltantes: un adjetivo, un verbo y un adverbio, y podemos agregar palabras de nuestra elección para completarla. Luego podemos asignar la oración completa a una variable de la siguiente manera:
|
||||
<blockquote>var sentence = "It was really" + "hot" + ", and we" + "laughed" + "ourselves" + "silly.";</blockquote>
|
||||
</section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
En este desafío, le proporcionamos un sustantivo, un verbo, un adjetivo y un adverbio. Debe formar una oración completa con las palabras de su elección, junto con las palabras que proporcionamos.
|
||||
Necesitará utilizar el operador de concatenación de cadenas <code>+</code> para crear una nueva cadena, utilizando las variables proporcionadas: <code>myNoun</code> , <code>myAdjective</code> , <code>myVerb</code> y <code>myAdverb</code> . A continuación, asignará la cadena formada a la variable de <code>result</code> .
|
||||
También deberá tener en cuenta los espacios en su cadena, de modo que la oración final tenga espacios entre todas las palabras. El resultado debe ser una oración completa.
|
||||
<section id='instructions'>
|
||||
En este desafío, le proporcionamos un sustantivo, un verbo, un adjetivo y un adverbio. Debe formar una oración completa con las palabras de su elección, junto con las palabras que proporcionamos.
|
||||
Necesitará utilizar el operador de concatenación de cadenas <code>+</code> para crear una nueva cadena, utilizando las variables proporcionadas: <code>myNoun</code> , <code>myAdjective</code> , <code>myVerb</code> y <code>myAdverb</code> . A continuación, asignará la cadena formada a la variable de <code>result</code> .
|
||||
También deberá tener en cuenta los espacios en su cadena, de modo que la oración final tenga espacios entre todas las palabras. El resultado debe ser una oración completa.
|
||||
</section>
|
||||
|
||||
## Tests
|
||||
@@ -25,11 +25,11 @@ También deberá tener en cuenta los espacios en su cadena, de modo que la oraci
|
||||
|
||||
```yml
|
||||
tests:
|
||||
- text: ' <code>wordBlanks("","","","")</code> debe devolver una cadena.'
|
||||
- text: '<code>wordBlanks("","","","")</code> debe devolver una cadena.'
|
||||
testString: 'assert(typeof wordBlanks("","","","") === "string", "<code>wordBlanks("","","","")</code> should return a string.");'
|
||||
- text: ' <code>wordBlanks("dog", "big", "ran", "quickly")</code> debe contener todas las palabras pasadas separadas por caracteres que no sean de palabras (y cualquier palabra adicional en su libreta).
|
||||
- text: '<code>wordBlanks("dog", "big", "ran", "quickly")</code> debe contener todas las palabras pasadas separadas por caracteres que no sean de palabras (y cualquier palabra adicional en su libreta).'
|
||||
testString: 'assert(/\bdog\b/.test(test1) && /\bbig\b/.test(test1) && /\bran\b/.test(test1) && /\bquickly\b/.test(test1),"<code>wordBlanks("dog", "big", "ran", "quickly")</code> should contain all of the passed in words separated by non-word characters (and any additional words in your madlib).");'
|
||||
- text: ' <code>wordBlanks("cat", "little", "hit", "slowly")</code> debe contener todas las palabras pasadas separadas por caracteres que no sean de palabras (y cualquier otra palabra adicional en su madlib).
|
||||
- text: ' <code>wordBlanks("cat", "little", "hit", "slowly")</code> debe contener todas las palabras pasadas separadas por caracteres que no sean de palabras (y cualquier otra palabra adicional en su madlib).'
|
||||
testString: 'assert(/\bcat\b/.test(test2) && /\blittle\b/.test(test2) && /\bhit\b/.test(test2) && /\bslowly\b/.test(test2),"<code>wordBlanks("cat", "little", "hit", "slowly")</code> should contain all of the passed in words separated by non-word characters (and any additional words in your madlib).");'
|
||||
|
||||
```
|
||||
|
||||
@@ -6,13 +6,13 @@ challengeType: 1
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
Continuando con la discusión sobre las funciones de llamada, el siguiente error a tener en cuenta es cuando los argumentos de una función se suministran en el orden incorrecto. Si los argumentos son de tipos diferentes, como una función que espera una matriz y un entero, es probable que se produzca un error de tiempo de ejecución. Si los argumentos son del mismo tipo (todos los enteros, por ejemplo), entonces la lógica del código no tendrá sentido. Asegúrese de proporcionar todos los argumentos necesarios, en el orden correcto para evitar estos problemas.
|
||||
<section id='description'>
|
||||
Continuando con la discusión sobre las funciones de llamada, el siguiente error a tener en cuenta es cuando los argumentos de una función se suministran en el orden incorrecto. Si los argumentos son de tipos diferentes, como una función que espera una matriz y un entero, es probable que se produzca un error de tiempo de ejecución. Si los argumentos son del mismo tipo (todos los enteros, por ejemplo), entonces la lógica del código no tendrá sentido. Asegúrese de proporcionar todos los argumentos necesarios, en el orden correcto para evitar estos problemas.
|
||||
</section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
La función <code>raiseToPower</code> eleva una base a un exponente. Desafortunadamente, no se llama correctamente: repare el código para que el valor de la <code>power</code> sea el esperado 8.
|
||||
<section id='instructions'>
|
||||
La función <code>raiseToPower</code> eleva una base a un exponente. Desafortunadamente, no se llama correctamente: repare el código para que el valor de la <code>power</code> sea el esperado 8.
|
||||
</section>
|
||||
|
||||
## Tests
|
||||
@@ -20,7 +20,7 @@ La función <code>raiseToPower</code> eleva una base a un exponente. Desafortuna
|
||||
|
||||
```yml
|
||||
tests:
|
||||
- text: 'Su código debería fijar la <code>power</code> variable de modo que sea igual a 2 elevado a la tercera potencia, no 3 elevado a la segunda potencia'.
|
||||
- text: 'Su código debería fijar la <code>power</code> variable de modo que sea igual a 2 elevado a la tercera potencia, no 3 elevado a la segunda potencia'
|
||||
testString: 'assert(power == 8, "Your code should fix the variable <code>power</code> so it equals 2 raised to the 3rd power, not 3 raised to the 2nd power.");'
|
||||
- text: Su código debe usar el orden correcto de los argumentos para la <code>raiseToPower</code> función <code>raiseToPower</code> .
|
||||
testString: 'assert(code.match(/raiseToPower\(\s*?base\s*?,\s*?exp\s*?\);/g), "Your code should use the correct order of the arguments for the <code>raiseToPower</code> function call.");'
|
||||
|
||||
@@ -6,14 +6,14 @@ challengeType: 1
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
<code>console.log()</code> y los métodos de <code>typeof</code> son las dos formas principales de verificar los valores intermedios y los tipos de salida del programa. Ahora es el momento de entrar en las formas comunes que toman los errores. Un problema de nivel de sintaxis con el que los usuarios rápidos pueden compadecerse es el humilde error de ortografía.
|
||||
transpuestos, faltantes o mal colocados en una variable o nombre de función harán que el navegador busque un objeto que no existe, y se quejen en forma de un error de referencia. Las variables de JavaScript y los nombres de funciones distinguen entre mayúsculas y minúsculas.
|
||||
<section id='description'>
|
||||
<code>console.log()</code> y los métodos de <code>typeof</code> son las dos formas principales de verificar los valores intermedios y los tipos de salida del programa. Ahora es el momento de entrar en las formas comunes que toman los errores. Un problema de nivel de sintaxis con el que los usuarios rápidos pueden compadecerse es el humilde error de ortografía.
|
||||
transpuestos, faltantes o mal colocados en una variable o nombre de función harán que el navegador busque un objeto que no existe, y se quejen en forma de un error de referencia. Las variables de JavaScript y los nombres de funciones distinguen entre mayúsculas y minúsculas.
|
||||
</section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
Corrija los dos errores de ortografía en el código para que <code>netWorkingCapital</code> cálculo de <code>netWorkingCapital</code> .
|
||||
<section id='instructions'>
|
||||
Corrija los dos errores de ortografía en el código para que <code>netWorkingCapital</code> cálculo de <code>netWorkingCapital</code> .
|
||||
</section>
|
||||
|
||||
## Tests
|
||||
@@ -21,7 +21,7 @@ Corrija los dos errores de ortografía en el código para que <code>netWorkingCa
|
||||
|
||||
```yml
|
||||
tests:
|
||||
- text: 'Verifique la ortografía de las dos variables utilizadas en el cálculo de netWorkingCapital, la salida de la consola debe mostrar que "El capital de trabajo neto es: 2".
|
||||
- text: 'Verifique la ortografía de las dos variables utilizadas en el cálculo de netWorkingCapital, la salida de la consola debe mostrar que "El capital de trabajo neto es: 2."
|
||||
testString: 'assert(netWorkingCapital === 2, "Check the spelling of the two variables used in the netWorkingCapital calculation, the console output should show that "Net working capital is: 2".");'
|
||||
- text: No debe haber instancias de variables mal escritas en el código.
|
||||
testString: 'assert(!code.match(/recievables/g), "There should be no instances of mis-spelled variables in the code.");'
|
||||
|
||||
@@ -6,18 +6,18 @@ challengeType: 1
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
JavaScript permite el uso de comillas simples (") y dobles (" ") para declarar una cadena. Decidir cuál usar generalmente se reduce a preferencias personales, con algunas excepciones.
|
||||
Tener dos opciones es excelente cuando una cadena tiene contracciones u otro fragmento de texto entre comillas. Solo tenga cuidado de no cerrar la cadena demasiado pronto, lo que provoca un error de sintaxis.
|
||||
Aquí hay algunos ejemplos de comillas de mezcla:
|
||||
<blockquote>// These are correct:<br>const grouchoContraction = "I've had a perfectly wonderful evening, but this wasn't it.";<br>const quoteInString = "Groucho Marx once said 'Quote me as saying I was mis-quoted.'";<br>// This is incorrect:<br>const uhOhGroucho = 'I've had a perfectly wonderful evening, but this wasn't it.';</blockquote>
|
||||
Por supuesto, está bien usar solo un estilo de citas. Puede escapar de las comillas dentro de la cadena usando el carácter de escape de barra invertida (\):
|
||||
<blockquote>// Correct use of same quotes:<br>const allSameQuotes = 'I\'ve had a perfectly wonderful evening, but this wasn\'t it.';</blockquote>
|
||||
<section id='description'>
|
||||
JavaScript permite el uso de comillas simples (") y dobles (" ") para declarar una cadena. Decidir cuál usar generalmente se reduce a preferencias personales, con algunas excepciones.
|
||||
Tener dos opciones es excelente cuando una cadena tiene contracciones u otro fragmento de texto entre comillas. Solo tenga cuidado de no cerrar la cadena demasiado pronto, lo que provoca un error de sintaxis.
|
||||
Aquí hay algunos ejemplos de comillas de mezcla:
|
||||
<blockquote>// These are correct:<br>const grouchoContraction = "I've had a perfectly wonderful evening, but this wasn't it.";<br>const quoteInString = "Groucho Marx once said 'Quote me as saying I was mis-quoted.'";<br>// This is incorrect:<br>const uhOhGroucho = 'I've had a perfectly wonderful evening, but this wasn't it.';</blockquote>
|
||||
Por supuesto, está bien usar solo un estilo de citas. Puede escapar de las comillas dentro de la cadena usando el carácter de escape de barra invertida (\):
|
||||
<blockquote>// Correct use of same quotes:<br>const allSameQuotes = 'I\'ve had a perfectly wonderful evening, but this wasn\'t it.';</blockquote>
|
||||
</section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
Arregle la cadena para que use comillas diferentes para el valor <code>href</code> , o escape de las existentes. Mantenga las comillas dobles alrededor de toda la cadena.
|
||||
<section id='instructions'>
|
||||
Arregle la cadena para que use comillas diferentes para el valor <code>href</code> , o escape de las existentes. Mantenga las comillas dobles alrededor de toda la cadena.
|
||||
</section>
|
||||
|
||||
## Tests
|
||||
@@ -25,7 +25,7 @@ Arregle la cadena para que use comillas diferentes para el valor <code>href</cod
|
||||
|
||||
```yml
|
||||
tests:
|
||||
- text: 'Tu código debe corregir las comillas alrededor del valor <code>href</code> "#Home", ya sea cambiándolos o escapándolos.'
|
||||
- text: 'Tu código debe corregir las comillas alrededor del valor <code>href</code> "#Home", ya sea cambiándolos o escapándolos.'
|
||||
testString: 'assert(code.match(/<a href=\s*?("|\\")#Home\1\s*?>/g), "Your code should fix the quotes around the <code>href</code> value "#Home" by either changing or escaping them.");'
|
||||
- text: Su código debe mantener las comillas dobles alrededor de toda la cadena.
|
||||
testString: 'assert(code.match(/"<p>.*?<\/p>";/g), "Your code should keep the double quotes around the entire string.");'
|
||||
|
||||
@@ -6,14 +6,14 @@ challengeType: 1
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
Otro error de sintaxis a tener en cuenta es que todos los paréntesis de apertura, paréntesis, llaves y comillas tienen un par de cierre. El olvido de una pieza suele suceder cuando edita el código existente e inserta elementos con uno de los tipos de pares. Además, tenga cuidado al anidar bloques de código en otros, como agregar una función de devolución de llamada como un argumento a un método.
|
||||
Una forma de evitar este error es tan pronto como se escribe el carácter de apertura, incluya inmediatamente la coincidencia de cierre, luego mueva el cursor entre ellos y continúe la codificación. Afortunadamente, la mayoría de los editores de código modernos generan la segunda mitad del par automáticamente.
|
||||
<section id='description'>
|
||||
Otro error de sintaxis a tener en cuenta es que todos los paréntesis de apertura, paréntesis, llaves y comillas tienen un par de cierre. El olvido de una pieza suele suceder cuando edita el código existente e inserta elementos con uno de los tipos de pares. Además, tenga cuidado al anidar bloques de código en otros, como agregar una función de devolución de llamada como un argumento a un método.
|
||||
Una forma de evitar este error es tan pronto como se escribe el carácter de apertura, incluya inmediatamente la coincidencia de cierre, luego mueva el cursor entre ellos y continúe la codificación. Afortunadamente, la mayoría de los editores de código modernos generan la segunda mitad del par automáticamente.
|
||||
</section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
Arreglar los errores de dos pares en el código.
|
||||
<section id='instructions'>
|
||||
Arreglar los errores de dos pares en el código.
|
||||
</section>
|
||||
|
||||
## Tests
|
||||
@@ -23,7 +23,7 @@ Arreglar los errores de dos pares en el código.
|
||||
tests:
|
||||
- text: Tu código debería arreglar la pieza faltante de la matriz.
|
||||
testString: 'assert(code.match(/myArray\s*?=\s*?\[\s*?1\s*?,\s*?2\s*?,\s*?3\s*?\];/g), "Your code should fix the missing piece of the array.");'
|
||||
- text: 'Su código debe arreglar la pieza faltante del método <code clase = "notranslate">. Reduce () </code>. La salida de la consola debería mostrar que "la suma de los valores de la matriz es: 6".
|
||||
- text: 'Su código debe arreglar la pieza faltante del método <code clase = "notranslate">. Reduce () </code>. La salida de la consola debería mostrar que "la suma de los valores de la matriz es: 6."
|
||||
testString: 'assert(arraySum === 6, "Your code should fix the missing piece of the <code>.reduce()</code> method. The console output should show that "Sum of array values is: 6".");'
|
||||
|
||||
```
|
||||
|
||||
@@ -6,17 +6,17 @@ challengeType: 1
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
Los programas de derivación, es decir, los que hacen cosas diferentes si se cumplen ciertas condiciones, dependen de las declaraciones <code>if</code> , <code>else if</code> , y <code>else</code> en JavaScript. La condición a veces toma la forma de probar si un resultado es igual a un valor.
|
||||
Esta lógica se habla (en inglés, al menos) como "si x es igual a y, entonces ..." que puede traducirse literalmente en código usando el operador <code>=</code> , o asignación. Esto conduce a un flujo de control inesperado en su programa.
|
||||
Como se cubrió en desafíos anteriores, el operador de asignación ( <code>=</code> ) en JavaScript asigna un valor a un nombre de variable. Y los operadores <code>==</code> y <code>===</code> verifican la igualdad (las pruebas triples <code>===</code> para la igualdad estricta, lo que significa que tanto el valor como el tipo son iguales).
|
||||
El siguiente código asigna <code>x</code> para ser 2, que se evalúa como <code>true</code> . Casi todos los valores en JavaScript se evalúan como <code>true</code> , excepto lo que se conoce como valores "falsos": <code>false</code> , <code>0</code> , <code>""</code> (una cadena vacía), <code>NaN</code> , <code>undefined</code> y <code>null</code> .
|
||||
<blockquote>let x = 1;<br>let y = 2;<br>if (x = y) {<br> // this code block will run for any value of y (unless y were originally set as a falsy)<br>} else {<br> // this code block is what should run (but won't) in this example<br>}</blockquote>
|
||||
<section id='description'>
|
||||
Los programas de derivación, es decir, los que hacen cosas diferentes si se cumplen ciertas condiciones, dependen de las declaraciones <code>if</code> , <code>else if</code> , y <code>else</code> en JavaScript. La condición a veces toma la forma de probar si un resultado es igual a un valor.
|
||||
Esta lógica se habla (en inglés, al menos) como "si x es igual a y, entonces ..." que puede traducirse literalmente en código usando el operador <code>=</code> , o asignación. Esto conduce a un flujo de control inesperado en su programa.
|
||||
Como se cubrió en desafíos anteriores, el operador de asignación ( <code>=</code> ) en JavaScript asigna un valor a un nombre de variable. Y los operadores <code>==</code> y <code>===</code> verifican la igualdad (las pruebas triples <code>===</code> para la igualdad estricta, lo que significa que tanto el valor como el tipo son iguales).
|
||||
El siguiente código asigna <code>x</code> para ser 2, que se evalúa como <code>true</code> . Casi todos los valores en JavaScript se evalúan como <code>true</code> , excepto lo que se conoce como valores "falsos": <code>false</code> , <code>0</code> , <code>""</code> (una cadena vacía), <code>NaN</code> , <code>undefined</code> y <code>null</code> .
|
||||
<blockquote>let x = 1;<br>let y = 2;<br>if (x = y) {<br> // this code block will run for any value of y (unless y were originally set as a falsy)<br>} else {<br> // this code block is what should run (but won't) in this example<br>}</blockquote>
|
||||
</section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
Corrija la condición para que el programa ejecute la rama derecha y se asigne el valor apropiado al <code>result</code> .
|
||||
<section id='instructions'>
|
||||
Corrija la condición para que el programa ejecute la rama derecha y se asigne el valor apropiado al <code>result</code> .
|
||||
</section>
|
||||
|
||||
## Tests
|
||||
@@ -24,7 +24,7 @@ Corrija la condición para que el programa ejecute la rama derecha y se asigne e
|
||||
|
||||
```yml
|
||||
tests:
|
||||
- text: 'Tu código debería arreglar la condición para que verifique la igualdad, en lugar de usar la asignación'.
|
||||
- text: 'Tu código debería arreglar la condición para que verifique la igualdad, en lugar de usar la asignación'
|
||||
testString: 'assert(result == "Not equal!", "Your code should fix the condition so it checks for equality, instead of using assignment.");'
|
||||
- text: La condición puede usar <code class = "notranslate"> == </code> o <code class = "notranslate"> === </code> para probar la igualdad.
|
||||
testString: 'assert(code.match(/x\s*?===?\s*?y/g), "The condition can use either <code>==</code> or <code>===</code> to test for equality.");'
|
||||
|
||||
@@ -6,17 +6,17 @@ challengeType: 1
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
La declaración <code>const</code> tiene muchos casos de uso en JavaScript moderno.
|
||||
Algunos desarrolladores prefieren asignar todas sus variables usando <code>const</code> de forma predeterminada, a menos que sepan que deberán reasignar el valor. Solo en ese caso, usan <code>let</code> .
|
||||
Sin embargo, es importante comprender que los objetos (incluidas las matrices y las funciones) asignados a una variable que usa <code>const</code> todavía son mutables. El uso de la declaración <code>const</code> solo evita la reasignación del identificador de variable.
|
||||
<blockquote>"use strict";<br>const s = [5, 6, 7];<br>s = [1, 2, 3]; // throws error, trying to assign a const<br>s[2] = 45; // works just as it would with an array declared with var or let<br>console.log(s); // returns [5, 6, 45]</blockquote>
|
||||
Como puede ver, puede mutar el objeto <code>[5, 6, 7]</code> sí mismo y la variable <code>s</code> seguirá apuntando a la matriz alterada <code>[5, 6, 45]</code> . Al igual que todas las matrices, los elementos de la matriz en <code>s</code> son mutables, pero debido a que se utilizó <code>const</code> , no puede usar el identificador de la variable <code>s</code> para apuntar a una matriz diferente mediante el operador de asignación.
|
||||
<section id='description'>
|
||||
La declaración <code>const</code> tiene muchos casos de uso en JavaScript moderno.
|
||||
Algunos desarrolladores prefieren asignar todas sus variables usando <code>const</code> de forma predeterminada, a menos que sepan que deberán reasignar el valor. Solo en ese caso, usan <code>let</code> .
|
||||
Sin embargo, es importante comprender que los objetos (incluidas las matrices y las funciones) asignados a una variable que usa <code>const</code> todavía son mutables. El uso de la declaración <code>const</code> solo evita la reasignación del identificador de variable.
|
||||
<blockquote>"use strict";<br>const s = [5, 6, 7];<br>s = [1, 2, 3]; // throws error, trying to assign a const<br>s[2] = 45; // works just as it would with an array declared with var or let<br>console.log(s); // returns [5, 6, 45]</blockquote>
|
||||
Como puede ver, puede mutar el objeto <code>[5, 6, 7]</code> sí mismo y la variable <code>s</code> seguirá apuntando a la matriz alterada <code>[5, 6, 45]</code> . Al igual que todas las matrices, los elementos de la matriz en <code>s</code> son mutables, pero debido a que se utilizó <code>const</code> , no puede usar el identificador de la variable <code>s</code> para apuntar a una matriz diferente mediante el operador de asignación.
|
||||
</section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
Una matriz se declara como <code>const s = [5, 7, 2]</code> . Cambie la matriz a <code>[2, 5, 7]</code> usando varias asignaciones de elementos.
|
||||
<section id='instructions'>
|
||||
Una matriz se declara como <code>const s = [5, 7, 2]</code> . Cambie la matriz a <code>[2, 5, 7]</code> usando varias asignaciones de elementos.
|
||||
</section>
|
||||
|
||||
## Tests
|
||||
@@ -30,7 +30,7 @@ tests:
|
||||
testString: 'getUserInput => assert(getUserInput("index").match(/const\s+s/g), "<code>s</code> should be a constant variable (by using <code>const</code>).");'
|
||||
- text: No cambie la declaración original de la matriz.
|
||||
testString: 'getUserInput => assert(getUserInput("index").match(/const\s+s\s*=\s*\[\s*5\s*,\s*7\s*,\s*2\s*\]\s*;?/g), "Do not change the original array declaration.");'
|
||||
- text: ' <code>s</code> debe ser igual a <code>[2, 5, 7]</code> .'
|
||||
- text: ' <code>s</code> debe ser igual a <code>[2, 5, 7]</code> .'
|
||||
testString: 'assert.deepEqual(s, [2, 5, 7], "<code>s</code> should be equal to <code>[2, 5, 7]</code>.");'
|
||||
|
||||
```
|
||||
|
||||
@@ -6,16 +6,16 @@ challengeType: 1
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
Para ayudarnos a crear funciones más flexibles, ES6 introduce <dfn>parámetros predeterminados</dfn> para las funciones.
|
||||
Echa un vistazo a este código:
|
||||
<blockquote>function greeting(name = "Anonymous") {<br> return "Hello " + name;<br>}<br>console.log(greeting("John")); // Hello John<br>console.log(greeting()); // Hello Anonymous</blockquote>
|
||||
El parámetro predeterminado se activa cuando el argumento no está especificado (no está definido). Como puede ver en el ejemplo anterior, el <code>name</code> del parámetro recibirá su valor predeterminado <code>"Anonymous"</code> cuando no proporcione un valor para el parámetro. Puede agregar valores predeterminados para tantos parámetros como desee.
|
||||
<section id='description'>
|
||||
Para ayudarnos a crear funciones más flexibles, ES6 introduce <dfn>parámetros predeterminados</dfn> para las funciones.
|
||||
Echa un vistazo a este código:
|
||||
<blockquote>function greeting(name = "Anonymous") {<br> return "Hello " + name;<br>}<br>console.log(greeting("John")); // Hello John<br>console.log(greeting()); // Hello Anonymous</blockquote>
|
||||
El parámetro predeterminado se activa cuando el argumento no está especificado (no está definido). Como puede ver en el ejemplo anterior, el <code>name</code> del parámetro recibirá su valor predeterminado <code>"Anonymous"</code> cuando no proporcione un valor para el parámetro. Puede agregar valores predeterminados para tantos parámetros como desee.
|
||||
</section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
Modifique el <code>increment</code> la función agregando parámetros predeterminados para que agregue 1 al <code>number</code> si no se especifica el <code>value</code> .
|
||||
<section id='instructions'>
|
||||
Modifique el <code>increment</code> la función agregando parámetros predeterminados para que agregue 1 al <code>number</code> si no se especifica el <code>value</code> .
|
||||
</section>
|
||||
|
||||
## Tests
|
||||
@@ -23,7 +23,7 @@ Modifique el <code>increment</code> la función agregando parámetros predetermi
|
||||
|
||||
```yml
|
||||
tests:
|
||||
- text: 'El resultado del <code>increment(5, 2)</code> debe ser <code>7</code> '.
|
||||
- text: 'El resultado del <code>increment(5, 2)</code> debe ser <code>7</code> '
|
||||
testString: 'assert(increment(5, 2) === 7, "The result of <code>increment(5, 2)</code> should be <code>7</code>.");'
|
||||
- text: El resultado del <code>increment(5)</code> debe ser <code>6</code> .
|
||||
testString: 'assert(increment(5) === 6, "The result of <code>increment(5)</code> should be <code>6</code>.");'
|
||||
|
||||
@@ -6,19 +6,19 @@ challengeType: 1
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
ES6 hace que la desestructuración de matrices sea tan fácil como desestructurar objetos.
|
||||
Una diferencia clave entre el operador de propagación y la desestructuración de matrices es que el operador de propagación desempaqueta todo el contenido de una matriz en una lista separada por comas. Por consiguiente, no puede seleccionar o elegir qué elementos desea asignar a las variables.
|
||||
destrucción de una matriz nos permite hacer exactamente eso:
|
||||
<blockquote>const [a, b] = [1, 2, 3, 4, 5, 6];<br>console.log(a, b); // 1, 2</blockquote>
|
||||
A la variable <code>a</code> se le asigna el primer valor de la matriz, <code>b</code> se le asigna el segundo valor de la matriz.
|
||||
También podemos acceder al valor en cualquier índice en una matriz con desestructuración usando comas para alcanzar el índice deseado:
|
||||
<blockquote>const [a, b,,, c] = [1, 2, 3, 4, 5, 6];<br>console.log(a, b, c); // 1, 2, 5 </blockquote>
|
||||
<section id='description'>
|
||||
ES6 hace que la desestructuración de matrices sea tan fácil como desestructurar objetos.
|
||||
Una diferencia clave entre el operador de propagación y la desestructuración de matrices es que el operador de propagación desempaqueta todo el contenido de una matriz en una lista separada por comas. Por consiguiente, no puede seleccionar o elegir qué elementos desea asignar a las variables.
|
||||
destrucción de una matriz nos permite hacer exactamente eso:
|
||||
<blockquote>const [a, b] = [1, 2, 3, 4, 5, 6];<br>console.log(a, b); // 1, 2</blockquote>
|
||||
A la variable <code>a</code> se le asigna el primer valor de la matriz, <code>b</code> se le asigna el segundo valor de la matriz.
|
||||
También podemos acceder al valor en cualquier índice en una matriz con desestructuración usando comas para alcanzar el índice deseado:
|
||||
<blockquote>const [a, b,,, c] = [1, 2, 3, 4, 5, 6];<br>console.log(a, b, c); // 1, 2, 5 </blockquote>
|
||||
</section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
Use la asignación de desestructuración para intercambiar los valores de <code>a</code> y <code>b</code> modo que <code>a</code> reciba el valor almacenado en <code>b</code> , y <code>b</code> reciba el valor almacenado en <code>a</code> .
|
||||
<section id='instructions'>
|
||||
Use la asignación de desestructuración para intercambiar los valores de <code>a</code> y <code>b</code> modo que <code>a</code> reciba el valor almacenado en <code>b</code> , y <code>b</code> reciba el valor almacenado en <code>a</code> .
|
||||
</section>
|
||||
|
||||
## Tests
|
||||
@@ -26,9 +26,9 @@ Use la asignación de desestructuración para intercambiar los valores de <code>
|
||||
|
||||
```yml
|
||||
tests:
|
||||
- text: 'El valor de <code>a</code> debe ser 6, después del intercambio.'
|
||||
- text: 'El valor de <code>a</code> debe ser 6, después del intercambio.'
|
||||
testString: 'assert(a === 6, "Value of <code>a</code> should be 6, after swapping.");'
|
||||
- text: 'El valor de <code>b</code> debería ser 8, después del intercambio.'
|
||||
- text: 'El valor de <code>b</code> debería ser 8, después del intercambio.'
|
||||
testString: 'assert(b === 8, "Value of <code>b</code> should be 8, after swapping.");'
|
||||
- text: Utilice la desestructuración de matrices para intercambiar a y b.
|
||||
testString: '// assert(/\[\s*(\w)\s*,\s*(\w)\s*\]\s*=\s*\[\s*\2\s*,\s*\1\s*\]/g.test(code), "Use array destructuring to swap a and b.");'
|
||||
|
||||
@@ -6,17 +6,17 @@ challengeType: 1
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
En algunas situaciones que involucran la desestructuración de matrices, podríamos querer recopilar el resto de los elementos en una matriz separada.
|
||||
El resultado es similar a <code>Array.prototype.slice()</code> , como se muestra a continuación:
|
||||
<blockquote>const [a, b, ...arr] = [1, 2, 3, 4, 5, 7];<br>console.log(a, b); // 1, 2<br>console.log(arr); // [3, 4, 5, 7]</blockquote>
|
||||
Las variables <code>a</code> y <code>b</code> toman los valores primero y segundo de la matriz. Después de eso, debido a la presencia del operador en reposo, <code>arr</code> obtiene el resto de los valores en forma de una matriz.
|
||||
El elemento resto solo funciona correctamente como la última variable en la lista. Como en, no puede usar el operador de descanso para capturar un subarreglo que omita el último elemento de la matriz original.
|
||||
<section id='description'>
|
||||
En algunas situaciones que involucran la desestructuración de matrices, podríamos querer recopilar el resto de los elementos en una matriz separada.
|
||||
El resultado es similar a <code>Array.prototype.slice()</code> , como se muestra a continuación:
|
||||
<blockquote>const [a, b, ...arr] = [1, 2, 3, 4, 5, 7];<br>console.log(a, b); // 1, 2<br>console.log(arr); // [3, 4, 5, 7]</blockquote>
|
||||
Las variables <code>a</code> y <code>b</code> toman los valores primero y segundo de la matriz. Después de eso, debido a la presencia del operador en reposo, <code>arr</code> obtiene el resto de los valores en forma de una matriz.
|
||||
El elemento resto solo funciona correctamente como la última variable en la lista. Como en, no puede usar el operador de descanso para capturar un subarreglo que omita el último elemento de la matriz original.
|
||||
</section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
Use la asignación de desestructuración con el operador de descanso para realizar un <code>Array.prototype.slice()</code> efectivo de manera que <code>arr</code> sea una sub-matriz de la <code>source</code> de la matriz original con los dos primeros elementos omitidos.
|
||||
<section id='instructions'>
|
||||
Use la asignación de desestructuración con el operador de descanso para realizar un <code>Array.prototype.slice()</code> efectivo de manera que <code>arr</code> sea una sub-matriz de la <code>source</code> de la matriz original con los dos primeros elementos omitidos.
|
||||
</section>
|
||||
|
||||
## Tests
|
||||
@@ -24,7 +24,7 @@ Use la asignación de desestructuración con el operador de descanso para realiz
|
||||
|
||||
```yml
|
||||
tests:
|
||||
- text: ' <code>arr</code> debería ser <code>[3,4,5,6,7,8,9,10]</code> '
|
||||
- text: ' <code>arr</code> debería ser <code>[3,4,5,6,7,8,9,10]</code> '
|
||||
testString: 'assert(arr.every((v, i) => v === i + 3) && arr.length === 8,"<code>arr</code> should be <code>[3,4,5,6,7,8,9,10]</code>");'
|
||||
- text: Se debe utilizar la destrucción.
|
||||
testString: 'getUserInput => assert(getUserInput("index").match(/\[\s*\w*\s*,\s*\w*\s*,\s*...\w+\s*\]/g),"Destructuring should be used.");'
|
||||
|
||||
@@ -6,16 +6,16 @@ challengeType: 1
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
Para ayudarnos a crear funciones más flexibles, ES6 presenta al <dfn>operador de resto</dfn> para los parámetros de función. Con el operador resto, puede crear funciones que toman un número variable de argumentos. Estos argumentos se almacenan en una matriz a la que se puede acceder posteriormente desde dentro de la función.
|
||||
Echa un vistazo a este código:
|
||||
<blockquote>function howMany(...args) {<br> return "You have passed " + args.length + " arguments.";<br>}<br>console.log(howMany(0, 1, 2)); // You have passed 3 arguments<br>console.log(howMany("string", null, [1, 2, 3], { })); // You have passed 4 arguments.</blockquote>
|
||||
El operador restante elimina la necesidad de verificar la matriz de <code>args</code> y nos permite aplicar <code>map()</code> , <code>filter()</code> y <code>reduce()</code> en la matriz de parámetros.
|
||||
<section id='description'>
|
||||
Para ayudarnos a crear funciones más flexibles, ES6 presenta al <dfn>operador de resto</dfn> para los parámetros de función. Con el operador resto, puede crear funciones que toman un número variable de argumentos. Estos argumentos se almacenan en una matriz a la que se puede acceder posteriormente desde dentro de la función.
|
||||
Echa un vistazo a este código:
|
||||
<blockquote>function howMany(...args) {<br> return "You have passed " + args.length + " arguments.";<br>}<br>console.log(howMany(0, 1, 2)); // You have passed 3 arguments<br>console.log(howMany("string", null, [1, 2, 3], { })); // You have passed 4 arguments.</blockquote>
|
||||
El operador restante elimina la necesidad de verificar la matriz de <code>args</code> y nos permite aplicar <code>map()</code> , <code>filter()</code> y <code>reduce()</code> en la matriz de parámetros.
|
||||
</section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
Modifique la <code>sum</code> la función para que use el operador de descanso y funcione de la misma manera con cualquier número de parámetros.
|
||||
<section id='instructions'>
|
||||
Modifique la <code>sum</code> la función para que use el operador de descanso y funcione de la misma manera con cualquier número de parámetros.
|
||||
</section>
|
||||
|
||||
## Tests
|
||||
@@ -23,9 +23,9 @@ Modifique la <code>sum</code> la función para que use el operador de descanso y
|
||||
|
||||
```yml
|
||||
tests:
|
||||
- text: 'El resultado de la <code>sum(0,1,2)</code> debe ser 3'
|
||||
- text: 'El resultado de la <code>sum(0,1,2)</code> debe ser 3'
|
||||
testString: 'assert(sum(0,1,2) === 3, "The result of <code>sum(0,1,2)</code> should be 3");'
|
||||
- text: 'El resultado de la <code>sum(1,2,3,4)</code> debe ser 10'
|
||||
- text: 'El resultado de la <code>sum(1,2,3,4)</code> debe ser 10'
|
||||
testString: 'assert(sum(1,2,3,4) === 10, "The result of <code>sum(1,2,3,4)</code> should be 10");'
|
||||
- text: El resultado de la <code>sum(5)</code> debe ser 5.
|
||||
testString: 'assert(sum(5) === 5, "The result of <code>sum(5)</code> should be 5");'
|
||||
|
||||
@@ -6,19 +6,19 @@ challengeType: 1
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
ES6 agrega un buen soporte para definir fácilmente literales de objetos.
|
||||
Considera el siguiente código:
|
||||
<blockquote>const getMousePosition = (x, y) => ({<br> x: x,<br> y: y<br>});</blockquote>
|
||||
<code>getMousePosition</code> es una función simple que devuelve un objeto que contiene dos campos.
|
||||
ES6 proporciona el azúcar sintáctico para eliminar la redundancia de tener que escribir <code>x: x</code> . Simplemente puede escribir <code>x</code> una vez, y se convertirá a <code>x: x</code> (o algo equivalente) debajo del capó.
|
||||
Aquí se reescribe la misma función de la anterior para usar esta nueva sintaxis:
|
||||
<blockquote>const getMousePosition = (x, y) => ({ x, y });</blockquote>
|
||||
<section id='description'>
|
||||
ES6 agrega un buen soporte para definir fácilmente literales de objetos.
|
||||
Considera el siguiente código:
|
||||
<blockquote>const getMousePosition = (x, y) => ({<br> x: x,<br> y: y<br>});</blockquote>
|
||||
<code>getMousePosition</code> es una función simple que devuelve un objeto que contiene dos campos.
|
||||
ES6 proporciona el azúcar sintáctico para eliminar la redundancia de tener que escribir <code>x: x</code> . Simplemente puede escribir <code>x</code> una vez, y se convertirá a <code>x: x</code> (o algo equivalente) debajo del capó.
|
||||
Aquí se reescribe la misma función de la anterior para usar esta nueva sintaxis:
|
||||
<blockquote>const getMousePosition = (x, y) => ({ x, y });</blockquote>
|
||||
</section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
Utilice campos simples con objetos literales para crear y devolver un objeto <code>Person</code> .
|
||||
<section id='instructions'>
|
||||
Utilice campos simples con objetos literales para crear y devolver un objeto <code>Person</code> .
|
||||
</section>
|
||||
|
||||
## Tests
|
||||
@@ -26,9 +26,9 @@ Utilice campos simples con objetos literales para crear y devolver un objeto <co
|
||||
|
||||
```yml
|
||||
tests:
|
||||
- text: 'la salida es <code>{name: "Zodiac Hasbro", age: 56, gender: "male"}</code> .'
|
||||
- text: 'la salida es <code>{name: "Zodiac Hasbro", age: 56, gender: "male"}</code> .'
|
||||
testString: 'assert(() => {const res={name:"Zodiac Hasbro",age:56,gender:"male"}; const person=createPerson("Zodiac Hasbro", 56, "male"); return Object.keys(person).every(k => person[k] === res[k]);}, "the output is <code>{name: "Zodiac Hasbro", age: 56, gender: "male"}</code>.");'
|
||||
- text: 'No <code>:</code> fueron utilizados'.
|
||||
- text: 'No <code>:</code> fueron utilizados'
|
||||
testString: 'getUserInput => assert(!getUserInput("index").match(/:/g), "No <code>:</code> were used.");'
|
||||
|
||||
```
|
||||
|
||||
@@ -6,19 +6,19 @@ challengeType: 1
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
Es hora de que veamos cuán poderosas son las funciones de flecha al procesar datos.
|
||||
funciones de flecha funcionan realmente bien con funciones de orden superior, como <code>map()</code> , <code>filter()</code> y <code>reduce()</code> , que toman otras funciones como argumentos para procesar colecciones de datos.
|
||||
Lee el siguiente código:
|
||||
<blockquote>FBPosts.filter(function(post) {<br> return post.thumbnail !== null && post.shares > 100 && post.likes > 500;<br>})</blockquote>
|
||||
Hemos escrito esto con el <code>filter()</code> para al menos hacerlo un poco legible. Ahora compárelo con el siguiente código que usa la sintaxis de la función de flecha en su lugar:
|
||||
<blockquote>FBPosts.filter((post) => post.thumbnail !== null && post.shares > 100 && post.likes > 500)</blockquote>
|
||||
Este código es más breve y realiza la misma tarea con menos líneas de código.
|
||||
<section id='description'>
|
||||
Es hora de que veamos cuán poderosas son las funciones de flecha al procesar datos.
|
||||
funciones de flecha funcionan realmente bien con funciones de orden superior, como <code>map()</code> , <code>filter()</code> y <code>reduce()</code> , que toman otras funciones como argumentos para procesar colecciones de datos.
|
||||
Lee el siguiente código:
|
||||
<blockquote>FBPosts.filter(function(post) {<br> return post.thumbnail !== null && post.shares > 100 && post.likes > 500;<br>})</blockquote>
|
||||
Hemos escrito esto con el <code>filter()</code> para al menos hacerlo un poco legible. Ahora compárelo con el siguiente código que usa la sintaxis de la función de flecha en su lugar:
|
||||
<blockquote>FBPosts.filter((post) => post.thumbnail !== null && post.shares > 100 && post.likes > 500)</blockquote>
|
||||
Este código es más breve y realiza la misma tarea con menos líneas de código.
|
||||
</section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
Utilice la sintaxis de la función de flecha para calcular el cuadrado de solo los enteros positivos (los números decimales no son enteros) en la matriz <code>realNumberArray</code> y almacenar la nueva matriz en la variable <code>squaredIntegers</code> .
|
||||
<section id='instructions'>
|
||||
Utilice la sintaxis de la función de flecha para calcular el cuadrado de solo los enteros positivos (los números decimales no son enteros) en la matriz <code>realNumberArray</code> y almacenar la nueva matriz en la variable <code>squaredIntegers</code> .
|
||||
</section>
|
||||
|
||||
## Tests
|
||||
@@ -30,13 +30,13 @@ tests:
|
||||
testString: 'getUserInput => assert(getUserInput("index").match(/const\s+squaredIntegers/g), "<code>squaredIntegers</code> should be a constant variable (by using <code>const</code>).");'
|
||||
- text: <code>squaredIntegers</code> debe ser una <code>array</code>
|
||||
testString: 'assert(Array.isArray(squaredIntegers), "<code>squaredIntegers</code> should be an <code>array</code>");'
|
||||
- text: ' <code>squaredIntegers</code> debe ser <code>[16, 1764, 36]</code> '
|
||||
- text: ' <code>squaredIntegers</code> debe ser <code>[16, 1764, 36]</code> '
|
||||
testString: 'assert.deepStrictEqual(squaredIntegers, [16, 1764, 36], "<code>squaredIntegers</code> should be <code>[16, 1764, 36]</code>");'
|
||||
- text: <code>function</code> palabra clave de la <code>function</code> no se utilizó.
|
||||
testString: 'getUserInput => assert(!getUserInput("index").match(/function/g), "<code>function</code> keyword was not used.");'
|
||||
- text: bucle no debe ser utilizado
|
||||
testString: 'getUserInput => assert(!getUserInput("index").match(/(for)|(while)/g), "loop should not be used");'
|
||||
- text: ' <code>map</code> , <code>filter</code> o <code>reduce</code> debe ser utilizado'
|
||||
- text: ' <code>map</code> , <code>filter</code> o <code>reduce</code> debe ser utilizado'
|
||||
testString: 'getUserInput => assert(getUserInput("index").match(/map|filter|reduce/g), "<code>map</code>, <code>filter</code>, or <code>reduce</code> should be used");'
|
||||
|
||||
```
|
||||
|
||||
@@ -6,16 +6,16 @@ challengeType: 1
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
La programación funcional tiene que ver con la creación y el uso de funciones no mutantes.
|
||||
El último desafío introdujo el método <code>concat</code> como una forma de combinar arreglos en uno nuevo sin mutar los arreglos originales. Comparar <code>concat</code> con el método de <code>push</code> . <code>Push</code> agrega un elemento al final de la misma matriz a la que se llama, lo que muta esa matriz. Aquí hay un ejemplo:
|
||||
<blockquote>var arr = [1, 2, 3];<br>arr.push([4, 5, 6]);<br>// arr is changed to [1, 2, 3, [4, 5, 6]]<br>// Not the functional programming way</blockquote>
|
||||
<code>Concat</code> ofrece una forma de agregar nuevos elementos al final de una matriz sin efectos secundarios de mutación.
|
||||
<section id='description'>
|
||||
La programación funcional tiene que ver con la creación y el uso de funciones no mutantes.
|
||||
El último desafío introdujo el método <code>concat</code> como una forma de combinar arreglos en uno nuevo sin mutar los arreglos originales. Comparar <code>concat</code> con el método de <code>push</code> . <code>Push</code> agrega un elemento al final de la misma matriz a la que se llama, lo que muta esa matriz. Aquí hay un ejemplo:
|
||||
<blockquote>var arr = [1, 2, 3];<br>arr.push([4, 5, 6]);<br>// arr is changed to [1, 2, 3, [4, 5, 6]]<br>// Not the functional programming way</blockquote>
|
||||
<code>Concat</code> ofrece una forma de agregar nuevos elementos al final de una matriz sin efectos secundarios de mutación.
|
||||
</section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
Cambie la función <code>nonMutatingPush</code> para que use <code>concat</code> para agregar <code>newItem</code> al final del <code>original</code> lugar de <code>push</code> . La función debe devolver una matriz.
|
||||
<section id='instructions'>
|
||||
Cambie la función <code>nonMutatingPush</code> para que use <code>concat</code> para agregar <code>newItem</code> al final del <code>original</code> lugar de <code>push</code> . La función debe devolver una matriz.
|
||||
</section>
|
||||
|
||||
## Tests
|
||||
@@ -31,7 +31,7 @@ tests:
|
||||
testString: 'assert(JSON.stringify(first) === JSON.stringify([1, 2, 3]), "The <code>first</code> array should not change.");'
|
||||
- text: La <code>second</code> matriz no debe cambiar.
|
||||
testString: 'assert(JSON.stringify(second) === JSON.stringify([4, 5]), "The <code>second</code> array should not change.");'
|
||||
- text: ' <code>nonMutatingPush([1, 2, 3], [4, 5])</code> debe devolver <code>[1, 2, 3, 4, 5]</code> .'
|
||||
- text: ' <code>nonMutatingPush([1, 2, 3], [4, 5])</code> debe devolver <code>[1, 2, 3, 4, 5]</code> .'
|
||||
testString: 'assert(JSON.stringify(nonMutatingPush([1, 2, 3], [4, 5])) === JSON.stringify([1, 2, 3, 4, 5]), "<code>nonMutatingPush([1, 2, 3], [4, 5])</code> should return <code>[1, 2, 3, 4, 5]</code>.");'
|
||||
|
||||
```
|
||||
|
||||
@@ -6,15 +6,15 @@ challengeType: 1
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
El método de <code>join</code> se utiliza para unir los elementos de una matriz para crear una cadena. Toma un argumento para el delimitador que se usa para separar los elementos de la matriz en la cadena.
|
||||
Aquí hay un ejemplo:
|
||||
<blockquote>var arr = ["Hello", "World"];<br>var str = arr.join(" ");<br>// Sets str to "Hello World"</blockquote>
|
||||
<section id='description'>
|
||||
El método de <code>join</code> se utiliza para unir los elementos de una matriz para crear una cadena. Toma un argumento para el delimitador que se usa para separar los elementos de la matriz en la cadena.
|
||||
Aquí hay un ejemplo:
|
||||
<blockquote>var arr = ["Hello", "World"];<br>var str = arr.join(" ");<br>// Sets str to "Hello World"</blockquote>
|
||||
</section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
Use el método de <code>join</code> (entre otros) dentro de la función de <code>sentensify</code> para hacer una oración de las palabras en la cadena <code>str</code> . La función debe devolver una cadena. Por ejemplo, "I-like-Star-Wars" se convertiría a "Me gusta Star Wars". Para este desafío, no utilice el método de <code>replace</code> .
|
||||
<section id='instructions'>
|
||||
Use el método de <code>join</code> (entre otros) dentro de la función de <code>sentensify</code> para hacer una oración de las palabras en la cadena <code>str</code> . La función debe devolver una cadena. Por ejemplo, "I-like-Star-Wars" se convertiría a "Me gusta Star Wars". Para este desafío, no utilice el método de <code>replace</code> .
|
||||
</section>
|
||||
|
||||
## Tests
|
||||
@@ -32,7 +32,7 @@ tests:
|
||||
testString: 'assert(sentensify("May-the-force-be-with-you") === "May the force be with you", "<code>sentensify("May-the-force-be-with-you")</code> should return <code>"May the force be with you"</code>.");'
|
||||
- text: <code>sentensify("The.force.is.strong.with.this.one")</code> debe devolver <code>"The force is strong with this one"</code> .
|
||||
testString: 'assert(sentensify("The.force.is.strong.with.this.one") === "The force is strong with this one", "<code>sentensify("The.force.is.strong.with.this.one")</code> should return <code>"The force is strong with this one"</code>.");'
|
||||
- text: ' <code>sentensify("There,has,been,an,awakening")</code> debería regresar <code>"There has been an awakening"</code> .
|
||||
- text: ' <code>sentensify("There,has,been,an,awakening")</code> debería regresar <code>"There has been an awakening"</code> .
|
||||
testString: 'assert(sentensify("There,has,been,an,awakening") === "There has been an awakening", "<code>sentensify("There,has,been,an,awakening")</code> should return <code>"There has been an awakening"</code>.");'
|
||||
|
||||
```
|
||||
|
||||
@@ -6,14 +6,14 @@ challengeType: 1
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
<code>Concatenation</code> significa unir elementos de extremo a extremo. JavaScript ofrece el método <code>concat</code> para cadenas y matrices que funcionan de la misma manera. Para las matrices, el método se llama en una, luego se proporciona otra matriz como el argumento a <code>concat</code> , que se agrega al final de la primera matriz. Devuelve una nueva matriz y no muta ninguna de las matrices originales. Aquí hay un ejemplo:
|
||||
<blockquote>[1, 2, 3].concat([4, 5, 6]);<br>// Returns a new array [1, 2, 3, 4, 5, 6]</blockquote>
|
||||
<section id='description'>
|
||||
<code>Concatenation</code> significa unir elementos de extremo a extremo. JavaScript ofrece el método <code>concat</code> para cadenas y matrices que funcionan de la misma manera. Para las matrices, el método se llama en una, luego se proporciona otra matriz como el argumento a <code>concat</code> , que se agrega al final de la primera matriz. Devuelve una nueva matriz y no muta ninguna de las matrices originales. Aquí hay un ejemplo:
|
||||
<blockquote>[1, 2, 3].concat([4, 5, 6]);<br>// Returns a new array [1, 2, 3, 4, 5, 6]</blockquote>
|
||||
</section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
Utilice el método <code>concat</code> en la función <code>nonMutatingConcat</code> para concatenar <code>attach</code> al final del <code>original</code> . La función debe devolver la matriz concatenada.
|
||||
<section id='instructions'>
|
||||
Utilice el método <code>concat</code> en la función <code>nonMutatingConcat</code> para concatenar <code>attach</code> al final del <code>original</code> . La función debe devolver la matriz concatenada.
|
||||
</section>
|
||||
|
||||
## Tests
|
||||
@@ -27,7 +27,7 @@ tests:
|
||||
testString: 'assert(JSON.stringify(first) === JSON.stringify([1, 2, 3]), "The <code>first</code> array should not change.");'
|
||||
- text: La <code>second</code> matriz no debe cambiar.
|
||||
testString: 'assert(JSON.stringify(second) === JSON.stringify([4, 5]), "The <code>second</code> array should not change.");'
|
||||
- text: ' <code>nonMutatingConcat([1, 2, 3], [4, 5])</code> debe devolver <code>[1, 2, 3, 4, 5]</code> .'
|
||||
- text: ' <code>nonMutatingConcat([1, 2, 3], [4, 5])</code> debe devolver <code>[1, 2, 3, 4, 5]</code> .'
|
||||
testString: 'assert(JSON.stringify(nonMutatingConcat([1, 2, 3], [4, 5])) === JSON.stringify([1, 2, 3, 4, 5]), "<code>nonMutatingConcat([1, 2, 3], [4, 5])</code> should return <code>[1, 2, 3, 4, 5]</code>.");'
|
||||
|
||||
```
|
||||
|
||||
@@ -6,16 +6,16 @@ challengeType: 1
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
Como ha visto al aplicar <code>Array.prototype.map()</code> , o simplemente <code>map()</code> anteriormente, el método de <code>map</code> devuelve una matriz de la misma longitud que la que se solicitó. Tampoco altera la matriz original, siempre que su función de devolución de llamada no lo haga.
|
||||
En otras palabras, el <code>map</code> es una función pura, y su salida depende únicamente de sus entradas. Además, toma otra función como argumento.
|
||||
Nos enseñaría mucho sobre el <code>map</code> para intentar implementar una versión que se comporte exactamente como <code>Array.prototype.map()</code> con un bucle <code>for</code> o <code>Array.prototype.forEach()</code> .
|
||||
Nota: Una función pura puede alterar las variables locales definidas dentro de su alcance, aunque es preferible evitar eso también.
|
||||
<section id='description'>
|
||||
Como ha visto al aplicar <code>Array.prototype.map()</code> , o simplemente <code>map()</code> anteriormente, el método de <code>map</code> devuelve una matriz de la misma longitud que la que se solicitó. Tampoco altera la matriz original, siempre que su función de devolución de llamada no lo haga.
|
||||
En otras palabras, el <code>map</code> es una función pura, y su salida depende únicamente de sus entradas. Además, toma otra función como argumento.
|
||||
Nos enseñaría mucho sobre el <code>map</code> para intentar implementar una versión que se comporte exactamente como <code>Array.prototype.map()</code> con un bucle <code>for</code> o <code>Array.prototype.forEach()</code> .
|
||||
Nota: Una función pura puede alterar las variables locales definidas dentro de su alcance, aunque es preferible evitar eso también.
|
||||
</section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
Escriba su propio <code>Array.prototype.myMap()</code> , que debería comportarse exactamente como <code>Array.prototype.map()</code> . Puedes usar un bucle <code>for</code> o el método <code>forEach</code> .
|
||||
<section id='instructions'>
|
||||
Escriba su propio <code>Array.prototype.myMap()</code> , que debería comportarse exactamente como <code>Array.prototype.map()</code> . Puedes usar un bucle <code>for</code> o el método <code>forEach</code> .
|
||||
</section>
|
||||
|
||||
## Tests
|
||||
@@ -23,7 +23,7 @@ Escriba su propio <code>Array.prototype.myMap()</code> , que debería comportars
|
||||
|
||||
```yml
|
||||
tests:
|
||||
- text: ' <code>new_s</code> debe ser igual a <code>[46, 130, 196, 10]</code> .'
|
||||
- text: ' <code>new_s</code> debe ser igual a <code>[46, 130, 196, 10]</code> .'
|
||||
testString: 'assert(JSON.stringify(new_s) === JSON.stringify([46, 130, 196, 10]), "<code>new_s</code> should equal <code>[46, 130, 196, 10]</code>.");'
|
||||
- text: Su código no debe utilizar el método de <code>map</code> .
|
||||
testString: 'assert(!code.match(/\.map/g), "Your code should not use the <code>map</code> method.");'
|
||||
|
||||
@@ -6,14 +6,14 @@ challengeType: 1
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
Nos enseñaría mucho sobre el método de <code>filter</code> si intentáramos implementar una versión que se comporte exactamente como <code>Array.prototype.filter()</code> . Puede usar un bucle <code>for</code> o <code>Array.prototype.forEach()</code> .
|
||||
Nota: Una función pura puede alterar las variables locales definidas dentro de su alcance, aunque es preferible evitar eso también.
|
||||
<section id='description'>
|
||||
Nos enseñaría mucho sobre el método de <code>filter</code> si intentáramos implementar una versión que se comporte exactamente como <code>Array.prototype.filter()</code> . Puede usar un bucle <code>for</code> o <code>Array.prototype.forEach()</code> .
|
||||
Nota: Una función pura puede alterar las variables locales definidas dentro de su alcance, aunque es preferible evitar eso también.
|
||||
</section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
Escriba su propio <code>Array.prototype.myFilter()</code> , que debe comportarse exactamente como <code>Array.prototype.filter()</code> . Puede usar un bucle <code>for</code> o el método <code>Array.prototype.forEach()</code> .
|
||||
<section id='instructions'>
|
||||
Escriba su propio <code>Array.prototype.myFilter()</code> , que debe comportarse exactamente como <code>Array.prototype.filter()</code> . Puede usar un bucle <code>for</code> o el método <code>Array.prototype.forEach()</code> .
|
||||
</section>
|
||||
|
||||
## Tests
|
||||
@@ -21,7 +21,7 @@ Escriba su propio <code>Array.prototype.myFilter()</code> , que debe comportarse
|
||||
|
||||
```yml
|
||||
tests:
|
||||
- text: ' <code>new_s</code> debe ser igual a <code>[23, 65, 5]</code> .'
|
||||
- text: ' <code>new_s</code> debe ser igual a <code>[23, 65, 5]</code> .'
|
||||
testString: 'assert(JSON.stringify(new_s) === JSON.stringify([23, 65, 5]), "<code>new_s</code> should equal <code>[23, 65, 5]</code>.");'
|
||||
- text: Su código no debe utilizar el método de <code>filter</code> .
|
||||
testString: 'assert(!code.match(/\.filter/g), "Your code should not use the <code>filter</code> method.");'
|
||||
|
||||
@@ -6,16 +6,16 @@ challengeType: 1
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
Hasta ahora, hemos visto dos principios distintos para la programación funcional:
|
||||
1) No alterar una variable u objeto: cree nuevas variables y objetos y devuélvalos si es necesario desde una función.
|
||||
2) Declare los argumentos de la función: cualquier cálculo dentro de una función depende solo de los argumentos, y no de cualquier objeto global o variable.
|
||||
Agregar uno a un número no es muy emocionante, pero podemos aplicar estos principios al trabajar con matrices u objetos más complejos.
|
||||
<section id='description'>
|
||||
Hasta ahora, hemos visto dos principios distintos para la programación funcional:
|
||||
1) No alterar una variable u objeto: cree nuevas variables y objetos y devuélvalos si es necesario desde una función.
|
||||
2) Declare los argumentos de la función: cualquier cálculo dentro de una función depende solo de los argumentos, y no de cualquier objeto global o variable.
|
||||
Agregar uno a un número no es muy emocionante, pero podemos aplicar estos principios al trabajar con matrices u objetos más complejos.
|
||||
</section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
Refactorice (reescriba) el código para que la matriz de <code>bookList</code> global no se <code>bookList</code> dentro de ninguna de las funciones. La función de <code>add</code> debería agregar el <code>bookName</code> de <code>bookName</code> dado al final de una matriz. La función de <code>remove</code> debe eliminar el <code>bookName</code> de <code>bookName</code> dado de una matriz. Ambas funciones deben devolver una matriz, y cualquier parámetro nuevo debe agregarse antes del <code>bookName</code> one.
|
||||
<section id='instructions'>
|
||||
Refactorice (reescriba) el código para que la matriz de <code>bookList</code> global no se <code>bookList</code> dentro de ninguna de las funciones. La función de <code>add</code> debería agregar el <code>bookName</code> de <code>bookName</code> dado al final de una matriz. La función de <code>remove</code> debe eliminar el <code>bookName</code> de <code>bookName</code> dado de una matriz. Ambas funciones deben devolver una matriz, y cualquier parámetro nuevo debe agregarse antes del <code>bookName</code> one.
|
||||
</section>
|
||||
|
||||
## Tests
|
||||
@@ -23,13 +23,13 @@ Refactorice (reescriba) el código para que la matriz de <code>bookList</code> g
|
||||
|
||||
```yml
|
||||
tests:
|
||||
- text: ' <code>bookList</code> no debe cambiar y aún debe ser igual a <code>["The Hound of the Baskervilles", "On The Electrodynamics of Moving Bodies", "Philosophiæ Naturalis Principia Mathematica", "Disquisitiones Arithmeticae"]</code> .'
|
||||
- text: ' <code>bookList</code> no debe cambiar y aún debe ser igual a <code>["The Hound of the Baskervilles", "On The Electrodynamics of Moving Bodies", "Philosophiæ Naturalis Principia Mathematica", "Disquisitiones Arithmeticae"]</code> .'
|
||||
testString: 'assert(JSON.stringify(bookList) === JSON.stringify(["The Hound of the Baskervilles", "On The Electrodynamics of Moving Bodies", "Philosophiæ Naturalis Principia Mathematica", "Disquisitiones Arithmeticae"]), "<code>bookList</code> should not change and still equal <code>["The Hound of the Baskervilles", "On The Electrodynamics of Moving Bodies", "Philosophiæ Naturalis Principia Mathematica", "Disquisitiones Arithmeticae"]</code>.");'
|
||||
- text: ' <code>newBookList</code> debería ser igual a <code>["The Hound of the Baskervilles", "On The Electrodynamics of Moving Bodies", "Philosophiæ Naturalis Principia Mathematica", "Disquisitiones Arithmeticae", "A Brief History of Time"]</code> .'
|
||||
- text: ' <code>newBookList</code> debería ser igual a <code>["The Hound of the Baskervilles", "On The Electrodynamics of Moving Bodies", "Philosophiæ Naturalis Principia Mathematica", "Disquisitiones Arithmeticae", "A Brief History of Time"]</code> .'
|
||||
testString: 'assert(JSON.stringify(newBookList) === JSON.stringify(["The Hound of the Baskervilles", "On The Electrodynamics of Moving Bodies", "Philosophiæ Naturalis Principia Mathematica", "Disquisitiones Arithmeticae", "A Brief History of Time"]), "<code>newBookList</code> should equal <code>["The Hound of the Baskervilles", "On The Electrodynamics of Moving Bodies", "Philosophiæ Naturalis Principia Mathematica", "Disquisitiones Arithmeticae", "A Brief History of Time"]</code>.");'
|
||||
- text: ' <code>newerBookList</code> debería ser igual a <code>["The Hound of the Baskervilles", "Philosophiæ Naturalis Principia Mathematica", "Disquisitiones Arithmeticae"]</code> .'
|
||||
- text: ' <code>newerBookList</code> debería ser igual a <code>["The Hound of the Baskervilles", "Philosophiæ Naturalis Principia Mathematica", "Disquisitiones Arithmeticae"]</code> .'
|
||||
testString: 'assert(JSON.stringify(newerBookList) === JSON.stringify(["The Hound of the Baskervilles", "Philosophiæ Naturalis Principia Mathematica", "Disquisitiones Arithmeticae"]), "<code>newerBookList</code> should equal <code>["The Hound of the Baskervilles", "Philosophiæ Naturalis Principia Mathematica", "Disquisitiones Arithmeticae"]</code>.");'
|
||||
- text: ' <code>newestBookList</code> debería ser igual a <code>["The Hound of the Baskervilles", "Philosophiæ Naturalis Principia Mathematica", "Disquisitiones Arithmeticae", "A Brief History of Time"]</code> .
|
||||
- text: ' <code>newestBookList</code> debería ser igual a <code>["The Hound of the Baskervilles", "Philosophiæ Naturalis Principia Mathematica", "Disquisitiones Arithmeticae", "A Brief History of Time"]</code> .
|
||||
testString: 'assert(JSON.stringify(newestBookList) === JSON.stringify(["The Hound of the Baskervilles", "Philosophiæ Naturalis Principia Mathematica", "Disquisitiones Arithmeticae", "A Brief History of Time"]), "<code>newestBookList</code> should equal <code>["The Hound of the Baskervilles", "Philosophiæ Naturalis Principia Mathematica", "Disquisitiones Arithmeticae", "A Brief History of Time"]</code>.");'
|
||||
|
||||
```
|
||||
|
||||
@@ -6,16 +6,16 @@ challengeType: 1
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
Un patrón común al trabajar con matrices es cuando desea eliminar elementos y conservar el resto de la matriz. JavaScript ofrece el método de <code>splice</code> para esto, que toma argumentos para el índice de dónde comenzar a eliminar elementos, luego la cantidad de elementos que se eliminarán. Si no se proporciona el segundo argumento, el valor predeterminado es eliminar elementos hasta el final. Sin embargo, el método de <code>splice</code> muta la matriz original a la que se llama. Aquí hay un ejemplo:
|
||||
<blockquote>var cities = ["Chicago", "Delhi", "Islamabad", "London", "Berlin"];<br>cities.splice(3, 1); // Returns "London" and deletes it from the cities array<br>// cities is now ["Chicago", "Delhi", "Islamabad", "Berlin"]</blockquote>
|
||||
Como hemos visto en el último desafío, la <code>slice</code> método no muta la matriz original, pero devuelve una nueva que se pueden guardar en una variable. Recuerde que el método de <code>slice</code> toma dos argumentos para que los índices comiencen y terminen la división (el final no es inclusivo) y devuelve esos elementos en una nueva matriz. Uso de la <code>slice</code> método en lugar de <code>splice</code> ayuda a evitar los efectos secundarios de matriz-mutación.
|
||||
<section id='description'>
|
||||
Un patrón común al trabajar con matrices es cuando desea eliminar elementos y conservar el resto de la matriz. JavaScript ofrece el método de <code>splice</code> para esto, que toma argumentos para el índice de dónde comenzar a eliminar elementos, luego la cantidad de elementos que se eliminarán. Si no se proporciona el segundo argumento, el valor predeterminado es eliminar elementos hasta el final. Sin embargo, el método de <code>splice</code> muta la matriz original a la que se llama. Aquí hay un ejemplo:
|
||||
<blockquote>var cities = ["Chicago", "Delhi", "Islamabad", "London", "Berlin"];<br>cities.splice(3, 1); // Returns "London" and deletes it from the cities array<br>// cities is now ["Chicago", "Delhi", "Islamabad", "Berlin"]</blockquote>
|
||||
Como hemos visto en el último desafío, la <code>slice</code> método no muta la matriz original, pero devuelve una nueva que se pueden guardar en una variable. Recuerde que el método de <code>slice</code> toma dos argumentos para que los índices comiencen y terminen la división (el final no es inclusivo) y devuelve esos elementos en una nueva matriz. Uso de la <code>slice</code> método en lugar de <code>splice</code> ayuda a evitar los efectos secundarios de matriz-mutación.
|
||||
</section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
Reescriba la función <code>nonMutatingSplice</code> utilizando <code>slice</code> lugar de <code>splice</code> . Debe limitar la matriz de <code>cities</code> proporcionada a una longitud de 3 y devolver una nueva matriz con solo los tres primeros elementos.
|
||||
No mutar la matriz original proporcionada a la función.
|
||||
<section id='instructions'>
|
||||
Reescriba la función <code>nonMutatingSplice</code> utilizando <code>slice</code> lugar de <code>splice</code> . Debe limitar la matriz de <code>cities</code> proporcionada a una longitud de 3 y devolver una nueva matriz con solo los tres primeros elementos.
|
||||
No mutar la matriz original proporcionada a la función.
|
||||
</section>
|
||||
|
||||
## Tests
|
||||
@@ -29,7 +29,7 @@ tests:
|
||||
testString: 'assert(!code.match(/\.splice/g), "Your code should not use the <code>splice</code> method.");'
|
||||
- text: La matriz <code>inputCities</code> no debería cambiar.
|
||||
testString: 'assert(JSON.stringify(inputCities) === JSON.stringify(["Chicago", "Delhi", "Islamabad", "London", "Berlin"]), "The <code>inputCities</code> array should not change.");'
|
||||
- text: ' <code>nonMutatingSplice(["Chicago", "Delhi", "Islamabad", "London", "Berlin"])</code> debe devolver <code>["Chicago", "Delhi", "Islamabad"]</code> .'
|
||||
- text: ' <code>nonMutatingSplice(["Chicago", "Delhi", "Islamabad", "London", "Berlin"])</code> debe devolver <code>["Chicago", "Delhi", "Islamabad"]</code> .'
|
||||
testString: 'assert(JSON.stringify(nonMutatingSplice(["Chicago", "Delhi", "Islamabad", "London", "Berlin"])) === JSON.stringify(["Chicago", "Delhi", "Islamabad"]), "<code>nonMutatingSplice(["Chicago", "Delhi", "Islamabad", "London", "Berlin"])</code> should return <code>["Chicago", "Delhi", "Islamabad"]</code>.");'
|
||||
|
||||
```
|
||||
|
||||
@@ -6,13 +6,13 @@ challengeType: 1
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
Un efecto secundario del método de <code>sort</code> es que cambia el orden de los elementos en la matriz original. En otras palabras, muta la matriz en su lugar. Una forma de evitar esto es primero concatenar una matriz vacía con la ordenada (recuerde que <code>concat</code> devuelve una nueva matriz), luego ejecute el método de <code>sort</code> .
|
||||
<section id='description'>
|
||||
Un efecto secundario del método de <code>sort</code> es que cambia el orden de los elementos en la matriz original. En otras palabras, muta la matriz en su lugar. Una forma de evitar esto es primero concatenar una matriz vacía con la ordenada (recuerde que <code>concat</code> devuelve una nueva matriz), luego ejecute el método de <code>sort</code> .
|
||||
</section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
Utilice el método de <code>sort</code> en la función <code>nonMutatingSort</code> para ordenar los elementos de una matriz en orden ascendente. La función debe devolver una nueva matriz y no mutar la variable <code>globalArray</code> .
|
||||
<section id='instructions'>
|
||||
Utilice el método de <code>sort</code> en la función <code>nonMutatingSort</code> para ordenar los elementos de una matriz en orden ascendente. La función debe devolver una nueva matriz y no mutar la variable <code>globalArray</code> .
|
||||
</section>
|
||||
|
||||
## Tests
|
||||
@@ -26,7 +26,7 @@ tests:
|
||||
testString: 'assert(code.match(/\.concat/g), "Your code should use the <code>concat</code> method.");'
|
||||
- text: La variable <code>globalArray</code> no debe cambiar.
|
||||
testString: 'assert(JSON.stringify(globalArray) === JSON.stringify([5, 6, 3, 2, 9]), "The <code>globalArray</code> variable should not change.");'
|
||||
- text: ' <code>nonMutatingSort(globalArray)</code> debe devolver <code>[2, 3, 5, 6, 9]</code> .'
|
||||
- text: ' <code>nonMutatingSort(globalArray)</code> debe devolver <code>[2, 3, 5, 6, 9]</code> .'
|
||||
testString: 'assert(JSON.stringify(nonMutatingSort(globalArray)) === JSON.stringify([2, 3, 5, 6, 9]), "<code>nonMutatingSort(globalArray)</code> should return <code>[2, 3, 5, 6, 9]</code>.");'
|
||||
|
||||
```
|
||||
|
||||
@@ -6,15 +6,15 @@ challengeType: 1
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
El método de <code>slice</code> devuelve una copia de ciertos elementos de una matriz. Puede tomar dos argumentos, el primero proporciona el índice de dónde comenzar la división, el segundo es el índice de dónde finalizar la división (y no está incluido). Si no se proporcionan los argumentos, el valor predeterminado es comenzar desde el principio de la matriz hasta el final, lo cual es una forma fácil de hacer una copia de toda la matriz. La <code>slice</code> método no muta la matriz original, pero devuelve una nueva.
|
||||
Aquí hay un ejemplo:
|
||||
<blockquote>var arr = ["Cat", "Dog", "Tiger", "Zebra"];<br>var newArray = arr.slice(1, 3);<br>// Sets newArray to ["Dog", "Tiger"]</blockquote>
|
||||
<section id='description'>
|
||||
El método de <code>slice</code> devuelve una copia de ciertos elementos de una matriz. Puede tomar dos argumentos, el primero proporciona el índice de dónde comenzar la división, el segundo es el índice de dónde finalizar la división (y no está incluido). Si no se proporcionan los argumentos, el valor predeterminado es comenzar desde el principio de la matriz hasta el final, lo cual es una forma fácil de hacer una copia de toda la matriz. La <code>slice</code> método no muta la matriz original, pero devuelve una nueva.
|
||||
Aquí hay un ejemplo:
|
||||
<blockquote>var arr = ["Cat", "Dog", "Tiger", "Zebra"];<br>var newArray = arr.slice(1, 3);<br>// Sets newArray to ["Dog", "Tiger"]</blockquote>
|
||||
</section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
Utilice la <code>slice</code> método en el <code>sliceArray</code> función para devolver parte de la <code>anim</code> matriz dada las proporcionadas <code>beginSlice</code> y <code>endSlice</code> índices. La función debe devolver una matriz.
|
||||
<section id='instructions'>
|
||||
Utilice la <code>slice</code> método en el <code>sliceArray</code> función para devolver parte de la <code>anim</code> matriz dada las proporcionadas <code>beginSlice</code> y <code>endSlice</code> índices. La función debe devolver una matriz.
|
||||
</section>
|
||||
|
||||
## Tests
|
||||
@@ -26,11 +26,11 @@ tests:
|
||||
testString: 'assert(code.match(/\.slice/g), "Your code should use the <code>slice</code> method.");'
|
||||
- text: La variable <code>inputAnim</code> no debe cambiar.
|
||||
testString: 'assert(JSON.stringify(inputAnim) === JSON.stringify(["Cat", "Dog", "Tiger", "Zebra", "Ant"]), "The <code>inputAnim</code> variable should not change.");'
|
||||
- text: ' <code>sliceArray(["Cat", "Dog", "Tiger", "Zebra", "Ant"], 1, 3)</code> debe devolver <code>["Dog", "Tiger"]</code> .'
|
||||
- text: ' <code>sliceArray(["Cat", "Dog", "Tiger", "Zebra", "Ant"], 1, 3)</code> debe devolver <code>["Dog", "Tiger"]</code> .'
|
||||
testString: 'assert(JSON.stringify(sliceArray(["Cat", "Dog", "Tiger", "Zebra", "Ant"], 1, 3)) === JSON.stringify(["Dog", "Tiger"]), "<code>sliceArray(["Cat", "Dog", "Tiger", "Zebra", "Ant"], 1, 3)</code> should return <code>["Dog", "Tiger"]</code>.");'
|
||||
- text: ' <code>sliceArray(["Cat", "Dog", "Tiger", "Zebra", "Ant"], 0, 1)</code> debe devolver <code>["Cat"]</code> .'
|
||||
- text: ' <code>sliceArray(["Cat", "Dog", "Tiger", "Zebra", "Ant"], 0, 1)</code> debe devolver <code>["Cat"]</code> .'
|
||||
testString: 'assert(JSON.stringify(sliceArray(["Cat", "Dog", "Tiger", "Zebra", "Ant"], 0, 1)) === JSON.stringify(["Cat"]), "<code>sliceArray(["Cat", "Dog", "Tiger", "Zebra", "Ant"], 0, 1)</code> should return <code>["Cat"]</code>.");'
|
||||
- text: ' <code>sliceArray(["Cat", "Dog", "Tiger", "Zebra", "Ant"], 1, 4)</code> debe devolver <code>["Dog", "Tiger", "Zebra"]</code> .'
|
||||
- text: ' <code>sliceArray(["Cat", "Dog", "Tiger", "Zebra", "Ant"], 1, 4)</code> debe devolver <code>["Dog", "Tiger", "Zebra"]</code> .'
|
||||
testString: 'assert(JSON.stringify(sliceArray(["Cat", "Dog", "Tiger", "Zebra", "Ant"], 1, 4)) === JSON.stringify(["Dog", "Tiger", "Zebra"]), "<code>sliceArray(["Cat", "Dog", "Tiger", "Zebra", "Ant"], 1, 4)</code> should return <code>["Dog", "Tiger", "Zebra"]</code>.");'
|
||||
|
||||
```
|
||||
|
||||
@@ -6,16 +6,16 @@ challengeType: 1
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
El método de <code>sort</code> ordena los elementos de una matriz de acuerdo con la función de devolución de llamada.
|
||||
Por ejemplo:
|
||||
<blockquote>function ascendingOrder(arr) {<br> return arr.sort(function(a, b) {<br> return a - b;<br> });<br>}<br>ascendingOrder([1, 5, 2, 3, 4]);<br>// Returns [1, 2, 3, 4, 5]<br><br>function reverseAlpha(arr) {<br> return arr.sort(function(a, b) {<br> return a < b;<br> });<br>}<br>reverseAlpha(['l', 'h', 'z', 'b', 's']);<br>// Returns ['z', 's', 'l', 'h', 'b']</blockquote>
|
||||
Nota: Se recomienda proporcionar una función de devolución de llamada para especificar cómo ordenar los elementos de la matriz. El método de clasificación predeterminado de JavaScript es por valor de punto Unicode de cadena, que puede devolver resultados inesperados.
|
||||
<section id='description'>
|
||||
El método de <code>sort</code> ordena los elementos de una matriz de acuerdo con la función de devolución de llamada.
|
||||
Por ejemplo:
|
||||
<blockquote>function ascendingOrder(arr) {<br> return arr.sort(function(a, b) {<br> return a - b;<br> });<br>}<br>ascendingOrder([1, 5, 2, 3, 4]);<br>// Returns [1, 2, 3, 4, 5]<br><br>function reverseAlpha(arr) {<br> return arr.sort(function(a, b) {<br> return a < b;<br> });<br>}<br>reverseAlpha(['l', 'h', 'z', 'b', 's']);<br>// Returns ['z', 's', 'l', 'h', 'b']</blockquote>
|
||||
Nota: Se recomienda proporcionar una función de devolución de llamada para especificar cómo ordenar los elementos de la matriz. El método de clasificación predeterminado de JavaScript es por valor de punto Unicode de cadena, que puede devolver resultados inesperados.
|
||||
</section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
Utilice el método de <code>sort</code> en la función de orden <code>alphabeticalOrder</code> para ordenar los elementos de <code>arr</code> en orden alfabético.
|
||||
<section id='instructions'>
|
||||
Utilice el método de <code>sort</code> en la función de orden <code>alphabeticalOrder</code> para ordenar los elementos de <code>arr</code> en orden alfabético.
|
||||
</section>
|
||||
|
||||
## Tests
|
||||
@@ -25,11 +25,11 @@ Utilice el método de <code>sort</code> en la función de orden <code>alphabetic
|
||||
tests:
|
||||
- text: Su código debe utilizar el método de <code>sort</code> .
|
||||
testString: 'assert(code.match(/\.sort/g), "Your code should use the <code>sort</code> method.");'
|
||||
- text: ' <code>alphabeticalOrder(["a", "d", "c", "a", "z", "g"])</code> debe devolver <code>["a", "a", "c", "d", "g", "z"]</code> . '
|
||||
- text: ' <code>alphabeticalOrder(["a", "d", "c", "a", "z", "g"])</code> debe devolver <code>["a", "a", "c", "d", "g", "z"]</code> . '
|
||||
testString: 'assert(JSON.stringify(alphabeticalOrder(["a", "d", "c", "a", "z", "g"])) === JSON.stringify(["a", "a", "c", "d", "g", "z"]), "<code>alphabeticalOrder(["a", "d", "c", "a", "z", "g"])</code> should return <code>["a", "a", "c", "d", "g", "z"]</code>.");'
|
||||
- text: ' <code>alphabeticalOrder(["x", "h", "a", "m", "n", "m"])</code> debe devolver <code>["a", "h", "m", "m", "n", "x"]</code> . '
|
||||
- text: ' <code>alphabeticalOrder(["x", "h", "a", "m", "n", "m"])</code> debe devolver <code>["a", "h", "m", "m", "n", "x"]</code> . '
|
||||
testString: 'assert(JSON.stringify(alphabeticalOrder(["x", "h", "a", "m", "n", "m"])) === JSON.stringify(["a", "h", "m", "m", "n", "x"]), "<code>alphabeticalOrder(["x", "h", "a", "m", "n", "m"])</code> should return <code>["a", "h", "m", "m", "n", "x"]</code>.");'
|
||||
- text: ' <code>alphabeticalOrder(["a", "a", "a", "a", "x", "t"])</code> debe devolver <code>["a", "a", "a", "a", "t", "x"]</code> . '
|
||||
- text: ' <code>alphabeticalOrder(["a", "a", "a", "a", "x", "t"])</code> debe devolver <code>["a", "a", "a", "a", "t", "x"]</code> . '
|
||||
testString: 'assert(JSON.stringify(alphabeticalOrder(["a", "a", "a", "a", "x", "t"])) === JSON.stringify(["a", "a", "a", "a", "t", "x"]), "<code>alphabeticalOrder(["a", "a", "a", "a", "x", "t"])</code> should return <code>["a", "a", "a", "a", "t", "x"]</code>.");'
|
||||
|
||||
```
|
||||
|
||||
@@ -6,16 +6,16 @@ challengeType: 1
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
El método de <code>split</code> divide una cadena en una matriz de cadenas. Toma un argumento para el delimitador, que puede ser un carácter que se usa para separar la cadena o una expresión regular. Por ejemplo, si el delimitador es un espacio, obtiene una matriz de palabras, y si el delimitador es una cadena vacía, obtiene una matriz de cada carácter en la cadena.
|
||||
Aquí hay dos ejemplos que dividen una cadena por espacios, luego otro por dígitos usando una expresión regular:
|
||||
<blockquote>var str = "Hello World";<br>var bySpace = str.split(" ");<br>// Sets bySpace to ["Hello", "World"]<br><br>var otherString = "How9are7you2today";<br>var byDigits = otherString.split(/\d/);<br>// Sets byDigits to ["How", "are", "you", "today"]</blockquote>
|
||||
Dado que las cadenas son inmutables, el método de <code>split</code> facilita el trabajo con ellas.
|
||||
<section id='description'>
|
||||
El método de <code>split</code> divide una cadena en una matriz de cadenas. Toma un argumento para el delimitador, que puede ser un carácter que se usa para separar la cadena o una expresión regular. Por ejemplo, si el delimitador es un espacio, obtiene una matriz de palabras, y si el delimitador es una cadena vacía, obtiene una matriz de cada carácter en la cadena.
|
||||
Aquí hay dos ejemplos que dividen una cadena por espacios, luego otro por dígitos usando una expresión regular:
|
||||
<blockquote>var str = "Hello World";<br>var bySpace = str.split(" ");<br>// Sets bySpace to ["Hello", "World"]<br><br>var otherString = "How9are7you2today";<br>var byDigits = otherString.split(/\d/);<br>// Sets byDigits to ["How", "are", "you", "today"]</blockquote>
|
||||
Dado que las cadenas son inmutables, el método de <code>split</code> facilita el trabajo con ellas.
|
||||
</section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
Utilice la <code>split</code> método dentro de la <code>splitify</code> función de dividir <code>str</code> en una matriz de palabras. La función debe devolver la matriz. Tenga en cuenta que las palabras no siempre están separadas por espacios y que la matriz no debe contener puntuación.
|
||||
<section id='instructions'>
|
||||
Utilice la <code>split</code> método dentro de la <code>splitify</code> función de dividir <code>str</code> en una matriz de palabras. La función debe devolver la matriz. Tenga en cuenta que las palabras no siempre están separadas por espacios y que la matriz no debe contener puntuación.
|
||||
</section>
|
||||
|
||||
## Tests
|
||||
@@ -25,11 +25,11 @@ Utilice la <code>split</code> método dentro de la <code>splitify</code> funció
|
||||
tests:
|
||||
- text: Su código debe utilizar el método de <code>split</code> .
|
||||
testString: 'assert(code.match(/\.split/g), "Your code should use the <code>split</code> method.");'
|
||||
- text: ' <code>splitify("Hello World,I-am code")</code> debe devolver <code>["Hello", "World", "I", "am", "code"]</code> .'
|
||||
- text: ' <code>splitify("Hello World,I-am code")</code> debe devolver <code>["Hello", "World", "I", "am", "code"]</code> .'
|
||||
testString: 'assert(JSON.stringify(splitify("Hello World,I-am code")) === JSON.stringify(["Hello", "World", "I", "am", "code"]), "<code>splitify("Hello World,I-am code")</code> should return <code>["Hello", "World", "I", "am", "code"]</code>.");'
|
||||
- text: ' <code>splitify("Earth-is-our home")</code> debería devolver <code>["Earth", "is", "our", "home"]</code> .'
|
||||
- text: ' <code>splitify("Earth-is-our home")</code> debería devolver <code>["Earth", "is", "our", "home"]</code> .'
|
||||
testString: 'assert(JSON.stringify(splitify("Earth-is-our home")) === JSON.stringify(["Earth", "is", "our", "home"]), "<code>splitify("Earth-is-our home")</code> should return <code>["Earth", "is", "our", "home"]</code>.");'
|
||||
- text: ' <code>splitify("This.is.a-sentence")</code> debe devolver <code>["This", "is", "a", "sentence"]</code> .'
|
||||
- text: ' <code>splitify("This.is.a-sentence")</code> debe devolver <code>["This", "is", "a", "sentence"]</code> .'
|
||||
testString: 'assert(JSON.stringify(splitify("This.is.a-sentence")) === JSON.stringify(["This", "is", "a", "sentence"]), "<code>splitify("This.is.a-sentence")</code> should return <code>["This", "is", "a", "sentence"]</code>.");'
|
||||
|
||||
```
|
||||
|
||||
@@ -6,15 +6,15 @@ challengeType: 1
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
<code>every</code> métodos funcionan con matrices para verificar si <em>cada</em> elemento pasa una prueba en particular. Devuelve un valor booleano: <code>true</code> si todos los valores cumplen los criterios, <code>false</code> si no.
|
||||
Por ejemplo, el siguiente código verificará si cada elemento de la matriz de <code>numbers</code> es menor que 10:
|
||||
<blockquote>var numbers = [1, 5, 8, 0, 10, 11];<br>numbers.every(function(currentValue) {<br> return currentValue < 10;<br>});<br>// Returns false</blockquote>
|
||||
<section id='description'>
|
||||
<code>every</code> métodos funcionan con matrices para verificar si <em>cada</em> elemento pasa una prueba en particular. Devuelve un valor booleano: <code>true</code> si todos los valores cumplen los criterios, <code>false</code> si no.
|
||||
Por ejemplo, el siguiente código verificará si cada elemento de la matriz de <code>numbers</code> es menor que 10:
|
||||
<blockquote>var numbers = [1, 5, 8, 0, 10, 11];<br>numbers.every(function(currentValue) {<br> return currentValue < 10;<br>});<br>// Returns false</blockquote>
|
||||
</section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
Use <code>every</code> método dentro de la función <code>checkPositive</code> para verificar si cada elemento en <code>arr</code> es positivo. La función debe devolver un valor booleano.
|
||||
<section id='instructions'>
|
||||
Use <code>every</code> método dentro de la función <code>checkPositive</code> para verificar si cada elemento en <code>arr</code> es positivo. La función debe devolver un valor booleano.
|
||||
</section>
|
||||
|
||||
## Tests
|
||||
@@ -24,11 +24,11 @@ Use <code>every</code> método dentro de la función <code>checkPositive</code>
|
||||
tests:
|
||||
- text: Su código debe utilizar <code>every</code> métodos.
|
||||
testString: 'assert(code.match(/\.every/g), "Your code should use the <code>every</code> method.");'
|
||||
- text: ' <code>checkPositive([1, 2, 3, -4, 5])</code> debe devolver <code>false</code> .'
|
||||
- text: ' <code>checkPositive([1, 2, 3, -4, 5])</code> debe devolver <code>false</code> .'
|
||||
testString: 'assert(!checkPositive([1, 2, 3, -4, 5]), "<code>checkPositive([1, 2, 3, -4, 5])</code> should return <code>false</code>.");'
|
||||
- text: ' <code>checkPositive([1, 2, 3, 4, 5])</code> debe devolver <code>true</code> .'
|
||||
- text: ' <code>checkPositive([1, 2, 3, 4, 5])</code> debe devolver <code>true</code> .'
|
||||
testString: 'assert(checkPositive([1, 2, 3, 4, 5]), "<code>checkPositive([1, 2, 3, 4, 5])</code> should return <code>true</code>.");'
|
||||
- text: ' <code>checkPositive([1, -2, 3, -4, 5])</code> debe devolver <code>false</code> .'
|
||||
- text: ' <code>checkPositive([1, -2, 3, -4, 5])</code> debe devolver <code>false</code> .'
|
||||
testString: 'assert(!checkPositive([1, -2, 3, -4, 5]), "<code>checkPositive([1, -2, 3, -4, 5])</code> should return <code>false</code>.");'
|
||||
|
||||
```
|
||||
|
||||
@@ -6,14 +6,14 @@ challengeType: 1
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
Otra función de matriz útil es <code>Array.prototype.filter()</code> , o simplemente <code>filter()</code> . El método de <code>filter</code> devuelve una nueva matriz que es a lo sumo tan larga como la matriz original, pero generalmente tiene menos elementos.
|
||||
<code>Filter</code> no altera la matriz original, al igual que el <code>map</code> . Toma una función de devolución de llamada que aplica la lógica dentro de la devolución de llamada en cada elemento de la matriz. Si un elemento devuelve verdadero según los criterios en la función de devolución de llamada, entonces se incluye en la nueva matriz.
|
||||
<section id='description'>
|
||||
Otra función de matriz útil es <code>Array.prototype.filter()</code> , o simplemente <code>filter()</code> . El método de <code>filter</code> devuelve una nueva matriz que es a lo sumo tan larga como la matriz original, pero generalmente tiene menos elementos.
|
||||
<code>Filter</code> no altera la matriz original, al igual que el <code>map</code> . Toma una función de devolución de llamada que aplica la lógica dentro de la devolución de llamada en cada elemento de la matriz. Si un elemento devuelve verdadero según los criterios en la función de devolución de llamada, entonces se incluye en la nueva matriz.
|
||||
</section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
La variable <code>watchList</code> contiene una serie de objetos con información sobre varias películas. Use una combinación de <code>filter</code> y <code>map</code> para devolver una nueva matriz de objetos con solo <code>title</code> y claves de <code>rating</code> , pero donde <code>imdbRating</code> es mayor o igual a 8.0. Tenga en cuenta que los valores de calificación se guardan como cadenas en el objeto y es posible que desee convertirlos en números para realizar operaciones matemáticas en ellos.
|
||||
<section id='instructions'>
|
||||
La variable <code>watchList</code> contiene una serie de objetos con información sobre varias películas. Use una combinación de <code>filter</code> y <code>map</code> para devolver una nueva matriz de objetos con solo <code>title</code> y claves de <code>rating</code> , pero donde <code>imdbRating</code> es mayor o igual a 8.0. Tenga en cuenta que los valores de calificación se guardan como cadenas en el objeto y es posible que desee convertirlos en números para realizar operaciones matemáticas en ellos.
|
||||
</section>
|
||||
|
||||
## Tests
|
||||
@@ -27,7 +27,7 @@ tests:
|
||||
testString: 'assert(code.match(/\.filter/g), "Your code should use the <code>filter</code> method.");'
|
||||
- text: Su código no debe utilizar un bucle <code>for</code> .
|
||||
testString: 'assert(!code.match(/for\s*?\(.+?\)/g), "Your code should not use a <code>for</code> loop.");'
|
||||
- text: ' <code>filteredList</code> debe ser igual a <code>[{"title": "Inception","rating": "8.8"},{"title": "Interstellar","rating": "8.6"},{"title": "The Dark Knight","rating": "9.0"},{"title": "Batman Begins","rating": "8.3"}]</code> . '
|
||||
- text: ' <code>filteredList</code> debe ser igual a <code>[{"title": "Inception","rating": "8.8"},{"title": "Interstellar","rating": "8.6"},{"title": "The Dark Knight","rating": "9.0"},{"title": "Batman Begins","rating": "8.3"}]</code> . '
|
||||
testString: 'assert.deepEqual(filteredList, [{"title": "Inception","rating": "8.8"},{"title": "Interstellar","rating": "8.6"},{"title": "The Dark Knight","rating": "9.0"},{"title": "Batman Begins","rating": "8.3"}], "<code>filteredList</code> should equal <code>[{"title": "Inception","rating": "8.8"},{"title": "Interstellar","rating": "8.6"},{"title": "The Dark Knight","rating": "9.0"},{"title": "Batman Begins","rating": "8.3"}]</code>.");'
|
||||
|
||||
```
|
||||
|
||||
@@ -6,17 +6,17 @@ challengeType: 1
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
Hasta ahora hemos aprendido a usar funciones puras para evitar efectos secundarios en un programa. Además, hemos visto que el valor de tener una función solo depende de sus argumentos de entrada.
|
||||
Esto es solo el comienzo. Como su nombre lo indica, la programación funcional se centra en una teoría de funciones.
|
||||
Tendría sentido poder pasarlos como argumentos a otras funciones y devolver una función desde otra función. Las funciones se consideran <code>First Class Objects</code> en JavaScript, lo que significa que se pueden usar como cualquier otro objeto. Pueden guardarse en variables, almacenarse en un objeto o pasarse como argumentos de función.
|
||||
Comencemos con algunas funciones de matriz simples, que son métodos en el prototipo de objeto de matriz. En este ejercicio estamos viendo <code>Array.prototype.map()</code> , o más simplemente un <code>map</code> .
|
||||
Recuerde que el método de <code>map</code> es una forma de iterar sobre cada elemento en una matriz. Crea una nueva matriz (sin cambiar la original) después de aplicar una función de devolución de llamada a cada elemento.
|
||||
<section id='description'>
|
||||
Hasta ahora hemos aprendido a usar funciones puras para evitar efectos secundarios en un programa. Además, hemos visto que el valor de tener una función solo depende de sus argumentos de entrada.
|
||||
Esto es solo el comienzo. Como su nombre lo indica, la programación funcional se centra en una teoría de funciones.
|
||||
Tendría sentido poder pasarlos como argumentos a otras funciones y devolver una función desde otra función. Las funciones se consideran <code>First Class Objects</code> en JavaScript, lo que significa que se pueden usar como cualquier otro objeto. Pueden guardarse en variables, almacenarse en un objeto o pasarse como argumentos de función.
|
||||
Comencemos con algunas funciones de matriz simples, que son métodos en el prototipo de objeto de matriz. En este ejercicio estamos viendo <code>Array.prototype.map()</code> , o más simplemente un <code>map</code> .
|
||||
Recuerde que el método de <code>map</code> es una forma de iterar sobre cada elemento en una matriz. Crea una nueva matriz (sin cambiar la original) después de aplicar una función de devolución de llamada a cada elemento.
|
||||
</section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
La matriz <code>watchList</code> contiene objetos con información sobre varias películas. Use el <code>map</code> para extraer el título y la clasificación de la <code>watchList</code> de <code>watchList</code> y guarde la nueva matriz en la variable de <code>rating</code> . El código en el editor actualmente usa un bucle <code>for</code> para hacer esto, reemplaza la funcionalidad de bucle con tu expresión de <code>map</code> .
|
||||
<section id='instructions'>
|
||||
La matriz <code>watchList</code> contiene objetos con información sobre varias películas. Use el <code>map</code> para extraer el título y la clasificación de la <code>watchList</code> de <code>watchList</code> y guarde la nueva matriz en la variable de <code>rating</code> . El código en el editor actualmente usa un bucle <code>for</code> para hacer esto, reemplaza la funcionalidad de bucle con tu expresión de <code>map</code> .
|
||||
</section>
|
||||
|
||||
## Tests
|
||||
@@ -30,7 +30,7 @@ tests:
|
||||
testString: 'assert(!code.match(/for\s*?\(.+?\)/g), "Your code should not use a <code>for</code> loop.");'
|
||||
- text: Su código debe utilizar el método de <code>map</code> .
|
||||
testString: 'assert(code.match(/\.map/g), "Your code should use the <code>map</code> method.");'
|
||||
- text: La <code>rating</code> debería ser igual a <code>[{"title":"Inception","rating":"8.8"},{"title":"Interstellar","rating":"8.6"},{"title":"The Dark Knight","rating":"9.0"},{"title":"Batman Begins","rating":"8.3"},{"title":"Avatar","rating":"7.9"}]</code> . '
|
||||
- text: La <code>rating</code> debería ser igual a <code>[{"title":"Inception","rating":"8.8"},{"title":"Interstellar","rating":"8.6"},{"title":"The Dark Knight","rating":"9.0"},{"title":"Batman Begins","rating":"8.3"},{"title":"Avatar","rating":"7.9"}]</code> . '
|
||||
testString: 'assert(JSON.stringify(rating) === JSON.stringify([{"title":"Inception","rating":"8.8"},{"title":"Interstellar","rating":"8.6"},{"title":"The Dark Knight","rating":"9.0"},{"title":"Batman Begins","rating":"8.3"},{"title":"Avatar","rating":"7.9"}]), "<code>rating</code> should equal <code>[{"title":"Inception","rating":"8.8"},{"title":"Interstellar","rating":"8.6"},{"title":"The Dark Knight","rating":"9.0"},{"title":"Batman Begins","rating":"8.3"},{"title":"Avatar","rating":"7.9"}]</code>.");'
|
||||
|
||||
```
|
||||
|
||||
@@ -6,15 +6,15 @@ challengeType: 1
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
El <code>some</code> método funciona con matrices para comprobar si <em>cualquier</em> elemento pasa una prueba particular. Devuelve un valor booleano: <code>true</code> si alguno de los valores cumple los criterios, <code>false</code> si no.
|
||||
Por ejemplo, el siguiente código verificará si algún elemento de la matriz de <code>numbers</code> es menor que 10:
|
||||
<blockquote>var numbers = [10, 50, 8, 220, 110, 11];<br>numbers.some(function(currentValue) {<br> return currentValue < 10;<br>});<br>// Returns true</blockquote>
|
||||
<section id='description'>
|
||||
El <code>some</code> método funciona con matrices para comprobar si <em>cualquier</em> elemento pasa una prueba particular. Devuelve un valor booleano: <code>true</code> si alguno de los valores cumple los criterios, <code>false</code> si no.
|
||||
Por ejemplo, el siguiente código verificará si algún elemento de la matriz de <code>numbers</code> es menor que 10:
|
||||
<blockquote>var numbers = [10, 50, 8, 220, 110, 11];<br>numbers.some(function(currentValue) {<br> return currentValue < 10;<br>});<br>// Returns true</blockquote>
|
||||
</section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
Use <code>some</code> método dentro de la función <code>checkPositive</code> para verificar si algún elemento en <code>arr</code> es positivo. La función debe devolver un valor booleano.
|
||||
<section id='instructions'>
|
||||
Use <code>some</code> método dentro de la función <code>checkPositive</code> para verificar si algún elemento en <code>arr</code> es positivo. La función debe devolver un valor booleano.
|
||||
</section>
|
||||
|
||||
## Tests
|
||||
@@ -24,11 +24,11 @@ Use <code>some</code> método dentro de la función <code>checkPositive</code> p
|
||||
tests:
|
||||
- text: Su código debe utilizar <code>some</code> método.
|
||||
testString: 'assert(code.match(/\.some/g), "Your code should use the <code>some</code> method.");'
|
||||
- text: ' <code>checkPositive([1, 2, 3, -4, 5])</code> debe devolver <code>true</code> .'
|
||||
- text: ' <code>checkPositive([1, 2, 3, -4, 5])</code> debe devolver <code>true</code> .'
|
||||
testString: 'assert(checkPositive([1, 2, 3, -4, 5]), "<code>checkPositive([1, 2, 3, -4, 5])</code> should return <code>true</code>.");'
|
||||
- text: ' <code>checkPositive([1, 2, 3, 4, 5])</code> debe devolver <code>true</code> .'
|
||||
- text: ' <code>checkPositive([1, 2, 3, 4, 5])</code> debe devolver <code>true</code> .'
|
||||
testString: 'assert(checkPositive([1, 2, 3, 4, 5]), "<code>checkPositive([1, 2, 3, 4, 5])</code> should return <code>true</code>.");'
|
||||
- text: ' <code>checkPositive([-1, -2, -3, -4, -5])</code> debe devolver <code>false</code> .'
|
||||
- text: ' <code>checkPositive([-1, -2, -3, -4, -5])</code> debe devolver <code>false</code> .'
|
||||
testString: 'assert(!checkPositive([-1, -2, -3, -4, -5]), "<code>checkPositive([-1, -2, -3, -4, -5])</code> should return <code>false</code>.");'
|
||||
|
||||
```
|
||||
|
||||
@@ -8,18 +8,18 @@ guideUrl: 'https://spanish.freecodecamp.org/guide/certificates/arguments-optiona
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
Crea una función que suma dos argumentos juntos. Si solo se proporciona un argumento, entonces devuelva una función que espere un argumento y devuelva la suma.
|
||||
Por ejemplo, <code>addTogether(2, 3)</code> debe devolver <code>5</code> y <code>addTogether(2)</code> debe devolver una función.
|
||||
llamar a esta función devuelta con un solo argumento, se devolverá la suma:
|
||||
<code>var sumTwoAnd = addTogether(2);</code>
|
||||
<code>sumTwoAnd(3)</code> devuelve <code>5</code> .
|
||||
Si cualquiera de los argumentos no es un número válido, 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 id='description'>
|
||||
Crea una función que suma dos argumentos juntos. Si solo se proporciona un argumento, entonces devuelva una función que espere un argumento y devuelva la suma.
|
||||
Por ejemplo, <code>addTogether(2, 3)</code> debe devolver <code>5</code> y <code>addTogether(2)</code> debe devolver una función.
|
||||
llamar a esta función devuelta con un solo argumento, se devolverá la suma:
|
||||
<code>var sumTwoAnd = addTogether(2);</code>
|
||||
<code>sumTwoAnd(3)</code> devuelve <code>5</code> .
|
||||
Si cualquiera de los argumentos no es un número válido, 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>
|
||||
|
||||
@@ -28,15 +28,15 @@ Recuerda usar <a href='http://forum.freecodecamp.org/t/how-to-get-help-when-you-
|
||||
|
||||
```yml
|
||||
tests:
|
||||
- text: ' <code>addTogether(2, 3)</code> debe devolver 5.'
|
||||
- text: ' <code>addTogether(2, 3)</code> debe devolver 5.'
|
||||
testString: 'assert.deepEqual(addTogether(2, 3), 5, "<code>addTogether(2, 3)</code> should return 5.");'
|
||||
- text: <code>addTogether(2)(3)</code> debe devolver 5.
|
||||
testString: 'assert.deepEqual(addTogether(2)(3), 5, "<code>addTogether(2)(3)</code> should return 5.");'
|
||||
- text: ' <code>addTogether("http://bit.ly/IqT6zt")</code> debe devolver undefined.'
|
||||
- text: ' <code>addTogether("http://bit.ly/IqT6zt")</code> debe devolver undefined.'
|
||||
testString: 'assert.isUndefined(addTogether("http://bit.ly/IqT6zt"), "<code>addTogether("http://bit.ly/IqT6zt")</code> should return undefined.");'
|
||||
- text: ' <code>addTogether(2, "3")</code> debe devolver indefinido.'
|
||||
- text: ' <code>addTogether(2, "3")</code> debe devolver indefinido.'
|
||||
testString: 'assert.isUndefined(addTogether(2, "3"), "<code>addTogether(2, "3")</code> should return undefined.");'
|
||||
- text: ' <code>addTogether(2)([3])</code> debe devolver indefinido.'
|
||||
- text: ' <code>addTogether(2)([3])</code> debe devolver indefinido.'
|
||||
testString: 'assert.isUndefined(addTogether(2)([3]), "<code>addTogether(2)([3])</code> should return undefined.");'
|
||||
|
||||
```
|
||||
|
||||
@@ -7,14 +7,14 @@ challengeType: 5
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
Devuelve una frase traducida al inglés de la cadena binaria pasada.
|
||||
La cadena binaria estará separada por espacios.
|
||||
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 id='description'>
|
||||
Devuelve una frase traducida al inglés de la cadena binaria pasada.
|
||||
La cadena binaria estará separada por espacios.
|
||||
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>
|
||||
|
||||
@@ -23,7 +23,7 @@ Recuerda usar <a href='http://forum.freecodecamp.org/t/how-to-get-help-when-you-
|
||||
|
||||
```yml
|
||||
tests:
|
||||
- text: ' <code>binaryAgent("01000001 01110010 01100101 01101110 00100111 01110100 00100000 01100010 01101111 01101110 01100110 01101001 01110010 01100101 01110011 00100000 01100110 01110101 01101110 00100001 00111111")</code> ' '' '' '' '' '' '' '' '' '' '' '' '' '' '' '' '.
|
||||
- text: ' <code>binaryAgent("01000001 01110010 01100101 01101110 00100111 01110100 00100000 01100010 01101111 01101110 01100110 01101001 01110010 01100101 01110011 00100000 01100110 01110101 01101110 00100001 00111111")</code> ' '' '' '' '' '' '' '' '' '' '' '' '' '' '' '' '
|
||||
testString: 'assert.deepEqual(binaryAgent("01000001 01110010 01100101 01101110 00100111 01110100 00100000 01100010 01101111 01101110 01100110 01101001 01110010 01100101 01110011 00100000 01100110 01110101 01101110 00100001 00111111"), "Aren"t bonfires fun!?", "<code>binaryAgent("01000001 01110010 01100101 01101110 00100111 01110100 00100000 01100010 01101111 01101110 01100110 01101001 01110010 01100101 01110011 00100000 01100110 01110101 01101110 00100001 00111111")</code> should return "Aren't bonfires fun!?"");'
|
||||
- text: <code>binaryAgent("01001001 00100000 01101100 01101111 01110110 01100101 00100000 01000110 01110010 01100101 01100101 01000011 01101111 01100100 01100101 01000011 01100001 01101101 01110000 00100001")</code> 0011.
|
||||
testString: 'assert.deepEqual(binaryAgent("01001001 00100000 01101100 01101111 01110110 01100101 00100000 01000110 01110010 01100101 01100101 01000011 01101111 01100100 01100101 01000011 01100001 01101101 01110000 00100001"), "I love FreeCodeCamp!", "<code>binaryAgent("01001001 00100000 01101100 01101111 01110110 01100101 00100000 01000110 01110010 01100101 01100101 01000011 01101111 01100100 01100101 01000011 01100001 01101101 01110000 00100001")</code> should return "I love FreeCodeCamp!"");'
|
||||
|
||||
@@ -7,13 +7,13 @@ challengeType: 5
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
Convierta los caracteres <code>&</code> , <code><</code> , <code>></code> , <code>"</code> (comillas dobles) y <code>'</code> (apóstrofe), en una cadena a sus entidades HTML correspondientes.
|
||||
Recuerde usar <a href='http://forum.freecodecamp.org/t/how-to-get-help-when-you-are-stuck/19514' target='_blank'>Lectura-Búsqueda-Preguntar</a> si se atasca. Intente vincular el programa. Escribe tu propio código.
|
||||
<section id='description'>
|
||||
Convierta los caracteres <code>&</code> , <code><</code> , <code>></code> , <code>"</code> (comillas dobles) y <code>'</code> (apóstrofe), en una cadena a sus entidades HTML correspondientes.
|
||||
Recuerde usar <a href='http://forum.freecodecamp.org/t/how-to-get-help-when-you-are-stuck/19514' target='_blank'>Lectura-Búsqueda-Preguntar</a> si se atasca. Intente vincular el programa. Escribe tu propio código.
|
||||
</section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
<section id='instructions'>
|
||||
|
||||
</section>
|
||||
|
||||
@@ -22,17 +22,17 @@ Recuerde usar <a href='http://forum.freecodecamp.org/t/how-to-get-help-when-you-
|
||||
|
||||
```yml
|
||||
tests:
|
||||
- text: ' <code>convertHTML("Dolce & Gabbana")</code> debe devolver <code>Dolce &amp; Gabbana</code> .
|
||||
- text: ' <code>convertHTML("Dolce & Gabbana")</code> debe devolver <code>Dolce &amp; Gabbana</code> .
|
||||
testString: 'assert.match(convertHTML("Dolce & Gabbana"), /Dolce & Gabbana/, "<code>convertHTML("Dolce & Gabbana")</code> should return <code>Dolce &​amp; Gabbana</code>.");'
|
||||
- text: ' <code>convertHTML("Hamburgers < Pizza < Tacos")</code> debe devolver <code>Hamburgers &lt; Pizza &lt; Tacos</code> .
|
||||
- text: ' <code>convertHTML("Hamburgers < Pizza < Tacos")</code> debe devolver <code>Hamburgers &lt; Pizza &lt; Tacos</code> .
|
||||
testString: 'assert.match(convertHTML("Hamburgers < Pizza < Tacos"), /Hamburgers < Pizza < Tacos/, "<code>convertHTML("Hamburgers < Pizza < Tacos")</code> should return <code>Hamburgers &​lt; Pizza &​lt; Tacos</code>.");'
|
||||
- text: ' <code>convertHTML("Sixty > twelve")</code> debe devolver <code>Sixty &gt; twelve</code> .
|
||||
- text: ' <code>convertHTML("Sixty > twelve")</code> debe devolver <code>Sixty &gt; twelve</code> .
|
||||
testString: 'assert.match(convertHTML("Sixty > twelve"), /Sixty > twelve/, "<code>convertHTML("Sixty > twelve")</code> should return <code>Sixty &​gt; twelve</code>.");'
|
||||
- text: ' <code>convertHTML('Stuff in "quotation marks"')</code> debería devolver <code>Stuff in &quot;quotation marks&quot;</code> .
|
||||
- text: ' <code>convertHTML('Stuff in "quotation marks"')</code> debería devolver <code>Stuff in &quot;quotation marks&quot;</code> .
|
||||
testString: 'assert.match(convertHTML("Stuff in "quotation marks""), /Stuff in "quotation marks"/, "<code>convertHTML('Stuff in "quotation marks"')</code> should return <code>Stuff in &​quot;quotation marks&​quot;</code>.");'
|
||||
- text: ' <code>convertHTML("Schindler's List")</code> debe devolver la <code>Schindler&apos;s List</code> .
|
||||
- text: ' <code>convertHTML("Schindler's List")</code> debe devolver la <code>Schindler&apos;s List</code> .
|
||||
testString: 'assert.match(convertHTML("Schindler"s List"), /Schindler's List/, "<code>convertHTML("Schindler's List")</code> should return <code>Schindler&​apos;s List</code>.");'
|
||||
- text: ' <code>convertHTML("<>")</code> debe devolver <code>&lt;&gt;</code> .
|
||||
- text: ' <code>convertHTML("<>")</code> debe devolver <code>&lt;&gt;</code> .
|
||||
testString: 'assert.match(convertHTML("<>"), /<>/, "<code>convertHTML("<>")</code> should return <code>&​lt;&​gt;</code>.");'
|
||||
- text: <code>convertHTML("abc")</code> debe devolver <code>abc</code> .
|
||||
testString: 'assert.strictEqual(convertHTML("abc"), "abc", "<code>convertHTML("abc")</code> should return <code>abc</code>.");'
|
||||
|
||||
@@ -7,14 +7,14 @@ challengeType: 5
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
Compare dos arreglos y devuelva un nuevo arreglo con los elementos que solo se encuentran en uno de los dos arreglos dados, pero no en ambos. En otras palabras, devuelva la diferencia simétrica de las dos matrices.
|
||||
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.
|
||||
<strong>Nota</strong> <br> Puede devolver la matriz con sus elementos en cualquier orden.
|
||||
<section id='description'>
|
||||
Compare dos arreglos y devuelva un nuevo arreglo con los elementos que solo se encuentran en uno de los dos arreglos dados, pero no en ambos. En otras palabras, devuelva la diferencia simétrica de las dos matrices.
|
||||
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.
|
||||
<strong>Nota</strong> <br> Puede devolver la matriz con sus elementos en cualquier orden.
|
||||
</section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
<section id='instructions'>
|
||||
|
||||
</section>
|
||||
|
||||
@@ -23,35 +23,35 @@ Recuerda usar <a href='http://forum.freecodecamp.org/t/how-to-get-help-when-you-
|
||||
|
||||
```yml
|
||||
tests:
|
||||
- text: ' <code>diffArray([1, 2, 3, 5], [1, 2, 3, 4, 5])</code> debe devolver una matriz.'
|
||||
- text: ' <code>diffArray([1, 2, 3, 5], [1, 2, 3, 4, 5])</code> debe devolver una matriz.'
|
||||
testString: 'assert(typeof diffArray([1, 2, 3, 5], [1, 2, 3, 4, 5]) === "object", "<code>diffArray([1, 2, 3, 5], [1, 2, 3, 4, 5])</code> should return an array.");'
|
||||
- text: ' <code>["diorite", "andesite", "grass", "dirt", "pink wool", "dead shrub"], ["diorite", "andesite", "grass", "dirt", "dead shrub"]</code> debe devolver <code>["pink wool"]</code> . '
|
||||
- text: ' <code>["diorite", "andesite", "grass", "dirt", "pink wool", "dead shrub"], ["diorite", "andesite", "grass", "dirt", "dead shrub"]</code> debe devolver <code>["pink wool"]</code> . '
|
||||
testString: 'assert.sameMembers(diffArray(["diorite", "andesite", "grass", "dirt", "pink wool", "dead shrub"], ["diorite", "andesite", "grass", "dirt", "dead shrub"]), ["pink wool"], "<code>["diorite", "andesite", "grass", "dirt", "pink wool", "dead shrub"], ["diorite", "andesite", "grass", "dirt", "dead shrub"]</code> should return <code>["pink wool"]</code>.");'
|
||||
- text: ' <code>["diorite", "andesite", "grass", "dirt", "pink wool", "dead shrub"], ["diorite", "andesite", "grass", "dirt", "dead shrub"]</code> debería devolver una matriz con un elemento '.
|
||||
- text: ' <code>["diorite", "andesite", "grass", "dirt", "pink wool", "dead shrub"], ["diorite", "andesite", "grass", "dirt", "dead shrub"]</code> debería devolver una matriz con un elemento '
|
||||
testString: 'assert(diffArray(["diorite", "andesite", "grass", "dirt", "pink wool", "dead shrub"], ["diorite", "andesite", "grass", "dirt", "dead shrub"]).length === 1, "<code>["diorite", "andesite", "grass", "dirt", "pink wool", "dead shrub"], ["diorite", "andesite", "grass", "dirt", "dead shrub"]</code> should return an array with one item.");'
|
||||
- text: ' <code>["andesite", "grass", "dirt", "pink wool", "dead shrub"], ["diorite", "andesite", "grass", "dirt", "dead shrub"]</code> debe devolver <code>["diorite", "pink wool"]</code> .
|
||||
- text: ' <code>["andesite", "grass", "dirt", "pink wool", "dead shrub"], ["diorite", "andesite", "grass", "dirt", "dead shrub"]</code> debe devolver <code>["diorite", "pink wool"]</code> .
|
||||
testString: 'assert.sameMembers(diffArray(["andesite", "grass", "dirt", "pink wool", "dead shrub"], ["diorite", "andesite", "grass", "dirt", "dead shrub"]), ["diorite", "pink wool"], "<code>["andesite", "grass", "dirt", "pink wool", "dead shrub"], ["diorite", "andesite", "grass", "dirt", "dead shrub"]</code> should return <code>["diorite", "pink wool"]</code>.");'
|
||||
- text: ' <code>["andesite", "grass", "dirt", "pink wool", "dead shrub"], ["diorite", "andesite", "grass", "dirt", "dead shrub"]</code> debe devolver una matriz con dos elementos.
|
||||
- text: ' <code>["andesite", "grass", "dirt", "pink wool", "dead shrub"], ["diorite", "andesite", "grass", "dirt", "dead shrub"]</code> debe devolver una matriz con dos elementos.
|
||||
testString: 'assert(diffArray(["andesite", "grass", "dirt", "pink wool", "dead shrub"], ["diorite", "andesite", "grass", "dirt", "dead shrub"]).length === 2, "<code>["andesite", "grass", "dirt", "pink wool", "dead shrub"], ["diorite", "andesite", "grass", "dirt", "dead shrub"]</code> should return an array with two items.");'
|
||||
- text: ' <code>["andesite", "grass", "dirt", "dead shrub"], ["andesite", "grass", "dirt", "dead shrub"]</code> debe devolver <code>[]</code> .'
|
||||
- text: ' <code>["andesite", "grass", "dirt", "dead shrub"], ["andesite", "grass", "dirt", "dead shrub"]</code> debe devolver <code>[]</code> .'
|
||||
testString: 'assert.sameMembers(diffArray(["andesite", "grass", "dirt", "dead shrub"], ["andesite", "grass", "dirt", "dead shrub"]), [], "<code>["andesite", "grass", "dirt", "dead shrub"], ["andesite", "grass", "dirt", "dead shrub"]</code> should return <code>[]</code>.");'
|
||||
- text: ' <code>["andesite", "grass", "dirt", "dead shrub"], ["andesite", "grass", "dirt", "dead shrub"]</code> debe devolver una matriz vacía.'
|
||||
- text: ' <code>["andesite", "grass", "dirt", "dead shrub"], ["andesite", "grass", "dirt", "dead shrub"]</code> debe devolver una matriz vacía.'
|
||||
testString: 'assert(diffArray(["andesite", "grass", "dirt", "dead shrub"], ["andesite", "grass", "dirt", "dead shrub"]).length === 0, "<code>["andesite", "grass", "dirt", "dead shrub"], ["andesite", "grass", "dirt", "dead shrub"]</code> should return an empty array.");'
|
||||
- text: ' <code>[1, 2, 3, 5], [1, 2, 3, 4, 5]</code> debe devolver <code>[4]</code> .'
|
||||
- text: ' <code>[1, 2, 3, 5], [1, 2, 3, 4, 5]</code> debe devolver <code>[4]</code> .'
|
||||
testString: 'assert.sameMembers(diffArray([1, 2, 3, 5], [1, 2, 3, 4, 5]), [4], "<code>[1, 2, 3, 5], [1, 2, 3, 4, 5]</code> should return <code>[4]</code>.");'
|
||||
- text: ' <code>[1, 2, 3, 5], [1, 2, 3, 4, 5]</code> debe devolver una matriz con un elemento.'
|
||||
- text: ' <code>[1, 2, 3, 5], [1, 2, 3, 4, 5]</code> debe devolver una matriz con un elemento.'
|
||||
testString: 'assert(diffArray([1, 2, 3, 5], [1, 2, 3, 4, 5]).length === 1, "<code>[1, 2, 3, 5], [1, 2, 3, 4, 5]</code> should return an array with one item.");'
|
||||
- text: ' <code>[1, "calf", 3, "piglet"], [1, "calf", 3, 4]</code> debe devolver <code>["piglet", 4]</code> .'
|
||||
- text: ' <code>[1, "calf", 3, "piglet"], [1, "calf", 3, 4]</code> debe devolver <code>["piglet", 4]</code> .'
|
||||
testString: 'assert.sameMembers(diffArray([1, "calf", 3, "piglet"], [1, "calf", 3, 4]), ["piglet", 4], "<code>[1, "calf", 3, "piglet"], [1, "calf", 3, 4]</code> should return <code>["piglet", 4]</code>.");'
|
||||
- text: ' <code>[1, "calf", 3, "piglet"], [1, "calf", 3, 4]</code> debe devolver una matriz con dos elementos.'
|
||||
- text: ' <code>[1, "calf", 3, "piglet"], [1, "calf", 3, 4]</code> debe devolver una matriz con dos elementos.'
|
||||
testString: 'assert(diffArray([1, "calf", 3, "piglet"], [1, "calf", 3, 4]).length === 2, "<code>[1, "calf", 3, "piglet"], [1, "calf", 3, 4]</code> should return an array with two items.");'
|
||||
- text: ' <code>[], ["snuffleupagus", "cookie monster", "elmo"]</code> debe devolver <code>["snuffleupagus", "cookie monster", "elmo"]</code> .'
|
||||
- text: ' <code>[], ["snuffleupagus", "cookie monster", "elmo"]</code> debe devolver <code>["snuffleupagus", "cookie monster", "elmo"]</code> .'
|
||||
testString: 'assert.sameMembers(diffArray([], ["snuffleupagus", "cookie monster", "elmo"]), ["snuffleupagus", "cookie monster", "elmo"], "<code>[], ["snuffleupagus", "cookie monster", "elmo"]</code> should return <code>["snuffleupagus", "cookie monster", "elmo"]</code>.");'
|
||||
- text: ' <code>[], ["snuffleupagus", "cookie monster", "elmo"]</code> debe devolver una matriz con tres elementos.'
|
||||
- text: ' <code>[], ["snuffleupagus", "cookie monster", "elmo"]</code> debe devolver una matriz con tres elementos.'
|
||||
testString: 'assert(diffArray([], ["snuffleupagus", "cookie monster", "elmo"]).length === 3, "<code>[], ["snuffleupagus", "cookie monster", "elmo"]</code> should return an array with three items.");'
|
||||
- text: ' <code>[1, "calf", 3, "piglet"], [7, "filly"]</code> debe devolver <code>[1, "calf", 3, "piglet", 7, "filly"]</code> .'
|
||||
- text: ' <code>[1, "calf", 3, "piglet"], [7, "filly"]</code> debe devolver <code>[1, "calf", 3, "piglet", 7, "filly"]</code> .'
|
||||
testString: 'assert.sameMembers(diffArray([1, "calf", 3, "piglet"], [7, "filly"]), [1, "calf", 3, "piglet", 7, "filly"], "<code>[1, "calf", 3, "piglet"], [7, "filly"]</code> should return <code>[1, "calf", 3, "piglet", 7, "filly"]</code>.");'
|
||||
- text: ' <code>[1, "calf", 3, "piglet"], [7, "filly"]</code> debe devolver una matriz con seis elementos.'
|
||||
- text: ' <code>[1, "calf", 3, "piglet"], [7, "filly"]</code> debe devolver una matriz con seis elementos.'
|
||||
testString: 'assert(diffArray([1, "calf", 3, "piglet"], [7, "filly"]).length === 6, "<code>[1, "calf", 3, "piglet"], [7, "filly"]</code> should return an array with six items.");'
|
||||
|
||||
```
|
||||
|
||||
@@ -7,17 +7,17 @@ challengeType: 5
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
A la cadena de ADN le falta el elemento de emparejamiento. Tome cada carácter, obtenga su par y devuelva los resultados como una matriz 2d.
|
||||
<a href="http://en.wikipedia.org/wiki/Base_pair" target="_blank">pares de bases</a> son un par de AT y CG. Empareja el elemento que falta con el carácter proporcionado.
|
||||
Devuelve el carácter proporcionado como el primer elemento en cada matriz.
|
||||
Por ejemplo, para la entrada GCG, devuelva [["G", "C"], ["C", "G"], ["G", "C"]]
|
||||
El carácter y su par están emparejados en una matriz, y todas las matrices se agrupan en una matriz de encapsulació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. Trate de emparejar el programa. Escribe tu propio código.
|
||||
<section id='description'>
|
||||
A la cadena de ADN le falta el elemento de emparejamiento. Tome cada carácter, obtenga su par y devuelva los resultados como una matriz 2d.
|
||||
<a href="http://en.wikipedia.org/wiki/Base_pair" target="_blank">pares de bases</a> son un par de AT y CG. Empareja el elemento que falta con el carácter proporcionado.
|
||||
Devuelve el carácter proporcionado como el primer elemento en cada matriz.
|
||||
Por ejemplo, para la entrada GCG, devuelva [["G", "C"], ["C", "G"], ["G", "C"]]
|
||||
El carácter y su par están emparejados en una matriz, y todas las matrices se agrupan en una matriz de encapsulació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. Trate de emparejar el programa. Escribe tu propio código.
|
||||
</section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
<section id='instructions'>
|
||||
|
||||
</section>
|
||||
|
||||
@@ -26,11 +26,11 @@ Recuerda usar <a href='http://forum.freecodecamp.org/t/how-to-get-help-when-you-
|
||||
|
||||
```yml
|
||||
tests:
|
||||
- text: ' <code>pairElement("ATCGA")</code> debe devolver <code>[["A","T"],["T","A"],["C","G"],["G","C"],["A","T"]]</code> . '
|
||||
- text: ' <code>pairElement("ATCGA")</code> debe devolver <code>[["A","T"],["T","A"],["C","G"],["G","C"],["A","T"]]</code> . '
|
||||
testString: 'assert.deepEqual(pairElement("ATCGA"),[["A","T"],["T","A"],["C","G"],["G","C"],["A","T"]], "<code>pairElement("ATCGA")</code> should return <code>[["A","T"],["T","A"],["C","G"],["G","C"],["A","T"]]</code>.");'
|
||||
- text: ' <code>pairElement("TTGAG")</code> debe devolver <code>[["T","A"],["T","A"],["G","C"],["A","T"],["G","C"]]</code> . '
|
||||
- text: ' <code>pairElement("TTGAG")</code> debe devolver <code>[["T","A"],["T","A"],["G","C"],["A","T"],["G","C"]]</code> . '
|
||||
testString: 'assert.deepEqual(pairElement("TTGAG"),[["T","A"],["T","A"],["G","C"],["A","T"],["G","C"]], "<code>pairElement("TTGAG")</code> should return <code>[["T","A"],["T","A"],["G","C"],["A","T"],["G","C"]]</code>.");'
|
||||
- text: ' <code>pairElement("CTCTA")</code> debe devolver <code>[["C","G"],["T","A"],["C","G"],["T","A"],["A","T"]]</code> . '
|
||||
- text: ' <code>pairElement("CTCTA")</code> debe devolver <code>[["C","G"],["T","A"],["C","G"],["T","A"],["A","T"]]</code> . '
|
||||
testString: 'assert.deepEqual(pairElement("CTCTA"),[["C","G"],["T","A"],["C","G"],["T","A"],["A","T"]], "<code>pairElement("CTCTA")</code> should return <code>[["C","G"],["T","A"],["C","G"],["T","A"],["A","T"]]</code>.");'
|
||||
|
||||
```
|
||||
|
||||
@@ -7,14 +7,14 @@ challengeType: 5
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
Dado la matriz <code>arr</code> , iterar a través y eliminar cada elemento comenzando desde el primer elemento (el índice 0) hasta que la función <code>func</code> devuelva <code>true</code> cuando el elemento iterado se pasa a través de él.
|
||||
Luego, devuelva el resto de la matriz una vez que se cumpla la condición; de lo contrario, <code>arr</code> debe devolverse como una matriz vacía.
|
||||
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 id='description'>
|
||||
Dado la matriz <code>arr</code> , iterar a través y eliminar cada elemento comenzando desde el primer elemento (el índice 0) hasta que la función <code>func</code> devuelva <code>true</code> cuando el elemento iterado se pasa a través de él.
|
||||
Luego, devuelva el resto de la matriz una vez que se cumpla la condición; de lo contrario, <code>arr</code> debe devolverse como una matriz vacía.
|
||||
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>
|
||||
|
||||
@@ -23,17 +23,17 @@ Recuerda usar <a href='http://forum.freecodecamp.org/t/how-to-get-help-when-you-
|
||||
|
||||
```yml
|
||||
tests:
|
||||
- text: ' <code>dropElements([1, 2, 3, 4], function(n) {return n >= 3;})</code> debe devolver <code>[3, 4]</code> .'
|
||||
- text: ' <code>dropElements([1, 2, 3, 4], function(n) {return n >= 3;})</code> debe devolver <code>[3, 4]</code> .'
|
||||
testString: 'assert.deepEqual(dropElements([1, 2, 3, 4], function(n) {return n >= 3;}), [3, 4], "<code>dropElements([1, 2, 3, 4], function(n) {return n >= 3;})</code> should return <code>[3, 4]</code>.");'
|
||||
- text: ' <code>dropElements([0, 1, 0, 1], function(n) {return n === 1;})</code> debe devolver <code>[1, 0, 1]</code> .'
|
||||
- text: ' <code>dropElements([0, 1, 0, 1], function(n) {return n === 1;})</code> debe devolver <code>[1, 0, 1]</code> .'
|
||||
testString: 'assert.deepEqual(dropElements([0, 1, 0, 1], function(n) {return n === 1;}), [1, 0, 1], "<code>dropElements([0, 1, 0, 1], function(n) {return n === 1;})</code> should return <code>[1, 0, 1]</code>.");'
|
||||
- text: ' <code>dropElements([1, 2, 3], function(n) {return n > 0;})</code> debe devolver <code>[1, 2, 3]</code> .'
|
||||
- text: ' <code>dropElements([1, 2, 3], function(n) {return n > 0;})</code> debe devolver <code>[1, 2, 3]</code> .'
|
||||
testString: 'assert.deepEqual(dropElements([1, 2, 3], function(n) {return n > 0;}), [1, 2, 3], "<code>dropElements([1, 2, 3], function(n) {return n > 0;})</code> should return <code>[1, 2, 3]</code>.");'
|
||||
- text: ' <code>dropElements([1, 2, 3, 4], function(n) {return n > 5;})</code> debe devolver <code>[]</code> .'
|
||||
- text: ' <code>dropElements([1, 2, 3, 4], function(n) {return n > 5;})</code> debe devolver <code>[]</code> .'
|
||||
testString: 'assert.deepEqual(dropElements([1, 2, 3, 4], function(n) {return n > 5;}), [], "<code>dropElements([1, 2, 3, 4], function(n) {return n > 5;})</code> should return <code>[]</code>.");'
|
||||
- text: ' <code>dropElements([1, 2, 3, 7, 4], function(n) {return n > 3;})</code> debe devolver <code>[7, 4]</code> .'
|
||||
- text: ' <code>dropElements([1, 2, 3, 7, 4], function(n) {return n > 3;})</code> debe devolver <code>[7, 4]</code> .'
|
||||
testString: 'assert.deepEqual(dropElements([1, 2, 3, 7, 4], function(n) {return n > 3;}), [7, 4], "<code>dropElements([1, 2, 3, 7, 4], function(n) {return n > 3;})</code> should return <code>[7, 4]</code>.");'
|
||||
- text: ' <code>dropElements([1, 2, 3, 9, 2], function(n) {return n > 2;})</code> debe devolver <code>[3, 9, 2]</code> .'
|
||||
- text: ' <code>dropElements([1, 2, 3, 9, 2], function(n) {return n > 2;})</code> debe devolver <code>[3, 9, 2]</code> .'
|
||||
testString: 'assert.deepEqual(dropElements([1, 2, 3, 9, 2], function(n) {return n > 2;}), [3, 9, 2], "<code>dropElements([1, 2, 3, 9, 2], function(n) {return n > 2;})</code> should return <code>[3, 9, 2]</code>.");'
|
||||
|
||||
```
|
||||
|
||||
@@ -7,48 +7,51 @@ challengeType: 5
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
Compruebe si el predicado (segundo argumento) es <dfn>verdadero</dfn> en todos los elementos de una colección (primer argumento).
|
||||
En otras palabras, se le da una colección de objetos de matriz. El predicado <code>pre</code> será una propiedad de objeto y debe devolver <code>true</code> si su valor es <code>truthy</code> . De lo contrario, devuelve <code>false</code> .
|
||||
En JavaScript, los valores de <code>truthy</code> son valores que se convierten en <code>true</code> cuando se evalúan en un contexto booleano.
|
||||
Recuerde, puede acceder a las propiedades del objeto a través de la notación de puntos o la notación de <code>[]</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. Trate de emparejar el programa. Escribe tu propio código.
|
||||
|
||||
<section id='description'>
|
||||
Compruebe si el predicado (segundo argumento) es <dfn>verdadero</dfn> en todos los elementos de una colección (primer argumento).
|
||||
En otras palabras, se le da una colección de objetos de matriz. El predicado <code>pre</code> será una propiedad de objeto y debe devolver <code>true</code> si su valor es <code>truthy</code> . De lo contrario, devuelve <code>false</code> .
|
||||
En JavaScript, los valores de <code>truthy</code> son valores que se convierten en <code>true</code> cuando se evalúan en un contexto booleano.
|
||||
Recuerde, puede acceder a las propiedades del objeto a través de la notación de puntos o la notación de <code>[]</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. Trate de emparejar el programa. Escribe tu propio código.
|
||||
</section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
|
||||
<section id='instructions'>
|
||||
|
||||
</section>
|
||||
|
||||
## Tests
|
||||
|
||||
<section id='tests'>
|
||||
|
||||
```yml
|
||||
tests:
|
||||
- text: ' <code>truthCheck([{"user": "Tinky-Winky", "sex": "male"}, {"user": "Dipsy", "sex": "male"}, {"user": "Laa-Laa", "sex": "female"}, {"user": "Po", "sex": "female"}], "sex")</code> debe devolver el valor".
|
||||
- text: ' <code>truthCheck([{"user": "Tinky-Winky", "sex": "male"}, {"user": "Dipsy", "sex": "male"}, {"user": "Laa-Laa", "sex": "female"}, {"user": "Po", "sex": "female"}], "sex")</code> debe devolver el valor".'
|
||||
testString: 'assert.strictEqual(truthCheck([{"user": "Tinky-Winky", "sex": "male"}, {"user": "Dipsy", "sex": "male"}, {"user": "Laa-Laa", "sex": "female"}, {"user": "Po", "sex": "female"}], "sex"), true, "<code>truthCheck([{"user": "Tinky-Winky", "sex": "male"}, {"user": "Dipsy", "sex": "male"}, {"user": "Laa-Laa", "sex": "female"}, {"user": "Po", "sex": "female"}], "sex")</code> should return true.");'
|
||||
- text: ' <code>truthCheck([{"user": "Tinky-Winky", "sex": "male"}, {"user": "Dipsy"}, {"user": "Laa-Laa", "sex": "female"}, {"user": "Po", "sex": "female"}], "sex")</code> debe devolver falso.
|
||||
- text: ' <code>truthCheck([{"user": "Tinky-Winky", "sex": "male"}, {"user": "Dipsy"}, {"user": "Laa-Laa", "sex": "female"}, {"user": "Po", "sex": "female"}], "sex")</code> debe devolver falso.'
|
||||
testString: 'assert.strictEqual(truthCheck([{"user": "Tinky-Winky", "sex": "male"}, {"user": "Dipsy"}, {"user": "Laa-Laa", "sex": "female"}, {"user": "Po", "sex": "female"}], "sex"), false, "<code>truthCheck([{"user": "Tinky-Winky", "sex": "male"}, {"user": "Dipsy"}, {"user": "Laa-Laa", "sex": "female"}, {"user": "Po", "sex": "female"}], "sex")</code> should return false.");'
|
||||
- text: ' <code>truthCheck([{"user": "Tinky-Winky", "sex": "male", "age": 0}, {"user": "Dipsy", "sex": "male", "age": 3}, {"user": "Laa-Laa", "sex": "female", "age": 5}, {"user": "Po", "sex": "female", "age": 4}], "age")</code> debe devolver falso.
|
||||
- text: ' <code>truthCheck([{"user": "Tinky-Winky", "sex": "male", "age": 0}, {"user": "Dipsy", "sex": "male", "age": 3}, {"user": "Laa-Laa", "sex": "female", "age": 5}, {"user": "Po", "sex": "female", "age": 4}], "age")</code> debe devolver falso.'
|
||||
testString: 'assert.strictEqual(truthCheck([{"user": "Tinky-Winky", "sex": "male", "age": 2}, {"user": "Dipsy", "sex": "male", "age": 0}, {"user": "Laa-Laa", "sex": "female", "age": 5}, {"user": "Po", "sex": "female", "age": 4}], "age"), false, "<code>truthCheck([{"user": "Tinky-Winky", "sex": "male", "age": 0}, {"user": "Dipsy", "sex": "male", "age": 3}, {"user": "Laa-Laa", "sex": "female", "age": 5}, {"user": "Po", "sex": "female", "age": 4}], "age")</code> should return false.");'
|
||||
- text: ' <code>truthCheck([{"name": "Pete", "onBoat": true}, {"name": "Repeat", "onBoat": true}, {"name": "FastFoward", "onBoat": null}], "onBoat")</code> debe devolver falso '
|
||||
- text: ' <code>truthCheck([{"name": "Pete", "onBoat": true}, {"name": "Repeat", "onBoat": true}, {"name": "FastFoward", "onBoat": null}], "onBoat")</code> debe devolver falso '
|
||||
testString: 'assert.strictEqual(truthCheck([{"name": "Pete", "onBoat": true}, {"name": "Repeat", "onBoat": true}, {"name": "FastFoward", "onBoat": null}], "onBoat"), false, "<code>truthCheck([{"name": "Pete", "onBoat": true}, {"name": "Repeat", "onBoat": true}, {"name": "FastFoward", "onBoat": null}], "onBoat")</code> should return false");'
|
||||
- text: ' <code>truthCheck([{"name": "Pete", "onBoat": true}, {"name": "Repeat", "onBoat": true, "alias": "Repete"}, {"name": "FastFoward", "onBoat": true}], "onBoat")</code> debe devolver true '
|
||||
- text: ' <code>truthCheck([{"name": "Pete", "onBoat": true}, {"name": "Repeat", "onBoat": true, "alias": "Repete"}, {"name": "FastFoward", "onBoat": true}], "onBoat")</code> debe devolver true '
|
||||
testString: 'assert.strictEqual(truthCheck([{"name": "Pete", "onBoat": true}, {"name": "Repeat", "onBoat": true, "alias": "Repete"}, {"name": "FastFoward", "onBoat": true}], "onBoat"), true, "<code>truthCheck([{"name": "Pete", "onBoat": true}, {"name": "Repeat", "onBoat": true, "alias": "Repete"}, {"name": "FastFoward", "onBoat": true}], "onBoat")</code> should return true");'
|
||||
- text: ' <code>truthCheck([{"single": "yes"}], "single")</code> debe devolver verdadero'
|
||||
- text: ' <code>truthCheck([{"single": "yes"}], "single")</code> debe devolver verdadero'
|
||||
testString: 'assert.strictEqual(truthCheck([{"single": "yes"}], "single"), true, "<code>truthCheck([{"single": "yes"}], "single")</code> should return true");'
|
||||
- text: ' <code>truthCheck([{"single": ""}, {"single": "double"}], "single")</code> debe devolver falso'
|
||||
- text: ' <code>truthCheck([{"single": ""}, {"single": "double"}], "single")</code> debe devolver falso'
|
||||
testString: 'assert.strictEqual(truthCheck([{"single": ""}, {"single": "double"}], "single"), false, "<code>truthCheck([{"single": ""}, {"single": "double"}], "single")</code> should return false");'
|
||||
- text: ' <code>truthCheck([{"single": "double"}, {"single": undefined}], "single")</code> debe devolver falso'
|
||||
- text: ' <code>truthCheck([{"single": "double"}, {"single": undefined}], "single")</code> debe devolver falso'
|
||||
testString: 'assert.strictEqual(truthCheck([{"single": "double"}, {"single": undefined}], "single"), false, "<code>truthCheck([{"single": "double"}, {"single": undefined}], "single")</code> should return false");'
|
||||
- text: ' <code>truthCheck([{"single": "double"}, {"single": NaN}], "single")</code> debe devolver falso'
|
||||
- text: ' <code>truthCheck([{"single": "double"}, {"single": NaN}], "single")</code> debe devolver falso'
|
||||
testString: 'assert.strictEqual(truthCheck([{"single": "double"}, {"single": NaN}], "single"), false, "<code>truthCheck([{"single": "double"}, {"single": NaN}], "single")</code> should return false");'
|
||||
|
||||
```
|
||||
|
||||
</section>
|
||||
|
||||
## Challenge Seed
|
||||
|
||||
<section id='challengeSeed'>
|
||||
|
||||
<div id='js-seed'>
|
||||
@@ -59,23 +62,31 @@ function truthCheck(collection, pre) {
|
||||
return pre;
|
||||
}
|
||||
|
||||
truthCheck([{"user": "Tinky-Winky", "sex": "male"}, {"user": "Dipsy", "sex": "male"}, {"user": "Laa-Laa", "sex": "female"}, {"user": "Po", "sex": "female"}], "sex");
|
||||
truthCheck(
|
||||
[
|
||||
{ user: 'Tinky-Winky', sex: 'male' },
|
||||
{ user: 'Dipsy', sex: 'male' },
|
||||
{ user: 'Laa-Laa', sex: 'female' },
|
||||
{ user: 'Po', sex: 'female' }
|
||||
],
|
||||
'sex'
|
||||
);
|
||||
```
|
||||
|
||||
</div>
|
||||
|
||||
|
||||
|
||||
</section>
|
||||
|
||||
## Solution
|
||||
<section id='solution'>
|
||||
|
||||
<section id='solution'>
|
||||
|
||||
```js
|
||||
function truthCheck(collection, pre) {
|
||||
// Does everyone have one of these?
|
||||
return collection.every(function(e) { return e[pre]; });
|
||||
return collection.every(function(e) {
|
||||
return e[pre];
|
||||
});
|
||||
}
|
||||
```
|
||||
|
||||
|
||||
@@ -6,17 +6,17 @@ challengeType: 5
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
Devuelve una nueva matriz que transforma la altitud promedio de los elementos en sus períodos orbitales (en segundos).
|
||||
La matriz contendrá objetos en el formato <code>{name: 'name', avgAlt: avgAlt}</code> .
|
||||
Puedes leer sobre periodos orbitales <a href="http://en.wikipedia.org/wiki/Orbital_period" target='_blank'>en Wikipedia</a> .
|
||||
Los valores deben redondearse al número entero más cercano. El cuerpo que está siendo orbitado es la Tierra.
|
||||
El radio de la Tierra es 6367.4447 kilómetros, y el valor GM de la Tierra es 398600.4418 km <sup>3</sup> s <sup>-2</sup> .
|
||||
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 id='description'>
|
||||
Devuelve una nueva matriz que transforma la altitud promedio de los elementos en sus períodos orbitales (en segundos).
|
||||
La matriz contendrá objetos en el formato <code>{name: 'name', avgAlt: avgAlt}</code> .
|
||||
Puedes leer sobre periodos orbitales <a href="http://en.wikipedia.org/wiki/Orbital_period" target='_blank'>en Wikipedia</a> .
|
||||
Los valores deben redondearse al número entero más cercano. El cuerpo que está siendo orbitado es la Tierra.
|
||||
El radio de la Tierra es 6367.4447 kilómetros, y el valor GM de la Tierra es 398600.4418 km <sup>3</sup> s <sup>-2</sup> .
|
||||
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>
|
||||
|
||||
@@ -25,9 +25,9 @@ Recuerda usar <a href='http://forum.freecodecamp.org/t/how-to-get-help-when-you-
|
||||
|
||||
```yml
|
||||
tests:
|
||||
- text: ' <code>orbitalPeriod([{name : "sputnik", avgAlt : 35873.5553}])</code> debe devolver <code>[{name: "sputnik", orbitalPeriod: 86400}]</code> .'
|
||||
- text: ' <code>orbitalPeriod([{name : "sputnik", avgAlt : 35873.5553}])</code> debe devolver <code>[{name: "sputnik", orbitalPeriod: 86400}]</code> .'
|
||||
testString: 'assert.deepEqual(orbitalPeriod([{name : "sputnik", avgAlt : 35873.5553}]), [{name: "sputnik", orbitalPeriod: 86400}], "<code>orbitalPeriod([{name : "sputnik", avgAlt : 35873.5553}])</code> should return <code>[{name: "sputnik", orbitalPeriod: 86400}]</code>.");'
|
||||
- text: ' <code>orbitalPeriod([{name: "iss", avgAlt: 413.6}, {name: "hubble", avgAlt: 556.7}, {name: "moon", avgAlt: 378632.553}])</code> debe devolver <code>[{name : "iss", orbitalPeriod: 5557}, {name: "hubble", orbitalPeriod: 5734}, {name: "moon", orbitalPeriod: 2377399}]</code> . '
|
||||
- text: ' <code>orbitalPeriod([{name: "iss", avgAlt: 413.6}, {name: "hubble", avgAlt: 556.7}, {name: "moon", avgAlt: 378632.553}])</code> debe devolver <code>[{name : "iss", orbitalPeriod: 5557}, {name: "hubble", orbitalPeriod: 5734}, {name: "moon", orbitalPeriod: 2377399}]</code> . '
|
||||
testString: 'assert.deepEqual(orbitalPeriod([{name: "iss", avgAlt: 413.6}, {name: "hubble", avgAlt: 556.7}, {name: "moon", avgAlt: 378632.553}]), [{name : "iss", orbitalPeriod: 5557}, {name: "hubble", orbitalPeriod: 5734}, {name: "moon", orbitalPeriod: 2377399}], "<code>orbitalPeriod([{name: "iss", avgAlt: 413.6}, {name: "hubble", avgAlt: 556.7}, {name: "moon", avgAlt: 378632.553}])</code> should return <code>[{name : "iss", orbitalPeriod: 5557}, {name: "hubble", orbitalPeriod: 5734}, {name: "moon", orbitalPeriod: 2377399}]</code>.");'
|
||||
|
||||
```
|
||||
|
||||
@@ -7,17 +7,17 @@ challengeType: 5
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
Realice una búsqueda y reemplace la oración usando los argumentos proporcionados y devuelva la nueva oración.
|
||||
primer argumento es la oración para realizar la búsqueda y reemplazar.
|
||||
Segundo argumento es la palabra que reemplazará (antes).
|
||||
Tercer argumento es con lo que reemplazará el segundo argumento por (después).
|
||||
<strong>Nota</strong> <br> Conserve el caso del primer carácter en la palabra original cuando lo reemplace. Por ejemplo, si quiere reemplazar la palabra "Libro" con la palabra "perro", debe ser reemplazada como "Perro"
|
||||
Recuerde usar <a href='http://forum.freecodecamp.org/t/how-to-get-help-when-you-are-stuck/19514' target='_blank'>Lectura-Búsqueda-Preguntar</a> si se atasca. Trate de emparejar el programa. Escribe tu propio código.
|
||||
<section id='description'>
|
||||
Realice una búsqueda y reemplace la oración usando los argumentos proporcionados y devuelva la nueva oración.
|
||||
primer argumento es la oración para realizar la búsqueda y reemplazar.
|
||||
Segundo argumento es la palabra que reemplazará (antes).
|
||||
Tercer argumento es con lo que reemplazará el segundo argumento por (después).
|
||||
<strong>Nota</strong> <br> Conserve el caso del primer carácter en la palabra original cuando lo reemplace. Por ejemplo, si quiere reemplazar la palabra "Libro" con la palabra "perro", debe ser reemplazada como "Perro"
|
||||
Recuerde usar <a href='http://forum.freecodecamp.org/t/how-to-get-help-when-you-are-stuck/19514' target='_blank'>Lectura-Búsqueda-Preguntar</a> si se atasca. Trate de emparejar el programa. Escribe tu propio código.
|
||||
</section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
<section id='instructions'>
|
||||
|
||||
</section>
|
||||
|
||||
@@ -26,15 +26,15 @@ Recuerde usar <a href='http://forum.freecodecamp.org/t/how-to-get-help-when-you-
|
||||
|
||||
```yml
|
||||
tests:
|
||||
- text: ' <code>myReplace("Let us go to the store", "store", "mall")</code> debe devolver "Vamos <code>myReplace("Let us go to the store", "store", "mall")</code> ".'
|
||||
- text: ' <code>myReplace("Let us go to the store", "store", "mall")</code> debe devolver "Vamos <code>myReplace("Let us go to the store", "store", "mall")</code> ".'
|
||||
testString: 'assert.deepEqual(myReplace("Let us go to the store", "store", "mall"), "Let us go to the mall", "<code>myReplace("Let us go to the store", "store", "mall")</code> should return "Let us go to the mall".");'
|
||||
- text: ' <code>myReplace("He is Sleeping on the couch", "Sleeping", "sitting")</code> debe devolver "Está sentado en el sofá".
|
||||
- text: ' <code>myReplace("He is Sleeping on the couch", "Sleeping", "sitting")</code> debe devolver "Está sentado en el sofá".
|
||||
testString: 'assert.deepEqual(myReplace("He is Sleeping on the couch", "Sleeping", "sitting"), "He is Sitting on the couch", "<code>myReplace("He is Sleeping on the couch", "Sleeping", "sitting")</code> should return "He is Sitting on the couch".");'
|
||||
- text: ' <code>myReplace("This has a spellngi error", "spellngi", "spelling")</code> debe devolver "Esto tiene un error de ortografía".'
|
||||
- text: ' <code>myReplace("This has a spellngi error", "spellngi", "spelling")</code> debe devolver "Esto tiene un error de ortografía".'
|
||||
testString: 'assert.deepEqual(myReplace("This has a spellngi error", "spellngi", "spelling"), "This has a spelling error", "<code>myReplace("This has a spellngi error", "spellngi", "spelling")</code> should return "This has a spelling error".");'
|
||||
- text: ' <code>myReplace("His name is Tom", "Tom", "john")</code> debe devolver "Su nombre es John".
|
||||
- text: ' <code>myReplace("His name is Tom", "Tom", "john")</code> debe devolver "Su nombre es John".
|
||||
testString: 'assert.deepEqual(myReplace("His name is Tom", "Tom", "john"), "His name is John", "<code>myReplace("His name is Tom", "Tom", "john")</code> should return "His name is John".");'
|
||||
- text: ' <code>myReplace("Let us get back to more Coding", "Coding", "algorithms")</code> debería devolver "Regresemos a más Algoritmos".
|
||||
- text: ' <code>myReplace("Let us get back to more Coding", "Coding", "algorithms")</code> debería devolver "Regresemos a más Algoritmos".
|
||||
testString: 'assert.deepEqual(myReplace("Let us get back to more Coding", "Coding", "algorithms"), "Let us get back to more Algorithms", "<code>myReplace("Let us get back to more Coding", "Coding", "algorithms")</code> should return "Let us get back to more Algorithms".");'
|
||||
|
||||
```
|
||||
|
||||
@@ -7,14 +7,14 @@ challengeType: 5
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
Se le proporcionará una matriz inicial (el primer argumento en la función del destructor), seguido de uno o más argumentos. Elimine todos los elementos de la matriz inicial que tengan el mismo valor que estos argumentos.
|
||||
<strong>Nota</strong> <br> Tienes que usar el objeto <code>arguments</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 id='description'>
|
||||
Se le proporcionará una matriz inicial (el primer argumento en la función del destructor), seguido de uno o más argumentos. Elimine todos los elementos de la matriz inicial que tengan el mismo valor que estos argumentos.
|
||||
<strong>Nota</strong> <br> Tienes que usar el objeto <code>arguments</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>
|
||||
|
||||
@@ -23,17 +23,17 @@ Recuerda usar <a href="http://forum.freecodecamp.org/t/how-to-get-help-when-you-
|
||||
|
||||
```yml
|
||||
tests:
|
||||
- text: ' <code>destroyer([1, 2, 3, 1, 2, 3], 2, 3)</code> debe devolver <code>[1, 1]</code> .'
|
||||
- text: ' <code>destroyer([1, 2, 3, 1, 2, 3], 2, 3)</code> debe devolver <code>[1, 1]</code> .'
|
||||
testString: 'assert.deepEqual(destroyer([1, 2, 3, 1, 2, 3], 2, 3), [1, 1], "<code>destroyer([1, 2, 3, 1, 2, 3], 2, 3)</code> should return <code>[1, 1]</code>.");'
|
||||
- text: ' <code>destroyer([1, 2, 3, 5, 1, 2, 3], 2, 3)</code> debe devolver <code>[1, 5, 1]</code> .'
|
||||
- text: ' <code>destroyer([1, 2, 3, 5, 1, 2, 3], 2, 3)</code> debe devolver <code>[1, 5, 1]</code> .'
|
||||
testString: 'assert.deepEqual(destroyer([1, 2, 3, 5, 1, 2, 3], 2, 3), [1, 5, 1], "<code>destroyer([1, 2, 3, 5, 1, 2, 3], 2, 3)</code> should return <code>[1, 5, 1]</code>.");'
|
||||
- text: ' <code>destroyer([3, 5, 1, 2, 2], 2, 3, 5)</code> debe devolver <code>[1]</code> .'
|
||||
- text: ' <code>destroyer([3, 5, 1, 2, 2], 2, 3, 5)</code> debe devolver <code>[1]</code> .'
|
||||
testString: 'assert.deepEqual(destroyer([3, 5, 1, 2, 2], 2, 3, 5), [1], "<code>destroyer([3, 5, 1, 2, 2], 2, 3, 5)</code> should return <code>[1]</code>.");'
|
||||
- text: ' <code>destroyer([2, 3, 2, 3], 2, 3)</code> debe devolver <code>[]</code> .'
|
||||
- text: ' <code>destroyer([2, 3, 2, 3], 2, 3)</code> debe devolver <code>[]</code> .'
|
||||
testString: 'assert.deepEqual(destroyer([2, 3, 2, 3], 2, 3), [], "<code>destroyer([2, 3, 2, 3], 2, 3)</code> should return <code>[]</code>.");'
|
||||
- text: ' <code>destroyer(["tree", "hamburger", 53], "tree", 53)</code> debe devolver <code>["hamburger"]</code> .'
|
||||
- text: ' <code>destroyer(["tree", "hamburger", 53], "tree", 53)</code> debe devolver <code>["hamburger"]</code> .'
|
||||
testString: 'assert.deepEqual(destroyer(["tree", "hamburger", 53], "tree", 53), ["hamburger"], "<code>destroyer(["tree", "hamburger", 53], "tree", 53)</code> should return <code>["hamburger"]</code>.");'
|
||||
- text: ' <code>destroyer(["possum", "trollo", 12, "safari", "hotdog", 92, 65, "grandma", "bugati", "trojan", "yacht"], "yacht", "possum", "trollo", "safari", "hotdog", "grandma", "bugati", "trojan")</code> debe devolver <code>[12,92,65]</code> . '
|
||||
- text: ' <code>destroyer(["possum", "trollo", 12, "safari", "hotdog", 92, 65, "grandma", "bugati", "trojan", "yacht"], "yacht", "possum", "trollo", "safari", "hotdog", "grandma", "bugati", "trojan")</code> debe devolver <code>[12,92,65]</code> . '
|
||||
testString: 'assert.deepEqual(destroyer(["possum", "trollo", 12, "safari", "hotdog", 92, 65, "grandma", "bugati", "trojan", "yacht"], "yacht", "possum", "trollo", "safari", "hotdog", "grandma", "bugati", "trojan"), [12,92,65], "<code>destroyer(["possum", "trollo", 12, "safari", "hotdog", 92, 65, "grandma", "bugati", "trojan", "yacht"], "yacht", "possum", "trollo", "safari", "hotdog", "grandma", "bugati", "trojan")</code> should return <code>[12,92,65]</code>.");'
|
||||
|
||||
```
|
||||
|
||||
@@ -7,15 +7,15 @@ challengeType: 5
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
Encuentre el múltiplo común más pequeño de los parámetros provistos que pueden dividirse de manera uniforme por ambos, así como por todos los números secuenciales en el rango entre estos parámetros.
|
||||
El rango será una matriz de dos números que no necesariamente estarán en orden numérico.
|
||||
Por ejemplo, si se proporciona 1 y 3, encuentre el mínimo común múltiplo de 1 y 3 que también es divisible por todos los números <em>entre</em> 1 y 3. La respuesta aquí sería 6.
|
||||
Recuerde usar <a href='http://forum.freecodecamp.org/t/how-to-get-help-when-you-are-stuck/19514' target='_blank'>Lectura-Búsqueda-Preguntar</a> si te quedas atascado Trate de emparejar el programa. Escribe tu propio código.
|
||||
<section id='description'>
|
||||
Encuentre el múltiplo común más pequeño de los parámetros provistos que pueden dividirse de manera uniforme por ambos, así como por todos los números secuenciales en el rango entre estos parámetros.
|
||||
El rango será una matriz de dos números que no necesariamente estarán en orden numérico.
|
||||
Por ejemplo, si se proporciona 1 y 3, encuentre el mínimo común múltiplo de 1 y 3 que también es divisible por todos los números <em>entre</em> 1 y 3. La respuesta aquí sería 6.
|
||||
Recuerde usar <a href='http://forum.freecodecamp.org/t/how-to-get-help-when-you-are-stuck/19514' target='_blank'>Lectura-Búsqueda-Preguntar</a> si te quedas atascado Trate de emparejar el programa. Escribe tu propio código.
|
||||
</section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
<section id='instructions'>
|
||||
|
||||
</section>
|
||||
|
||||
@@ -24,17 +24,17 @@ Recuerde usar <a href='http://forum.freecodecamp.org/t/how-to-get-help-when-you-
|
||||
|
||||
```yml
|
||||
tests:
|
||||
- text: ' <code>smallestCommons([1, 5])</code> debe devolver un número.'
|
||||
- text: ' <code>smallestCommons([1, 5])</code> debe devolver un número.'
|
||||
testString: 'assert.deepEqual(typeof smallestCommons([1, 5]), "number", "<code>smallestCommons([1, 5])</code> should return a number.");'
|
||||
- text: ' <code>smallestCommons([1, 5])</code> debe devolver 60.'
|
||||
- text: ' <code>smallestCommons([1, 5])</code> debe devolver 60.'
|
||||
testString: 'assert.deepEqual(smallestCommons([1, 5]), 60, "<code>smallestCommons([1, 5])</code> should return 60.");'
|
||||
- text: ' <code>smallestCommons([5, 1])</code> debe devolver 60.'
|
||||
- text: ' <code>smallestCommons([5, 1])</code> debe devolver 60.'
|
||||
testString: 'assert.deepEqual(smallestCommons([5, 1]), 60, "<code>smallestCommons([5, 1])</code> should return 60.");'
|
||||
- text: ' <code>smallestCommons([2, 10])</code> debe devolver 2520.'
|
||||
- text: ' <code>smallestCommons([2, 10])</code> debe devolver 2520.'
|
||||
testString: 'assert.deepEqual(smallestCommons([2, 10]), 2520, "<code>smallestCommons([2, 10])</code> should return 2520.");'
|
||||
- text: ' <code>smallestCommons([1, 13])</code> debe devolver 360360.'
|
||||
- text: ' <code>smallestCommons([1, 13])</code> debe devolver 360360.'
|
||||
testString: 'assert.deepEqual(smallestCommons([1, 13]), 360360, "<code>smallestCommons([1, 13])</code> should return 360360.");'
|
||||
- text: ' <code>smallestCommons([23, 18])</code> debe devolver 6056820.'
|
||||
- text: ' <code>smallestCommons([23, 18])</code> debe devolver 6056820.'
|
||||
testString: 'assert.deepEqual(smallestCommons([23, 18]), 6056820, "<code>smallestCommons([23, 18])</code> should return 6056820.");'
|
||||
|
||||
```
|
||||
|
||||
Some files were not shown because too many files have changed in this diff Show More
Reference in New Issue
Block a user