fix: add Api challenges - Spanish
This commit is contained in:
Beau Carnes
committed by
Kristofer Koishigawa
Kristofer Koishigawa
parent
24a9bb98ac
commit
f427fb4b91
@ -0,0 +1,52 @@
|
||||
---
|
||||
id: 5a8b073d06fa14fcfde687aa
|
||||
title: Exercise Tracker
|
||||
localeTitle: Rastreador de ejercicios
|
||||
challengeType: 4
|
||||
isRequired: true
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
Cree una aplicación de JavaScript de pila completa que sea funcionalmente similar a esta: <a href='https://fuschia-custard.glitch.me/' target='_blank'>https://fuschia-custard.glitch.me/</a> .
|
||||
Trabajar en este proyecto implicará que escriba su código en Glitch en nuestro proyecto de inicio. Después de completar este proyecto, puede copiar su URL de error público (en la página de inicio de su aplicación) en esta pantalla para probarlo. Opcionalmente, puede optar por escribir su proyecto en otra plataforma, pero debe ser visible públicamente para nuestras pruebas.
|
||||
Inicie este proyecto en Glitch usando <a href='https://glitch.com/#!/import/github/freeCodeCamp/boilerplate-project-exercisetracker/' target='_blank'>este enlace</a> o clone <a href='https://github.com/freeCodeCamp/boilerplate-project-exercisetracker/'>este repositorio</a> en GitHub! Si utiliza Glitch, recuerde guardar el enlace a su proyecto en un lugar seguro.
|
||||
</section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
|
||||
</section>
|
||||
|
||||
## Tests
|
||||
<section id='tests'>
|
||||
|
||||
```yml
|
||||
tests:
|
||||
- text: Puedo crear un usuario al publicar el nombre de usuario de los datos del formulario en / api / exercise / new-user y se devolverá un objeto con nombre de usuario y <code>_id</code> .
|
||||
testString: ''
|
||||
- text: Puedo obtener una matriz de todos los usuarios al obtener api / ejercicio / usuarios con la misma información que cuando se crea un usuario.
|
||||
testString: ''
|
||||
- text: 'Puedo agregar un ejercicio a cualquier usuario publicando los datos del formulario ID de usuario (_id), descripción, duración y, opcionalmente, fechar en / api / ejercicio / agregar. Si no se proporciona la fecha, se utilizará la fecha actual. La aplicación devolverá el objeto de usuario con los campos de ejercicio agregados. '
|
||||
testString: ''
|
||||
- text: Puedo recuperar un registro de ejercicio completo de cualquier usuario obteniendo / api / exercise / log con un parámetro de userId (_id). La aplicación devolverá el objeto de usuario con el registro de matriz agregada y el conteo (recuento total de ejercicios).
|
||||
testString: ''
|
||||
- text: 'Puedo recuperar parte del registro de cualquier usuario pasando también parámetros opcionales de desde y hasta o límite. (Formato de fecha aaaa-mm-dd, límite = int) '
|
||||
testString: ''
|
||||
|
||||
```
|
||||
|
||||
</section>
|
||||
|
||||
## Challenge Seed
|
||||
<section id='challengeSeed'>
|
||||
|
||||
</section>
|
||||
|
||||
## Solution
|
||||
<section id='solution'>
|
||||
|
||||
```js
|
||||
// solution required
|
||||
```
|
||||
</section>
|
||||
@ -0,0 +1,46 @@
|
||||
---
|
||||
id: bd7158d8c443edefaeb5bd0f
|
||||
title: File Metadata Microservice
|
||||
localeTitle: Archivo de metadatos de microservicio
|
||||
challengeType: 4
|
||||
isRequired: true
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
Cree una aplicación de JavaScript de pila completa que sea funcionalmente similar a esto: <a href='https://purple-paladin.glitch.me/' target='_blank'>https://purple-paladin.glitch.me/</a> .
|
||||
Trabajar en este proyecto implicará que escriba su código en Glitch en nuestro proyecto de inicio. Después de completar este proyecto, puede copiar su URL de error público (en la página de inicio de su aplicación) en esta pantalla para probarlo. Opcionalmente, puede optar por escribir su proyecto en otra plataforma, pero debe ser visible públicamente para nuestras pruebas.
|
||||
Inicie este proyecto en Glitch usando <a href='https://glitch.com/#!/import/github/freeCodeCamp/boilerplate-project-filemetadata/' target='_blank'>este enlace</a> o clone <a href='https://github.com/freeCodeCamp/boilerplate-project-filemetadata/'>este repositorio</a> en GitHub! Si utiliza Glitch, recuerde guardar el enlace a su proyecto en un lugar seguro.
|
||||
</section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
|
||||
</section>
|
||||
|
||||
## Tests
|
||||
<section id='tests'>
|
||||
|
||||
```yml
|
||||
tests:
|
||||
- text: Puedo enviar un objeto FormData que incluya una carga de archivos.
|
||||
testString: ''
|
||||
- text: "Cuando envíe algo, recibiré el tamaño del archivo en bytes dentro de la respuesta JSON."
|
||||
testString: ''
|
||||
|
||||
```
|
||||
|
||||
</section>
|
||||
|
||||
## Challenge Seed
|
||||
<section id='challengeSeed'>
|
||||
|
||||
</section>
|
||||
|
||||
## Solution
|
||||
<section id='solution'>
|
||||
|
||||
```js
|
||||
// solution required
|
||||
```
|
||||
</section>
|
||||
@ -0,0 +1,44 @@
|
||||
---
|
||||
id: bd7158d8c443edefaeb5bdff
|
||||
title: Request Header Parser Microservice
|
||||
localeTitle: Solicitud de encabezado Analizador de microservicio
|
||||
challengeType: 4
|
||||
isRequired: true
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
Cree una aplicación de JavaScript de pila completa que sea funcionalmente similar a esto: <a href='https://dandelion-roar.glitch.me/' target='_blank'>https://dandelion-roar.glitch.me/</a> .
|
||||
Trabajar en este proyecto implicará que escriba su código en Glitch en nuestro proyecto de inicio. Después de completar este proyecto, puede copiar su URL de error público (en la página de inicio de su aplicación) en esta pantalla para probarlo. Opcionalmente, puede optar por escribir su proyecto en otra plataforma, pero debe ser visible públicamente para nuestras pruebas.
|
||||
Inicie este proyecto en Glitch usando <a href='https://glitch.com/#!/import/github/freeCodeCamp/boilerplate-project-headerparser/' target='_blank'>este enlace</a> o clone <a href='https://github.com/freeCodeCamp/boilerplate-project-headerparser/'>este repositorio</a> en GitHub! Si utiliza Glitch, recuerde guardar el enlace a su proyecto en un lugar seguro.
|
||||
</section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
|
||||
</section>
|
||||
|
||||
## Tests
|
||||
<section id='tests'>
|
||||
|
||||
```yml
|
||||
tests:
|
||||
- text: "Puedo obtener la dirección IP, el idioma y el sistema operativo de mi navegador."
|
||||
testString: ''
|
||||
|
||||
```
|
||||
|
||||
</section>
|
||||
|
||||
## Challenge Seed
|
||||
<section id='challengeSeed'>
|
||||
|
||||
</section>
|
||||
|
||||
## Solution
|
||||
<section id='solution'>
|
||||
|
||||
```js
|
||||
// solution required
|
||||
```
|
||||
</section>
|
||||
@ -0,0 +1,54 @@
|
||||
---
|
||||
id: bd7158d8c443edefaeb5bdef
|
||||
title: Timestamp Microservice
|
||||
localeTitle: Marca de tiempo microservicio
|
||||
challengeType: 4
|
||||
isRequired: true
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
Cree una aplicación de JavaScript de pila completa que sea funcionalmente similar a esto: <a href='https://curse-arrow.glitch.me/' target='_blank'>https://curse-arrow.glitch.me/</a> .
|
||||
Trabajar en este proyecto implicará que escriba su código en Glitch en nuestro proyecto de inicio. Después de completar este proyecto, puede copiar su URL de error público (en la página de inicio de su aplicación) en esta pantalla para probarlo. Opcionalmente, puede optar por escribir su proyecto en otra plataforma, pero debe ser visible públicamente para nuestras pruebas.
|
||||
Inicie este proyecto en Glitch usando <a href='https://glitch.com/#!/import/github/freeCodeCamp/boilerplate-project-timestamp/' target='_blank'>este enlace</a> o clone <a href='https://github.com/freeCodeCamp/boilerplate-project-timestamp/'>este repositorio</a> en GitHub! Si utiliza Glitch, recuerde guardar el enlace a su proyecto en un lugar seguro.
|
||||
</section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
|
||||
</section>
|
||||
|
||||
## Tests
|
||||
<section id='tests'>
|
||||
|
||||
```yml
|
||||
tests:
|
||||
- text: 'Debe manejar una fecha válida y devolver la marca de tiempo de Unix correcta'
|
||||
testString: 'getUserInput => $.get(getUserInput(''url'') + ''/api/timestamp/2016-12-25'').then(data => { assert.equal(data.unix, 1482624000000, ''Should be a valid unix timestamp''); }, xhr => { throw new Error(xhr.responseText); })'
|
||||
- text: 'Debe manejar una fecha válida y devolver la cadena UTC correcta'
|
||||
testString: 'getUserInput => $.get(getUserInput(''url'')+ ''/api/timestamp/2016-12-25'').then(data => { assert.equal(data.utc, ''Sun, 25 Dec 2016 00:00:00 GMT'', ''Should be a valid UTC date string''); }, xhr => { throw new Error(xhr.responseText); })'
|
||||
- text: 'Debe manejar una fecha de Unix válida y devolver la marca de tiempo de Unix correcta'
|
||||
testString: 'getUserInput => $.get(getUserInput(''url'') + ''/api/timestamp/1482624000000'').then(data => { assert.equal(data.unix, 1482624000000) ; }, xhr => { throw new Error(xhr.responseText); })'
|
||||
- text: Debe devolver el mensaje de error esperado para una fecha no válida
|
||||
testString: 'getUserInput => $.get(getUserInput(''url'') + ''/api/timestamp/this-is-not-a-date'').then(data => { assert.equal(data.error.toLowerCase(), ''invalid date'');}, xhr => { throw new Error(xhr.responseText); })'
|
||||
- text: 'Debería manejar un parámetro de fecha vacío y devolver la hora actual en formato unix'
|
||||
testString: 'getUserInput => $.get(getUserInput(''url'') + ''/api/timestamp'').then(data => { var now = Date.now(); assert.approximately(data.unix, now, 20000) ;}, xhr => { throw new Error(xhr.responseText); })'
|
||||
- text: 'Debe manejar un parámetro de fecha vacío y devolver la hora actual en formato UTC'
|
||||
testString: 'getUserInput => $.get(getUserInput(''url'') + ''/api/timestamp'').then(data => { var now = Date.now(); var serverTime = (new Date(data.utc)).getTime(); assert.approximately(serverTime, now, 20000) ;}, xhr => { throw new Error(xhr.responseText); })'
|
||||
|
||||
```
|
||||
|
||||
</section>
|
||||
|
||||
## Challenge Seed
|
||||
<section id='challengeSeed'>
|
||||
|
||||
</section>
|
||||
|
||||
## Solution
|
||||
<section id='solution'>
|
||||
|
||||
```js
|
||||
// solution required
|
||||
```
|
||||
</section>
|
||||
@ -0,0 +1,48 @@
|
||||
---
|
||||
id: bd7158d8c443edefaeb5bd0e
|
||||
title: URL Shortener Microservice
|
||||
localeTitle: Microservicio de acortador de URL
|
||||
challengeType: 4
|
||||
isRequired: true
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
Cree una aplicación de JavaScript de pila completa que sea funcionalmente similar a esto: <a href='https://thread-paper.glitch.me/' target='_blank'>https://thread-paper.glitch.me/</a> .
|
||||
Trabajar en este proyecto implicará que escriba su código en Glitch en nuestro proyecto de inicio. Después de completar este proyecto, puede copiar su URL de error público (en la página de inicio de su aplicación) en esta pantalla para probarlo. Opcionalmente, puede optar por escribir su proyecto en otra plataforma, pero debe ser visible públicamente para nuestras pruebas.
|
||||
Inicie este proyecto en Glitch usando <a href='https://glitch.com/#!/import/github/freeCodeCamp/boilerplate-project-urlshortener/' target='_blank'>este enlace</a> o clone <a href='https://github.com/freeCodeCamp/boilerplate-project-urlshortener/'>este repositorio</a> en GitHub! Si utiliza Glitch, recuerde guardar el enlace a su proyecto en un lugar seguro.
|
||||
</section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
|
||||
</section>
|
||||
|
||||
## Tests
|
||||
<section id='tests'>
|
||||
|
||||
```yml
|
||||
tests:
|
||||
- text: Puedo pasar una URL como parámetro y recibiré una URL abreviada en la respuesta JSON.
|
||||
testString: ''
|
||||
- text: "Si paso una URL no válida que no sigue el formato válido de http://www.example.com, la respuesta JSON contendrá un error."
|
||||
testString: ''
|
||||
- text: "Cuando visite esa URL abreviada, me redirigirá a mi enlace original."
|
||||
testString: ''
|
||||
|
||||
```
|
||||
|
||||
</section>
|
||||
|
||||
## Challenge Seed
|
||||
<section id='challengeSeed'>
|
||||
|
||||
</section>
|
||||
|
||||
## Solution
|
||||
<section id='solution'>
|
||||
|
||||
```js
|
||||
// solution required
|
||||
```
|
||||
</section>
|
||||
@ -0,0 +1,48 @@
|
||||
---
|
||||
id: 587d7fb1367417b2b2512bf4
|
||||
title: Chain Middleware to Create a Time Server
|
||||
localeTitle: Cadena de middleware para crear un servidor de tiempo
|
||||
challengeType: 2
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
Middleware puede montarse en una ruta específica usando <code>app.METHOD(path, middlewareFunction)</code> . Middleware también puede ser encadenado dentro de la definición de ruta.
|
||||
Mira el siguiente ejemplo:
|
||||
<blockquote>app.get('/user', function(req, res, next) {<br> req.user = getTheUserSync(); // Hypothetical synchronous operation<br> next();<br>}, function(req, res) {<br> res.send(req.user);<br>})</blockquote>
|
||||
Este enfoque es útil para dividir las operaciones del servidor en unidades más pequeñas. Esto conduce a una mejor estructura de la aplicación y la posibilidad de reutilizar el código en diferentes lugares. Este enfoque también se puede utilizar para realizar una validación de los datos. En cada punto de la pila de middleware puede bloquear la ejecución de la cadena actual y pasar el control a funciones específicamente diseñadas para manejar errores. O puede pasar el control a la siguiente ruta coincidente, para manejar casos especiales. Veremos cómo en la sección avanzada de Express.
|
||||
En la ruta <code>app.get('/now', ...)</code> una función de middleware y el controlador final. En la función de middleware, debe agregar la hora actual al objeto de solicitud en la clave <code>req.time</code> . Puede usar la <code>new Date().toString()</code> . En el controlador, responda con un objeto JSON, tomando la estructura <code>{time: req.time}</code> .
|
||||
Sugerencia: la prueba no pasará si no encadena el middleware. Si monta la función en otro lugar, la prueba fallará, incluso si el resultado de salida es correcto.
|
||||
</section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
|
||||
</section>
|
||||
|
||||
## Tests
|
||||
<section id='tests'>
|
||||
|
||||
```yml
|
||||
tests:
|
||||
- text: El punto final / ahora debería tener middleware montado
|
||||
testString: 'getUserInput => $.get(getUserInput(''url'') + ''/_api/chain-middleware-time'').then(data => { assert.equal(data.stackLength, 2, ''"/now" route has no mounted middleware''); }, xhr => { throw new Error(xhr.responseText); })'
|
||||
- text: El punto final / now debería devolver un tiempo que es de +/- 20 segundos a partir de ahora
|
||||
testString: 'getUserInput => $.get(getUserInput(''url'') + ''/_api/chain-middleware-time'').then(data => { var now = new Date(); assert.isAtMost(Math.abs(new Date(data.time) - now), 20000, ''the returned time is not between +- 20 secs from now''); }, xhr => { throw new Error(xhr.responseText); })'
|
||||
|
||||
```
|
||||
|
||||
</section>
|
||||
|
||||
## Challenge Seed
|
||||
<section id='challengeSeed'>
|
||||
|
||||
</section>
|
||||
|
||||
## Solution
|
||||
<section id='solution'>
|
||||
|
||||
```js
|
||||
// solution required
|
||||
```
|
||||
</section>
|
||||
@ -0,0 +1,51 @@
|
||||
---
|
||||
id: 587d7fb2367417b2b2512bf8
|
||||
title: Get Data from POST Requests
|
||||
localeTitle: Obtener datos de solicitudes POST
|
||||
challengeType: 2
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
Monte un controlador POST en la ruta <code>/name</code> . Es el mismo camino que antes. Hemos preparado un formulario en la portada html. Se enviarán los mismos datos del ejercicio 10 (cadena de consulta). Si el analizador de cuerpo está configurado correctamente, debería encontrar los parámetros en el objeto <code>req.body</code> . Eche un vistazo al ejemplo habitual de la biblioteca:
|
||||
<blockquote>route: POST '/library'<br>urlencoded_body: userId=546&bookId=6754 <br>req.body: {userId: '546', bookId: '6754'}</blockquote>
|
||||
Responda con el mismo objeto JSON que antes: <code>{name: 'firstname lastname'}</code> . Pruebe si su punto final funciona con el formulario html que proporcionamos en la página principal de la aplicación.
|
||||
Sugerencia: hay varios otros métodos http distintos de GET y POST. Y, por convención, hay una correspondencia entre el verbo http y la operación que se va a ejecutar en el servidor. La asignación convencional es:
|
||||
POST (a veces PUT): cree un nuevo recurso utilizando la información enviada con la solicitud,
|
||||
GET: lea un recurso existente sin modificarlo,
|
||||
PUT o PATCH (a veces POST): actualice un recurso utilizando los datos enviado,
|
||||
BORRAR => Eliminar un recurso.
|
||||
También hay un par de otros métodos que se utilizan para negociar una conexión con el servidor. Excepto en GET, todos los otros métodos mencionados anteriormente pueden tener una carga útil (es decir, los datos en el cuerpo de la solicitud). El middleware body-parser también funciona con estos métodos.
|
||||
</section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
|
||||
</section>
|
||||
|
||||
## Tests
|
||||
<section id='tests'>
|
||||
|
||||
```yml
|
||||
tests:
|
||||
- text: 'Prueba 1: su punto final de API debe responder con el nombre correcto'
|
||||
testString: 'getUserInput => $.post(getUserInput(''url'') + ''/name'', {first: ''Mick'', last: ''Jagger''}).then(data => { assert.equal(data.name, ''Mick Jagger'', ''Test 1: "POST /name" route does not behave as expected'') }, xhr => { throw new Error(xhr.responseText); })'
|
||||
- text: 'Prueba 2: su punto final de API debe responder con el nombre correcto'
|
||||
testString: 'getUserInput => $.post(getUserInput(''url'') + ''/name'', {first: ''Keith'', last: ''Richards''}).then(data => { assert.equal(data.name, ''Keith Richards'', ''Test 2: "POST /name" route does not behave as expected'') }, xhr => { throw new Error(xhr.responseText); })'
|
||||
|
||||
```
|
||||
|
||||
</section>
|
||||
|
||||
## Challenge Seed
|
||||
<section id='challengeSeed'>
|
||||
|
||||
</section>
|
||||
|
||||
## Solution
|
||||
<section id='solution'>
|
||||
|
||||
```js
|
||||
// solution required
|
||||
```
|
||||
</section>
|
||||
@ -0,0 +1,46 @@
|
||||
---
|
||||
id: 587d7fb2367417b2b2512bf6
|
||||
title: Get Query Parameter Input from the Client
|
||||
localeTitle: Obtener entrada de parámetros de consulta del cliente
|
||||
challengeType: 2
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
Otra forma común de obtener información del cliente es codificando los datos después de la ruta, utilizando una cadena de consulta. La cadena de consulta está delimitada por un signo de interrogación (?) E incluye parejas field = value. Cada pareja está separada por un signo (&). Express puede analizar los datos de la cadena de consulta y rellenar el objeto <code>req.query</code> . Algunos caracteres no pueden estar en las URL, tienen que estar codificados en un <a href='https://en.wikipedia.org/wiki/Percent-encoding' target='_blank'>formato diferente</a> antes de poder enviarlos. Si usa la API desde JavaScript, puede usar métodos específicos para codificar / decodificar estos caracteres.
|
||||
<blockquote>route_path: '/library'<br>actual_request_URL: '/library?userId=546&bookId=6754' <br>req.query: {userId: '546', bookId: '6754'}</blockquote>
|
||||
Construir un punto final de API, montado en <code>GET /name</code> . Responda con un documento JSON, tomando la estructura <code>{ name: 'firstname lastname'}</code> . Los parámetros de nombre y apellido deben estar codificados en una cadena de consulta, por ejemplo, <code>?first=firstname&last=lastname</code> .
|
||||
CONSEJO: En el siguiente ejercicio vamos a recibir datos de una solicitud POST, en la misma ruta de ruta <code>/name</code> . Si lo desea, puede utilizar el método <code>app.route(path).get(handler).post(handler)</code> . Esta sintaxis le permite encadenar diferentes controladores de verbos en la misma ruta de ruta. Puede guardar un poco de escritura y tener un código más limpio.
|
||||
</section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
|
||||
</section>
|
||||
|
||||
## Tests
|
||||
<section id='tests'>
|
||||
|
||||
```yml
|
||||
tests:
|
||||
- text: 'Prueba 1: su punto final de API debe responder con el nombre correcto'
|
||||
testString: 'getUserInput => $.get(getUserInput(''url'') + ''/name?first=Mick&last=Jagger'').then(data => { assert.equal(data.name, ''Mick Jagger'', ''Test 1: "GET /name" route does not behave as expected'') }, xhr => { throw new Error(xhr.responseText); })'
|
||||
- text: 'Prueba 2: su punto final APi debe responder con el nombre correcto'
|
||||
testString: 'getUserInput => $.get(getUserInput(''url'') + ''/name?last=Richards&first=Keith'').then(data => { assert.equal(data.name, ''Keith Richards'', ''Test 2: "GET /name" route does not behave as expected'') }, xhr => { throw new Error(xhr.responseText); })'
|
||||
|
||||
```
|
||||
|
||||
</section>
|
||||
|
||||
## Challenge Seed
|
||||
<section id='challengeSeed'>
|
||||
|
||||
</section>
|
||||
|
||||
## Solution
|
||||
<section id='solution'>
|
||||
|
||||
```js
|
||||
// solution required
|
||||
```
|
||||
</section>
|
||||
@ -0,0 +1,45 @@
|
||||
---
|
||||
id: 587d7fb2367417b2b2512bf5
|
||||
title: Get Route Parameter Input from the Client
|
||||
localeTitle: Obtener entrada de parámetros de ruta del cliente
|
||||
challengeType: 2
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
Al crear una API, debemos permitir que los usuarios nos comuniquen lo que desean obtener de nuestro servicio. Por ejemplo, si el cliente solicita información sobre un usuario almacenado en la base de datos, necesita una manera de informarnos en qué usuario está interesado. Una posible forma de lograr este resultado es mediante el uso de parámetros de ruta. Los parámetros de ruta se denominan segmentos de la URL, delimitados por barras inclinadas (/). Cada segmento captura el valor de la parte de la URL que coincide con su posición. Los valores capturados se pueden encontrar en el objeto <code>req.params</code> .
|
||||
<blockquote>route_path: '/user/:userId/book/:bookId'<br>actual_request_URL: '/user/546/book/6754' <br>req.params: {userId: '546', bookId: '6754'}</blockquote>
|
||||
Construya un servidor de eco, montado en la ruta <code>GET /:word/echo</code> . Responda con un objeto JSON, tomando la estructura <code>{echo: word}</code> . Puede encontrar la palabra que debe repetirse en <code>req.params.word</code> . Puede probar su ruta desde la barra de direcciones de su navegador, visitando algunas rutas coincidentes, por ejemplo, su-app-rootpath / freecodecamp / echo
|
||||
</section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
|
||||
</section>
|
||||
|
||||
## Tests
|
||||
<section id='tests'>
|
||||
|
||||
```yml
|
||||
tests:
|
||||
- text: 'Prueba 1: su servidor de eco debe repetir palabras correctamente'
|
||||
testString: 'getUserInput => $.get(getUserInput(''url'') + ''/eChOtEsT/echo'').then(data => { assert.equal(data.echo, ''eChOtEsT'', ''Test 1: the echo server is not working as expected'') }, xhr => { throw new Error(xhr.responseText); })'
|
||||
- text: 'Prueba 2: su servidor de eco debe repetir palabras correctamente'
|
||||
testString: 'getUserInput => $.get(getUserInput(''url'') + ''/ech0-t3st/echo'').then(data => { assert.equal(data.echo, ''ech0-t3st'', ''Test 2: the echo server is not working as expected'') }, xhr => { throw new Error(xhr.responseText); })'
|
||||
|
||||
```
|
||||
|
||||
</section>
|
||||
|
||||
## Challenge Seed
|
||||
<section id='challengeSeed'>
|
||||
|
||||
</section>
|
||||
|
||||
## Solution
|
||||
<section id='solution'>
|
||||
|
||||
```js
|
||||
// solution required
|
||||
```
|
||||
</section>
|
||||
@ -0,0 +1,47 @@
|
||||
---
|
||||
id: 587d7fb1367417b2b2512bf3
|
||||
title: Implement a Root-Level Request Logger Middleware
|
||||
localeTitle: Implementar un middleware de registrador de solicitudes de nivel raíz
|
||||
challengeType: 2
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
Antes presentamos la función de middleware <code>express.static()</code> . Ahora es el momento de ver qué es el middleware, con más detalle. Las funciones de middleware son funciones que toman 3 argumentos: el objeto de solicitud, el objeto de respuesta y la siguiente función en el ciclo de solicitud-respuesta de la aplicación. Estas funciones ejecutan algunos códigos que pueden tener efectos secundarios en la aplicación y, por lo general, agregan información a los objetos de solicitud o respuesta. También pueden finalizar el ciclo enviando la respuesta, cuando se cumple alguna condición. Si no envían la respuesta, cuando terminan, comienzan la ejecución de la siguiente función en la pila. Esto se activa llamando al tercer argumento <code>next()</code> . Más información en la <a href='http://expressjs.com/en/guide/using-middleware.html' target='_blank'>documentación expresa</a> .
|
||||
Mira el siguiente ejemplo:
|
||||
<blockquote>function(req, res, next) {<br> console.log("I'm a middleware...");<br> next();<br>}</blockquote>
|
||||
Supongamos que montamos esta función en una ruta. Cuando una solicitud coincide con la ruta, muestra la cadena "Soy un middleware ...". Luego ejecuta la siguiente función en la pila.
|
||||
En este ejercicio vamos a construir un middleware de nivel raíz. Como hemos visto en el desafío 4, para montar una función de middleware en el nivel raíz podemos usar el método <code>app.use(<mware-function>)</code> . En este caso, la función se ejecutará para todas las solicitudes, pero también puede establecer condiciones más específicas. Por ejemplo, si desea que una función se ejecute solo para solicitudes POST, puede usar <code>app.post(<mware-function>)</code> . Existen métodos análogos para todos los verbos http (GET, DELETE, PUT,…).
|
||||
Construir un registrador simple. Para cada solicitud, debe iniciar sesión en la consola con una cadena que tenga el siguiente formato: <code>method path - ip</code> . Un ejemplo sería: <code>GET /json - ::ffff:127.0.0.1</code> . Tenga en cuenta que hay un espacio entre el <code>method</code> y la <code>path</code> y que la raya que separa la <code>path</code> y la <code>ip</code> está rodeada por un espacio en cada lado. Puede obtener el método de solicitud (verbo http), la ruta de ruta relativa y la dirección IP de la persona que llama desde el objeto de solicitud, utilizando <code>req.method</code> , <code>req.path</code> y <code>req.ip</code> Recuerde llamar a <code>next()</code> cuando haya terminado, o su servidor quedará atascado para siempre. Asegúrese de tener abiertos los 'Registros' y vea qué sucede cuando llega alguna solicitud ...
|
||||
Sugerencia: Express evalúa las funciones en el orden en que aparecen en el código. Esto también es cierto para el middleware. Si desea que funcione para todas las rutas, debe montarse antes que ellas.
|
||||
</section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
|
||||
</section>
|
||||
|
||||
## Tests
|
||||
<section id='tests'>
|
||||
|
||||
```yml
|
||||
tests:
|
||||
- text: El middleware del registrador de nivel raíz debe estar activo
|
||||
testString: 'getUserInput => $.get(getUserInput(''url'') + ''/_api/root-middleware-logger'').then(data => { assert.isTrue(data.passed, ''root-level logger is not working as expected''); }, xhr => { throw new Error(xhr.responseText); })'
|
||||
|
||||
```
|
||||
|
||||
</section>
|
||||
|
||||
## Challenge Seed
|
||||
<section id='challengeSeed'>
|
||||
|
||||
</section>
|
||||
|
||||
## Solution
|
||||
<section id='solution'>
|
||||
|
||||
```js
|
||||
// solution required
|
||||
```
|
||||
</section>
|
||||
@ -0,0 +1,42 @@
|
||||
---
|
||||
id: 587d7fb0367417b2b2512bed
|
||||
title: Meet the Node console
|
||||
localeTitle: Conozca la consola Node
|
||||
challengeType: 2
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
Durante el proceso de desarrollo, es importante poder verificar lo que está pasando en su código. Nodo es solo un entorno de JavaScript. Al igual que JavaScript del lado del cliente, puede usar la consola para mostrar información útil de depuración. En su máquina local, vería la salida de la consola en un terminal. En Glitch puede abrir los registros en la parte inferior de la pantalla. Puede alternar el panel de registro con el botón 'Registros' (arriba a la izquierda, debajo del nombre de la aplicación).
|
||||
Para comenzar, simplemente imprima el clásico "Hello World" en la consola. Recomendamos mantener abierto el panel de registro mientras se trabaja en estos desafíos. Al leer los registros, puede estar al tanto de la naturaleza de los errores que pueden ocurrir.
|
||||
</section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
Modifique el archivo <code>myApp.js</code> para registrar "Hello World" en la consola.
|
||||
</section>
|
||||
|
||||
## Tests
|
||||
<section id='tests'>
|
||||
|
||||
```yml
|
||||
tests:
|
||||
- text: <code>"Hello World"</code> debería estar en la consola
|
||||
testString: 'getUserInput => $.get(getUserInput(''url'') + ''/_api/hello-console'').then(data => { assert.isTrue(data.passed, ''"Hello World" is not in the server console''); }, xhr => { throw new Error(xhr.responseText); })'
|
||||
|
||||
```
|
||||
|
||||
</section>
|
||||
|
||||
## Challenge Seed
|
||||
<section id='challengeSeed'>
|
||||
|
||||
</section>
|
||||
|
||||
## Solution
|
||||
<section id='solution'>
|
||||
|
||||
```js
|
||||
// solution required
|
||||
```
|
||||
</section>
|
||||
@ -0,0 +1,45 @@
|
||||
---
|
||||
id: 587d7fb0367417b2b2512bef
|
||||
title: Serve an HTML File
|
||||
localeTitle: Servir un archivo HTML
|
||||
challengeType: 2
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
Podemos responder con un archivo utilizando el método <code>res.sendFile(path)</code> .
|
||||
Puede colocarlo dentro del manejador de ruta <code>app.get('/', ...)</code> . Detrás de escena, este método establecerá los encabezados adecuados para instruir a su navegador sobre cómo manejar el archivo que desea enviar, según su tipo. Luego leerá y enviará el archivo. Este método necesita una ruta de archivo absoluta. Le recomendamos que utilice la variable global Node <code>__dirname</code> para calcular la ruta.
|
||||
por ejemplo <code>absolutePath = __dirname + relativePath/file.ext</code> .
|
||||
El archivo a enviar es <code>/views/index.html</code> . Intente 'Mostrar en vivo' su aplicación, debería ver un encabezado HTML grande (y un formulario que usaremos más adelante ...), sin estilo aplicado.
|
||||
Nota: puede editar la solución del desafío anterior o crear una nueva. Si crea una nueva solución, tenga en cuenta que Express evalúa las rutas de arriba a abajo. Ejecuta el controlador para la primera partida. Debe comentar la solución anterior, o el servidor seguirá respondiendo con una cadena.
|
||||
</section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
|
||||
</section>
|
||||
|
||||
## Tests
|
||||
<section id='tests'>
|
||||
|
||||
```yml
|
||||
tests:
|
||||
- text: Su aplicación debe servir el archivo views / index.html
|
||||
testString: 'getUserInput => $.get(getUserInput(''url'')).then(data => { assert.match(data, /<h1>.*<\/h1>/, ''Your app does not serve the expected HTML''); }, xhr => { throw new Error(xhr.responseText); })'
|
||||
|
||||
```
|
||||
|
||||
</section>
|
||||
|
||||
## Challenge Seed
|
||||
<section id='challengeSeed'>
|
||||
|
||||
</section>
|
||||
|
||||
## Solution
|
||||
<section id='solution'>
|
||||
|
||||
```js
|
||||
// solution required
|
||||
```
|
||||
</section>
|
||||
@ -0,0 +1,43 @@
|
||||
---
|
||||
id: 587d7fb1367417b2b2512bf1
|
||||
title: Serve JSON on a Specific Route
|
||||
localeTitle: Servir JSON en una ruta específica
|
||||
challengeType: 2
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
Mientras que un servidor HTML sirve (¡lo has adivinado!) HTML, una API sirve datos. Una API <dfn>REST</dfn> (transferencia de estado representativa) permite el intercambio de datos de una manera sencilla, sin la necesidad de que los clientes conozcan ningún detalle sobre el servidor. El cliente solo necesita saber dónde está el recurso (la URL) y la acción que desea realizar en él (el verbo). El verbo GET se usa cuando estás obteniendo información, sin modificar nada. En estos días, el formato de datos preferido para mover información a través de la web es JSON. En pocas palabras, JSON es una forma conveniente de representar un objeto JavaScript como una cadena, por lo que se puede transmitir fácilmente.
|
||||
Vamos a crear una API simple creando una ruta que responda con JSON en la ruta <code>/json</code> . Puedes hacerlo como de costumbre, con el método <code>app.get()</code> . Dentro del controlador de ruta use el método <code>res.json()</code> , pasando un objeto como argumento. Este método cierra el bucle de solicitud-respuesta, devolviendo los datos. Detrás de escena, convierte un objeto JavaScript válido en una cadena, luego establece los encabezados adecuados para indicar a su navegador que está sirviendo JSON y le devuelve los datos. Un objeto válido tiene la estructura habitual <code>{key: data}</code> . Los datos pueden ser un número, una cadena, un objeto anidado o una matriz. Los datos también pueden ser una variable o el resultado de una llamada de función; en cuyo caso se evaluará antes de convertirse en una cadena.
|
||||
Servir el objeto <code>{"message": "Hello json"}</code> como respuesta en formato JSON, a las solicitudes GET a la ruta <code>/json</code> . Luego apunte su navegador a your-app-url / json, debería ver el mensaje en la pantalla.
|
||||
</section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
|
||||
</section>
|
||||
|
||||
## Tests
|
||||
<section id='tests'>
|
||||
|
||||
```yml
|
||||
tests:
|
||||
- text: 'El punto final <code>/json</code> debe servir el objeto json <code>{"message": "Hello json"}</code> '
|
||||
testString: 'getUserInput => $.get(getUserInput(''url'') + ''/json'').then(data => { assert.equal(data.message, ''Hello json'', ''The \''/json\'' endpoint does not serve the right data''); }, xhr => { throw new Error(xhr.responseText); })'
|
||||
|
||||
```
|
||||
|
||||
</section>
|
||||
|
||||
## Challenge Seed
|
||||
<section id='challengeSeed'>
|
||||
|
||||
</section>
|
||||
|
||||
## Solution
|
||||
<section id='solution'>
|
||||
|
||||
```js
|
||||
// solution required
|
||||
```
|
||||
</section>
|
||||
@ -0,0 +1,43 @@
|
||||
---
|
||||
id: 587d7fb0367417b2b2512bf0
|
||||
title: Serve Static Assets
|
||||
localeTitle: Servir activos estáticos
|
||||
challengeType: 2
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
Un servidor HTML generalmente tiene uno o más directorios que son accesibles por el usuario. Puede colocar allí los recursos estáticos que necesita su aplicación (hojas de estilo, scripts, imágenes). En Express puede implementar esta funcionalidad utilizando el middleware <code>express.static(path)</code> , donde el parámetro es la ruta absoluta de la carpeta que contiene los recursos. Si no sabes qué es un middleware, no te preocupes. Lo discutiremos más adelante en detalles. Básicamente, los middlewares son funciones que interceptan los manejadores de ruta, agregando algún tipo de información. Es necesario montar un middleware utilizando el método <code>app.use(path, middlewareFunction)</code> . El primer argumento de ruta es opcional. Si no lo pasa, el middleware se ejecutará para todas las solicitudes.
|
||||
Monte el middleware <code>express.static()</code> para todas las solicitudes con <code>app.use()</code> . La ruta absoluta a la carpeta de activos es <code>__dirname + /public</code> .
|
||||
Ahora su aplicación debería poder servir una hoja de estilo CSS. Desde fuera la carpeta pública aparecerá montada en el directorio raíz. Tu portada debería verse un poco mejor ahora!
|
||||
</section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
|
||||
</section>
|
||||
|
||||
## Tests
|
||||
<section id='tests'>
|
||||
|
||||
```yml
|
||||
tests:
|
||||
- text: Su aplicación debe servir archivos de activos del directorio <code>/public</code>
|
||||
testString: 'getUserInput => $.get(getUserInput(''url'') + ''/style.css'').then(data => { assert.match(data, /body\s*\{[^\}]*\}/, ''Your app does not serve static assets''); }, xhr => { throw new Error(xhr.responseText); })'
|
||||
|
||||
```
|
||||
|
||||
</section>
|
||||
|
||||
## Challenge Seed
|
||||
<section id='challengeSeed'>
|
||||
|
||||
</section>
|
||||
|
||||
## Solution
|
||||
<section id='solution'>
|
||||
|
||||
```js
|
||||
// solution required
|
||||
```
|
||||
</section>
|
||||
@ -0,0 +1,46 @@
|
||||
---
|
||||
id: 587d7fb0367417b2b2512bee
|
||||
title: Start a Working Express Server
|
||||
localeTitle: Iniciar un servidor Express de trabajo
|
||||
challengeType: 2
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
En las dos primeras líneas del archivo myApp.js puede ver cómo es fácil crear un objeto de aplicación Express. Este objeto tiene varios métodos, y aprenderemos muchos de ellos en estos desafíos. Un método fundamental es <code>app.listen(port)</code> . Le dice a su servidor que escuche en un puerto dado, poniéndolo en estado de ejecución. Puedes verlo en la parte inferior del archivo. Se encuentra dentro de los comentarios porque, por razones de prueba, necesitamos que la aplicación se ejecute en segundo plano. Todo el código que desee agregar va entre estas dos partes fundamentales. Glitch almacena el número de puerto en la variable de entorno <code>process.env.PORT</code> . Su valor es de <code>3000</code> .
|
||||
¡Vamos a servir nuestra primera cuerda! En Express, las rutas tienen la siguiente estructura: <code>app.METHOD(PATH, HANDLER)</code> . METHOD es un método http en minúsculas. PATH es una ruta relativa en el servidor (puede ser una cadena, o incluso una expresión regular). HANDLER es una función que llama expresamente cuando la ruta coincide.
|
||||
manejadores toman la <code>function(req, res) {...}</code> formulario <code>function(req, res) {...}</code> , donde req es el objeto de solicitud, y res es el objeto de respuesta. Por ejemplo, el controlador
|
||||
<blockquote>function(req, res) {<br> res.send('Response String');<br>}</blockquote>
|
||||
servirá la cadena 'Cadena de respuesta'.
|
||||
Use el método <code>app.get()</code> para servir la cadena Hello Express, para obtener solicitudes que coincidan con la ruta / root. Asegúrese de que su código funcione mirando los registros, luego vea los resultados en su navegador y haga clic en el botón 'Mostrar en vivo' en la interfaz de usuario de Glitch.
|
||||
</section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
|
||||
</section>
|
||||
|
||||
## Tests
|
||||
<section id='tests'>
|
||||
|
||||
```yml
|
||||
tests:
|
||||
- text: Su aplicación debe servir la cadena 'Hola Express'
|
||||
testString: 'getUserInput => $.get(getUserInput(''url'')).then(data => { assert.equal(data, ''Hello Express'', ''Your app does not serve the text "Hello Express"''); }, xhr => { throw new Error(xhr.responseText); })'
|
||||
|
||||
```
|
||||
|
||||
</section>
|
||||
|
||||
## Challenge Seed
|
||||
<section id='challengeSeed'>
|
||||
|
||||
</section>
|
||||
|
||||
## Solution
|
||||
<section id='solution'>
|
||||
|
||||
```js
|
||||
// solution required
|
||||
```
|
||||
</section>
|
||||
@ -0,0 +1,48 @@
|
||||
---
|
||||
id: 587d7fb2367417b2b2512bf7
|
||||
title: Use body-parser to Parse POST Requests
|
||||
localeTitle: Usar el analizador de cuerpo para analizar las solicitudes POST
|
||||
challengeType: 2
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
Además de GET hay otro verbo http común, es POST. POST es el método predeterminado utilizado para enviar datos de clientes con formularios HTML. En la convención REST, POST se utiliza para enviar datos para crear nuevos elementos en la base de datos (un nuevo usuario o una nueva publicación de blog). No tenemos una base de datos en este proyecto, pero de todos modos vamos a aprender cómo manejar las solicitudes POST.
|
||||
En este tipo de solicitudes, los datos no aparecen en la URL, están ocultos en el cuerpo de la solicitud. Esta es una parte de la solicitud HTML, también llamada carga útil. Dado que HTML está basado en texto, incluso si no ve los datos, no significa que sean secretos. El contenido sin procesar de una solicitud HTTP POST se muestra a continuación:
|
||||
<blockquote>POST /path/subpath HTTP/1.0<br>From: john@example.com<br>User-Agent: someBrowser/1.0<br>Content-Type: application/x-www-form-urlencoded<br>Content-Length: 20<br>name=John+Doe&age=25</blockquote>
|
||||
Como puede ver, el cuerpo está codificado como la cadena de consulta. Este es el formato predeterminado utilizado por los formularios HTML. Con Ajax también podemos usar JSON para poder manejar datos que tienen una estructura más compleja. También hay otro tipo de codificación: multipart / form-data. Este se usa para subir archivos binarios.
|
||||
En este ejercicio utilizaremos un cuerpo urlencodificado.
|
||||
Para analizar los datos procedentes de solicitudes POST, debe instalar un paquete: el analizador de cuerpo. Este paquete le permite utilizar una serie de middleware, que puede decodificar datos en diferentes formatos. Vea los documentos <a href="https://github.com/expressjs/body-parser" target="_blank" >aquí</a> .
|
||||
Instale el módulo body-parser en su package.json. Luego, solicítelo en la parte superior del archivo. Almacénelo en una variable llamada bodyParser.
|
||||
El middleware para manejar los datos codificados en url es devuelto por <code>bodyParser.urlencoded({extended: false})</code> . <code>extended=false</code> es una opción de configuración que le dice al analizador que use la codificación clásica. Cuando se usa, los valores pueden ser solo cadenas o matrices. La versión extendida permite más flexibilidad de datos, pero es superada por JSON. Pase a <code>app.use()</code> la función devuelta por la llamada al método anterior. Como es habitual, el middleware debe montarse antes de todas las rutas que lo necesiten.
|
||||
</section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
|
||||
</section>
|
||||
|
||||
## Tests
|
||||
<section id='tests'>
|
||||
|
||||
```yml
|
||||
tests:
|
||||
- text: El middleware 'body-parser' debería ser montado
|
||||
testString: 'getUserInput => $.get(getUserInput(''url'') + ''/_api/add-body-parser'').then(data => { assert.isAbove(data.mountedAt, 0, ''"body-parser" is not mounted correctly'') }, xhr => { throw new Error(xhr.responseText); })'
|
||||
|
||||
```
|
||||
|
||||
</section>
|
||||
|
||||
## Challenge Seed
|
||||
<section id='challengeSeed'>
|
||||
|
||||
</section>
|
||||
|
||||
## Solution
|
||||
<section id='solution'>
|
||||
|
||||
```js
|
||||
// solution required
|
||||
```
|
||||
</section>
|
||||
@ -0,0 +1,43 @@
|
||||
---
|
||||
id: 587d7fb1367417b2b2512bf2
|
||||
title: Use the .env File
|
||||
localeTitle: Usa el archivo .env
|
||||
challengeType: 2
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
El archivo <code>.env</code> es un archivo oculto que se utiliza para pasar variables de entorno a su aplicación. Este archivo es secreto, nadie más que usted puede acceder a él, y se puede usar para almacenar datos que desea mantener privados u ocultos. Por ejemplo, puede almacenar claves de API de servicios externos o su URI de base de datos. También puedes usarlo para almacenar opciones de configuración. Al configurar las opciones de configuración, puede cambiar el comportamiento de su aplicación, sin la necesidad de volver a escribir algún código.
|
||||
Se puede acceder a las variables de entorno desde la aplicación como <code>process.env.VAR_NAME</code> . El objeto <code>process.env</code> es un objeto de nodo global, y las variables se pasan como cadenas. Por convención, los nombres de las variables están en mayúsculas, con palabras separadas por un guión bajo. El <code>.env</code> es un archivo de shell, por lo que no necesita incluir nombres o valores entre comillas. También es importante tener en cuenta que no puede haber espacio alrededor del signo igual cuando está asignando valores a sus variables, por ejemplo, <code>VAR_NAME=value</code> . Por lo general, colocará cada definición de variable en una línea separada.
|
||||
Agreguemos una variable de entorno como una opción de configuración. Almacene la variable <code>MESSAGE_STYLE=uppercase</code> en el archivo <code>.env</code> . Luego diga al controlador de ruta GET <code>/json</code> que creó en el último desafío para transformar el mensaje del objeto de respuesta en mayúsculas si <code>process.env.MESSAGE_STYLE</code> es igual a <code>uppercase</code> . El objeto de respuesta debe convertirse en <code>{"message": "HELLO JSON"}</code> .
|
||||
</section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
|
||||
</section>
|
||||
|
||||
## Tests
|
||||
<section id='tests'>
|
||||
|
||||
```yml
|
||||
tests:
|
||||
- text: La respuesta del punto final <code>/json</code> debe cambiar de acuerdo con la variable de entorno <code>MESSAGE_STYLE</code>
|
||||
testString: 'getUserInput => $.get(getUserInput(''url'') + ''/_api/use-env-vars'').then(data => { assert.isTrue(data.passed, ''The response of "/json" does not change according to MESSAGE_STYLE''); }, xhr => { throw new Error(xhr.responseText); })'
|
||||
|
||||
```
|
||||
|
||||
</section>
|
||||
|
||||
## Challenge Seed
|
||||
<section id='challengeSeed'>
|
||||
|
||||
</section>
|
||||
|
||||
## Solution
|
||||
<section id='solution'>
|
||||
|
||||
```js
|
||||
// solution required
|
||||
```
|
||||
</section>
|
||||
@ -0,0 +1,47 @@
|
||||
---
|
||||
id: 587d7fb3367417b2b2512bfc
|
||||
title: Add a Description to Your package.json
|
||||
localeTitle: Agregue una descripción a su package.json
|
||||
challengeType: 2
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
La siguiente parte de un buen package.json es el campo de descripción, donde pertenece una descripción breve pero informativa sobre su proyecto.
|
||||
Si algún día planea publicar un paquete en npm, recuerde que esta es la cadena que debe vender su idea al usuario cuando decide instalar el paquete o no. Sin embargo, este no es el único caso de uso para la descripción: es una excelente manera de resumir lo que hace un proyecto, es tan importante para sus proyectos Node.js normales para ayudar a otros desarrolladores, futuros mantenedores o incluso a su propio yo a entender el proyecto. con rapidez.
|
||||
Independientemente de lo que planee para su proyecto, definitivamente se recomienda una descripción. Agreguemos algo similar a esto:
|
||||
<code>"description": "A project that does something awesome",</code>
|
||||
Instrucciones
|
||||
Agrega una descripción al package.json en tu proyecto de Glitch.
|
||||
Recuerde usar comillas dobles para los nombres de campo (") y las comas (,) para separar los campos.
|
||||
</section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
|
||||
</section>
|
||||
|
||||
## Tests
|
||||
<section id='tests'>
|
||||
|
||||
```yml
|
||||
tests:
|
||||
- text: package.json debería tener una clave de "descripción" válida
|
||||
testString: 'getUserInput => $.get(getUserInput(''url'') + ''/_api/package.json'').then(data => { var packJson = JSON.parse(data); assert(packJson.description, ''"description" is missing''); }, xhr => { throw new Error(xhr.responseText); })'
|
||||
|
||||
```
|
||||
|
||||
</section>
|
||||
|
||||
## Challenge Seed
|
||||
<section id='challengeSeed'>
|
||||
|
||||
</section>
|
||||
|
||||
## Solution
|
||||
<section id='solution'>
|
||||
|
||||
```js
|
||||
// solution required
|
||||
```
|
||||
</section>
|
||||
@ -0,0 +1,47 @@
|
||||
---
|
||||
id: 587d7fb4367417b2b2512bfe
|
||||
title: Add a License to Your package.json
|
||||
localeTitle: Agregue una licencia a su paquete.json
|
||||
challengeType: 2
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
El campo de licencia es donde usted informa a los usuarios de su proyecto sobre lo que pueden hacer con él.
|
||||
Algunas licencias comunes para proyectos de código abierto incluyen MIT y BSD. http://choosealicense.com es un gran recurso si desea obtener más información acerca de qué licencia podría adaptarse a su proyecto.
|
||||
No se requiere información de licencia. Las leyes de derechos de autor en la mayoría de los países le otorgarán la propiedad de lo que crea de forma predeterminada. Sin embargo, siempre es una buena práctica indicar explícitamente lo que los usuarios pueden y no pueden hacer.
|
||||
Ejemplo
|
||||
<code>"license": "MIT",</code>
|
||||
Instrucciones
|
||||
Rellene el campo de licencia en el paquete.json de su proyecto de Glitch cuando lo considere adecuado.
|
||||
</section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
|
||||
</section>
|
||||
|
||||
## Tests
|
||||
<section id='tests'>
|
||||
|
||||
```yml
|
||||
tests:
|
||||
- text: package.json debería tener una clave de "licencia" válida
|
||||
testString: 'getUserInput => $.get(getUserInput(''url'') + ''/_api/package.json'').then(data => { var packJson = JSON.parse(data); assert(packJson.license, ''"license" is missing''); }, xhr => { throw new Error(xhr.responseText); })'
|
||||
|
||||
```
|
||||
|
||||
</section>
|
||||
|
||||
## Challenge Seed
|
||||
<section id='challengeSeed'>
|
||||
|
||||
</section>
|
||||
|
||||
## Solution
|
||||
<section id='solution'>
|
||||
|
||||
```js
|
||||
// solution required
|
||||
```
|
||||
</section>
|
||||
@ -0,0 +1,45 @@
|
||||
---
|
||||
id: 587d7fb4367417b2b2512bff
|
||||
title: Add a Version to Your package.json
|
||||
localeTitle: Agregue una versión a su package.json
|
||||
challengeType: 2
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
La versión es junto con el nombre de uno de los campos requeridos en package.json. Este campo describe la versión actual de su proyecto.
|
||||
Ejemplo
|
||||
<code>"version": "1.2",</code>
|
||||
Instrucciones
|
||||
Agregue una versión a package.json en su proyecto de Glitch.
|
||||
</section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
|
||||
</section>
|
||||
|
||||
## Tests
|
||||
<section id='tests'>
|
||||
|
||||
```yml
|
||||
tests:
|
||||
- text: package.json debería tener una clave de "versión" válida
|
||||
testString: 'getUserInput => $.get(getUserInput(''url'') + ''/_api/package.json'').then(data => { var packJson = JSON.parse(data); assert(packJson.version, ''"version" is missing''); }, xhr => { throw new Error(xhr.responseText); })'
|
||||
|
||||
```
|
||||
|
||||
</section>
|
||||
|
||||
## Challenge Seed
|
||||
<section id='challengeSeed'>
|
||||
|
||||
</section>
|
||||
|
||||
## Solution
|
||||
<section id='solution'>
|
||||
|
||||
```js
|
||||
// solution required
|
||||
```
|
||||
</section>
|
||||
@ -0,0 +1,51 @@
|
||||
---
|
||||
id: 587d7fb4367417b2b2512bfd
|
||||
title: Add Keywords to Your package.json
|
||||
localeTitle: Añadir palabras clave a su package.json
|
||||
challengeType: 2
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
El campo de palabras clave es donde puede describir su proyecto usando palabras clave relacionadas.
|
||||
Ejemplo
|
||||
<code>"keywords": [ "descriptive", "related", "words" ],</code>
|
||||
Como puede ver, este campo está estructurado como una matriz de cadenas entre comillas dobles.
|
||||
Instrucciones
|
||||
Agregue una serie de cadenas adecuadas al campo de palabras clave en el paquete.json de su proyecto de Glitch.
|
||||
Una de las palabras clave debe ser freecodecamp.
|
||||
</section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
|
||||
</section>
|
||||
|
||||
## Tests
|
||||
<section id='tests'>
|
||||
|
||||
```yml
|
||||
tests:
|
||||
- text: package.json debe tener una clave de "palabras clave" válida
|
||||
testString: 'getUserInput => $.get(getUserInput(''url'') + ''/_api/package.json'').then(data => { var packJson = JSON.parse(data); assert(packJson.keywords, ''"keywords" is missing''); }, xhr => { throw new Error(xhr.responseText); })'
|
||||
- text: El campo "palabras clave" debería ser una matriz "
|
||||
testString: 'getUserInput => $.get(getUserInput(''url'') + ''/_api/package.json'').then(data => { var packJson = JSON.parse(data); assert.isArray(packJson.keywords, ''"keywords" is not an array''); }, xhr => { throw new Error(xhr.responseText); })'
|
||||
- text: '"palabras clave" debe incluir "freecodecamp"'
|
||||
testString: 'getUserInput => $.get(getUserInput(''url'') + ''/_api/package.json'').then(data => { var packJson = JSON.parse(data); assert.include(packJson.keywords, ''freecodecamp'', ''"keywords" does not include "freecodecamp"''); }, xhr => { throw new Error(xhr.responseText); })'
|
||||
|
||||
```
|
||||
|
||||
</section>
|
||||
|
||||
## Challenge Seed
|
||||
<section id='challengeSeed'>
|
||||
|
||||
</section>
|
||||
|
||||
## Solution
|
||||
<section id='solution'>
|
||||
|
||||
```js
|
||||
// solution required
|
||||
```
|
||||
</section>
|
||||
@ -0,0 +1,51 @@
|
||||
---
|
||||
id: 587d7fb4367417b2b2512c00
|
||||
title: Expand Your Project with External Packages from npm
|
||||
localeTitle: Expanda su proyecto con paquetes externos desde npm
|
||||
challengeType: 2
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
Una de las razones más importantes para usar un administrador de paquetes es su poderosa administración de dependencias. En lugar de tener que asegurarse manualmente de que obtiene todas las dependencias cada vez que configura un proyecto en una computadora nueva, npm instala automáticamente todo por usted. Pero, ¿cómo puede npm saber exactamente lo que necesita su proyecto? Conoce la sección de dependencias de tu package.json.
|
||||
En la sección de dependencias, los paquetes que requiere su proyecto se almacenan con el siguiente formato:
|
||||
<code>"dependencies": {</code>
|
||||
<code>"package-name": "version",</code>
|
||||
<code>"express": "4.14.0"</code>
|
||||
<code>}</code>
|
||||
Instrucciones
|
||||
Agregue la versión 2.14.0 del momento del paquete al campo de dependencias de su paquete.json
|
||||
Moment es una biblioteca útil para trabajar con la hora y las fechas.
|
||||
</section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
|
||||
</section>
|
||||
|
||||
## Tests
|
||||
<section id='tests'>
|
||||
|
||||
```yml
|
||||
tests:
|
||||
- text: '"dependencias" debe incluir "momento"'
|
||||
testString: 'getUserInput => $.get(getUserInput(''url'') + ''/_api/package.json'').then(data => { var packJson = JSON.parse(data); assert.property(packJson.dependencies, ''moment'', ''"dependencies" does not include "moment"''); }, xhr => { throw new Error(xhr.responseText); })'
|
||||
- text: La versión "moment" debería ser "2.14.0" '
|
||||
testString: 'getUserInput => $.get(getUserInput(''url'') + ''/_api/package.json'').then(data => { var packJson = JSON.parse(data); assert.match(packJson.dependencies.moment, /^[\^\~]?2\.14\.0/, ''Wrong version of "moment" installed. It should be 2.14.0''); }, xhr => { throw new Error(xhr.responseText); })'
|
||||
|
||||
```
|
||||
|
||||
</section>
|
||||
|
||||
## Challenge Seed
|
||||
<section id='challengeSeed'>
|
||||
|
||||
</section>
|
||||
|
||||
## Solution
|
||||
<section id='solution'>
|
||||
|
||||
```js
|
||||
// solution required
|
||||
```
|
||||
</section>
|
||||
@ -0,0 +1,50 @@
|
||||
---
|
||||
id: 587d7fb3367417b2b2512bfb
|
||||
title: 'How to Use package.json, the Core of Any Node.js Project or npm Package'
|
||||
localeTitle: 'Cómo usar package.json, el núcleo de cualquier proyecto Node.js o paquete npm'
|
||||
challengeType: 2
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
El archivo package.json es el centro de cualquier proyecto Node.js o paquete npm. Almacena información sobre su proyecto al igual que la sección <head> en un documento HTML describe el contenido de una página web. El package.json consiste en un solo objeto JSON donde la información se almacena en "clave": pares de valores. Solo hay dos campos obligatorios en un paquete mínimo.json (nombre y versión), pero es una buena práctica proporcionar información adicional sobre su proyecto que pueda ser útil para futuros usuarios o mantenedores.
|
||||
El campo de autor
|
||||
Si va al proyecto de Glitch que configuró anteriormente y mira en el lado izquierdo de su pantalla, encontrará el árbol de archivos donde puede ver un resumen de los diversos archivos en su proyecto. Bajo la sección de back-end del árbol de archivos, encontrará package.json, el archivo que mejoraremos en los próximos dos desafíos.
|
||||
Una de las piezas de información más comunes en este archivo es el campo de autor que especifica quién es el creador de un proyecto. Puede ser una cadena o un objeto con detalles de contacto. El objeto se recomienda para proyectos más grandes, pero en nuestro caso, una cadena simple como la del siguiente ejemplo servirá.
|
||||
<code>"author": "Jane Doe",</code>
|
||||
Instrucciones
|
||||
Agregue su nombre al campo de autor en el paquete.json de su proyecto de Glitch.
|
||||
Recuerda que estás escribiendo JSON.
|
||||
Todos los nombres de campo deben usar comillas dobles ("), por ejemplo," autor "
|
||||
Todos los campos deben estar separados por una coma (,)
|
||||
</section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
|
||||
</section>
|
||||
|
||||
## Tests
|
||||
<section id='tests'>
|
||||
|
||||
```yml
|
||||
tests:
|
||||
- text: package.json debería tener una clave de "autor" válida
|
||||
testString: 'getUserInput => $.get(getUserInput(''url'') + ''/_api/package.json'').then(data => { var packJson = JSON.parse(data); assert(packJson.author, ''"author" is missing''); }, xhr => { throw new Error(xhr.responseText); })'
|
||||
|
||||
```
|
||||
|
||||
</section>
|
||||
|
||||
## Challenge Seed
|
||||
<section id='challengeSeed'>
|
||||
|
||||
</section>
|
||||
|
||||
## Solution
|
||||
<section id='solution'>
|
||||
|
||||
```js
|
||||
// solution required
|
||||
```
|
||||
</section>
|
||||
@ -0,0 +1,56 @@
|
||||
---
|
||||
id: 587d7fb5367417b2b2512c01
|
||||
title: Manage npm Dependencies By Understanding Semantic Versioning
|
||||
localeTitle: Administre las dependencias de npm entendiendo el control de versiones semántico
|
||||
challengeType: 2
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
Las versiones de los paquetes npm en la sección de dependencias de su package.json siguen lo que se denomina Semantic Versioning (SemVer), un estándar de la industria para las versiones de software que apunta a facilitar la administración de las dependencias. Las bibliotecas, marcos u otras herramientas publicadas en npm deben usar SemVer para comunicar claramente qué tipo de cambios pueden esperar los proyectos que dependen del paquete si se actualizan.
|
||||
SemVer no tiene sentido en proyectos sin API públicas, por lo tanto, a menos que su proyecto sea similar a los ejemplos anteriores, use otro formato de versión.
|
||||
Entonces, ¿por qué necesitas entender a SemVer?
|
||||
Conocer SemVer puede ser útil cuando desarrolla software que utiliza dependencias externas (lo que casi siempre hace). Un día, su comprensión de estos números le evitará la introducción accidental de cambios de última hora en su proyecto sin comprender por qué las cosas que "funcionaron ayer" de repente no lo hacen.
|
||||
Así es como funciona la Versión semántica según el sitio web oficial:
|
||||
Dado un número de versión MAJOR.MINOR.PATCH, incremente la versión:
|
||||
MAJOR cuando realice cambios en la API incompatibles,
|
||||
versión MENOR cuando agregue la funcionalidad de una manera compatible con versiones anteriores y la versión
|
||||
PATCH cuando realice correcciones de errores compatibles con versiones anteriores.
|
||||
Esto significa que los PARCHES son correcciones de errores y los MENORES agregan nuevas funciones, pero ninguno de ellos rompe lo que funcionaba antes. Finalmente, MAJORs agrega cambios que no funcionarán con versiones anteriores.
|
||||
Ejemplo
|
||||
Un número de versión semántica: 1.3.8
|
||||
Instrucciones
|
||||
En la sección de dependencias de su package.json, cambie la versión de momento para que coincida con MAJOR versión 2, MINOR versión 10 y PATCH versión 2
|
||||
</section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
|
||||
</section>
|
||||
|
||||
## Tests
|
||||
<section id='tests'>
|
||||
|
||||
```yml
|
||||
tests:
|
||||
- text: '"dependencias" debe incluir "momento"'
|
||||
testString: 'getUserInput => $.get(getUserInput(''url'') + ''/_api/package.json'').then(data => { var packJson = JSON.parse(data); assert.property(packJson.dependencies, ''moment'', ''"dependencies" does not include "moment"''); }, xhr => { throw new Error(xhr.responseText); })'
|
||||
- text: La versión "moment" debería ser "2.10.2" '
|
||||
testString: 'getUserInput => $.get(getUserInput(''url'') + ''/_api/package.json'').then(data => { var packJson = JSON.parse(data); assert.match(packJson.dependencies.moment, /^[\^\~]?2\.10\.2/, ''Wrong version of "moment". It should be 2.10.2''); }, xhr => { throw new Error(xhr.responseText); })'
|
||||
|
||||
```
|
||||
|
||||
</section>
|
||||
|
||||
## Challenge Seed
|
||||
<section id='challengeSeed'>
|
||||
|
||||
</section>
|
||||
|
||||
## Solution
|
||||
<section id='solution'>
|
||||
|
||||
```js
|
||||
// solution required
|
||||
```
|
||||
</section>
|
||||
@ -0,0 +1,46 @@
|
||||
---
|
||||
id: 587d7fb5367417b2b2512c04
|
||||
title: Remove a Package from Your Dependencies
|
||||
localeTitle: Retire un paquete de sus dependencias
|
||||
challengeType: 2
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
Ahora ha probado algunas formas en que puede administrar las dependencias de su proyecto usando la sección de dependencias de package.json. Ha incluido paquetes externos al agregarlos al archivo e incluso le ha dicho a npm qué tipo de versiones desea utilizando caracteres especiales como la tilde (~) o el caret (^).
|
||||
¿Pero qué sucede si desea eliminar un paquete externo que ya no necesita? Es posible que ya lo haya adivinado: simplemente elimine la "clave" correspondiente: par de valores para eso de sus dependencias.
|
||||
Este mismo método se aplica a la eliminación de otros campos en su package.json y
|
||||
Instrucciones
|
||||
Elimine el momento del paquete de sus dependencias.
|
||||
Asegúrese de tener la cantidad correcta de comas después de quitarla.
|
||||
</section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
|
||||
</section>
|
||||
|
||||
## Tests
|
||||
<section id='tests'>
|
||||
|
||||
```yml
|
||||
tests:
|
||||
- text: '"dependencias" no debe incluir "momento"'
|
||||
testString: 'getUserInput => $.get(getUserInput(''url'') + ''/_api/package.json'').then(data => { var packJson = JSON.parse(data); assert.notProperty(packJson.dependencies, ''moment'', ''"dependencies" still includes "moment"''); }, xhr => { throw new Error(xhr.responseText); })'
|
||||
|
||||
```
|
||||
|
||||
</section>
|
||||
|
||||
## Challenge Seed
|
||||
<section id='challengeSeed'>
|
||||
|
||||
</section>
|
||||
|
||||
## Solution
|
||||
<section id='solution'>
|
||||
|
||||
```js
|
||||
// solution required
|
||||
```
|
||||
</section>
|
||||
@ -0,0 +1,49 @@
|
||||
---
|
||||
id: 587d7fb5367417b2b2512c03
|
||||
title: Use the Caret-Character to Use the Latest Minor Version of a Dependency
|
||||
localeTitle: Use el Caret-Character para usar la última versión menor de una dependencia
|
||||
challengeType: 2
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
De manera similar a como aprendimos acerca de la tilde (~) en el último desafío, permite a npm instalar el último PATCH para una dependencia, el caret (^) también permite que npm instale actualizaciones futuras. La diferencia es que el compás permitirá tanto las actualizaciones MENORES como los PARCHES.
|
||||
En este momento, su versión actual de moment debería ser ~ 2.10.2, que permite que npm se instale en la última versión 2.10.x. Si, en cambio, utilizáramos el caret (^) como nuestro prefijo de versión, a npm se le permitiría actualizar a cualquier versión 2.xx.
|
||||
Ejemplo
|
||||
<code>"some-package-name": "^1.3.8" allows updates to any 1.xx version.</code>
|
||||
Instrucciones
|
||||
Use el carácter de intercalación (^) para prefijar la versión del momento en sus dependencias y permita que npm la actualice a cualquier nueva versión MINOR.
|
||||
Tenga en cuenta que los números de versión en sí no deben cambiarse.
|
||||
</section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
|
||||
</section>
|
||||
|
||||
## Tests
|
||||
<section id='tests'>
|
||||
|
||||
```yml
|
||||
tests:
|
||||
- text: '"dependencias" debe incluir "momento"'
|
||||
testString: 'getUserInput => $.get(getUserInput(''url'') + ''/_api/package.json'').then(data => { var packJson = JSON.parse(data); assert.property(packJson.dependencies, ''moment'', ''"dependencies" does not include "moment"''); }, xhr => { throw new Error(xhr.responseText); })'
|
||||
- text: La versión "moment" debe coincidir con "^ 2.x.x" '
|
||||
testString: 'getUserInput => $.get(getUserInput(''url'') + ''/_api/package.json'').then(data => { var packJson = JSON.parse(data); assert.match(packJson.dependencies.moment, /^\^2\./, ''Wrong version of "moment". It should be ^2.10.2''); }, xhr => { throw new Error(xhr.responseText); })'
|
||||
|
||||
```
|
||||
|
||||
</section>
|
||||
|
||||
## Challenge Seed
|
||||
<section id='challengeSeed'>
|
||||
|
||||
</section>
|
||||
|
||||
## Solution
|
||||
<section id='solution'>
|
||||
|
||||
```js
|
||||
// solution required
|
||||
```
|
||||
</section>
|
||||
@ -0,0 +1,49 @@
|
||||
---
|
||||
id: 587d7fb5367417b2b2512c02
|
||||
title: Use the Tilde-Character to Always Use the Latest Patch Version of a Dependency
|
||||
localeTitle: Use el carácter de tilde para usar siempre la última versión de parche de una dependencia
|
||||
challengeType: 2
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
En el último desafío, le dijimos a npm que solo incluya una versión específica de un paquete. Es una forma útil de congelar sus dependencias si necesita asegurarse de que las diferentes partes de su proyecto sean compatibles entre sí. Pero en la mayoría de los casos de uso, no querrá perderse la corrección de errores, ya que a menudo incluyen importantes parches de seguridad y (con suerte) no rompen las cosas al hacerlo.
|
||||
Para permitir que una dependencia npm se actualice a la última versión de PATCH, puede prefijar la versión de la dependencia con el carácter de tilde (~). En package.json, nuestra regla actual sobre cómo npm puede actualizarse en el momento es usar solo una versión específica (2.10.2), pero queremos permitir la última versión 2.10.x.
|
||||
Ejemplo
|
||||
<code>"some-package-name": "~1.3.8" allows updates to any 1.3.x version.</code>
|
||||
Instrucciones
|
||||
Use el carácter de tilde (~) para prefijar la versión de momento en sus dependencias y permita que npm la actualice a cualquier nueva versión de PATCH.
|
||||
Tenga en cuenta que los números de versión en sí no deben cambiarse.
|
||||
</section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
|
||||
</section>
|
||||
|
||||
## Tests
|
||||
<section id='tests'>
|
||||
|
||||
```yml
|
||||
tests:
|
||||
- text: '"dependencias" debe incluir "momento"'
|
||||
testString: 'getUserInput => $.get(getUserInput(''url'') + ''/_api/package.json'').then(data => { var packJson = JSON.parse(data); assert.property(packJson.dependencies, ''moment'', ''"dependencies" does not include "moment"''); }, xhr => { throw new Error(xhr.responseText); })'
|
||||
- text: La versión "moment" debe coincidir con "~ 2.10.2" '
|
||||
testString: 'getUserInput => $.get(getUserInput(''url'') + ''/_api/package.json'').then(data => { var packJson = JSON.parse(data); assert.match(packJson.dependencies.moment, /^\~2\.10\.2/, ''Wrong version of "moment". It should be ~2.10.2''); }, xhr => { throw new Error(xhr.responseText); })'
|
||||
|
||||
```
|
||||
|
||||
</section>
|
||||
|
||||
## Challenge Seed
|
||||
<section id='challengeSeed'>
|
||||
|
||||
</section>
|
||||
|
||||
## Solution
|
||||
<section id='solution'>
|
||||
|
||||
```js
|
||||
// solution required
|
||||
```
|
||||
</section>
|
||||
@ -0,0 +1,42 @@
|
||||
---
|
||||
id: 587d7fb9367417b2b2512c12
|
||||
title: Chain Search Query Helpers to Narrow Search Results
|
||||
localeTitle: Encadene a los ayudantes de consulta para reducir los resultados de búsqueda
|
||||
challengeType: 2
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
Si no pasa la devolución de llamada como último argumento a Model.find () (o a los otros métodos de búsqueda), la consulta no se ejecuta. Puede almacenar la consulta en una variable para su uso posterior. Este tipo de objeto le permite crear una consulta utilizando la sintaxis de encadenamiento. La búsqueda real de db se ejecuta cuando finalmente encadena el método .exec (). Pase su devolución de llamada a este último método. Hay muchos ayudantes de consulta, aquí usaremos los más "famosos".
|
||||
Encuentra gente que le gusta "burrito". Ordénelos por nombre, limite los resultados a dos documentos y oculte su edad. Encadene .find (), .sort (), .limit (), .select (), y luego .exec (). Pase la devolución de llamada done (err, data) a exec ().
|
||||
</section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
|
||||
</section>
|
||||
|
||||
## Tests
|
||||
<section id='tests'>
|
||||
|
||||
```yml
|
||||
tests:
|
||||
- text: Los ayudantes de encadenamiento de consultas deben tener éxito
|
||||
testString: 'getUserInput => $.ajax({url: getUserInput(''url'') + ''/_api/query-tools'', type: ''POST'', contentType:''application/json'', data: JSON.stringify([{name: ''Pablo'', age: 26, favoriteFoods: [''burrito'', ''hot-dog'']}, {name: ''Bob'', age: 23, favoriteFoods: [''pizza'', ''nachos'']}, {name: ''Ashley'', age: 32, favoriteFoods: [''steak'', ''burrito'']}, {name: ''Mario'', age: 51, favoriteFoods: [''burrito'', ''prosciutto'']} ]) }).then(data => { assert.isArray(data, ''the response should be an Array''); assert.equal(data.length, 2, ''the data array length is not what expected''); assert.notProperty(data[0], ''age'', ''The returned first item has too many properties''); assert.equal(data[0].name, ''Ashley'', ''The returned first item name is not what expected''); assert.notProperty(data[1], ''age'', ''The returned second item has too many properties''); assert.equal(data[1].name, ''Mario'', ''The returned second item name is not what expected'');}, xhr => { throw new Error(xhr.responseText); })'
|
||||
|
||||
```
|
||||
|
||||
</section>
|
||||
|
||||
## Challenge Seed
|
||||
<section id='challengeSeed'>
|
||||
|
||||
</section>
|
||||
|
||||
## Solution
|
||||
<section id='solution'>
|
||||
|
||||
```js
|
||||
// solution required
|
||||
```
|
||||
</section>
|
||||
@ -0,0 +1,61 @@
|
||||
---
|
||||
id: 587d7fb6367417b2b2512c07
|
||||
title: Create a Model
|
||||
localeTitle: Crear un modelo
|
||||
challengeType: 2
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
Primero que todo necesitamos un esquema. Cada esquema se asigna a una colección de MongoDB. Define la forma de los documentos dentro de esa colección.
|
||||
esquemas son bloques de construcción para los modelos. Se pueden anidar para crear modelos complejos, pero en este caso mantendremos las cosas simples.
|
||||
Un modelo le permite crear instancias de sus objetos, llamados documentos.
|
||||
Crea una persona que tenga este prototipo:
|
||||
<code>- Person Prototype -</code>
|
||||
<code>--------------------</code>
|
||||
<code>name : string [required]</code>
|
||||
<code>age : number</code>
|
||||
<code>favoriteFoods : array of strings (*)</code>
|
||||
Utilice los tipos de esquema básicos de mangosta. Si lo desea, también puede agregar
|
||||
campos más, use validadores simples como requeridos o únicos,
|
||||
y configure los valores predeterminados. Ver los <a href='http://mongoosejs.com/docs/guide.html'>documentos de mangosta</a> .
|
||||
[C] RUD Parte I - CREAR
|
||||
Nota: Glitch es un servidor real, y en servidores reales las interacciones con el db ocurren en las funciones del controlador. Estas funciones se ejecutan cuando ocurre algún evento (por ejemplo, alguien llega a un punto final en su API). Seguiremos el mismo enfoque en estos ejercicios. La función done () es una devolución de llamada que nos dice que podemos continuar después de completar una operación asíncrona, como insertar, buscar, actualizar o eliminar. Sigue la convención de Nodo y debe llamarse como hecho (nulo, datos) en caso de éxito o hecho (error) en caso de error
|
||||
Advertencia: al interactuar con servicios remotos, pueden producirse errores.
|
||||
<code>/* Example */</code>
|
||||
<code>var someFunc = function(done) {</code>
|
||||
<code>//... do something (risky) ...</code>
|
||||
<code>if(error) return done(error);</code>
|
||||
<code>done(null, result);</code>
|
||||
<code>};</code>
|
||||
</section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
|
||||
</section>
|
||||
|
||||
## Tests
|
||||
<section id='tests'>
|
||||
|
||||
```yml
|
||||
tests:
|
||||
- text: La creación de una instancia a partir de un esquema de mangosta debería tener éxito
|
||||
testString: 'getUserInput => $.post(getUserInput(''url'') + ''/_api/mongoose-model'', {name: ''Mike'', age: 28, favoriteFoods: [''pizza'', ''cheese'']}).then(data => { assert.equal(data.name, ''Mike'', ''"model.name" is not what expected''); assert.equal(data.age, ''28'', ''"model.age" is not what expected''); assert.isArray(data.favoriteFoods, ''"model.favoriteFoods" is not an Array''); assert.include(data.favoriteFoods, ''pizza'', ''"model.favoriteFoods" does not include the expected items''); assert.include(data.favoriteFoods, ''cheese'', ''"model.favoriteFoods" does not include the expected items''); }, xhr => { throw new Error(xhr.responseText); })'
|
||||
|
||||
```
|
||||
|
||||
</section>
|
||||
|
||||
## Challenge Seed
|
||||
<section id='challengeSeed'>
|
||||
|
||||
</section>
|
||||
|
||||
## Solution
|
||||
<section id='solution'>
|
||||
|
||||
```js
|
||||
// solution required
|
||||
```
|
||||
</section>
|
||||
@ -0,0 +1,46 @@
|
||||
---
|
||||
id: 587d7fb6367417b2b2512c09
|
||||
title: Create and Save a Record of a Model
|
||||
localeTitle: Crear y guardar un registro de un modelo
|
||||
challengeType: 2
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
Crea una instancia de documento utilizando el constructor de persona que creaste antes. Pase al constructor un objeto que tenga los campos nombre, edad y favoriteFoods. Sus tipos deben ser conformes a los del esquema de persona. Luego llame al método document.save () en la instancia del documento devuelto. Pasar a él una devolución de llamada utilizando la convención de nodo. Este es un patrón común, todos los siguientes métodos de CRUD toman una función de devolución de llamada como el último argumento.
|
||||
<code>/* Example */</code>
|
||||
<code>// ...</code>
|
||||
<code>person.save(function(err, data) {</code>
|
||||
<code>// ...do your stuff here...</code>
|
||||
<code>});</code>
|
||||
</section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
|
||||
</section>
|
||||
|
||||
## Tests
|
||||
<section id='tests'>
|
||||
|
||||
```yml
|
||||
tests:
|
||||
- text: Crear y guardar un elemento db debería tener éxito
|
||||
testString: 'getUserInput => $.get(getUserInput(''url'') + ''/_api/create-and-save-person'').then(data => { assert.isString(data.name, ''"item.name" should be a String''); assert.isNumber(data.age, ''28'', ''"item.age" should be a Number''); assert.isArray(data.favoriteFoods, ''"item.favoriteFoods" should be an Array''); assert.equal(data.__v, 0, ''The db item should be not previously edited''); }, xhr => { throw new Error(xhr.responseText); })'
|
||||
|
||||
```
|
||||
|
||||
</section>
|
||||
|
||||
## Challenge Seed
|
||||
<section id='challengeSeed'>
|
||||
|
||||
</section>
|
||||
|
||||
## Solution
|
||||
<section id='solution'>
|
||||
|
||||
```js
|
||||
// solution required
|
||||
```
|
||||
</section>
|
||||
@ -0,0 +1,41 @@
|
||||
---
|
||||
id: 587d7fb7367417b2b2512c0a
|
||||
title: Create Many Records with model.create()
|
||||
localeTitle: Crear muchos registros con model.create ()
|
||||
challengeType: 2
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
A veces necesita crear muchas instancias de sus modelos, por ejemplo, al sembrar una base de datos con datos iniciales. Model.create () toma una matriz de objetos como [{nombre: 'John', ...}, {...}, ...] como el primer argumento, y los guarda todos en la db. Cree muchas personas con Model.create (), usando la función argumentoOfPeople.
|
||||
</section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
|
||||
</section>
|
||||
|
||||
## Tests
|
||||
<section id='tests'>
|
||||
|
||||
```yml
|
||||
tests:
|
||||
- text: La creación de muchos elementos db a la vez debe tener éxito
|
||||
testString: 'getUserInput => $.ajax({url: getUserInput(''url'') + ''/_api/create-many-people'', type: ''POST'', contentType:''application/json'', data: JSON.stringify([{name: ''John'', age: 24, favoriteFoods: [''pizza'', ''salad'']}, {name: ''Mary'', age: 21, favoriteFoods: [''onions'', ''chicken'']}])}).then(data => { assert.isArray(data, ''the response should be an array''); assert.equal(data.length, 2, ''the response does not contain the expected number of items''); assert.equal(data[0].name, ''John'', ''The first item is not correct''); assert.equal(data[0].__v, 0, ''The first item should be not previously edited''); assert.equal(data[1].name, ''Mary'', ''The second item is not correct''); assert.equal(data[1].__v, 0, ''The second item should be not previously edited''); }, xhr => { throw new Error(xhr.responseText); })'
|
||||
|
||||
```
|
||||
|
||||
</section>
|
||||
|
||||
## Challenge Seed
|
||||
<section id='challengeSeed'>
|
||||
|
||||
</section>
|
||||
|
||||
## Solution
|
||||
<section id='solution'>
|
||||
|
||||
```js
|
||||
// solution required
|
||||
```
|
||||
</section>
|
||||
@ -0,0 +1,42 @@
|
||||
---
|
||||
id: 587d7fb8367417b2b2512c11
|
||||
title: Delete Many Documents with model.remove()
|
||||
localeTitle: Eliminar muchos documentos con model.remove ()
|
||||
challengeType: 2
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
Model.remove () es útil para eliminar todos los documentos que coincidan con los criterios dados. Elimine a todas las personas cuyo nombre es "Mary", usando Model.remove (). Pasarlo a un documento de consulta con el conjunto de campos "nombre" y, por supuesto, una devolución de llamada.
|
||||
Nota: Model.remove () no devuelve el documento eliminado, sino un objeto JSON que contiene el resultado de la operación y el número de elementos afectados. No olvide pasarlo a la devolución de llamada done (), ya que lo usamos en las pruebas.
|
||||
</section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
|
||||
</section>
|
||||
|
||||
## Tests
|
||||
<section id='tests'>
|
||||
|
||||
```yml
|
||||
tests:
|
||||
- text: Eliminar muchos elementos a la vez debería tener éxito
|
||||
testString: 'getUserInput => $.ajax({url: getUserInput(''url'') + ''/_api/remove-many-people'', type: ''POST'', contentType:''application/json'', data: JSON.stringify([{name: ''Mary'', age: 16, favoriteFoods: [''lollipop'']}, {name: ''Mary'', age: 21, favoriteFoods: [''steak'']}])}).then(data => { assert.isTrue(!!data.ok, ''The mongo stats are not what expected''); assert.equal(data.n, 2, ''The number of items affected is not what expected''); assert.equal(data.count, 0, ''the db items count is not what expected''); }, xhr => { throw new Error(xhr.responseText); })'
|
||||
|
||||
```
|
||||
|
||||
</section>
|
||||
|
||||
## Challenge Seed
|
||||
<section id='challengeSeed'>
|
||||
|
||||
</section>
|
||||
|
||||
## Solution
|
||||
<section id='solution'>
|
||||
|
||||
```js
|
||||
// solution required
|
||||
```
|
||||
</section>
|
||||
@ -0,0 +1,41 @@
|
||||
---
|
||||
id: 587d7fb8367417b2b2512c10
|
||||
title: Delete One Document Using model.findByIdAndRemove
|
||||
localeTitle: Eliminar un documento utilizando model.findByIdAndRemove
|
||||
challengeType: 2
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
Eliminar una persona por su _id. Debe usar uno de los métodos findByIdAndRemove () o findOneAndRemove (). Son como los métodos de actualización anteriores. Pasan el documento eliminado a la cb. Como de costumbre, use la función argumento personId como clave de búsqueda.
|
||||
</section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
|
||||
</section>
|
||||
|
||||
## Tests
|
||||
<section id='tests'>
|
||||
|
||||
```yml
|
||||
tests:
|
||||
- text: Eliminar un elemento debe tener éxito
|
||||
testString: 'getUserInput => $.post(getUserInput(''url'') + ''/_api/remove-one-person'', {name:''Jason Bourne'', age: 36, favoriteFoods:[''apples'']}).then(data => { assert.equal(data.name, ''Jason Bourne'', ''item.name is not what expected''); assert.equal(data.age, 36, ''item.age is not what expected''); assert.deepEqual(data.favoriteFoods, [''apples''], ''item.favoriteFoods is not what expected''); assert.equal(data.__v, 0); assert.equal(data.count, 0, ''the db items count is not what expected''); }, xhr => { throw new Error(xhr.responseText); })'
|
||||
|
||||
```
|
||||
|
||||
</section>
|
||||
|
||||
## Challenge Seed
|
||||
<section id='challengeSeed'>
|
||||
|
||||
</section>
|
||||
|
||||
## Solution
|
||||
<section id='solution'>
|
||||
|
||||
```js
|
||||
// solution required
|
||||
```
|
||||
</section>
|
||||
@ -0,0 +1,45 @@
|
||||
---
|
||||
id: 587d7fb6367417b2b2512c06
|
||||
title: Install and Set Up Mongoose
|
||||
localeTitle: Instalar y configurar la mangosta
|
||||
challengeType: 2
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
Agregue mongodb y mongoose al package.json del proyecto. Entonces requiere mangosta. Almacene su URI de la base de datos de mLab en el archivo .env privado como MONGO_URI. Conéctese a la base de datos utilizando mongoose.connect ( <Your URI> )
|
||||
</section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
|
||||
</section>
|
||||
|
||||
## Tests
|
||||
<section id='tests'>
|
||||
|
||||
```yml
|
||||
tests:
|
||||
- text: La dependencia "mongodb" debería estar en package.json '
|
||||
testString: 'getUserInput => $.get(getUserInput(''url'') + ''/_api/file/package.json'').then(data => { var packJson = JSON.parse(data); assert.property(packJson.dependencies, ''mongodb''); }, xhr => { throw new Error(xhr.responseText); })'
|
||||
- text: 'La dependencia de "mongoose" debe estar en package.json'
|
||||
testString: 'getUserInput => $.get(getUserInput(''url'') + ''/_api/file/package.json'').then(data => { var packJson = JSON.parse(data); assert.property(packJson.dependencies, ''mongoose''); }, xhr => { throw new Error(xhr.responseText); })'
|
||||
- text: '"mangosta" debe estar conectada a una base de datos'
|
||||
testString: 'getUserInput => $.get(getUserInput(''url'') + ''/_api/is-mongoose-ok'').then(data => {assert.isTrue(data.isMongooseOk, ''mongoose is not connected'')}, xhr => { throw new Error(xhr.responseText); })'
|
||||
|
||||
```
|
||||
|
||||
</section>
|
||||
|
||||
## Challenge Seed
|
||||
<section id='challengeSeed'>
|
||||
|
||||
</section>
|
||||
|
||||
## Solution
|
||||
<section id='solution'>
|
||||
|
||||
```js
|
||||
// solution required
|
||||
```
|
||||
</section>
|
||||
@ -0,0 +1,43 @@
|
||||
---
|
||||
id: 587d7fb8367417b2b2512c0e
|
||||
title: 'Perform Classic Updates by Running Find, Edit, then Save'
|
||||
localeTitle: 'Realizar actualizaciones clásicas ejecutando Buscar, Editar y luego Guardar'
|
||||
challengeType: 2
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
En los viejos tiempos, esto era lo que tenía que hacer si quería editar un documento y poder usarlo de alguna manera, por ejemplo, enviándolo de vuelta en una respuesta del servidor. Mongoose tiene un método de actualización dedicado: Model.update (). Está vinculado al controlador mongo de bajo nivel. Puede editar de forma masiva muchos documentos que cumplen ciertos criterios, pero no envía el documento actualizado, solo un mensaje de "estado". Además, dificulta las validaciones de modelos, ya que solo llama directamente al controlador mongo.
|
||||
Encuentre una persona por _id (use cualquiera de los métodos anteriores) con el parámetro personId como clave de búsqueda. Agregue “hamburguesa” a la lista de sus alimentos favoritos (puede usar Array.push ()). Luego, dentro de la devolución de llamada de búsqueda, guarde () la Persona actualizada.
|
||||
[*] Sugerencia: Esto puede ser complicado si en tu Esquema declaraste favoriteFoods como una matriz, sin especificar el tipo (es decir, [Cadena]). En ese caso, el valor predeterminado de los alimentos predeterminados es de tipo mixto, y tiene que marcarlo manualmente como editado utilizando document.markModified ('campo editado'). (http://mongoosejs.com/docs/schematypes.html - #Mixed)
|
||||
</section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
|
||||
</section>
|
||||
|
||||
## Tests
|
||||
<section id='tests'>
|
||||
|
||||
```yml
|
||||
tests:
|
||||
- text: Buscar-editar-actualizar un elemento debería tener éxito
|
||||
testString: 'getUserInput => $.post(getUserInput(''url'') + ''/_api/find-edit-save'', {name:''Poldo'', age: 40, favoriteFoods:[''spaghetti'']}).then(data => { assert.equal(data.name, ''Poldo'', ''item.name is not what expected''); assert.equal(data.age, 40, ''item.age is not what expected''); assert.deepEqual(data.favoriteFoods, [''spaghetti'', ''hamburger''], ''item.favoriteFoods is not what expected''); assert.equal(data.__v, 1, ''The item should be previously edited''); }, xhr => { throw new Error(xhr.responseText); })'
|
||||
|
||||
```
|
||||
|
||||
</section>
|
||||
|
||||
## Challenge Seed
|
||||
<section id='challengeSeed'>
|
||||
|
||||
</section>
|
||||
|
||||
## Solution
|
||||
<section id='solution'>
|
||||
|
||||
```js
|
||||
// solution required
|
||||
```
|
||||
</section>
|
||||
@ -0,0 +1,43 @@
|
||||
---
|
||||
id: 587d7fb8367417b2b2512c0f
|
||||
title: Perform New Updates on a Document Using model.findOneAndUpdate()
|
||||
localeTitle: Realizar nuevas actualizaciones en un documento utilizando model.findOneAndUpdate ()
|
||||
challengeType: 2
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
Las versiones recientes de mongoose tienen métodos para simplificar la actualización de documentos. Algunas características más avanzadas (es decir, ganchos pre / post, validación) se comportan de manera diferente con este enfoque, por lo que el método Classic sigue siendo útil en muchas situaciones. findByIdAndUpdate () se puede usar cuando se busca por Id.
|
||||
Encuentre a una persona por su nombre y establezca su edad en 20. Use el parámetro de función personName como clave de búsqueda.
|
||||
Sugerencia: queremos que devuelva el documento actualizado. Para hacerlo, debe pasar el documento de opciones {nuevo: verdadero} como el tercer argumento para findOneAndUpdate (). Por defecto, estos métodos devuelven el objeto no modificado.
|
||||
</section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
|
||||
</section>
|
||||
|
||||
## Tests
|
||||
<section id='tests'>
|
||||
|
||||
```yml
|
||||
tests:
|
||||
- text: findOneAndUpdate un elemento debe tener éxito
|
||||
testString: 'getUserInput => $.post(getUserInput(''url'') + ''/_api/find-one-update'', {name:''Dorian Gray'', age: 35, favoriteFoods:[''unknown'']}).then(data => { assert.equal(data.name, ''Dorian Gray'', ''item.name is not what expected''); assert.equal(data.age, 20, ''item.age is not what expected''); assert.deepEqual(data.favoriteFoods, [''unknown''], ''item.favoriteFoods is not what expected''); assert.equal(data.__v, 0, ''findOneAndUpdate does not increment version by design !!!''); }, xhr => { throw new Error(xhr.responseText); })'
|
||||
|
||||
```
|
||||
|
||||
</section>
|
||||
|
||||
## Challenge Seed
|
||||
<section id='challengeSeed'>
|
||||
|
||||
</section>
|
||||
|
||||
## Solution
|
||||
<section id='solution'>
|
||||
|
||||
```js
|
||||
// solution required
|
||||
```
|
||||
</section>
|
||||
@ -0,0 +1,42 @@
|
||||
---
|
||||
id: 587d7fb7367417b2b2512c0b
|
||||
title: Use model.find() to Search Your Database
|
||||
localeTitle: Utilice model.find () para buscar su base de datos
|
||||
challengeType: 2
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
Encuentre a todas las personas que tienen un nombre dado, usando Model.find () -> [Persona]
|
||||
En su uso más simple, Model.find () acepta un documento de consulta (un objeto JSON) como primer argumento, luego una devolución de llamada. Devuelve una serie de coincidencias. Es compatible con una amplia gama de opciones de búsqueda. Compruébalo en los documentos. Utilice la función argumento personName como clave de búsqueda.
|
||||
</section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
|
||||
</section>
|
||||
|
||||
## Tests
|
||||
<section id='tests'>
|
||||
|
||||
```yml
|
||||
tests:
|
||||
- text: Encontrar todos los elementos correspondientes a un criterio debe tener éxito
|
||||
testString: 'getUserInput => $.post(getUserInput(''url'') + ''/_api/find-all-by-name'', {name: ''r@nd0mN4m3'', age: 24, favoriteFoods: [''pizza'']}).then(data => { assert.isArray(data, ''the response should be an Array''); assert.equal(data[0].name, ''r@nd0mN4m3'', ''item.name is not what expected''); assert.equal(data[0].__v, 0, ''The item should be not previously edited''); }, xhr => { throw new Error(xhr.responseText); })'
|
||||
|
||||
```
|
||||
|
||||
</section>
|
||||
|
||||
## Challenge Seed
|
||||
<section id='challengeSeed'>
|
||||
|
||||
</section>
|
||||
|
||||
## Solution
|
||||
<section id='solution'>
|
||||
|
||||
```js
|
||||
// solution required
|
||||
```
|
||||
</section>
|
||||
@ -0,0 +1,41 @@
|
||||
---
|
||||
id: 587d7fb7367417b2b2512c0d
|
||||
title: Use model.findById() to Search Your Database By _id
|
||||
localeTitle: Use model.findById () para buscar en su base de datos por _id
|
||||
challengeType: 2
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
Al guardar un documento, mongodb agrega automáticamente el campo _id y lo configura en una clave alfanumérica única. La búsqueda por _id es una operación extremadamente frecuente, por lo que la mangosta proporciona un método dedicado para ello. Encuentre la (solo !!) persona que tiene un _id dado, usando Model.findById () -> Person. Utilice el argumento de función personId como clave de búsqueda.
|
||||
</section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
|
||||
</section>
|
||||
|
||||
## Tests
|
||||
<section id='tests'>
|
||||
|
||||
```yml
|
||||
tests:
|
||||
- text: Encontrar un artículo por ID debe tener éxito
|
||||
testString: 'getUserInput => $.get(getUserInput(''url'') + ''/_api/find-by-id'').then(data => { assert.equal(data.name, ''test'', ''item.name is not what expected''); assert.equal(data.age, 0, ''item.age is not what expected''); assert.deepEqual(data.favoriteFoods, [''none''], ''item.favoriteFoods is not what expected''); assert.equal(data.__v, 0, ''The item should be not previously edited''); }, xhr => { throw new Error(xhr.responseText); })'
|
||||
|
||||
```
|
||||
|
||||
</section>
|
||||
|
||||
## Challenge Seed
|
||||
<section id='challengeSeed'>
|
||||
|
||||
</section>
|
||||
|
||||
## Solution
|
||||
<section id='solution'>
|
||||
|
||||
```js
|
||||
// solution required
|
||||
```
|
||||
</section>
|
||||
@ -0,0 +1,41 @@
|
||||
---
|
||||
id: 587d7fb7367417b2b2512c0c
|
||||
title: Use model.findOne() to Return a Single Matching Document from Your Database
|
||||
localeTitle: Use model.findOne () para devolver un solo documento coincidente de su base de datos
|
||||
challengeType: 2
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
Model.findOne () se comporta como .find (), pero solo devuelve un documento (no una matriz), incluso si hay varios elementos. Es especialmente útil cuando busca por propiedades que ha declarado como únicas. Encuentre solo una persona que tenga cierta comida en sus favoritos, usando Model.findOne () -> Person. Utilice la función de argumento de alimentos como clave de búsqueda.
|
||||
</section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
|
||||
</section>
|
||||
|
||||
## Tests
|
||||
<section id='tests'>
|
||||
|
||||
```yml
|
||||
tests:
|
||||
- text: Encontrar un elemento debe tener éxito
|
||||
testString: 'getUserInput => $.post(getUserInput(''url'') + ''/_api/find-one-by-food'', {name: ''Gary'', age: 46, favoriteFoods: [''chicken salad'']}).then(data => { assert.equal(data.name, ''Gary'', ''item.name is not what expected''); assert.deepEqual(data.favoriteFoods, [''chicken salad''], ''item.favoriteFoods is not what expected''); assert.equal(data.__v, 0, ''The item should be not previously edited''); }, xhr => { throw new Error(xhr.responseText); })'
|
||||
|
||||
```
|
||||
|
||||
</section>
|
||||
|
||||
## Challenge Seed
|
||||
<section id='challengeSeed'>
|
||||
|
||||
</section>
|
||||
|
||||
## Solution
|
||||
<section id='solution'>
|
||||
|
||||
```js
|
||||
// solution required
|
||||
```
|
||||
</section>
|
||||
Reference in New Issue
Block a user