feat: add Spanish and language parser
This commit is contained in:
Beau Carnes
committed by
mrugesh mohapatra
mrugesh mohapatra
parent
c2a45b58be
commit
e3f9dc4b86
@@ -1,22 +1,16 @@
|
||||
---
|
||||
id: 587d7da9367417b2b2512b67
|
||||
title: Add Elements to the End of an Array Using concat Instead of push
|
||||
localeTitle: Agregue elementos al final de una matriz usando concat en lugar de empujar
|
||||
challengeType: 1
|
||||
videoUrl: ''
|
||||
localeTitle: Agregue elementos al final de una matriz usando concat en lugar de empujar
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
La programación funcional tiene que ver con la creación y el uso de funciones no mutantes.
|
||||
El último desafío introdujo el método <code>concat</code> como una forma de combinar arreglos en uno nuevo sin mutar los arreglos originales. Comparar <code>concat</code> con el método de <code>push</code> . <code>Push</code> agrega un elemento al final de la misma matriz a la que se llama, lo que muta esa matriz. Aquí hay un ejemplo:
|
||||
<blockquote>var arr = [1, 2, 3];<br>arr.push([4, 5, 6]);<br>// arr is changed to [1, 2, 3, [4, 5, 6]]<br>// Not the functional programming way</blockquote>
|
||||
<code>Concat</code> ofrece una forma de agregar nuevos elementos al final de una matriz sin efectos secundarios de mutación.
|
||||
</section>
|
||||
<section id="description"> La programación funcional tiene que ver con la creación y el uso de funciones no mutantes. El último desafío introdujo el método <code>concat</code> como una forma de combinar arreglos en uno nuevo sin mutar los arreglos originales. Comparar <code>concat</code> con el método de <code>push</code> . <code>Push</code> agrega un elemento al final de la misma matriz a la que se llama, lo que muta esa matriz. Aquí hay un ejemplo: <blockquote> var arr = [1, 2, 3]; <br> arr.push ([4, 5, 6]); <br> // arr se cambia a [1, 2, 3, [4, 5, 6]] <br> // No es la forma de programación funcional </blockquote> <code>Concat</code> ofrece una forma de agregar nuevos elementos al final de una matriz sin efectos secundarios mutantes. </section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
Cambie la función <code>nonMutatingPush</code> para que use <code>concat</code> para agregar <code>newItem</code> al final del <code>original</code> lugar de <code>push</code> . La función debe devolver una matriz.
|
||||
</section>
|
||||
<section id="instructions"> Cambie la función <code>nonMutatingPush</code> para que use <code>concat</code> para agregar <code>newItem</code> al final del <code>original</code> lugar de <code>push</code> . La función debe devolver una matriz. </section>
|
||||
|
||||
## Tests
|
||||
<section id='tests'>
|
||||
@@ -31,7 +25,7 @@ tests:
|
||||
testString: 'assert(JSON.stringify(first) === JSON.stringify([1, 2, 3]), "The <code>first</code> array should not change.");'
|
||||
- text: La <code>second</code> matriz no debe cambiar.
|
||||
testString: 'assert(JSON.stringify(second) === JSON.stringify([4, 5]), "The <code>second</code> array should not change.");'
|
||||
- text: ' <code>nonMutatingPush([1, 2, 3], [4, 5])</code> debe devolver <code>[1, 2, 3, 4, 5]</code> .'
|
||||
- text: '<code>nonMutatingPush([1, 2, 3], [4, 5])</code> debe devolver <code>[1, 2, 3, 4, 5]</code> .'
|
||||
testString: 'assert(JSON.stringify(nonMutatingPush([1, 2, 3], [4, 5])) === JSON.stringify([1, 2, 3, 4, 5]), "<code>nonMutatingPush([1, 2, 3], [4, 5])</code> should return <code>[1, 2, 3, 4, 5]</code>.");'
|
||||
|
||||
```
|
||||
@@ -53,6 +47,7 @@ function nonMutatingPush(original, newItem) {
|
||||
var first = [1, 2, 3];
|
||||
var second = [4, 5];
|
||||
nonMutatingPush(first, second);
|
||||
|
||||
```
|
||||
|
||||
</div>
|
||||
|
||||
@@ -1,25 +1,16 @@
|
||||
---
|
||||
id: 587d7dab367417b2b2512b6d
|
||||
title: Apply Functional Programming to Convert Strings to URL Slugs
|
||||
localeTitle: Aplique programación funcional para convertir cadenas en slugs de URL
|
||||
challengeType: 1
|
||||
videoUrl: ''
|
||||
localeTitle: Aplique programación funcional para convertir cadenas en slugs de URL
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
Los últimos varios desafíos cubrieron una serie de métodos de matriz y cadena útiles que siguen los principios de programación funcional. También hemos aprendido sobre <code>reduce</code> , que es un método poderoso que se utiliza para reducir problemas a formas más simples. Desde los promedios de computación hasta la clasificación, cualquier operación de matriz se puede lograr aplicándolo. Recordemos que el <code>map</code> y el <code>filter</code> son casos especiales de <code>reduce</code> .
|
||||
Combinemos lo que hemos aprendido para resolver un problema práctico.
|
||||
Muchos sitios de administración de contenido (CMS) tienen los títulos de una publicación agregada a parte de la URL con fines de marcadores simples. Por ejemplo, si escribe una publicación mediana titulada "Dejar de usar reducir", es probable que la URL tenga alguna forma de la cadena de título ("... / stop-using-reduce-)". Es posible que ya hayas notado esto en el sitio freeCodeCamp.
|
||||
</section>
|
||||
<section id="description"> Los últimos varios desafíos cubrieron una serie de métodos de matriz y cadena útiles que siguen los principios de programación funcional. También hemos aprendido sobre <code>reduce</code> , que es un método poderoso que se utiliza para reducir problemas a formas más simples. Desde los promedios de computación hasta la clasificación, cualquier operación de matriz se puede lograr aplicándolo. Recordemos que el <code>map</code> y el <code>filter</code> son casos especiales de <code>reduce</code> . Combinemos lo que hemos aprendido para resolver un problema práctico. Muchos sitios de administración de contenido (CMS) tienen los títulos de una publicación agregada a parte de la URL con fines de marcadores simples. Por ejemplo, si escribe una publicación mediana titulada "Dejar de usar reducir", es probable que la URL tenga alguna forma de la cadena de título ("... / stop-using-reduce-)". Es posible que ya hayas notado esto en el sitio freeCodeCamp. </section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
Rellene la función <code>urlSlug</code> para que convierta un <code>title</code> cadena y devuelva la versión con guión para la URL. Puede usar cualquiera de los métodos cubiertos en esta sección, y no usar <code>replace</code> . Estos son los requisitos:
|
||||
La entrada es una cadena con espacios y palabras en mayúsculas
|
||||
La salida es una cadena con espacios entre palabras reemplazadas por un guión ( <code>-</code> )
|
||||
La salida debe ser todas letras minúsculas
|
||||
La salida debe no tiene espacios
|
||||
</section>
|
||||
<section id="instructions"> Complete la función <code>urlSlug</code> para que convierta un <code>title</code> cadena y devuelva la versión con guión para la URL. Puede usar cualquiera de los métodos cubiertos en esta sección, y no usar <code>replace</code> . Estos son los requisitos: La entrada es una cadena con espacios y palabras en letras. La salida es una cadena con los espacios entre palabras reemplazadas por un guión ( <code>-</code> ) La salida debe ser todas letras minúsculas La salida no debe tener espacios </section>
|
||||
|
||||
## Tests
|
||||
<section id='tests'>
|
||||
@@ -60,6 +51,7 @@ function urlSlug(title) {
|
||||
// Add your code above this line
|
||||
|
||||
var winterComing = urlSlug(globalTitle); // Should be "winter-is-coming"
|
||||
|
||||
```
|
||||
|
||||
</div>
|
||||
|
||||
@@ -1,24 +1,16 @@
|
||||
---
|
||||
id: 587d7b8e367417b2b2512b5e
|
||||
title: Avoid Mutations and Side Effects Using Functional Programming
|
||||
localeTitle: Evite las mutaciones y los efectos secundarios utilizando la programación funcional
|
||||
challengeType: 1
|
||||
videoUrl: ''
|
||||
localeTitle: Evite las mutaciones y los efectos secundarios utilizando la programación funcional
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
Si aún no lo ha resuelto, el problema en el desafío anterior fue con la llamada de <code>splice</code> en la función <code>tabClose()</code> . Desafortunadamente, el <code>splice</code> cambia la matriz original a la que se llama, por lo que la segunda llamada a esta usó una matriz modificada y dio resultados inesperados.
|
||||
Este es un pequeño ejemplo de un patrón mucho más grande: se llama una función en una variable, una matriz o un objeto, y la función cambia la variable o algo en el objeto.
|
||||
Uno de los principios básicos de la programación funcional es no cambiar las cosas. Los cambios conducen a errores. Es más fácil prevenir errores sabiendo que sus funciones no cambian nada, incluidos los argumentos de la función o cualquier variable global.
|
||||
El ejemplo anterior no tuvo operaciones complicadas, pero el método de <code>splice</code> cambió la matriz original y dio como resultado un error.
|
||||
Recuerde que en la programación funcional, cambiar o alterar las cosas se denomina <code>mutation</code> , y el resultado se denomina <code>side effect</code> . Una función, idealmente, debería ser una <code>pure function</code> , lo que significa que no causa ningún efecto secundario.
|
||||
Intentemos dominar esta disciplina y no alteremos ninguna variable u objeto en nuestro código.
|
||||
</section>
|
||||
<section id="description"> Si aún no lo ha resuelto, el problema en el desafío anterior fue con la llamada de <code>splice</code> en la función <code>tabClose()</code> . Desafortunadamente, el <code>splice</code> cambia la matriz original a la que se llama, por lo que la segunda llamada a esta usó una matriz modificada y dio resultados inesperados. Este es un pequeño ejemplo de un patrón mucho más grande: se llama una función en una variable, una matriz o un objeto, y la función cambia la variable o algo en el objeto. Uno de los principios básicos de la programación funcional es no cambiar las cosas. Los cambios conducen a errores. Es más fácil prevenir errores sabiendo que sus funciones no cambian nada, incluidos los argumentos de la función o cualquier variable global. El ejemplo anterior no tenía operaciones complicadas, pero el método de <code>splice</code> cambió la matriz original y dio como resultado un error. Recuerde que en la programación funcional, el cambio o la alteración de las cosas se denomina <code>mutation</code> y el resultado se denomina <code>side effect</code> . Una función, idealmente, debería ser una <code>pure function</code> , lo que significa que no causa ningún efecto secundario. Intentemos dominar esta disciplina y no alteremos ninguna variable u objeto en nuestro código. </section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
Rellene el código del <code>incrementer</code> función para que devuelva el valor de la variable global <code>fixedValue</code> incrementado en uno.
|
||||
</section>
|
||||
<section id="instructions"> Rellene el código del <code>incrementer</code> función para que devuelva el valor de la variable global <code>fixedValue</code> incrementado en uno. </section>
|
||||
|
||||
## Tests
|
||||
<section id='tests'>
|
||||
@@ -52,6 +44,7 @@ function incrementer () {
|
||||
|
||||
var newValue = incrementer(); // Should equal 5
|
||||
console.log(fixedValue); // Should print 4
|
||||
|
||||
```
|
||||
|
||||
</div>
|
||||
|
||||
@@ -1,21 +1,16 @@
|
||||
---
|
||||
id: 587d7daa367417b2b2512b6c
|
||||
title: Combine an Array into a String Using the join Method
|
||||
localeTitle: Combina una matriz en una cadena usando el método de unión
|
||||
challengeType: 1
|
||||
videoUrl: ''
|
||||
localeTitle: Combina una matriz en una cadena usando el método de unión
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
El método de <code>join</code> se utiliza para unir los elementos de una matriz para crear una cadena. Toma un argumento para el delimitador que se usa para separar los elementos de la matriz en la cadena.
|
||||
Aquí hay un ejemplo:
|
||||
<blockquote>var arr = ["Hello", "World"];<br>var str = arr.join(" ");<br>// Sets str to "Hello World"</blockquote>
|
||||
</section>
|
||||
<section id="description"> El método de <code>join</code> se utiliza para unir los elementos de una matriz para crear una cadena. Toma un argumento para el delimitador que se usa para separar los elementos de la matriz en la cadena. Aquí hay un ejemplo: <blockquote> var arr = ["Hola", "Mundo"]; <br> var str = arr.join (""); <br> // Establece str en "Hello World" </blockquote></section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
Use el método de <code>join</code> (entre otros) dentro de la función de <code>sentensify</code> para hacer una oración de las palabras en la cadena <code>str</code> . La función debe devolver una cadena. Por ejemplo, "I-like-Star-Wars" se convertiría a "Me gusta Star Wars". Para este desafío, no utilice el método de <code>replace</code> .
|
||||
</section>
|
||||
<section id="instructions"> Use el método de <code>join</code> (entre otros) dentro de la función de <code>sentensify</code> para hacer una oración de las palabras en la cadena <code>str</code> . La función debe devolver una cadena. Por ejemplo, "I-like-Star-Wars" se convertiría a "Me gusta Star Wars". Para este desafío, no utilice el método de <code>replace</code> . </section>
|
||||
|
||||
## Tests
|
||||
<section id='tests'>
|
||||
@@ -32,7 +27,7 @@ tests:
|
||||
testString: 'assert(sentensify("May-the-force-be-with-you") === "May the force be with you", "<code>sentensify("May-the-force-be-with-you")</code> should return <code>"May the force be with you"</code>.");'
|
||||
- text: <code>sentensify("The.force.is.strong.with.this.one")</code> debe devolver <code>"The force is strong with this one"</code> .
|
||||
testString: 'assert(sentensify("The.force.is.strong.with.this.one") === "The force is strong with this one", "<code>sentensify("The.force.is.strong.with.this.one")</code> should return <code>"The force is strong with this one"</code>.");'
|
||||
- text: ' <code>sentensify("There,has,been,an,awakening")</code> debería regresar <code>"There has been an awakening"</code> .
|
||||
- text: '<code>sentensify("There,has,been,an,awakening")</code> debería volver <code>"There has been an awakening"</code> .'
|
||||
testString: 'assert(sentensify("There,has,been,an,awakening") === "There has been an awakening", "<code>sentensify("There,has,been,an,awakening")</code> should return <code>"There has been an awakening"</code>.");'
|
||||
|
||||
```
|
||||
@@ -52,6 +47,7 @@ function sentensify(str) {
|
||||
// Add your code above this line
|
||||
}
|
||||
sentensify("May-the-force-be-with-you");
|
||||
|
||||
```
|
||||
|
||||
</div>
|
||||
|
||||
@@ -1,20 +1,16 @@
|
||||
---
|
||||
id: 587d7da9367417b2b2512b66
|
||||
title: Combine Two Arrays Using the concat Method
|
||||
localeTitle: Combina dos matrices usando el método concat
|
||||
challengeType: 1
|
||||
videoUrl: ''
|
||||
localeTitle: Combina dos matrices usando el método concat
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
<code>Concatenation</code> significa unir elementos de extremo a extremo. JavaScript ofrece el método <code>concat</code> para cadenas y matrices que funcionan de la misma manera. Para las matrices, el método se llama en una, luego se proporciona otra matriz como el argumento a <code>concat</code> , que se agrega al final de la primera matriz. Devuelve una nueva matriz y no muta ninguna de las matrices originales. Aquí hay un ejemplo:
|
||||
<blockquote>[1, 2, 3].concat([4, 5, 6]);<br>// Returns a new array [1, 2, 3, 4, 5, 6]</blockquote>
|
||||
</section>
|
||||
<section id="description"> <code>Concatenation</code> significa unir artículos de extremo a extremo. JavaScript ofrece el método <code>concat</code> para cadenas y matrices que funcionan de la misma manera. Para las matrices, el método se llama en una, luego se proporciona otra matriz como el argumento a <code>concat</code> , que se agrega al final de la primera matriz. Devuelve una nueva matriz y no muta ninguna de las matrices originales. Aquí hay un ejemplo: <blockquote> [1, 2, 3] .concat ([4, 5, 6]); <br> // Devuelve una nueva matriz [1, 2, 3, 4, 5, 6] </blockquote></section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
Utilice el método <code>concat</code> en la función <code>nonMutatingConcat</code> para concatenar <code>attach</code> al final del <code>original</code> . La función debe devolver la matriz concatenada.
|
||||
</section>
|
||||
<section id="instructions"> Utilice el método <code>concat</code> en la función <code>nonMutatingConcat</code> para concatenar <code>attach</code> al final del <code>original</code> . La función debe devolver la matriz concatenada. </section>
|
||||
|
||||
## Tests
|
||||
<section id='tests'>
|
||||
@@ -27,7 +23,7 @@ tests:
|
||||
testString: 'assert(JSON.stringify(first) === JSON.stringify([1, 2, 3]), "The <code>first</code> array should not change.");'
|
||||
- text: La <code>second</code> matriz no debe cambiar.
|
||||
testString: 'assert(JSON.stringify(second) === JSON.stringify([4, 5]), "The <code>second</code> array should not change.");'
|
||||
- text: ' <code>nonMutatingConcat([1, 2, 3], [4, 5])</code> debe devolver <code>[1, 2, 3, 4, 5]</code> .'
|
||||
- text: '<code>nonMutatingConcat([1, 2, 3], [4, 5])</code> debe devolver <code>[1, 2, 3, 4, 5]</code> .'
|
||||
testString: 'assert(JSON.stringify(nonMutatingConcat([1, 2, 3], [4, 5])) === JSON.stringify([1, 2, 3, 4, 5]), "<code>nonMutatingConcat([1, 2, 3], [4, 5])</code> should return <code>[1, 2, 3, 4, 5]</code>.");'
|
||||
|
||||
```
|
||||
@@ -49,6 +45,7 @@ function nonMutatingConcat(original, attach) {
|
||||
var first = [1, 2, 3];
|
||||
var second = [4, 5];
|
||||
nonMutatingConcat(first, second);
|
||||
|
||||
```
|
||||
|
||||
</div>
|
||||
|
||||
@@ -1,29 +1,23 @@
|
||||
---
|
||||
id: 587d7b8f367417b2b2512b62
|
||||
title: Implement map on a Prototype
|
||||
localeTitle: Implementar mapa en un prototipo
|
||||
challengeType: 1
|
||||
videoUrl: ''
|
||||
localeTitle: Implementar mapa en un prototipo
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
Como ha visto al aplicar <code>Array.prototype.map()</code> , o simplemente <code>map()</code> anteriormente, el método de <code>map</code> devuelve una matriz de la misma longitud que la que se solicitó. Tampoco altera la matriz original, siempre que su función de devolución de llamada no lo haga.
|
||||
En otras palabras, el <code>map</code> es una función pura, y su salida depende únicamente de sus entradas. Además, toma otra función como argumento.
|
||||
Nos enseñaría mucho sobre el <code>map</code> para intentar implementar una versión que se comporte exactamente como <code>Array.prototype.map()</code> con un bucle <code>for</code> o <code>Array.prototype.forEach()</code> .
|
||||
Nota: Una función pura puede alterar las variables locales definidas dentro de su alcance, aunque es preferible evitar eso también.
|
||||
</section>
|
||||
<section id="description"> Como ha visto al aplicar <code>Array.prototype.map()</code> , o simplemente <code>map()</code> anteriormente, el método de <code>map</code> devuelve una matriz de la misma longitud que la que se solicitó. Tampoco altera la matriz original, siempre que su función de devolución de llamada no lo haga. En otras palabras, el <code>map</code> es una función pura, y su salida depende únicamente de sus entradas. Además, toma otra función como argumento. Nos enseñaría mucho sobre el <code>map</code> para tratar de implementar una versión que se comporte exactamente como <code>Array.prototype.map()</code> con un bucle <code>for</code> o <code>Array.prototype.forEach()</code> . Nota: una función pura puede alterar las variables locales definidas dentro de su alcance, aunque es preferible evitar eso también. </section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
Escriba su propio <code>Array.prototype.myMap()</code> , que debería comportarse exactamente como <code>Array.prototype.map()</code> . Puedes usar un bucle <code>for</code> o el método <code>forEach</code> .
|
||||
</section>
|
||||
<section id="instructions"> Escriba su propio <code>Array.prototype.myMap()</code> , que debe comportarse exactamente como <code>Array.prototype.map()</code> . Puedes usar un bucle <code>for</code> o el método <code>forEach</code> . </section>
|
||||
|
||||
## Tests
|
||||
<section id='tests'>
|
||||
|
||||
```yml
|
||||
tests:
|
||||
- text: ' <code>new_s</code> debe ser igual a <code>[46, 130, 196, 10]</code> .'
|
||||
- text: '<code>new_s</code> debe ser igual a <code>[46, 130, 196, 10]</code> .'
|
||||
testString: 'assert(JSON.stringify(new_s) === JSON.stringify([46, 130, 196, 10]), "<code>new_s</code> should equal <code>[46, 130, 196, 10]</code>.");'
|
||||
- text: Su código no debe utilizar el método de <code>map</code> .
|
||||
testString: 'assert(!code.match(/\.map/g), "Your code should not use the <code>map</code> method.");'
|
||||
@@ -53,6 +47,7 @@ Array.prototype.myMap = function(callback){
|
||||
var new_s = s.myMap(function(item){
|
||||
return item * 2;
|
||||
});
|
||||
|
||||
```
|
||||
|
||||
</div>
|
||||
|
||||
@@ -1,27 +1,23 @@
|
||||
---
|
||||
id: 587d7b8f367417b2b2512b64
|
||||
title: Implement the filter Method on a Prototype
|
||||
localeTitle: Implementar el método de filtro en un prototipo
|
||||
challengeType: 1
|
||||
videoUrl: ''
|
||||
localeTitle: Implementar el método de filtro en un prototipo
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
Nos enseñaría mucho sobre el método de <code>filter</code> si intentáramos implementar una versión que se comporte exactamente como <code>Array.prototype.filter()</code> . Puede usar un bucle <code>for</code> o <code>Array.prototype.forEach()</code> .
|
||||
Nota: Una función pura puede alterar las variables locales definidas dentro de su alcance, aunque es preferible evitar eso también.
|
||||
</section>
|
||||
<section id="description"> Nos enseñaría mucho sobre el método de <code>filter</code> si intentáramos implementar una versión que se comporte exactamente como <code>Array.prototype.filter()</code> . Puede usar un bucle <code>for</code> o <code>Array.prototype.forEach()</code> . Nota: una función pura puede alterar las variables locales definidas dentro de su alcance, aunque es preferible evitar eso también. </section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
Escriba su propio <code>Array.prototype.myFilter()</code> , que debe comportarse exactamente como <code>Array.prototype.filter()</code> . Puede usar un bucle <code>for</code> o el método <code>Array.prototype.forEach()</code> .
|
||||
</section>
|
||||
<section id="instructions"> Escriba su propio <code>Array.prototype.myFilter()</code> , que debe comportarse exactamente como <code>Array.prototype.filter()</code> . Puede usar un bucle <code>for</code> o el método <code>Array.prototype.forEach()</code> . </section>
|
||||
|
||||
## Tests
|
||||
<section id='tests'>
|
||||
|
||||
```yml
|
||||
tests:
|
||||
- text: ' <code>new_s</code> debe ser igual a <code>[23, 65, 5]</code> .'
|
||||
- text: '<code>new_s</code> debe ser igual a <code>[23, 65, 5]</code> .'
|
||||
testString: 'assert(JSON.stringify(new_s) === JSON.stringify([23, 65, 5]), "<code>new_s</code> should equal <code>[23, 65, 5]</code>.");'
|
||||
- text: Su código no debe utilizar el método de <code>filter</code> .
|
||||
testString: 'assert(!code.match(/\.filter/g), "Your code should not use the <code>filter</code> method.");'
|
||||
@@ -51,6 +47,7 @@ Array.prototype.myFilter = function(callback){
|
||||
var new_s = s.myFilter(function(item){
|
||||
return item % 2 === 1;
|
||||
});
|
||||
|
||||
```
|
||||
|
||||
</div>
|
||||
|
||||
@@ -1,27 +1,16 @@
|
||||
---
|
||||
id: 587d7dab367417b2b2512b70
|
||||
title: Introduction to Currying and Partial Application
|
||||
localeTitle: Introducción al curry y aplicación parcial.
|
||||
challengeType: 1
|
||||
videoUrl: ''
|
||||
localeTitle: Introducción al curry y aplicación parcial.
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
La <code>arity</code> de una función es el número de argumentos que requiere. <code>Currying</code> una función significa convertir una función de N <code>arity</code> en N funciones de <code>arity</code> 1.
|
||||
En otras palabras, reestructura una función para que tome un argumento, luego devuelva otra función que tome el siguiente argumento, y así sucesivamente.
|
||||
Aquí hay un ejemplo:
|
||||
<blockquote>//Un-curried function<br>function unCurried(x, y) {<br> return x + y;<br>}<br><br>//Curried function<br>function curried(x) {<br> return function(y) {<br> return x + y;<br> }<br>}<br>curried(1)(2) // Returns 3</blockquote>
|
||||
Esto es útil en su programa si no puede suministrar todos los argumentos a una función al mismo tiempo. Puede guardar cada llamada de función en una variable, que mantendrá la referencia de función devuelta que toma el siguiente argumento cuando esté disponible. Aquí hay un ejemplo que usa la función <code>curried</code> en el ejemplo anterior:
|
||||
<blockquote>// Call a curried function in parts:<br>var funcForY = curried(1);<br>console.log(funcForY(2)); // Prints 3</blockquote>
|
||||
De manera similar, <code>partial application</code> puede describirse como la aplicación de algunos argumentos a una función a la vez y la devolución de otra función que se aplica a más argumentos.
|
||||
Aquí hay un ejemplo:
|
||||
<blockquote>//Impartial function<br>function impartial(x, y, z) {<br> return x + y + z;<br>}<br>var partialFn = impartial.bind(this, 1, 2);<br>partialFn(10); // Returns 13</blockquote>
|
||||
</section>
|
||||
<section id="description"> La <code>arity</code> de una función es el número de argumentos que requiere. <code>Currying</code> una función significa convertir una función de N <code>arity</code> en N funciones de <code>arity</code> 1. En otras palabras, reestructura una función para que tome un argumento, luego devuelva otra función que tome el siguiente argumento, y así sucesivamente. Aquí hay un ejemplo: <blockquote> // Función sin currículum <br> función unCurried (x, y) { <br> devuelve x + y; <br> } <br><br> // Función de curry <br> función curry (x) { <br> función de retorno (y) { <br> devuelve x + y; <br> } <br> } <br> Curried (1) (2) // Devoluciones 3 </blockquote> Esto es útil en su programa si no puede suministrar todos los argumentos a una función al mismo tiempo. Puede guardar cada llamada de función en una variable, que mantendrá la referencia de función devuelta que toma el siguiente argumento cuando esté disponible. Aquí hay un ejemplo que usa la función de <code>curried</code> en el ejemplo anterior: <blockquote> // Llamar una función al curry en partes: <br> var funcForY = al curry (1); <br> console.log (funcForY (2)); // Impresiones 3 </blockquote> De manera similar, <code>partial application</code> puede describirse como la aplicación de unos pocos argumentos a una función a la vez y la devolución de otra función que se aplica a más argumentos. Aquí hay un ejemplo: <blockquote> // Función imparcial <br> función imparcial (x, y, z) { <br> devuelve x + y + z; <br> } <br> var partialFn = imparcial.bind (esto, 1, 2); <br> parcialFn (10); // Devoluciones 13 </blockquote></section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
Rellene el cuerpo de la función de <code>add</code> para que use el curry para agregar los parámetros <code>x</code> , <code>y</code> y <code>z</code> .
|
||||
</section>
|
||||
<section id="instructions"> Rellene el cuerpo de la función de <code>add</code> para que use el curry para agregar los parámetros <code>x</code> , <code>y</code> y <code>z</code> . </section>
|
||||
|
||||
## Tests
|
||||
<section id='tests'>
|
||||
@@ -54,6 +43,7 @@ function add(x) {
|
||||
// Add your code above this line
|
||||
}
|
||||
add(10)(20)(30);
|
||||
|
||||
```
|
||||
|
||||
</div>
|
||||
|
||||
@@ -1,25 +1,16 @@
|
||||
---
|
||||
id: 587d7b8d367417b2b2512b5b
|
||||
title: Learn About Functional Programming
|
||||
localeTitle: Aprenda acerca de la programación funcional
|
||||
challengeType: 1
|
||||
videoUrl: ''
|
||||
localeTitle: Aprenda acerca de la programación funcional
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
La programación funcional es un estilo de programación donde las soluciones son funciones simples y aisladas, sin efectos secundarios fuera del alcance de la función.
|
||||
<code>INPUT -> PROCESS -> OUTPUT</code>
|
||||
La programación funcional se trata de:
|
||||
1) Funciones aisladas: no hay dependencia del estado del programa, que incluye variables globales que están sujetas a cambios
|
||||
2) Funciones puras: la misma entrada siempre da el mismo resultado
|
||||
3) Las funciones con efectos secundarios limitados: cualquier cambio o mutación en el estado del programa fuera de la función se controlan cuidadosamente
|
||||
</section>
|
||||
<section id="description"> La programación funcional es un estilo de programación donde las soluciones son funciones simples y aisladas, sin efectos secundarios fuera del alcance de la función. <code>INPUT -> PROCESS -> OUTPUT</code> La programación funcional trata sobre: 1) Funciones aisladas: no hay dependencia del estado del programa, que incluye variables globales que están sujetas a cambios 2) Funciones puras: la misma entrada siempre da la misma salida 3) Funciones con efectos secundarios limitados: cualquier cambio o mutación en el estado del programa fuera de la función se controlan cuidadosamente </section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
A los miembros de freeCodeCamp les encanta el té.
|
||||
En el editor de código, las funciones <code>prepareTea</code> y <code>getTea</code> ya están definidas para usted. Llame a la función <code>getTea</code> para obtener 40 tazas de té para el equipo y guárdelas en la variable <code>tea4TeamFCC</code> .
|
||||
</section>
|
||||
<section id="instructions"> A los miembros de freeCodeCamp les encanta el té. En el editor de código, las funciones <code>prepareTea</code> y <code>getTea</code> ya están definidas para usted. Llame a la función <code>getTea</code> para obtener 40 tazas de té para el equipo y guárdelas en la variable <code>tea4TeamFCC</code> . </section>
|
||||
|
||||
## Tests
|
||||
<section id='tests'>
|
||||
@@ -70,6 +61,7 @@ const tea4TeamFCC = null; // :(
|
||||
// Add your code above this line
|
||||
|
||||
console.log(tea4TeamFCC);
|
||||
|
||||
```
|
||||
|
||||
</div>
|
||||
|
||||
@@ -1,25 +1,16 @@
|
||||
---
|
||||
id: 587d7b8e367417b2b2512b5f
|
||||
title: Pass Arguments to Avoid External Dependence in a Function
|
||||
localeTitle: Pasar argumentos para evitar la dependencia externa en una función
|
||||
challengeType: 1
|
||||
videoUrl: ''
|
||||
localeTitle: Pasar argumentos para evitar la dependencia externa en una función
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
El último desafío fue un paso más cerca de los principios de programación funcional, pero todavía falta algo.
|
||||
No alteramos el valor de la variable global, pero el <code>incrementer</code> la función no funcionaría sin que la variable global <code>fixedValue</code> estuviera allí.
|
||||
Otro principio de la programación funcional es siempre declarar explícitamente sus dependencias. Esto significa que si una función depende de que una variable u objeto esté presente, entonces pase esa variable u objeto directamente a la función como un argumento.
|
||||
Hay varias buenas consecuencias de este principio. La función es más fácil de probar, usted sabe exactamente qué entrada toma, y no dependerá de nada más en su programa.
|
||||
Esto le puede dar más confianza cuando modifica, elimina o agrega un nuevo código. Sabría lo que puede o no puede cambiar y puede ver dónde están las posibles trampas.
|
||||
Finalmente, la función siempre produciría la misma salida para el mismo conjunto de entradas, sin importar qué parte del código la ejecute.
|
||||
</section>
|
||||
<section id="description"> El último desafío fue un paso más cerca de los principios de programación funcional, pero todavía falta algo. No alteramos el valor de la variable global, pero el <code>incrementer</code> la función no funcionaría sin que la variable global <code>fixedValue</code> estuviera allí. Otro principio de la programación funcional es declarar siempre sus dependencias explícitamente. Esto significa que si una función depende de que una variable u objeto esté presente, entonces pase esa variable u objeto directamente a la función como un argumento. Hay varias buenas consecuencias de este principio. La función es más fácil de probar, usted sabe exactamente qué entrada toma, y no dependerá de nada más en su programa. Esto puede darle más confianza cuando modifica, elimina o agrega un nuevo código. Sabría lo que puede o no puede cambiar y puede ver dónde están las posibles trampas. Finalmente, la función siempre produciría la misma salida para el mismo conjunto de entradas, sin importar qué parte del código la ejecute. </section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
Actualicemos la función <code>incrementer</code> para declarar claramente sus dependencias.
|
||||
Escriba la función <code>incrementer</code> para que tome un argumento y luego aumente el valor en uno.
|
||||
</section>
|
||||
<section id="instructions"> Vamos a actualizar la función <code>incrementer</code> para declarar claramente sus dependencias. Escriba la función <code>incrementer</code> para que tome un argumento y luego aumente el valor en uno. </section>
|
||||
|
||||
## Tests
|
||||
<section id='tests'>
|
||||
@@ -55,6 +46,7 @@ function incrementer () {
|
||||
|
||||
var newValue = incrementer(fixedValue); // Should equal 5
|
||||
console.log(fixedValue); // Should print 4
|
||||
|
||||
```
|
||||
|
||||
</div>
|
||||
|
||||
@@ -1,35 +1,29 @@
|
||||
---
|
||||
id: 587d7b8f367417b2b2512b60
|
||||
title: Refactor Global Variables Out of Functions
|
||||
localeTitle: Refactorizar variables globales fuera de funciones
|
||||
challengeType: 1
|
||||
videoUrl: ''
|
||||
localeTitle: Refactorizar variables globales fuera de funciones
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
Hasta ahora, hemos visto dos principios distintos para la programación funcional:
|
||||
1) No alterar una variable u objeto: cree nuevas variables y objetos y devuélvalos si es necesario desde una función.
|
||||
2) Declare los argumentos de la función: cualquier cálculo dentro de una función depende solo de los argumentos, y no de cualquier objeto global o variable.
|
||||
Agregar uno a un número no es muy emocionante, pero podemos aplicar estos principios al trabajar con matrices u objetos más complejos.
|
||||
</section>
|
||||
<section id="description"> Hasta ahora, hemos visto dos principios distintos para la programación funcional: 1) No alterar una variable u objeto: cree nuevas variables y objetos y devuélvalos si es necesario desde una función. 2) Declare los argumentos de la función: cualquier cálculo dentro de una función depende solo de los argumentos, y no de cualquier objeto global o variable. Agregar uno a un número no es muy emocionante, pero podemos aplicar estos principios al trabajar con matrices u objetos más complejos. </section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
Refactorice (reescriba) el código para que la matriz de <code>bookList</code> global no se <code>bookList</code> dentro de ninguna de las funciones. La función de <code>add</code> debería agregar el <code>bookName</code> de <code>bookName</code> dado al final de una matriz. La función de <code>remove</code> debe eliminar el <code>bookName</code> de <code>bookName</code> dado de una matriz. Ambas funciones deben devolver una matriz, y cualquier parámetro nuevo debe agregarse antes del <code>bookName</code> one.
|
||||
</section>
|
||||
<section id="instructions"> Refactorice (reescriba) el código para que la matriz de <code>bookList</code> global no se <code>bookList</code> dentro de ninguna de las funciones. La función de <code>add</code> debería agregar el <code>bookName</code> de <code>bookName</code> dado al final de una matriz. La función de <code>remove</code> debe eliminar el <code>bookName</code> de <code>bookName</code> dado de una matriz. Ambas funciones deben devolver una matriz, y cualquier parámetro nuevo debe agregarse antes del <code>bookName</code> one. </section>
|
||||
|
||||
## Tests
|
||||
<section id='tests'>
|
||||
|
||||
```yml
|
||||
tests:
|
||||
- text: ' <code>bookList</code> no debe cambiar y aún debe ser igual a <code>["The Hound of the Baskervilles", "On The Electrodynamics of Moving Bodies", "Philosophiæ Naturalis Principia Mathematica", "Disquisitiones Arithmeticae"]</code> .'
|
||||
- text: '<code>bookList</code> no debe cambiar y sigue siendo igual a <code>["The Hound of the Baskervilles", "On The Electrodynamics of Moving Bodies", "Philosophiæ Naturalis Principia Mathematica", "Disquisitiones Arithmeticae"]</code> .'
|
||||
testString: 'assert(JSON.stringify(bookList) === JSON.stringify(["The Hound of the Baskervilles", "On The Electrodynamics of Moving Bodies", "Philosophiæ Naturalis Principia Mathematica", "Disquisitiones Arithmeticae"]), "<code>bookList</code> should not change and still equal <code>["The Hound of the Baskervilles", "On The Electrodynamics of Moving Bodies", "Philosophiæ Naturalis Principia Mathematica", "Disquisitiones Arithmeticae"]</code>.");'
|
||||
- text: ' <code>newBookList</code> debería ser igual a <code>["The Hound of the Baskervilles", "On The Electrodynamics of Moving Bodies", "Philosophiæ Naturalis Principia Mathematica", "Disquisitiones Arithmeticae", "A Brief History of Time"]</code> .'
|
||||
- text: '<code>newBookList</code> debería ser igual a <code>["The Hound of the Baskervilles", "On The Electrodynamics of Moving Bodies", "Philosophiæ Naturalis Principia Mathematica", "Disquisitiones Arithmeticae", "A Brief History of Time"]</code> .'
|
||||
testString: 'assert(JSON.stringify(newBookList) === JSON.stringify(["The Hound of the Baskervilles", "On The Electrodynamics of Moving Bodies", "Philosophiæ Naturalis Principia Mathematica", "Disquisitiones Arithmeticae", "A Brief History of Time"]), "<code>newBookList</code> should equal <code>["The Hound of the Baskervilles", "On The Electrodynamics of Moving Bodies", "Philosophiæ Naturalis Principia Mathematica", "Disquisitiones Arithmeticae", "A Brief History of Time"]</code>.");'
|
||||
- text: ' <code>newerBookList</code> debería ser igual a <code>["The Hound of the Baskervilles", "Philosophiæ Naturalis Principia Mathematica", "Disquisitiones Arithmeticae"]</code> .'
|
||||
- text: '<code>newerBookList</code> debería ser igual a <code>["The Hound of the Baskervilles", "Philosophiæ Naturalis Principia Mathematica", "Disquisitiones Arithmeticae"]</code> .'
|
||||
testString: 'assert(JSON.stringify(newerBookList) === JSON.stringify(["The Hound of the Baskervilles", "Philosophiæ Naturalis Principia Mathematica", "Disquisitiones Arithmeticae"]), "<code>newerBookList</code> should equal <code>["The Hound of the Baskervilles", "Philosophiæ Naturalis Principia Mathematica", "Disquisitiones Arithmeticae"]</code>.");'
|
||||
- text: ' <code>newestBookList</code> debería ser igual a <code>["The Hound of the Baskervilles", "Philosophiæ Naturalis Principia Mathematica", "Disquisitiones Arithmeticae", "A Brief History of Time"]</code> .
|
||||
- text: '<code>newestBookList</code> debería ser igual a <code>["The Hound of the Baskervilles", "Philosophiæ Naturalis Principia Mathematica", "Disquisitiones Arithmeticae", "A Brief History of Time"]</code> .'
|
||||
testString: 'assert(JSON.stringify(newestBookList) === JSON.stringify(["The Hound of the Baskervilles", "Philosophiæ Naturalis Principia Mathematica", "Disquisitiones Arithmeticae", "A Brief History of Time"]), "<code>newestBookList</code> should equal <code>["The Hound of the Baskervilles", "Philosophiæ Naturalis Principia Mathematica", "Disquisitiones Arithmeticae", "A Brief History of Time"]</code>.");'
|
||||
|
||||
```
|
||||
@@ -74,6 +68,7 @@ var newerBookList = remove(bookList, 'On The Electrodynamics of Moving Bodies');
|
||||
var newestBookList = remove(add(bookList, 'A Brief History of Time'), 'On The Electrodynamics of Moving Bodies');
|
||||
|
||||
console.log(bookList);
|
||||
|
||||
```
|
||||
|
||||
</div>
|
||||
|
||||
@@ -1,22 +1,16 @@
|
||||
---
|
||||
id: 9d7123c8c441eeafaeb5bdef
|
||||
title: Remove Elements from an Array Using slice Instead of splice
|
||||
localeTitle: Eliminar elementos de una matriz usando una división en lugar de empalme
|
||||
challengeType: 1
|
||||
videoUrl: ''
|
||||
localeTitle: Eliminar elementos de una matriz usando una división en lugar de empalme
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
Un patrón común al trabajar con matrices es cuando desea eliminar elementos y conservar el resto de la matriz. JavaScript ofrece el método de <code>splice</code> para esto, que toma argumentos para el índice de dónde comenzar a eliminar elementos, luego la cantidad de elementos que se eliminarán. Si no se proporciona el segundo argumento, el valor predeterminado es eliminar elementos hasta el final. Sin embargo, el método de <code>splice</code> muta la matriz original a la que se llama. Aquí hay un ejemplo:
|
||||
<blockquote>var cities = ["Chicago", "Delhi", "Islamabad", "London", "Berlin"];<br>cities.splice(3, 1); // Returns "London" and deletes it from the cities array<br>// cities is now ["Chicago", "Delhi", "Islamabad", "Berlin"]</blockquote>
|
||||
Como hemos visto en el último desafío, la <code>slice</code> método no muta la matriz original, pero devuelve una nueva que se pueden guardar en una variable. Recuerde que el método de <code>slice</code> toma dos argumentos para que los índices comiencen y terminen la división (el final no es inclusivo) y devuelve esos elementos en una nueva matriz. Uso de la <code>slice</code> método en lugar de <code>splice</code> ayuda a evitar los efectos secundarios de matriz-mutación.
|
||||
</section>
|
||||
<section id="description"> Un patrón común al trabajar con matrices es cuando desea eliminar elementos y conservar el resto de la matriz. JavaScript ofrece el método de <code>splice</code> para esto, que toma argumentos para el índice de dónde comenzar a eliminar elementos, luego la cantidad de elementos que se eliminarán. Si no se proporciona el segundo argumento, el valor predeterminado es eliminar elementos hasta el final. Sin embargo, el método de <code>splice</code> muta la matriz original a la que se llama. Aquí hay un ejemplo: <blockquote> var cities = ["Chicago", "Delhi", "Islamabad", "London", "Berlin"]; <br> ciudades.splice (3, 1); // Devuelve "Londres" y lo elimina de la matriz de ciudades <br> // ciudades ahora es ["Chicago", "Delhi", "Islamabad", "Berlín"] </blockquote> Como vimos en el último desafío, la <code>slice</code> método no muta la matriz original, pero devuelve una nueva que se pueden guardar en una variable. Recuerde que el método de <code>slice</code> toma dos argumentos para que los índices comiencen y terminen la división (el final no es inclusivo) y devuelve esos elementos en una nueva matriz. Uso de la <code>slice</code> método en lugar de <code>splice</code> ayuda a evitar los efectos secundarios de matriz-mutación. </section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
Reescriba la función <code>nonMutatingSplice</code> utilizando <code>slice</code> lugar de <code>splice</code> . Debe limitar la matriz de <code>cities</code> proporcionada a una longitud de 3 y devolver una nueva matriz con solo los tres primeros elementos.
|
||||
No mutar la matriz original proporcionada a la función.
|
||||
</section>
|
||||
<section id="instructions"> Reescriba la función <code>nonMutatingSplice</code> utilizando <code>slice</code> lugar de <code>splice</code> . Debe limitar la matriz de <code>cities</code> proporcionada a una longitud de 3 y devolver una nueva matriz con solo los tres primeros elementos. No mute la matriz original proporcionada a la función. </section>
|
||||
|
||||
## Tests
|
||||
<section id='tests'>
|
||||
@@ -29,7 +23,7 @@ tests:
|
||||
testString: 'assert(!code.match(/\.splice/g), "Your code should not use the <code>splice</code> method.");'
|
||||
- text: La matriz <code>inputCities</code> no debería cambiar.
|
||||
testString: 'assert(JSON.stringify(inputCities) === JSON.stringify(["Chicago", "Delhi", "Islamabad", "London", "Berlin"]), "The <code>inputCities</code> array should not change.");'
|
||||
- text: ' <code>nonMutatingSplice(["Chicago", "Delhi", "Islamabad", "London", "Berlin"])</code> debe devolver <code>["Chicago", "Delhi", "Islamabad"]</code> .'
|
||||
- text: '<code>nonMutatingSplice(["Chicago", "Delhi", "Islamabad", "London", "Berlin"])</code> debe devolver <code>["Chicago", "Delhi", "Islamabad"]</code> .'
|
||||
testString: 'assert(JSON.stringify(nonMutatingSplice(["Chicago", "Delhi", "Islamabad", "London", "Berlin"])) === JSON.stringify(["Chicago", "Delhi", "Islamabad"]), "<code>nonMutatingSplice(["Chicago", "Delhi", "Islamabad", "London", "Berlin"])</code> should return <code>["Chicago", "Delhi", "Islamabad"]</code>.");'
|
||||
|
||||
```
|
||||
@@ -50,6 +44,7 @@ function nonMutatingSplice(cities) {
|
||||
}
|
||||
var inputCities = ["Chicago", "Delhi", "Islamabad", "London", "Berlin"];
|
||||
nonMutatingSplice(inputCities);
|
||||
|
||||
```
|
||||
|
||||
</div>
|
||||
|
||||
@@ -1,19 +1,16 @@
|
||||
---
|
||||
id: 587d7da9367417b2b2512b6a
|
||||
title: Return a Sorted Array Without Changing the Original Array
|
||||
localeTitle: Devuelva una matriz ordenada sin cambiar la matriz original
|
||||
challengeType: 1
|
||||
videoUrl: ''
|
||||
localeTitle: Devuelva una matriz ordenada sin cambiar la matriz original
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
Un efecto secundario del método de <code>sort</code> es que cambia el orden de los elementos en la matriz original. En otras palabras, muta la matriz en su lugar. Una forma de evitar esto es primero concatenar una matriz vacía con la ordenada (recuerde que <code>concat</code> devuelve una nueva matriz), luego ejecute el método de <code>sort</code> .
|
||||
</section>
|
||||
<section id="description"> Un efecto secundario del método de <code>sort</code> es que cambia el orden de los elementos en la matriz original. En otras palabras, muta la matriz en su lugar. Una forma de evitar esto es primero concatenar una matriz vacía con la ordenada (recuerde que <code>concat</code> devuelve una nueva matriz), luego ejecute el método de <code>sort</code> . </section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
Utilice el método de <code>sort</code> en la función <code>nonMutatingSort</code> para ordenar los elementos de una matriz en orden ascendente. La función debe devolver una nueva matriz y no mutar la variable <code>globalArray</code> .
|
||||
</section>
|
||||
<section id="instructions"> Utilice el método de <code>sort</code> en la función <code>nonMutatingSort</code> para ordenar los elementos de una matriz en orden ascendente. La función debe devolver una nueva matriz y no mutar la variable <code>globalArray</code> . </section>
|
||||
|
||||
## Tests
|
||||
<section id='tests'>
|
||||
@@ -26,7 +23,7 @@ tests:
|
||||
testString: 'assert(code.match(/\.concat/g), "Your code should use the <code>concat</code> method.");'
|
||||
- text: La variable <code>globalArray</code> no debe cambiar.
|
||||
testString: 'assert(JSON.stringify(globalArray) === JSON.stringify([5, 6, 3, 2, 9]), "The <code>globalArray</code> variable should not change.");'
|
||||
- text: ' <code>nonMutatingSort(globalArray)</code> debe devolver <code>[2, 3, 5, 6, 9]</code> .'
|
||||
- text: '<code>nonMutatingSort(globalArray)</code> debe devolver <code>[2, 3, 5, 6, 9]</code> .'
|
||||
testString: 'assert(JSON.stringify(nonMutatingSort(globalArray)) === JSON.stringify([2, 3, 5, 6, 9]), "<code>nonMutatingSort(globalArray)</code> should return <code>[2, 3, 5, 6, 9]</code>.");'
|
||||
|
||||
```
|
||||
@@ -47,6 +44,7 @@ function nonMutatingSort(arr) {
|
||||
// Add your code above this line
|
||||
}
|
||||
nonMutatingSort(globalArray);
|
||||
|
||||
```
|
||||
|
||||
</div>
|
||||
|
||||
@@ -1,21 +1,16 @@
|
||||
---
|
||||
id: 587d7b90367417b2b2512b65
|
||||
title: Return Part of an Array Using the slice Method
|
||||
localeTitle: Devolver parte de una matriz utilizando el método de corte
|
||||
challengeType: 1
|
||||
videoUrl: ''
|
||||
localeTitle: Devolver parte de una matriz utilizando el método de corte
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
El método de <code>slice</code> devuelve una copia de ciertos elementos de una matriz. Puede tomar dos argumentos, el primero proporciona el índice de dónde comenzar la división, el segundo es el índice de dónde finalizar la división (y no está incluido). Si no se proporcionan los argumentos, el valor predeterminado es comenzar desde el principio de la matriz hasta el final, lo cual es una forma fácil de hacer una copia de toda la matriz. La <code>slice</code> método no muta la matriz original, pero devuelve una nueva.
|
||||
Aquí hay un ejemplo:
|
||||
<blockquote>var arr = ["Cat", "Dog", "Tiger", "Zebra"];<br>var newArray = arr.slice(1, 3);<br>// Sets newArray to ["Dog", "Tiger"]</blockquote>
|
||||
</section>
|
||||
<section id="description"> El método de <code>slice</code> devuelve una copia de ciertos elementos de una matriz. Puede tomar dos argumentos, el primero proporciona el índice de dónde comenzar la división, el segundo es el índice de dónde finalizar la división (y no está incluido). Si no se proporcionan los argumentos, el valor predeterminado es comenzar desde el principio de la matriz hasta el final, lo cual es una forma fácil de hacer una copia de toda la matriz. La <code>slice</code> método no muta la matriz original, pero devuelve una nueva. Aquí hay un ejemplo: <blockquote> var arr = ["Cat", "Dog", "Tiger", "Zebra"]; <br> var newArray = arr.slice (1, 3); <br> // Establece newArray en ["Perro", "Tigre"] </blockquote></section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
Utilice la <code>slice</code> método en el <code>sliceArray</code> función para devolver parte de la <code>anim</code> matriz dada las proporcionadas <code>beginSlice</code> y <code>endSlice</code> índices. La función debe devolver una matriz.
|
||||
</section>
|
||||
<section id="instructions"> Utilice la <code>slice</code> método en el <code>sliceArray</code> función para devolver parte de la <code>anim</code> matriz dada las proporcionadas <code>beginSlice</code> y <code>endSlice</code> índices. La función debe devolver una matriz. </section>
|
||||
|
||||
## Tests
|
||||
<section id='tests'>
|
||||
@@ -26,11 +21,11 @@ tests:
|
||||
testString: 'assert(code.match(/\.slice/g), "Your code should use the <code>slice</code> method.");'
|
||||
- text: La variable <code>inputAnim</code> no debe cambiar.
|
||||
testString: 'assert(JSON.stringify(inputAnim) === JSON.stringify(["Cat", "Dog", "Tiger", "Zebra", "Ant"]), "The <code>inputAnim</code> variable should not change.");'
|
||||
- text: ' <code>sliceArray(["Cat", "Dog", "Tiger", "Zebra", "Ant"], 1, 3)</code> debe devolver <code>["Dog", "Tiger"]</code> .'
|
||||
- text: '<code>sliceArray(["Cat", "Dog", "Tiger", "Zebra", "Ant"], 1, 3)</code> debe devolver <code>["Dog", "Tiger"]</code> .'
|
||||
testString: 'assert(JSON.stringify(sliceArray(["Cat", "Dog", "Tiger", "Zebra", "Ant"], 1, 3)) === JSON.stringify(["Dog", "Tiger"]), "<code>sliceArray(["Cat", "Dog", "Tiger", "Zebra", "Ant"], 1, 3)</code> should return <code>["Dog", "Tiger"]</code>.");'
|
||||
- text: ' <code>sliceArray(["Cat", "Dog", "Tiger", "Zebra", "Ant"], 0, 1)</code> debe devolver <code>["Cat"]</code> .'
|
||||
- text: '<code>sliceArray(["Cat", "Dog", "Tiger", "Zebra", "Ant"], 0, 1)</code> debe devolver <code>["Cat"]</code> .'
|
||||
testString: 'assert(JSON.stringify(sliceArray(["Cat", "Dog", "Tiger", "Zebra", "Ant"], 0, 1)) === JSON.stringify(["Cat"]), "<code>sliceArray(["Cat", "Dog", "Tiger", "Zebra", "Ant"], 0, 1)</code> should return <code>["Cat"]</code>.");'
|
||||
- text: ' <code>sliceArray(["Cat", "Dog", "Tiger", "Zebra", "Ant"], 1, 4)</code> debe devolver <code>["Dog", "Tiger", "Zebra"]</code> .'
|
||||
- text: '<code>sliceArray(["Cat", "Dog", "Tiger", "Zebra", "Ant"], 1, 4)</code> debe devolver <code>["Dog", "Tiger", "Zebra"]</code> .'
|
||||
testString: 'assert(JSON.stringify(sliceArray(["Cat", "Dog", "Tiger", "Zebra", "Ant"], 1, 4)) === JSON.stringify(["Dog", "Tiger", "Zebra"]), "<code>sliceArray(["Cat", "Dog", "Tiger", "Zebra", "Ant"], 1, 4)</code> should return <code>["Dog", "Tiger", "Zebra"]</code>.");'
|
||||
|
||||
```
|
||||
@@ -51,6 +46,7 @@ function sliceArray(anim, beginSlice, endSlice) {
|
||||
}
|
||||
var inputAnim = ["Cat", "Dog", "Tiger", "Zebra", "Ant"];
|
||||
sliceArray(inputAnim, 1, 3);
|
||||
|
||||
```
|
||||
|
||||
</div>
|
||||
|
||||
@@ -1,22 +1,16 @@
|
||||
---
|
||||
id: 587d7da9367417b2b2512b69
|
||||
title: Sort an Array Alphabetically using the sort Method
|
||||
localeTitle: Ordena una matriz alfabéticamente usando el método de clasificación
|
||||
challengeType: 1
|
||||
videoUrl: ''
|
||||
localeTitle: Ordena una matriz alfabéticamente usando el método de clasificación
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
El método de <code>sort</code> ordena los elementos de una matriz de acuerdo con la función de devolución de llamada.
|
||||
Por ejemplo:
|
||||
<blockquote>function ascendingOrder(arr) {<br> return arr.sort(function(a, b) {<br> return a - b;<br> });<br>}<br>ascendingOrder([1, 5, 2, 3, 4]);<br>// Returns [1, 2, 3, 4, 5]<br><br>function reverseAlpha(arr) {<br> return arr.sort(function(a, b) {<br> return a < b;<br> });<br>}<br>reverseAlpha(['l', 'h', 'z', 'b', 's']);<br>// Returns ['z', 's', 'l', 'h', 'b']</blockquote>
|
||||
Nota: Se recomienda proporcionar una función de devolución de llamada para especificar cómo ordenar los elementos de la matriz. El método de clasificación predeterminado de JavaScript es por valor de punto Unicode de cadena, que puede devolver resultados inesperados.
|
||||
</section>
|
||||
<section id="description"> El método de <code>sort</code> ordena los elementos de una matriz de acuerdo con la función de devolución de llamada. Por ejemplo: <blockquote> función ascendingOrder (arr) { <br> devolver arr.sort (función (a, b) { <br> devuelve a - b; <br> }); <br> } <br> orden ascendente ([1, 5, 2, 3, 4]); <br> // Devoluciones [1, 2, 3, 4, 5] <br><br> funcion reverseAlpha (arr) { <br> devolver arr.sort (función (a, b) { <br> devuelve a <b; <br> }); <br> } <br> reverseAlpha (['l', 'h', 'z', 'b', 's']); <br> // Devuelve ['z', 's', 'l', 'h', 'b'] </blockquote> Nota: se recomienda proporcionar una función de devolución de llamada para especificar cómo ordenar los elementos de la matriz. El método de clasificación predeterminado de JavaScript es por valor de punto Unicode de cadena, que puede devolver resultados inesperados. </section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
Utilice el método de <code>sort</code> en la función de orden <code>alphabeticalOrder</code> para ordenar los elementos de <code>arr</code> en orden alfabético.
|
||||
</section>
|
||||
<section id="instructions"> Utilice el método de <code>sort</code> en la función <code>alphabeticalOrder</code> para ordenar los elementos de <code>arr</code> en orden alfabético. </section>
|
||||
|
||||
## Tests
|
||||
<section id='tests'>
|
||||
@@ -25,11 +19,11 @@ Utilice el método de <code>sort</code> en la función de orden <code>alphabetic
|
||||
tests:
|
||||
- text: Su código debe utilizar el método de <code>sort</code> .
|
||||
testString: 'assert(code.match(/\.sort/g), "Your code should use the <code>sort</code> method.");'
|
||||
- text: ' <code>alphabeticalOrder(["a", "d", "c", "a", "z", "g"])</code> debe devolver <code>["a", "a", "c", "d", "g", "z"]</code> . '
|
||||
- text: '<code>alphabeticalOrder(["a", "d", "c", "a", "z", "g"])</code> debe devolver <code>["a", "a", "c", "d", "g", "z"]</code> .'
|
||||
testString: 'assert(JSON.stringify(alphabeticalOrder(["a", "d", "c", "a", "z", "g"])) === JSON.stringify(["a", "a", "c", "d", "g", "z"]), "<code>alphabeticalOrder(["a", "d", "c", "a", "z", "g"])</code> should return <code>["a", "a", "c", "d", "g", "z"]</code>.");'
|
||||
- text: ' <code>alphabeticalOrder(["x", "h", "a", "m", "n", "m"])</code> debe devolver <code>["a", "h", "m", "m", "n", "x"]</code> . '
|
||||
- text: '<code>alphabeticalOrder(["x", "h", "a", "m", "n", "m"])</code> debe devolver <code>["a", "h", "m", "m", "n", "x"]</code> .'
|
||||
testString: 'assert(JSON.stringify(alphabeticalOrder(["x", "h", "a", "m", "n", "m"])) === JSON.stringify(["a", "h", "m", "m", "n", "x"]), "<code>alphabeticalOrder(["x", "h", "a", "m", "n", "m"])</code> should return <code>["a", "h", "m", "m", "n", "x"]</code>.");'
|
||||
- text: ' <code>alphabeticalOrder(["a", "a", "a", "a", "x", "t"])</code> debe devolver <code>["a", "a", "a", "a", "t", "x"]</code> . '
|
||||
- text: '<code>alphabeticalOrder(["a", "a", "a", "a", "x", "t"])</code> debe devolver <code>["a", "a", "a", "a", "t", "x"]</code> .'
|
||||
testString: 'assert(JSON.stringify(alphabeticalOrder(["a", "a", "a", "a", "x", "t"])) === JSON.stringify(["a", "a", "a", "a", "t", "x"]), "<code>alphabeticalOrder(["a", "a", "a", "a", "x", "t"])</code> should return <code>["a", "a", "a", "a", "t", "x"]</code>.");'
|
||||
|
||||
```
|
||||
@@ -49,6 +43,7 @@ function alphabeticalOrder(arr) {
|
||||
// Add your code above this line
|
||||
}
|
||||
alphabeticalOrder(["a", "d", "c", "a", "z", "g"]);
|
||||
|
||||
```
|
||||
|
||||
</div>
|
||||
|
||||
@@ -1,22 +1,16 @@
|
||||
---
|
||||
id: 587d7daa367417b2b2512b6b
|
||||
title: Split a String into an Array Using the split Method
|
||||
localeTitle: Dividir una cadena en una matriz usando el método de división
|
||||
challengeType: 1
|
||||
videoUrl: ''
|
||||
localeTitle: Dividir una cadena en una matriz usando el método de división
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
El método de <code>split</code> divide una cadena en una matriz de cadenas. Toma un argumento para el delimitador, que puede ser un carácter que se usa para separar la cadena o una expresión regular. Por ejemplo, si el delimitador es un espacio, obtiene una matriz de palabras, y si el delimitador es una cadena vacía, obtiene una matriz de cada carácter en la cadena.
|
||||
Aquí hay dos ejemplos que dividen una cadena por espacios, luego otro por dígitos usando una expresión regular:
|
||||
<blockquote>var str = "Hello World";<br>var bySpace = str.split(" ");<br>// Sets bySpace to ["Hello", "World"]<br><br>var otherString = "How9are7you2today";<br>var byDigits = otherString.split(/\d/);<br>// Sets byDigits to ["How", "are", "you", "today"]</blockquote>
|
||||
Dado que las cadenas son inmutables, el método de <code>split</code> facilita el trabajo con ellas.
|
||||
</section>
|
||||
<section id="description"> El método de <code>split</code> divide una cadena en una matriz de cadenas. Toma un argumento para el delimitador, que puede ser un carácter que se usa para separar la cadena o una expresión regular. Por ejemplo, si el delimitador es un espacio, obtiene una matriz de palabras, y si el delimitador es una cadena vacía, obtiene una matriz de cada carácter en la cadena. Aquí hay dos ejemplos que dividen una cadena por espacios, luego otro por dígitos usando una expresión regular: <blockquote> var str = "Hola Mundo"; <br> var bySpace = str.split (""); <br> // Establece bySpace en ["Hola", "Mundo"] <br><br> var otherString = "How9are7you2today"; <br> var byDigits = otherString.split (/ \ d /); <br> // Establece byDigits en ["How", "are", "you", "today"] </blockquote> Dado que las cadenas son inmutables, el método de <code>split</code> facilita el trabajo con ellas. </section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
Utilice la <code>split</code> método dentro de la <code>splitify</code> función de dividir <code>str</code> en una matriz de palabras. La función debe devolver la matriz. Tenga en cuenta que las palabras no siempre están separadas por espacios y que la matriz no debe contener puntuación.
|
||||
</section>
|
||||
<section id="instructions"> Utilice la <code>split</code> método dentro de la <code>splitify</code> función de dividir <code>str</code> en una matriz de palabras. La función debe devolver la matriz. Tenga en cuenta que las palabras no siempre están separadas por espacios y que la matriz no debe contener puntuación. </section>
|
||||
|
||||
## Tests
|
||||
<section id='tests'>
|
||||
@@ -25,11 +19,11 @@ Utilice la <code>split</code> método dentro de la <code>splitify</code> funció
|
||||
tests:
|
||||
- text: Su código debe utilizar el método de <code>split</code> .
|
||||
testString: 'assert(code.match(/\.split/g), "Your code should use the <code>split</code> method.");'
|
||||
- text: ' <code>splitify("Hello World,I-am code")</code> debe devolver <code>["Hello", "World", "I", "am", "code"]</code> .'
|
||||
- text: '<code>splitify("Hello World,I-am code")</code> debe devolver <code>["Hello", "World", "I", "am", "code"]</code> .'
|
||||
testString: 'assert(JSON.stringify(splitify("Hello World,I-am code")) === JSON.stringify(["Hello", "World", "I", "am", "code"]), "<code>splitify("Hello World,I-am code")</code> should return <code>["Hello", "World", "I", "am", "code"]</code>.");'
|
||||
- text: ' <code>splitify("Earth-is-our home")</code> debería devolver <code>["Earth", "is", "our", "home"]</code> .'
|
||||
- text: '<code>splitify("Earth-is-our home")</code> debe devolver <code>["Earth", "is", "our", "home"]</code> .'
|
||||
testString: 'assert(JSON.stringify(splitify("Earth-is-our home")) === JSON.stringify(["Earth", "is", "our", "home"]), "<code>splitify("Earth-is-our home")</code> should return <code>["Earth", "is", "our", "home"]</code>.");'
|
||||
- text: ' <code>splitify("This.is.a-sentence")</code> debe devolver <code>["This", "is", "a", "sentence"]</code> .'
|
||||
- text: '<code>splitify("This.is.a-sentence")</code> debe devolver <code>["This", "is", "a", "sentence"]</code> .'
|
||||
testString: 'assert(JSON.stringify(splitify("This.is.a-sentence")) === JSON.stringify(["This", "is", "a", "sentence"]), "<code>splitify("This.is.a-sentence")</code> should return <code>["This", "is", "a", "sentence"]</code>.");'
|
||||
|
||||
```
|
||||
@@ -49,6 +43,7 @@ function splitify(str) {
|
||||
// Add your code above this line
|
||||
}
|
||||
splitify("Hello World,I-am code");
|
||||
|
||||
```
|
||||
|
||||
</div>
|
||||
|
||||
@@ -1,26 +1,16 @@
|
||||
---
|
||||
id: 587d7b8e367417b2b2512b5c
|
||||
title: Understand Functional Programming Terminology
|
||||
localeTitle: Entender la terminología de programación funcional
|
||||
challengeType: 1
|
||||
videoUrl: ''
|
||||
localeTitle: Entender la terminología de programación funcional
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
El equipo de la FCC tuvo un cambio de humor y ahora quiere dos tipos de té: té verde y té negro. Hecho general: los cambios de humor del cliente son bastante comunes.
|
||||
Con esa información, tendremos que revisar la función <code>getTea</code> del último desafío para manejar varias solicitudes de té. Podemos modificar <code>getTea</code> para aceptar una función como parámetro para poder cambiar el tipo de té que prepara. Esto hace que <code>getTea</code> sea más flexible y le da al programador más control cuando cambian las solicitudes de los clientes.
|
||||
Pero primero, vamos a cubrir algunos términos funcionales:
|
||||
<code>Callbacks</code> son las funciones que se deslizan o pasan a otra función para decidir la invocación de esa función. Es posible que los haya visto pasar a otros métodos, por ejemplo, en el <code>filter</code> , la función de devolución de llamada le dice a JavaScript los criterios sobre cómo filtrar una matriz.
|
||||
funciones que pueden asignarse a una variable, pasarse a otra función o devolverse desde otra función como cualquier otro valor normal, se denominan funciones de <code>first class</code> . En JavaScript, todas las funciones son funciones de <code>first class</code> .
|
||||
Las funciones que toman una función como argumento o que devuelven una función como valor de retorno se denominan funciones de <code>higher order</code> .
|
||||
Cuando las funciones se pasan a otra función o se devuelven desde otra función, las funciones que se pasan o devuelven pueden llamarse <code>lambda</code> .
|
||||
</section>
|
||||
<section id="description"> El equipo de la FCC tuvo un cambio de humor y ahora quiere dos tipos de té: té verde y té negro. Hecho general: los cambios de humor del cliente son bastante comunes. Con esa información, tendremos que revisar la función <code>getTea</code> del último desafío para manejar varias solicitudes de té. Podemos modificar <code>getTea</code> para aceptar una función como parámetro para poder cambiar el tipo de té que prepara. Esto hace que <code>getTea</code> sea más flexible y le da al programador más control cuando cambian las solicitudes de los clientes. Pero primero, vamos a cubrir algunos términos funcionales: las <code>Callbacks</code> son las funciones que se deslizan o pasan a otra función para decidir la invocación de esa función. Es posible que los haya visto pasar a otros métodos, por ejemplo, en el <code>filter</code> , la función de devolución de llamada le dice a JavaScript los criterios sobre cómo filtrar una matriz. Las funciones que se pueden asignar a una variable, pasar a otra función o devolver desde otra función al igual que cualquier otro valor normal, se denominan funciones de <code>first class</code> . En JavaScript, todas las funciones son funciones de <code>first class</code> . Las funciones que toman una función como argumento o que devuelven una función como valor de retorno se denominan funciones de <code>higher order</code> . Cuando las funciones se pasan a otra función o se devuelven desde otra función, las funciones que se pasan o se devuelven pueden llamarse <code>lambda</code> . </section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
Prepare 27 tazas de té verde y 13 tazas de té negro y almacénelas en las variables <code>tea4GreenTeamFCC</code> y <code>tea4BlackTeamFCC</code> , respectivamente. Tenga en cuenta que la función <code>getTea</code> se ha modificado, por lo que ahora toma una función como primer argumento.
|
||||
Nota: Los datos (el número de tazas de té) se proporcionan como el último argumento. Discutiremos esto más en lecciones posteriores.
|
||||
</section>
|
||||
<section id="instructions"> Prepare 27 tazas de té verde y 13 tazas de té negro y almacénelas en las variables <code>tea4GreenTeamFCC</code> y <code>tea4BlackTeamFCC</code> , respectivamente. Tenga en cuenta que la función <code>getTea</code> se ha modificado, por lo que ahora toma una función como primer argumento. Nota: Los datos (el número de tazas de té) se proporcionan como el último argumento. Discutiremos esto más en lecciones posteriores. </section>
|
||||
|
||||
## Tests
|
||||
<section id='tests'>
|
||||
@@ -86,6 +76,7 @@ console.log(
|
||||
tea4GreenTeamFCC,
|
||||
tea4BlackTeamFCC
|
||||
);
|
||||
|
||||
```
|
||||
|
||||
</div>
|
||||
|
||||
@@ -1,28 +1,16 @@
|
||||
---
|
||||
id: 587d7b8e367417b2b2512b5d
|
||||
title: Understand the Hazards of Using Imperative Code
|
||||
localeTitle: Entender los peligros de usar el código imperativo
|
||||
challengeType: 1
|
||||
videoUrl: ''
|
||||
localeTitle: Entender los peligros de usar el código imperativo
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
La programación funcional es un buen hábito. Mantiene tu código fácil de administrar y te salva de errores furtivos. Pero antes de que lleguemos allí, veamos un enfoque imperativo de la programación para resaltar dónde puede tener problemas.
|
||||
En inglés (y en muchos otros idiomas), el tiempo imperativo se usa para dar comandos. De manera similar, un estilo imperativo en la programación es uno que le da a la computadora un conjunto de declaraciones para realizar una tarea.
|
||||
A menudo, las declaraciones cambian el estado del programa, como la actualización de variables globales. Un ejemplo clásico es escribir un bucle <code>for</code> que da instrucciones exactas para iterar sobre los índices de una matriz.
|
||||
En contraste, la programación funcional es una forma de programación declarativa. Usted le dice a la computadora lo que quiere hacer llamando a un método o función.
|
||||
JavaScript ofrece muchos métodos predefinidos que manejan tareas comunes, por lo que no necesita escribir cómo la computadora debe realizarlos. Por ejemplo, en lugar de utilizar el bucle <code>for</code> mencionado anteriormente, puede llamar al método de <code>map</code> que maneja los detalles de la iteración en una matriz. Esto ayuda a evitar errores semánticos, como los "Errores Off By One" que se cubrieron en la sección de Depuración.
|
||||
Considere el escenario: está navegando por la web en su navegador y desea rastrear las pestañas que ha abierto. Intentemos modelar esto usando un código simple orientado a objetos.
|
||||
Un objeto de ventana se compone de pestañas, y normalmente tiene más de una ventana abierta. Los títulos de cada sitio abierto en cada objeto de Ventana se mantienen en una matriz. Después de trabajar en el navegador (abrir nuevas pestañas, fusionar ventanas y cerrar pestañas), desea imprimir las pestañas que aún están abiertas. Las pestañas cerradas se eliminan de la matriz y las nuevas pestañas (para simplificar) se agregan al final de la misma.
|
||||
El editor de código muestra una implementación de esta funcionalidad con funciones para <code>tabOpen()</code> , <code>tabClose()</code> y <code>join()</code> . Las <code>tabs</code> matriz forman parte del objeto Window que almacena el nombre de las páginas abiertas.
|
||||
<h4> Instrucciones <h4>
|
||||
Ejecutar el código en el editor. Está utilizando un método que tiene efectos secundarios en el programa, lo que provoca un resultado incorrecto. La lista final de pestañas abiertas debe ser <code>['FB', 'Gitter', 'Reddit', 'Twitter', 'Medium', 'new tab', 'Netflix', 'YouTube', 'Vine', 'GMail', 'Work mail', 'Docs', 'freeCodeCamp', 'new tab']</code> pero la salida será ligeramente diferente.
|
||||
Revise el código y vea si puede resolver el problema, luego avance al próximo desafío para obtener más información.
|
||||
</section>
|
||||
<section id="description"> La programación funcional es un buen hábito. Mantiene tu código fácil de administrar y te salva de errores furtivos. Pero antes de que lleguemos allí, veamos un enfoque imperativo de la programación para resaltar dónde puede tener problemas. En inglés (y en muchos otros idiomas), el tiempo imperativo se usa para dar órdenes. De manera similar, un estilo imperativo en la programación es uno que le da a la computadora un conjunto de declaraciones para realizar una tarea. A menudo, las declaraciones cambian el estado del programa, como la actualización de variables globales. Un ejemplo clásico es escribir un bucle <code>for</code> que da instrucciones exactas para iterar sobre los índices de una matriz. En contraste, la programación funcional es una forma de programación declarativa. Usted le dice a la computadora lo que quiere hacer llamando a un método o función. JavaScript ofrece muchos métodos predefinidos que manejan tareas comunes, por lo que no necesita escribir cómo la computadora debe realizarlos. Por ejemplo, en lugar de utilizar el bucle <code>for</code> mencionado anteriormente, puede llamar al método de <code>map</code> que maneja los detalles de la iteración en una matriz. Esto ayuda a evitar errores semánticos, como los "Errores Off By One" que se cubrieron en la sección de Depuración. Considere el escenario: está navegando por la web en su navegador y desea rastrear las pestañas que ha abierto. Intentemos modelar esto usando un código simple orientado a objetos. Un objeto de ventana se compone de pestañas y, por lo general, tiene más de una ventana abierta. Los títulos de cada sitio abierto en cada objeto de Ventana se mantienen en una matriz. Después de trabajar en el navegador (abrir nuevas pestañas, fusionar ventanas y cerrar pestañas), desea imprimir las pestañas que aún están abiertas. Las pestañas cerradas se eliminan de la matriz y las nuevas pestañas (para simplificar) se agregan al final de la misma. El editor de código muestra una implementación de esta funcionalidad con funciones para <code>tabOpen()</code> , <code>tabClose()</code> y <code>join()</code> . Las <code>tabs</code> matriz forman parte del objeto Window que almacena el nombre de las páginas abiertas. <h4> Instrucciones </h4><h4> Ejecuta el código en el editor. Está utilizando un método que tiene efectos secundarios en el programa, lo que provoca un resultado incorrecto. La lista final de pestañas abiertas debe ser <code>['FB', 'Gitter', 'Reddit', 'Twitter', 'Medium', 'new tab', 'Netflix', 'YouTube', 'Vine', 'GMail', 'Work mail', 'Docs', 'freeCodeCamp', 'new tab']</code> pero la salida será ligeramente diferente. Revise el código y vea si puede resolver el problema, luego avance al siguiente desafío para obtener más información. </h4></section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
|
||||
<section id="instructions">
|
||||
</section>
|
||||
|
||||
## Tests
|
||||
@@ -81,6 +69,7 @@ var finalTabs = socialWindow
|
||||
.join(workWindow.tabClose(1).tabOpen());
|
||||
|
||||
alert(finalTabs.tabs);
|
||||
|
||||
```
|
||||
|
||||
</div>
|
||||
|
||||
@@ -1,21 +1,16 @@
|
||||
---
|
||||
id: 587d7dab367417b2b2512b6e
|
||||
title: Use the every Method to Check that Every Element in an Array Meets a Criteria
|
||||
localeTitle: Use cada método para verificar que cada elemento de una matriz cumple con los criterios
|
||||
challengeType: 1
|
||||
videoUrl: ''
|
||||
localeTitle: Use cada método para verificar que cada elemento de una matriz cumple con los criterios
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
<code>every</code> métodos funcionan con matrices para verificar si <em>cada</em> elemento pasa una prueba en particular. Devuelve un valor booleano: <code>true</code> si todos los valores cumplen los criterios, <code>false</code> si no.
|
||||
Por ejemplo, el siguiente código verificará si cada elemento de la matriz de <code>numbers</code> es menor que 10:
|
||||
<blockquote>var numbers = [1, 5, 8, 0, 10, 11];<br>numbers.every(function(currentValue) {<br> return currentValue < 10;<br>});<br>// Returns false</blockquote>
|
||||
</section>
|
||||
<section id="description"> <code>every</code> método funciona con matrices para verificar si <em>cada</em> elemento pasa una prueba en particular. Devuelve un valor booleano: <code>true</code> si todos los valores cumplen los criterios, <code>false</code> si no. Por ejemplo, el siguiente código verificará si cada elemento de la matriz de <code>numbers</code> es menor que 10: <blockquote> números var = [1, 5, 8, 0, 10, 11]; <br> numbers.every (function (currentValue) { <br> return currentValue <10; <br> }); <br> // Devuelve falso </blockquote></section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
Use <code>every</code> método dentro de la función <code>checkPositive</code> para verificar si cada elemento en <code>arr</code> es positivo. La función debe devolver un valor booleano.
|
||||
</section>
|
||||
<section id="instructions"> Use <code>every</code> método dentro de la función <code>checkPositive</code> para verificar si cada elemento en <code>arr</code> es positivo. La función debe devolver un valor booleano. </section>
|
||||
|
||||
## Tests
|
||||
<section id='tests'>
|
||||
@@ -24,11 +19,11 @@ Use <code>every</code> método dentro de la función <code>checkPositive</code>
|
||||
tests:
|
||||
- text: Su código debe utilizar <code>every</code> métodos.
|
||||
testString: 'assert(code.match(/\.every/g), "Your code should use the <code>every</code> method.");'
|
||||
- text: ' <code>checkPositive([1, 2, 3, -4, 5])</code> debe devolver <code>false</code> .'
|
||||
- text: '<code>checkPositive([1, 2, 3, -4, 5])</code> debe devolver <code>false</code> .'
|
||||
testString: 'assert(!checkPositive([1, 2, 3, -4, 5]), "<code>checkPositive([1, 2, 3, -4, 5])</code> should return <code>false</code>.");'
|
||||
- text: ' <code>checkPositive([1, 2, 3, 4, 5])</code> debe devolver <code>true</code> .'
|
||||
- text: '<code>checkPositive([1, 2, 3, 4, 5])</code> debe devolver <code>true</code> .'
|
||||
testString: 'assert(checkPositive([1, 2, 3, 4, 5]), "<code>checkPositive([1, 2, 3, 4, 5])</code> should return <code>true</code>.");'
|
||||
- text: ' <code>checkPositive([1, -2, 3, -4, 5])</code> debe devolver <code>false</code> .'
|
||||
- text: '<code>checkPositive([1, -2, 3, -4, 5])</code> debe devolver <code>false</code> .'
|
||||
testString: 'assert(!checkPositive([1, -2, 3, -4, 5]), "<code>checkPositive([1, -2, 3, -4, 5])</code> should return <code>false</code>.");'
|
||||
|
||||
```
|
||||
@@ -48,6 +43,7 @@ function checkPositive(arr) {
|
||||
// Add your code above this line
|
||||
}
|
||||
checkPositive([1, 2, 3, -4, 5]);
|
||||
|
||||
```
|
||||
|
||||
</div>
|
||||
|
||||
@@ -1,20 +1,16 @@
|
||||
---
|
||||
id: 587d7b8f367417b2b2512b63
|
||||
title: Use the filter Method to Extract Data from an Array
|
||||
localeTitle: Utilice el método de filtro para extraer datos de una matriz
|
||||
challengeType: 1
|
||||
videoUrl: ''
|
||||
localeTitle: Utilice el método de filtro para extraer datos de una matriz
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
Otra función de matriz útil es <code>Array.prototype.filter()</code> , o simplemente <code>filter()</code> . El método de <code>filter</code> devuelve una nueva matriz que es a lo sumo tan larga como la matriz original, pero generalmente tiene menos elementos.
|
||||
<code>Filter</code> no altera la matriz original, al igual que el <code>map</code> . Toma una función de devolución de llamada que aplica la lógica dentro de la devolución de llamada en cada elemento de la matriz. Si un elemento devuelve verdadero según los criterios en la función de devolución de llamada, entonces se incluye en la nueva matriz.
|
||||
</section>
|
||||
<section id="description"> Otra función de matriz útil es <code>Array.prototype.filter()</code> , o simplemente <code>filter()</code> . El método de <code>filter</code> devuelve una nueva matriz que es a lo sumo tan larga como la matriz original, pero generalmente tiene menos elementos. <code>Filter</code> no altera la matriz original, al igual que el <code>map</code> . Toma una función de devolución de llamada que aplica la lógica dentro de la devolución de llamada en cada elemento de la matriz. Si un elemento devuelve verdadero según los criterios en la función de devolución de llamada, entonces se incluye en la nueva matriz. </section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
La variable <code>watchList</code> contiene una serie de objetos con información sobre varias películas. Use una combinación de <code>filter</code> y <code>map</code> para devolver una nueva matriz de objetos con solo <code>title</code> y claves de <code>rating</code> , pero donde <code>imdbRating</code> es mayor o igual a 8.0. Tenga en cuenta que los valores de calificación se guardan como cadenas en el objeto y es posible que desee convertirlos en números para realizar operaciones matemáticas en ellos.
|
||||
</section>
|
||||
<section id="instructions"> La lista de <code>watchList</code> variable contiene una serie de objetos con información sobre varias películas. Use una combinación de <code>filter</code> y <code>map</code> para devolver una nueva matriz de objetos con solo <code>title</code> y claves de <code>rating</code> , pero donde <code>imdbRating</code> es mayor o igual a 8.0. Tenga en cuenta que los valores de calificación se guardan como cadenas en el objeto y es posible que desee convertirlos en números para realizar operaciones matemáticas en ellos. </section>
|
||||
|
||||
## Tests
|
||||
<section id='tests'>
|
||||
@@ -27,7 +23,7 @@ tests:
|
||||
testString: 'assert(code.match(/\.filter/g), "Your code should use the <code>filter</code> method.");'
|
||||
- text: Su código no debe utilizar un bucle <code>for</code> .
|
||||
testString: 'assert(!code.match(/for\s*?\(.+?\)/g), "Your code should not use a <code>for</code> loop.");'
|
||||
- text: ' <code>filteredList</code> debe ser igual a <code>[{"title": "Inception","rating": "8.8"},{"title": "Interstellar","rating": "8.6"},{"title": "The Dark Knight","rating": "9.0"},{"title": "Batman Begins","rating": "8.3"}]</code> . '
|
||||
- text: '<code>filteredList</code> debe ser igual a <code>[{"title": "Inception","rating": "8.8"},{"title": "Interstellar","rating": "8.6"},{"title": "The Dark Knight","rating": "9.0"},{"title": "Batman Begins","rating": "8.3"}]</code> .'
|
||||
testString: 'assert.deepEqual(filteredList, [{"title": "Inception","rating": "8.8"},{"title": "Interstellar","rating": "8.6"},{"title": "The Dark Knight","rating": "9.0"},{"title": "Batman Begins","rating": "8.3"}], "<code>filteredList</code> should equal <code>[{"title": "Inception","rating": "8.8"},{"title": "Interstellar","rating": "8.6"},{"title": "The Dark Knight","rating": "9.0"},{"title": "Batman Begins","rating": "8.3"}]</code>.");'
|
||||
|
||||
```
|
||||
@@ -161,6 +157,7 @@ var filteredList;
|
||||
// Add your code above this line
|
||||
|
||||
console.log(filteredList);
|
||||
|
||||
```
|
||||
|
||||
</div>
|
||||
|
||||
@@ -1,23 +1,16 @@
|
||||
---
|
||||
id: 587d7b8f367417b2b2512b61
|
||||
title: Use the map Method to Extract Data from an Array
|
||||
localeTitle: Utilice el método de mapa para extraer datos de una matriz
|
||||
challengeType: 1
|
||||
videoUrl: ''
|
||||
localeTitle: Utilice el método de mapa para extraer datos de una matriz
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
Hasta ahora hemos aprendido a usar funciones puras para evitar efectos secundarios en un programa. Además, hemos visto que el valor de tener una función solo depende de sus argumentos de entrada.
|
||||
Esto es solo el comienzo. Como su nombre lo indica, la programación funcional se centra en una teoría de funciones.
|
||||
Tendría sentido poder pasarlos como argumentos a otras funciones y devolver una función desde otra función. Las funciones se consideran <code>First Class Objects</code> en JavaScript, lo que significa que se pueden usar como cualquier otro objeto. Pueden guardarse en variables, almacenarse en un objeto o pasarse como argumentos de función.
|
||||
Comencemos con algunas funciones de matriz simples, que son métodos en el prototipo de objeto de matriz. En este ejercicio estamos viendo <code>Array.prototype.map()</code> , o más simplemente un <code>map</code> .
|
||||
Recuerde que el método de <code>map</code> es una forma de iterar sobre cada elemento en una matriz. Crea una nueva matriz (sin cambiar la original) después de aplicar una función de devolución de llamada a cada elemento.
|
||||
</section>
|
||||
<section id="description"> Hasta ahora hemos aprendido a usar funciones puras para evitar efectos secundarios en un programa. Además, hemos visto que el valor de tener una función solo depende de sus argumentos de entrada. Este es sólo el comienzo. Como su nombre lo indica, la programación funcional se centra en una teoría de funciones. Tendría sentido poder pasarlos como argumentos a otras funciones y devolver una función desde otra función. Las funciones se consideran <code>First Class Objects</code> en JavaScript, lo que significa que se pueden usar como cualquier otro objeto. Pueden guardarse en variables, almacenarse en un objeto o pasarse como argumentos de función. Comencemos con algunas funciones de matriz simples, que son métodos en el prototipo de objeto de matriz. En este ejercicio estamos viendo <code>Array.prototype.map()</code> , o más simplemente un <code>map</code> . Recuerde que el método de <code>map</code> es una forma de iterar sobre cada elemento en una matriz. Crea una nueva matriz (sin cambiar la original) después de aplicar una función de devolución de llamada a cada elemento. </section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
La matriz <code>watchList</code> contiene objetos con información sobre varias películas. Use el <code>map</code> para extraer el título y la clasificación de la <code>watchList</code> de <code>watchList</code> y guarde la nueva matriz en la variable de <code>rating</code> . El código en el editor actualmente usa un bucle <code>for</code> para hacer esto, reemplaza la funcionalidad de bucle con tu expresión de <code>map</code> .
|
||||
</section>
|
||||
<section id="instructions"> La matriz <code>watchList</code> contiene objetos con información sobre varias películas. Use el <code>map</code> para extraer el título y la clasificación de la <code>watchList</code> de <code>watchList</code> y guarde la nueva matriz en la variable de <code>rating</code> . El código en el editor actualmente usa un bucle <code>for</code> para hacer esto, reemplaza la funcionalidad de bucle con tu expresión de <code>map</code> . </section>
|
||||
|
||||
## Tests
|
||||
<section id='tests'>
|
||||
@@ -30,7 +23,7 @@ tests:
|
||||
testString: 'assert(!code.match(/for\s*?\(.+?\)/g), "Your code should not use a <code>for</code> loop.");'
|
||||
- text: Su código debe utilizar el método de <code>map</code> .
|
||||
testString: 'assert(code.match(/\.map/g), "Your code should use the <code>map</code> method.");'
|
||||
- text: La <code>rating</code> debería ser igual a <code>[{"title":"Inception","rating":"8.8"},{"title":"Interstellar","rating":"8.6"},{"title":"The Dark Knight","rating":"9.0"},{"title":"Batman Begins","rating":"8.3"},{"title":"Avatar","rating":"7.9"}]</code> . '
|
||||
- text: '<code>rating</code> debería ser igual a <code>[{"title":"Inception","rating":"8.8"},{"title":"Interstellar","rating":"8.6"},{"title":"The Dark Knight","rating":"9.0"},{"title":"Batman Begins","rating":"8.3"},{"title":"Avatar","rating":"7.9"}]</code> .'
|
||||
testString: 'assert(JSON.stringify(rating) === JSON.stringify([{"title":"Inception","rating":"8.8"},{"title":"Interstellar","rating":"8.6"},{"title":"The Dark Knight","rating":"9.0"},{"title":"Batman Begins","rating":"8.3"},{"title":"Avatar","rating":"7.9"}]), "<code>rating</code> should equal <code>[{"title":"Inception","rating":"8.8"},{"title":"Interstellar","rating":"8.6"},{"title":"The Dark Knight","rating":"9.0"},{"title":"Batman Begins","rating":"8.3"},{"title":"Avatar","rating":"7.9"}]</code>.");'
|
||||
|
||||
```
|
||||
@@ -167,6 +160,7 @@ for(var i=0; i < watchList.length; i++){
|
||||
// Add your code above this line
|
||||
|
||||
console.log(rating);
|
||||
|
||||
```
|
||||
|
||||
</div>
|
||||
|
||||
@@ -1,22 +1,16 @@
|
||||
---
|
||||
id: 587d7da9367417b2b2512b68
|
||||
title: Use the reduce Method to Analyze Data
|
||||
localeTitle: Utilice el método de reducción para analizar datos
|
||||
challengeType: 1
|
||||
videoUrl: ''
|
||||
localeTitle: Utilice el método de reducción para analizar datos
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
<code>Array.prototype.reduce()</code> , o simplemente <code>reduce()</code> , es la más general de todas las operaciones de matriz en JavaScript. Puede resolver casi cualquier problema de procesamiento de matrices utilizando el método de <code>reduce</code> .
|
||||
Este no es el caso con los métodos de <code>filter</code> y <code>map</code> , ya que no permiten la interacción entre dos elementos diferentes de la matriz. Por ejemplo, si desea comparar elementos de la matriz, o agregarlos juntos, el <code>filter</code> o el <code>map</code> no podrían procesarlo.
|
||||
El método de <code>reduce</code> permite formas más generales de procesamiento de matrices, y es posible mostrar que tanto el <code>filter</code> como el <code>map</code> pueden derivarse como una aplicación especial de <code>reduce</code> .
|
||||
Sin embargo, antes de que lleguemos allí, practiquemos <code>reduce</code> primero.
|
||||
</section>
|
||||
<section id="description"> <code>Array.prototype.reduce()</code> , o simplemente <code>reduce()</code> , es la más general de todas las operaciones de matriz en JavaScript. Puede resolver casi cualquier problema de procesamiento de matrices utilizando el método de <code>reduce</code> . Este no es el caso con los métodos de <code>filter</code> y <code>map</code> , ya que no permiten la interacción entre dos elementos diferentes de la matriz. Por ejemplo, si desea comparar elementos de la matriz, o agregarlos juntos, el <code>filter</code> o el <code>map</code> no podrían procesarlo. El método de <code>reduce</code> permite formas más generales de procesamiento de matrices, y es posible mostrar que tanto el <code>filter</code> como el <code>map</code> pueden derivarse como una aplicación especial de <code>reduce</code> . Sin embargo, antes de que lleguemos allí, practiquemos <code>reduce</code> primero. </section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
La variable <code>watchList</code> contiene una serie de objetos con información sobre varias películas. Use <code>reduce</code> para encontrar la calificación promedio de IMDB de las películas <strong>dirigidas por Christopher Nolan</strong> . Recuerde de los desafíos anteriores cómo <code>filter</code> datos y <code>map</code> para obtener lo que necesita. Es posible que deba crear otras variables, pero guardar el promedio final en la variable <code>averageRating</code> . Tenga en cuenta que los valores de calificación se guardan como cadenas en el objeto y deben convertirse en números antes de que se utilicen en cualquier operación matemática.
|
||||
</section>
|
||||
<section id="instructions"> La lista de <code>watchList</code> variable contiene una serie de objetos con información sobre varias películas. Use <code>reduce</code> para encontrar la calificación promedio de IMDB de las películas <strong>dirigidas por Christopher Nolan</strong> . Recuerde de los desafíos anteriores cómo <code>filter</code> datos y <code>map</code> para obtener lo que necesita. Es posible que deba crear otras variables, pero guardar el promedio final en la variable <code>averageRating</code> . Tenga en cuenta que los valores de calificación se guardan como cadenas en el objeto y deben convertirse en números antes de que se utilicen en cualquier operación matemática. </section>
|
||||
|
||||
## Tests
|
||||
<section id='tests'>
|
||||
@@ -163,6 +157,7 @@ var averageRating;
|
||||
// Add your code above this line
|
||||
|
||||
console.log(averageRating);
|
||||
|
||||
```
|
||||
|
||||
</div>
|
||||
|
||||
@@ -1,21 +1,16 @@
|
||||
---
|
||||
id: 587d7dab367417b2b2512b6f
|
||||
title: Use the some Method to Check that Any Elements in an Array Meet a Criteria
|
||||
localeTitle: Use el método para verificar que cualquier elemento de una matriz cumpla con los criterios
|
||||
challengeType: 1
|
||||
videoUrl: ''
|
||||
localeTitle: Use el método para verificar que cualquier elemento de una matriz cumpla con los criterios
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
El <code>some</code> método funciona con matrices para comprobar si <em>cualquier</em> elemento pasa una prueba particular. Devuelve un valor booleano: <code>true</code> si alguno de los valores cumple los criterios, <code>false</code> si no.
|
||||
Por ejemplo, el siguiente código verificará si algún elemento de la matriz de <code>numbers</code> es menor que 10:
|
||||
<blockquote>var numbers = [10, 50, 8, 220, 110, 11];<br>numbers.some(function(currentValue) {<br> return currentValue < 10;<br>});<br>// Returns true</blockquote>
|
||||
</section>
|
||||
<section id="description"> El método de <code>some</code> funciona con matrices para verificar si <em>algún</em> elemento pasa una prueba en particular. Devuelve un valor booleano: <code>true</code> si alguno de los valores cumple los criterios, <code>false</code> si no. Por ejemplo, el siguiente código verificará si algún elemento de la matriz de <code>numbers</code> es menor que 10: <blockquote> números var = [10, 50, 8, 220, 110, 11]; <br> numbers.some (function (currentValue) { <br> return currentValue <10; <br> }); <br> // Devuelve true </blockquote></section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
Use <code>some</code> método dentro de la función <code>checkPositive</code> para verificar si algún elemento en <code>arr</code> es positivo. La función debe devolver un valor booleano.
|
||||
</section>
|
||||
<section id="instructions"> Use <code>some</code> método dentro de la función <code>checkPositive</code> para verificar si algún elemento en <code>arr</code> es positivo. La función debe devolver un valor booleano. </section>
|
||||
|
||||
## Tests
|
||||
<section id='tests'>
|
||||
@@ -24,11 +19,11 @@ Use <code>some</code> método dentro de la función <code>checkPositive</code> p
|
||||
tests:
|
||||
- text: Su código debe utilizar <code>some</code> método.
|
||||
testString: 'assert(code.match(/\.some/g), "Your code should use the <code>some</code> method.");'
|
||||
- text: ' <code>checkPositive([1, 2, 3, -4, 5])</code> debe devolver <code>true</code> .'
|
||||
- text: '<code>checkPositive([1, 2, 3, -4, 5])</code> debe devolver <code>true</code> .'
|
||||
testString: 'assert(checkPositive([1, 2, 3, -4, 5]), "<code>checkPositive([1, 2, 3, -4, 5])</code> should return <code>true</code>.");'
|
||||
- text: ' <code>checkPositive([1, 2, 3, 4, 5])</code> debe devolver <code>true</code> .'
|
||||
- text: '<code>checkPositive([1, 2, 3, 4, 5])</code> debe devolver <code>true</code> .'
|
||||
testString: 'assert(checkPositive([1, 2, 3, 4, 5]), "<code>checkPositive([1, 2, 3, 4, 5])</code> should return <code>true</code>.");'
|
||||
- text: ' <code>checkPositive([-1, -2, -3, -4, -5])</code> debe devolver <code>false</code> .'
|
||||
- text: '<code>checkPositive([-1, -2, -3, -4, -5])</code> debe devolver <code>false</code> .'
|
||||
testString: 'assert(!checkPositive([-1, -2, -3, -4, -5]), "<code>checkPositive([-1, -2, -3, -4, -5])</code> should return <code>false</code>.");'
|
||||
|
||||
```
|
||||
@@ -48,6 +43,7 @@ function checkPositive(arr) {
|
||||
// Add your code above this line
|
||||
}
|
||||
checkPositive([1, 2, 3, -4, 5]);
|
||||
|
||||
```
|
||||
|
||||
</div>
|
||||
|
||||
Reference in New Issue
Block a user