fix(spanish-md): Address some formatting issues for Spanish md
This commit is contained in:
Bouncey
committed by
mrugesh mohapatra
mrugesh mohapatra
parent
ee9f6b2d72
commit
c2a45b58be
@@ -6,17 +6,17 @@ challengeType: 1
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
La declaración <code>const</code> tiene muchos casos de uso en JavaScript moderno.
|
||||
Algunos desarrolladores prefieren asignar todas sus variables usando <code>const</code> de forma predeterminada, a menos que sepan que deberán reasignar el valor. Solo en ese caso, usan <code>let</code> .
|
||||
Sin embargo, es importante comprender que los objetos (incluidas las matrices y las funciones) asignados a una variable que usa <code>const</code> todavía son mutables. El uso de la declaración <code>const</code> solo evita la reasignación del identificador de variable.
|
||||
<blockquote>"use strict";<br>const s = [5, 6, 7];<br>s = [1, 2, 3]; // throws error, trying to assign a const<br>s[2] = 45; // works just as it would with an array declared with var or let<br>console.log(s); // returns [5, 6, 45]</blockquote>
|
||||
Como puede ver, puede mutar el objeto <code>[5, 6, 7]</code> sí mismo y la variable <code>s</code> seguirá apuntando a la matriz alterada <code>[5, 6, 45]</code> . Al igual que todas las matrices, los elementos de la matriz en <code>s</code> son mutables, pero debido a que se utilizó <code>const</code> , no puede usar el identificador de la variable <code>s</code> para apuntar a una matriz diferente mediante el operador de asignación.
|
||||
<section id='description'>
|
||||
La declaración <code>const</code> tiene muchos casos de uso en JavaScript moderno.
|
||||
Algunos desarrolladores prefieren asignar todas sus variables usando <code>const</code> de forma predeterminada, a menos que sepan que deberán reasignar el valor. Solo en ese caso, usan <code>let</code> .
|
||||
Sin embargo, es importante comprender que los objetos (incluidas las matrices y las funciones) asignados a una variable que usa <code>const</code> todavía son mutables. El uso de la declaración <code>const</code> solo evita la reasignación del identificador de variable.
|
||||
<blockquote>"use strict";<br>const s = [5, 6, 7];<br>s = [1, 2, 3]; // throws error, trying to assign a const<br>s[2] = 45; // works just as it would with an array declared with var or let<br>console.log(s); // returns [5, 6, 45]</blockquote>
|
||||
Como puede ver, puede mutar el objeto <code>[5, 6, 7]</code> sí mismo y la variable <code>s</code> seguirá apuntando a la matriz alterada <code>[5, 6, 45]</code> . Al igual que todas las matrices, los elementos de la matriz en <code>s</code> son mutables, pero debido a que se utilizó <code>const</code> , no puede usar el identificador de la variable <code>s</code> para apuntar a una matriz diferente mediante el operador de asignación.
|
||||
</section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
Una matriz se declara como <code>const s = [5, 7, 2]</code> . Cambie la matriz a <code>[2, 5, 7]</code> usando varias asignaciones de elementos.
|
||||
<section id='instructions'>
|
||||
Una matriz se declara como <code>const s = [5, 7, 2]</code> . Cambie la matriz a <code>[2, 5, 7]</code> usando varias asignaciones de elementos.
|
||||
</section>
|
||||
|
||||
## Tests
|
||||
@@ -30,7 +30,7 @@ tests:
|
||||
testString: 'getUserInput => assert(getUserInput("index").match(/const\s+s/g), "<code>s</code> should be a constant variable (by using <code>const</code>).");'
|
||||
- text: No cambie la declaración original de la matriz.
|
||||
testString: 'getUserInput => assert(getUserInput("index").match(/const\s+s\s*=\s*\[\s*5\s*,\s*7\s*,\s*2\s*\]\s*;?/g), "Do not change the original array declaration.");'
|
||||
- text: ' <code>s</code> debe ser igual a <code>[2, 5, 7]</code> .'
|
||||
- text: ' <code>s</code> debe ser igual a <code>[2, 5, 7]</code> .'
|
||||
testString: 'assert.deepEqual(s, [2, 5, 7], "<code>s</code> should be equal to <code>[2, 5, 7]</code>.");'
|
||||
|
||||
```
|
||||
|
||||
@@ -6,16 +6,16 @@ challengeType: 1
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
Para ayudarnos a crear funciones más flexibles, ES6 introduce <dfn>parámetros predeterminados</dfn> para las funciones.
|
||||
Echa un vistazo a este código:
|
||||
<blockquote>function greeting(name = "Anonymous") {<br> return "Hello " + name;<br>}<br>console.log(greeting("John")); // Hello John<br>console.log(greeting()); // Hello Anonymous</blockquote>
|
||||
El parámetro predeterminado se activa cuando el argumento no está especificado (no está definido). Como puede ver en el ejemplo anterior, el <code>name</code> del parámetro recibirá su valor predeterminado <code>"Anonymous"</code> cuando no proporcione un valor para el parámetro. Puede agregar valores predeterminados para tantos parámetros como desee.
|
||||
<section id='description'>
|
||||
Para ayudarnos a crear funciones más flexibles, ES6 introduce <dfn>parámetros predeterminados</dfn> para las funciones.
|
||||
Echa un vistazo a este código:
|
||||
<blockquote>function greeting(name = "Anonymous") {<br> return "Hello " + name;<br>}<br>console.log(greeting("John")); // Hello John<br>console.log(greeting()); // Hello Anonymous</blockquote>
|
||||
El parámetro predeterminado se activa cuando el argumento no está especificado (no está definido). Como puede ver en el ejemplo anterior, el <code>name</code> del parámetro recibirá su valor predeterminado <code>"Anonymous"</code> cuando no proporcione un valor para el parámetro. Puede agregar valores predeterminados para tantos parámetros como desee.
|
||||
</section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
Modifique el <code>increment</code> la función agregando parámetros predeterminados para que agregue 1 al <code>number</code> si no se especifica el <code>value</code> .
|
||||
<section id='instructions'>
|
||||
Modifique el <code>increment</code> la función agregando parámetros predeterminados para que agregue 1 al <code>number</code> si no se especifica el <code>value</code> .
|
||||
</section>
|
||||
|
||||
## Tests
|
||||
@@ -23,7 +23,7 @@ Modifique el <code>increment</code> la función agregando parámetros predetermi
|
||||
|
||||
```yml
|
||||
tests:
|
||||
- text: 'El resultado del <code>increment(5, 2)</code> debe ser <code>7</code> '.
|
||||
- text: 'El resultado del <code>increment(5, 2)</code> debe ser <code>7</code> '
|
||||
testString: 'assert(increment(5, 2) === 7, "The result of <code>increment(5, 2)</code> should be <code>7</code>.");'
|
||||
- text: El resultado del <code>increment(5)</code> debe ser <code>6</code> .
|
||||
testString: 'assert(increment(5) === 6, "The result of <code>increment(5)</code> should be <code>6</code>.");'
|
||||
|
||||
@@ -6,19 +6,19 @@ challengeType: 1
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
ES6 hace que la desestructuración de matrices sea tan fácil como desestructurar objetos.
|
||||
Una diferencia clave entre el operador de propagación y la desestructuración de matrices es que el operador de propagación desempaqueta todo el contenido de una matriz en una lista separada por comas. Por consiguiente, no puede seleccionar o elegir qué elementos desea asignar a las variables.
|
||||
destrucción de una matriz nos permite hacer exactamente eso:
|
||||
<blockquote>const [a, b] = [1, 2, 3, 4, 5, 6];<br>console.log(a, b); // 1, 2</blockquote>
|
||||
A la variable <code>a</code> se le asigna el primer valor de la matriz, <code>b</code> se le asigna el segundo valor de la matriz.
|
||||
También podemos acceder al valor en cualquier índice en una matriz con desestructuración usando comas para alcanzar el índice deseado:
|
||||
<blockquote>const [a, b,,, c] = [1, 2, 3, 4, 5, 6];<br>console.log(a, b, c); // 1, 2, 5 </blockquote>
|
||||
<section id='description'>
|
||||
ES6 hace que la desestructuración de matrices sea tan fácil como desestructurar objetos.
|
||||
Una diferencia clave entre el operador de propagación y la desestructuración de matrices es que el operador de propagación desempaqueta todo el contenido de una matriz en una lista separada por comas. Por consiguiente, no puede seleccionar o elegir qué elementos desea asignar a las variables.
|
||||
destrucción de una matriz nos permite hacer exactamente eso:
|
||||
<blockquote>const [a, b] = [1, 2, 3, 4, 5, 6];<br>console.log(a, b); // 1, 2</blockquote>
|
||||
A la variable <code>a</code> se le asigna el primer valor de la matriz, <code>b</code> se le asigna el segundo valor de la matriz.
|
||||
También podemos acceder al valor en cualquier índice en una matriz con desestructuración usando comas para alcanzar el índice deseado:
|
||||
<blockquote>const [a, b,,, c] = [1, 2, 3, 4, 5, 6];<br>console.log(a, b, c); // 1, 2, 5 </blockquote>
|
||||
</section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
Use la asignación de desestructuración para intercambiar los valores de <code>a</code> y <code>b</code> modo que <code>a</code> reciba el valor almacenado en <code>b</code> , y <code>b</code> reciba el valor almacenado en <code>a</code> .
|
||||
<section id='instructions'>
|
||||
Use la asignación de desestructuración para intercambiar los valores de <code>a</code> y <code>b</code> modo que <code>a</code> reciba el valor almacenado en <code>b</code> , y <code>b</code> reciba el valor almacenado en <code>a</code> .
|
||||
</section>
|
||||
|
||||
## Tests
|
||||
@@ -26,9 +26,9 @@ Use la asignación de desestructuración para intercambiar los valores de <code>
|
||||
|
||||
```yml
|
||||
tests:
|
||||
- text: 'El valor de <code>a</code> debe ser 6, después del intercambio.'
|
||||
- text: 'El valor de <code>a</code> debe ser 6, después del intercambio.'
|
||||
testString: 'assert(a === 6, "Value of <code>a</code> should be 6, after swapping.");'
|
||||
- text: 'El valor de <code>b</code> debería ser 8, después del intercambio.'
|
||||
- text: 'El valor de <code>b</code> debería ser 8, después del intercambio.'
|
||||
testString: 'assert(b === 8, "Value of <code>b</code> should be 8, after swapping.");'
|
||||
- text: Utilice la desestructuración de matrices para intercambiar a y b.
|
||||
testString: '// assert(/\[\s*(\w)\s*,\s*(\w)\s*\]\s*=\s*\[\s*\2\s*,\s*\1\s*\]/g.test(code), "Use array destructuring to swap a and b.");'
|
||||
|
||||
@@ -6,17 +6,17 @@ challengeType: 1
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
En algunas situaciones que involucran la desestructuración de matrices, podríamos querer recopilar el resto de los elementos en una matriz separada.
|
||||
El resultado es similar a <code>Array.prototype.slice()</code> , como se muestra a continuación:
|
||||
<blockquote>const [a, b, ...arr] = [1, 2, 3, 4, 5, 7];<br>console.log(a, b); // 1, 2<br>console.log(arr); // [3, 4, 5, 7]</blockquote>
|
||||
Las variables <code>a</code> y <code>b</code> toman los valores primero y segundo de la matriz. Después de eso, debido a la presencia del operador en reposo, <code>arr</code> obtiene el resto de los valores en forma de una matriz.
|
||||
El elemento resto solo funciona correctamente como la última variable en la lista. Como en, no puede usar el operador de descanso para capturar un subarreglo que omita el último elemento de la matriz original.
|
||||
<section id='description'>
|
||||
En algunas situaciones que involucran la desestructuración de matrices, podríamos querer recopilar el resto de los elementos en una matriz separada.
|
||||
El resultado es similar a <code>Array.prototype.slice()</code> , como se muestra a continuación:
|
||||
<blockquote>const [a, b, ...arr] = [1, 2, 3, 4, 5, 7];<br>console.log(a, b); // 1, 2<br>console.log(arr); // [3, 4, 5, 7]</blockquote>
|
||||
Las variables <code>a</code> y <code>b</code> toman los valores primero y segundo de la matriz. Después de eso, debido a la presencia del operador en reposo, <code>arr</code> obtiene el resto de los valores en forma de una matriz.
|
||||
El elemento resto solo funciona correctamente como la última variable en la lista. Como en, no puede usar el operador de descanso para capturar un subarreglo que omita el último elemento de la matriz original.
|
||||
</section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
Use la asignación de desestructuración con el operador de descanso para realizar un <code>Array.prototype.slice()</code> efectivo de manera que <code>arr</code> sea una sub-matriz de la <code>source</code> de la matriz original con los dos primeros elementos omitidos.
|
||||
<section id='instructions'>
|
||||
Use la asignación de desestructuración con el operador de descanso para realizar un <code>Array.prototype.slice()</code> efectivo de manera que <code>arr</code> sea una sub-matriz de la <code>source</code> de la matriz original con los dos primeros elementos omitidos.
|
||||
</section>
|
||||
|
||||
## Tests
|
||||
@@ -24,7 +24,7 @@ Use la asignación de desestructuración con el operador de descanso para realiz
|
||||
|
||||
```yml
|
||||
tests:
|
||||
- text: ' <code>arr</code> debería ser <code>[3,4,5,6,7,8,9,10]</code> '
|
||||
- text: ' <code>arr</code> debería ser <code>[3,4,5,6,7,8,9,10]</code> '
|
||||
testString: 'assert(arr.every((v, i) => v === i + 3) && arr.length === 8,"<code>arr</code> should be <code>[3,4,5,6,7,8,9,10]</code>");'
|
||||
- text: Se debe utilizar la destrucción.
|
||||
testString: 'getUserInput => assert(getUserInput("index").match(/\[\s*\w*\s*,\s*\w*\s*,\s*...\w+\s*\]/g),"Destructuring should be used.");'
|
||||
|
||||
@@ -6,16 +6,16 @@ challengeType: 1
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
Para ayudarnos a crear funciones más flexibles, ES6 presenta al <dfn>operador de resto</dfn> para los parámetros de función. Con el operador resto, puede crear funciones que toman un número variable de argumentos. Estos argumentos se almacenan en una matriz a la que se puede acceder posteriormente desde dentro de la función.
|
||||
Echa un vistazo a este código:
|
||||
<blockquote>function howMany(...args) {<br> return "You have passed " + args.length + " arguments.";<br>}<br>console.log(howMany(0, 1, 2)); // You have passed 3 arguments<br>console.log(howMany("string", null, [1, 2, 3], { })); // You have passed 4 arguments.</blockquote>
|
||||
El operador restante elimina la necesidad de verificar la matriz de <code>args</code> y nos permite aplicar <code>map()</code> , <code>filter()</code> y <code>reduce()</code> en la matriz de parámetros.
|
||||
<section id='description'>
|
||||
Para ayudarnos a crear funciones más flexibles, ES6 presenta al <dfn>operador de resto</dfn> para los parámetros de función. Con el operador resto, puede crear funciones que toman un número variable de argumentos. Estos argumentos se almacenan en una matriz a la que se puede acceder posteriormente desde dentro de la función.
|
||||
Echa un vistazo a este código:
|
||||
<blockquote>function howMany(...args) {<br> return "You have passed " + args.length + " arguments.";<br>}<br>console.log(howMany(0, 1, 2)); // You have passed 3 arguments<br>console.log(howMany("string", null, [1, 2, 3], { })); // You have passed 4 arguments.</blockquote>
|
||||
El operador restante elimina la necesidad de verificar la matriz de <code>args</code> y nos permite aplicar <code>map()</code> , <code>filter()</code> y <code>reduce()</code> en la matriz de parámetros.
|
||||
</section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
Modifique la <code>sum</code> la función para que use el operador de descanso y funcione de la misma manera con cualquier número de parámetros.
|
||||
<section id='instructions'>
|
||||
Modifique la <code>sum</code> la función para que use el operador de descanso y funcione de la misma manera con cualquier número de parámetros.
|
||||
</section>
|
||||
|
||||
## Tests
|
||||
@@ -23,9 +23,9 @@ Modifique la <code>sum</code> la función para que use el operador de descanso y
|
||||
|
||||
```yml
|
||||
tests:
|
||||
- text: 'El resultado de la <code>sum(0,1,2)</code> debe ser 3'
|
||||
- text: 'El resultado de la <code>sum(0,1,2)</code> debe ser 3'
|
||||
testString: 'assert(sum(0,1,2) === 3, "The result of <code>sum(0,1,2)</code> should be 3");'
|
||||
- text: 'El resultado de la <code>sum(1,2,3,4)</code> debe ser 10'
|
||||
- text: 'El resultado de la <code>sum(1,2,3,4)</code> debe ser 10'
|
||||
testString: 'assert(sum(1,2,3,4) === 10, "The result of <code>sum(1,2,3,4)</code> should be 10");'
|
||||
- text: El resultado de la <code>sum(5)</code> debe ser 5.
|
||||
testString: 'assert(sum(5) === 5, "The result of <code>sum(5)</code> should be 5");'
|
||||
|
||||
@@ -6,19 +6,19 @@ challengeType: 1
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
ES6 agrega un buen soporte para definir fácilmente literales de objetos.
|
||||
Considera el siguiente código:
|
||||
<blockquote>const getMousePosition = (x, y) => ({<br> x: x,<br> y: y<br>});</blockquote>
|
||||
<code>getMousePosition</code> es una función simple que devuelve un objeto que contiene dos campos.
|
||||
ES6 proporciona el azúcar sintáctico para eliminar la redundancia de tener que escribir <code>x: x</code> . Simplemente puede escribir <code>x</code> una vez, y se convertirá a <code>x: x</code> (o algo equivalente) debajo del capó.
|
||||
Aquí se reescribe la misma función de la anterior para usar esta nueva sintaxis:
|
||||
<blockquote>const getMousePosition = (x, y) => ({ x, y });</blockquote>
|
||||
<section id='description'>
|
||||
ES6 agrega un buen soporte para definir fácilmente literales de objetos.
|
||||
Considera el siguiente código:
|
||||
<blockquote>const getMousePosition = (x, y) => ({<br> x: x,<br> y: y<br>});</blockquote>
|
||||
<code>getMousePosition</code> es una función simple que devuelve un objeto que contiene dos campos.
|
||||
ES6 proporciona el azúcar sintáctico para eliminar la redundancia de tener que escribir <code>x: x</code> . Simplemente puede escribir <code>x</code> una vez, y se convertirá a <code>x: x</code> (o algo equivalente) debajo del capó.
|
||||
Aquí se reescribe la misma función de la anterior para usar esta nueva sintaxis:
|
||||
<blockquote>const getMousePosition = (x, y) => ({ x, y });</blockquote>
|
||||
</section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
Utilice campos simples con objetos literales para crear y devolver un objeto <code>Person</code> .
|
||||
<section id='instructions'>
|
||||
Utilice campos simples con objetos literales para crear y devolver un objeto <code>Person</code> .
|
||||
</section>
|
||||
|
||||
## Tests
|
||||
@@ -26,9 +26,9 @@ Utilice campos simples con objetos literales para crear y devolver un objeto <co
|
||||
|
||||
```yml
|
||||
tests:
|
||||
- text: 'la salida es <code>{name: "Zodiac Hasbro", age: 56, gender: "male"}</code> .'
|
||||
- text: 'la salida es <code>{name: "Zodiac Hasbro", age: 56, gender: "male"}</code> .'
|
||||
testString: 'assert(() => {const res={name:"Zodiac Hasbro",age:56,gender:"male"}; const person=createPerson("Zodiac Hasbro", 56, "male"); return Object.keys(person).every(k => person[k] === res[k]);}, "the output is <code>{name: "Zodiac Hasbro", age: 56, gender: "male"}</code>.");'
|
||||
- text: 'No <code>:</code> fueron utilizados'.
|
||||
- text: 'No <code>:</code> fueron utilizados'
|
||||
testString: 'getUserInput => assert(!getUserInput("index").match(/:/g), "No <code>:</code> were used.");'
|
||||
|
||||
```
|
||||
|
||||
@@ -6,19 +6,19 @@ challengeType: 1
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
Es hora de que veamos cuán poderosas son las funciones de flecha al procesar datos.
|
||||
funciones de flecha funcionan realmente bien con funciones de orden superior, como <code>map()</code> , <code>filter()</code> y <code>reduce()</code> , que toman otras funciones como argumentos para procesar colecciones de datos.
|
||||
Lee el siguiente código:
|
||||
<blockquote>FBPosts.filter(function(post) {<br> return post.thumbnail !== null && post.shares > 100 && post.likes > 500;<br>})</blockquote>
|
||||
Hemos escrito esto con el <code>filter()</code> para al menos hacerlo un poco legible. Ahora compárelo con el siguiente código que usa la sintaxis de la función de flecha en su lugar:
|
||||
<blockquote>FBPosts.filter((post) => post.thumbnail !== null && post.shares > 100 && post.likes > 500)</blockquote>
|
||||
Este código es más breve y realiza la misma tarea con menos líneas de código.
|
||||
<section id='description'>
|
||||
Es hora de que veamos cuán poderosas son las funciones de flecha al procesar datos.
|
||||
funciones de flecha funcionan realmente bien con funciones de orden superior, como <code>map()</code> , <code>filter()</code> y <code>reduce()</code> , que toman otras funciones como argumentos para procesar colecciones de datos.
|
||||
Lee el siguiente código:
|
||||
<blockquote>FBPosts.filter(function(post) {<br> return post.thumbnail !== null && post.shares > 100 && post.likes > 500;<br>})</blockquote>
|
||||
Hemos escrito esto con el <code>filter()</code> para al menos hacerlo un poco legible. Ahora compárelo con el siguiente código que usa la sintaxis de la función de flecha en su lugar:
|
||||
<blockquote>FBPosts.filter((post) => post.thumbnail !== null && post.shares > 100 && post.likes > 500)</blockquote>
|
||||
Este código es más breve y realiza la misma tarea con menos líneas de código.
|
||||
</section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
Utilice la sintaxis de la función de flecha para calcular el cuadrado de solo los enteros positivos (los números decimales no son enteros) en la matriz <code>realNumberArray</code> y almacenar la nueva matriz en la variable <code>squaredIntegers</code> .
|
||||
<section id='instructions'>
|
||||
Utilice la sintaxis de la función de flecha para calcular el cuadrado de solo los enteros positivos (los números decimales no son enteros) en la matriz <code>realNumberArray</code> y almacenar la nueva matriz en la variable <code>squaredIntegers</code> .
|
||||
</section>
|
||||
|
||||
## Tests
|
||||
@@ -30,13 +30,13 @@ tests:
|
||||
testString: 'getUserInput => assert(getUserInput("index").match(/const\s+squaredIntegers/g), "<code>squaredIntegers</code> should be a constant variable (by using <code>const</code>).");'
|
||||
- text: <code>squaredIntegers</code> debe ser una <code>array</code>
|
||||
testString: 'assert(Array.isArray(squaredIntegers), "<code>squaredIntegers</code> should be an <code>array</code>");'
|
||||
- text: ' <code>squaredIntegers</code> debe ser <code>[16, 1764, 36]</code> '
|
||||
- text: ' <code>squaredIntegers</code> debe ser <code>[16, 1764, 36]</code> '
|
||||
testString: 'assert.deepStrictEqual(squaredIntegers, [16, 1764, 36], "<code>squaredIntegers</code> should be <code>[16, 1764, 36]</code>");'
|
||||
- text: <code>function</code> palabra clave de la <code>function</code> no se utilizó.
|
||||
testString: 'getUserInput => assert(!getUserInput("index").match(/function/g), "<code>function</code> keyword was not used.");'
|
||||
- text: bucle no debe ser utilizado
|
||||
testString: 'getUserInput => assert(!getUserInput("index").match(/(for)|(while)/g), "loop should not be used");'
|
||||
- text: ' <code>map</code> , <code>filter</code> o <code>reduce</code> debe ser utilizado'
|
||||
- text: ' <code>map</code> , <code>filter</code> o <code>reduce</code> debe ser utilizado'
|
||||
testString: 'getUserInput => assert(getUserInput("index").match(/map|filter|reduce/g), "<code>map</code>, <code>filter</code>, or <code>reduce</code> should be used");'
|
||||
|
||||
```
|
||||
|
||||
Reference in New Issue
Block a user