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
@ -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).");'
|
||||
|
||||
```
|
||||
|
||||
Reference in New Issue
Block a user