fix: Add Api challenges - Portuguese translation (#35165)
* fix: Add Api challenges - Portuguese translation * fix: md formatting
This commit is contained in:
Beau Carnes
Tom
@ -0,0 +1,52 @@
|
||||
---
|
||||
id: 5a8b073d06fa14fcfde687aa
|
||||
title: Exercise Tracker
|
||||
localeTitle: Rastreador de Exercícios
|
||||
challengeType: 4
|
||||
isRequired: true
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
Crie um aplicativo JavaScript de pilha completa que seja funcionalmente semelhante a este: <a href='https://fuschia-custard.glitch.me/' target='_blank'>https://fuschia-custard.glitch.me/</a> .
|
||||
Trabalhar neste projeto envolverá você escrevendo seu código no Glitch em nosso projeto inicial. Depois de concluir este projeto, você pode copiar sua URL de falha pública (para a página inicial do seu aplicativo) nesta tela para testá-lo! Opcionalmente, você pode optar por escrever seu projeto em outra plataforma, mas deve estar publicamente visível para nossos testes.
|
||||
iniciar este projeto em Glitch usando <a href='https://glitch.com/#!/import/github/freeCodeCamp/boilerplate-project-exercisetracker/' target='_blank'>este link</a> ou clonar <a href='https://github.com/freeCodeCamp/boilerplate-project-exercisetracker/'>este repositório</a> no GitHub! Se você usa o Glitch, lembre-se de salvar o link do seu projeto em algum lugar seguro!
|
||||
</section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
|
||||
</section>
|
||||
|
||||
## Tests
|
||||
<section id='tests'>
|
||||
|
||||
```yml
|
||||
tests:
|
||||
- text: Eu posso criar um usuário postando dados do formulário username para / api / exercise / new-user e retornado será um objeto com username e <code>_id</code> .
|
||||
testString: ''
|
||||
- text: Eu posso obter uma matriz de todos os usuários obtendo api / exercise / users com as mesmas informações que ao criar um usuário.
|
||||
testString: ''
|
||||
- text: Posso adicionar um exercício a qualquer usuário postando dados do formulário userId (_id), descrição, duração e, opcionalmente, data para / api / exercise / add. Se nenhuma data for fornecida, usará a data atual. O aplicativo retornará o objeto do usuário com os campos de exercício adicionados.
|
||||
testString: ''
|
||||
- text: Eu posso recuperar um log de exercício completo de qualquer usuário obtendo / api / exercise / log com um parâmetro de userId (_id). O aplicativo retornará o objeto do usuário com o registro da matriz adicionado e a contagem (contagem total de exercícios).
|
||||
testString: ''
|
||||
- text: 'Eu posso recuperar parte do log de qualquer usuário passando também parâmetros opcionais de & para ou limite. (Formato de data aaaa-mm-dd, limite = 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: Metadados de Arquivo Microservice
|
||||
challengeType: 4
|
||||
isRequired: true
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
Crie um aplicativo JavaScript de pilha completa que seja funcionalmente semelhante a este: <a href='https://purple-paladin.glitch.me/' target='_blank'>https://purple-paladin.glitch.me/</a> .
|
||||
Trabalhar neste projeto envolverá você escrevendo seu código no Glitch em nosso projeto inicial. Depois de concluir este projeto, você pode copiar sua URL de falha pública (para a página inicial do seu aplicativo) nesta tela para testá-lo! Opcionalmente, você pode optar por escrever seu projeto em outra plataforma, mas deve estar publicamente visível para nossos testes.
|
||||
iniciar este projeto em Glitch usando <a href='https://glitch.com/#!/import/github/freeCodeCamp/boilerplate-project-filemetadata/' target='_blank'>este link</a> ou clonar <a href='https://github.com/freeCodeCamp/boilerplate-project-filemetadata/'>este repositório</a> no GitHub! Se você usa o Glitch, lembre-se de salvar o link do seu projeto em algum lugar seguro!
|
||||
</section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
|
||||
</section>
|
||||
|
||||
## Tests
|
||||
<section id='tests'>
|
||||
|
||||
```yml
|
||||
tests:
|
||||
- text: Eu posso enviar um objeto FormData que inclua um upload de arquivo.
|
||||
testString: ''
|
||||
- text: 'Quando eu enviar algo, receberei o tamanho do arquivo em bytes dentro da resposta 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: Solicitar Microservice do Analisador de Cabeçalhos
|
||||
challengeType: 4
|
||||
isRequired: true
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
Crie um aplicativo JavaScript de pilha completa que seja funcionalmente semelhante a este: <a href='https://dandelion-roar.glitch.me/' target='_blank'>https://dandelion-roar.glitch.me/</a> .
|
||||
Trabalhar neste projeto envolverá você escrevendo seu código no Glitch em nosso projeto inicial. Depois de concluir este projeto, você pode copiar sua URL de falha pública (para a página inicial do seu aplicativo) nesta tela para testá-lo! Opcionalmente, você pode optar por escrever seu projeto em outra plataforma, mas deve estar publicamente visível para nossos testes.
|
||||
iniciar este projeto em Glitch usando <a href='https://glitch.com/#!/import/github/freeCodeCamp/boilerplate-project-headerparser/' target='_blank'>este link</a> ou clonar <a href='https://github.com/freeCodeCamp/boilerplate-project-headerparser/'>este repositório</a> no GitHub! Se você usa o Glitch, lembre-se de salvar o link do seu projeto em algum lugar seguro!
|
||||
</section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
|
||||
</section>
|
||||
|
||||
## Tests
|
||||
<section id='tests'>
|
||||
|
||||
```yml
|
||||
tests:
|
||||
- text: 'Eu posso obter o endereço IP, idioma e sistema operacional para o meu 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: Microservice de registro de data e hora
|
||||
challengeType: 4
|
||||
isRequired: true
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
Crie um aplicativo JavaScript de pilha completa que seja funcionalmente semelhante a este: <a href='https://curse-arrow.glitch.me/' target='_blank'>https://curse-arrow.glitch.me/</a> .
|
||||
Trabalhar neste projeto envolverá você escrevendo seu código no Glitch em nosso projeto inicial. Depois de concluir este projeto, você pode copiar sua URL de falha pública (para a página inicial do seu aplicativo) nesta tela para testá-lo! Opcionalmente, você pode optar por escrever seu projeto em outra plataforma, mas deve estar publicamente visível para nossos testes.
|
||||
iniciar este projeto em Glitch usando <a href='https://glitch.com/#!/import/github/freeCodeCamp/boilerplate-project-timestamp/' target='_blank'>este link</a> ou clonar <a href='https://github.com/freeCodeCamp/boilerplate-project-timestamp/'>este repositório</a> no GitHub! Se você usa o Glitch, lembre-se de salvar o link do seu projeto em algum lugar seguro!
|
||||
</section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
|
||||
</section>
|
||||
|
||||
## Tests
|
||||
<section id='tests'>
|
||||
|
||||
```yml
|
||||
tests:
|
||||
- text: 'Ele deve manipular uma data válida e retornar o registro de data e hora correto do unix'
|
||||
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: 'Ele deve manipular uma data válida e retornar a string UTC correta'
|
||||
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: 'Ele deve manipular uma data unix válida e retornar o registro de data e hora correto do unix'
|
||||
testString: 'getUserInput => $.get(getUserInput(''url'') + ''/api/timestamp/1482624000000'').then(data => { assert.equal(data.unix, 1482624000000) ; }, xhr => { throw new Error(xhr.responseText); })'
|
||||
- text: Deve devolver a mensagem de erro esperada para uma data invá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: 'Ele deve manipular um parâmetro de data vazio e retornar a hora atual no 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: 'Ele deve manipular um parâmetro de data vazio e retornar a hora atual no 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: Microservice do Shortener de URL
|
||||
challengeType: 4
|
||||
isRequired: true
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
Crie um aplicativo JavaScript de pilha completa que seja funcionalmente semelhante a este: <a href='https://thread-paper.glitch.me/' target='_blank'>https://thread-paper.glitch.me/</a> .
|
||||
Trabalhar neste projeto envolverá você escrevendo seu código no Glitch em nosso projeto inicial. Depois de concluir este projeto, você pode copiar sua URL de falha pública (para a página inicial do seu aplicativo) nesta tela para testá-lo! Opcionalmente, você pode optar por escrever seu projeto em outra plataforma, mas deve estar publicamente visível para nossos testes.
|
||||
iniciar este projeto em Glitch usando <a href='https://glitch.com/#!/import/github/freeCodeCamp/boilerplate-project-urlshortener/' target='_blank'>este link</a> ou clonar <a href='https://github.com/freeCodeCamp/boilerplate-project-urlshortener/'>este repositório</a> no GitHub! Se você usa o Glitch, lembre-se de salvar o link do seu projeto em algum lugar seguro!
|
||||
</section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
|
||||
</section>
|
||||
|
||||
## Tests
|
||||
<section id='tests'>
|
||||
|
||||
```yml
|
||||
tests:
|
||||
- text: Posso passar um URL como parâmetro e receberei um URL abreviado na resposta JSON.
|
||||
testString: ''
|
||||
- text: 'Se eu passar um URL inválido que não segue o formato http://www.example.com válido, a resposta JSON conterá um erro.'
|
||||
testString: ''
|
||||
- text: "Quando visito esse URL encurtado, ele me redireciona para o meu link 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: Chain Middleware para criar um servidor de horário
|
||||
challengeType: 2
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
Middleware pode ser montado em uma rota específica usando <code>app.METHOD(path, middlewareFunction)</code> . O middleware também pode ser encadeado dentro da definição da rota.
|
||||
Veja o seguinte exemplo:
|
||||
<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>
|
||||
Essa abordagem é útil para dividir as operações do servidor em unidades menores. Isso leva a uma estrutura de aplicativo melhor e à possibilidade de reutilizar códigos em locais diferentes. Essa abordagem também pode ser usada para executar alguma validação nos dados. Em cada ponto da pilha de middlewares, você pode bloquear a execução da corrente atual e passar o controle para funções especificamente projetadas para lidar com erros. Ou você pode passar o controle para a próxima rota correspondente, para lidar com casos especiais. Vamos ver como na seção Express avançada.
|
||||
Na rota <code>app.get('/now', ...)</code> uma função de middleware e o manipulador final. Na função middleware você deve adicionar a hora atual ao objeto request na chave <code>req.time</code> . Você pode usar o <code>new Date().toString()</code> . No manipulador, responda com um objeto JSON, usando a estrutura <code>{time: req.time}</code> .
|
||||
Dica: O teste não passará se você não encadear o middleware. Se você montar a função em outro lugar, o teste falhará, mesmo se o resultado da saída estiver correto.
|
||||
</section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
|
||||
</section>
|
||||
|
||||
## Tests
|
||||
<section id='tests'>
|
||||
|
||||
```yml
|
||||
tests:
|
||||
- text: O ponto de extremidade / now deve ter o 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: O ponto final / now deve retornar um tempo que é de +/- 20 segundos a partir de agora
|
||||
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: Obter dados de solicitações de POST
|
||||
challengeType: 2
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
Monte um manipulador POST no caminho <code>/name</code> . É o mesmo caminho de antes. Nós preparamos um formulário no frontpage html. Ele enviará os mesmos dados do exercício 10 (string de consulta). Se o analisador de corpo estiver configurado corretamente, você deverá encontrar os parâmetros no objeto <code>req.body</code> . Dê uma olhada no exemplo usual de biblioteca:
|
||||
<blockquote>route: POST '/library'<br>urlencoded_body: userId=546&bookId=6754 <br>req.body: {userId: '546', bookId: '6754'}</blockquote>
|
||||
Responda com o mesmo objeto JSON de antes: <code>{name: 'firstname lastname'}</code> . Teste se seu endpoint funciona usando o formulário html fornecido na página principal do aplicativo.
|
||||
Dica: Existem vários outros métodos de HTTP além de GET e POST. E por convenção existe uma correspondência entre o verbo http e a operação que você vai executar no servidor. O mapeamento convencional é:
|
||||
POST (às vezes PUT) - Cria um novo recurso usando as informações enviadas com o pedido,
|
||||
GET - Lê um recurso existente sem modificá-lo,
|
||||
PUT ou PATCH (às vezes POST) - Atualiza um recurso usando os dados enviado,
|
||||
DELETE => Excluir um recurso.
|
||||
Existem também alguns outros métodos que são usados para negociar uma conexão com o servidor. Exceto pelo GET, todos os outros métodos listados acima podem ter uma carga útil (ou seja, os dados no corpo da solicitação). O middleware do analisador de corpo também funciona com esses métodos.
|
||||
</section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
|
||||
</section>
|
||||
|
||||
## Tests
|
||||
<section id='tests'>
|
||||
|
||||
```yml
|
||||
tests:
|
||||
- text: 'Teste 1: o endpoint da sua API deve responder com o nome correto'
|
||||
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: 'Teste 2: seu endpoint da API deve responder com o nome correto'
|
||||
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: Obter entrada de parâmetro de consulta do cliente
|
||||
challengeType: 2
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
Outra maneira comum de obter entrada do cliente é codificando os dados após o caminho da rota, usando uma string de consulta. A cadeia de consulta é delimitada por um ponto de interrogação (?) E inclui pares campo = valor. Cada casal é separado por um e comercial (&). O Express pode analisar os dados da cadeia de consulta e preencher o objeto <code>req.query</code> . Alguns caracteres não podem estar em URLs, eles precisam ser codificados em um <a href='https://en.wikipedia.org/wiki/Percent-encoding' target='_blank'>formato diferente</a> antes de você poder enviá-los. Se você usar a API do JavaScript, poderá usar métodos específicos para codificar / decodificar esses caracteres.
|
||||
<blockquote>route_path: '/library'<br>actual_request_URL: '/library?userId=546&bookId=6754' <br>req.query: {userId: '546', bookId: '6754'}</blockquote>
|
||||
Construa um endpoint da API, montado em <code>GET /name</code> . Responda com um documento JSON, tomando a estrutura <code>{ name: 'firstname lastname'}</code> . Os parâmetros de nome e sobrenome devem ser codificados em uma string de consulta, por exemplo, <code>?first=firstname&last=lastname</code> .
|
||||
DICA: No exercício a seguir, vamos receber dados de uma solicitação POST, no mesmo caminho de rota <code>/name</code> . Se você quiser, pode usar o método <code>app.route(path).get(handler).post(handler)</code> . Essa sintaxe permite encadear diferentes manipuladores de verbo na mesma rota de caminho. Você pode economizar um pouco de digitação e ter um código mais limpo.
|
||||
</section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
|
||||
</section>
|
||||
|
||||
## Tests
|
||||
<section id='tests'>
|
||||
|
||||
```yml
|
||||
tests:
|
||||
- text: 'Teste 1: o endpoint da sua API deve responder com o nome correto'
|
||||
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: 'Teste 2: seu ponto de extremidade APi deve responder com o nome correto'
|
||||
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: Obter entrada de parâmetro de rota do cliente
|
||||
challengeType: 2
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
Ao criar uma API, precisamos permitir que os usuários nos comuniquem o que desejam obter de nosso serviço. Por exemplo, se o cliente estiver solicitando informações sobre um usuário armazenado no banco de dados, ele precisará de uma maneira de nos informar em qual usuário está interessado. Uma maneira possível de obter esse resultado é usando parâmetros de rota. Os parâmetros de rota são denominados segmentos da URL, delimitados por barras (/). Cada segmento captura o valor da parte do URL que corresponde à sua posição. Os valores capturados podem ser encontrados no 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>
|
||||
Construa um servidor de eco, montado na rota <code>GET /:word/echo</code> . Responda com um objeto JSON, tomando a estrutura <code>{echo: word}</code> . Você pode encontrar a palavra a ser repetida em <code>req.params.word</code> . Você pode testar sua rota a partir da barra de endereços do seu navegador, visitando algumas rotas correspondentes, por exemplo, your-app-rootpath / freecodecamp / echo
|
||||
</section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
|
||||
</section>
|
||||
|
||||
## Tests
|
||||
<section id='tests'>
|
||||
|
||||
```yml
|
||||
tests:
|
||||
- text: 'Teste 1: seu servidor de eco deve repetir palavras corretamente'
|
||||
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: 'Teste 2: seu servidor de eco deve repetir palavras corretamente'
|
||||
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 um middleware de logger de solicitação de nível raiz
|
||||
challengeType: 2
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
Antes de introduzirmos a função de middleware <code>express.static()</code> . Agora é hora de ver qual middleware é, com mais detalhes. As funções de middleware são funções que levam 3 argumentos: o objeto de solicitação, o objeto de resposta e a próxima função no ciclo de solicitação-resposta do aplicativo. Essas funções executam algum código que pode ter efeitos colaterais no aplicativo e geralmente adicionam informações aos objetos de solicitação ou resposta. Eles também podem terminar o ciclo enviando a resposta, quando alguma condição é atendida. Se eles não enviarem a resposta, quando eles terminarem, iniciarão a execução da próxima função na pilha. Isso é acionado chamando o terceiro argumento em <code>next()</code> . Mais informações na <a href='http://expressjs.com/en/guide/using-middleware.html' target='_blank'>documentação expressa</a> .
|
||||
Veja o seguinte exemplo:
|
||||
<blockquote>function(req, res, next) {<br> console.log("I'm a middleware...");<br> next();<br>}</blockquote>
|
||||
Vamos supor que montamos essa função em uma rota. Quando uma solicitação corresponde à rota, ela exibe a string "Sou um middleware ...". Em seguida, ele executa a próxima função na pilha.
|
||||
Neste exercício, vamos construir um middleware de nível raiz. Como vimos no desafio 4, para montar uma função de middleware no nível da raiz, podemos usar o método <code>app.use(<mware-function>)</code> . Nesse caso, a função será executada para todas as solicitações, mas você também pode definir condições mais específicas. Por exemplo, se você quiser que uma função seja executada apenas para solicitações POST, você pode usar <code>app.post(<mware-function>)</code> . Existem métodos análogos para todos os verbos http (GET, DELETE, PUT,…).
|
||||
Construa um logger simples. Para cada requisição, deve logar no console uma string tomando o seguinte formato: <code>method path - ip</code> . Um exemplo seria: <code>GET /json - ::ffff:127.0.0.1</code> . Observe que há um espaço entre o <code>method</code> e o <code>path</code> e que o traço que separa o <code>path</code> e o <code>ip</code> é cercado por um espaço em ambos os lados. Você pode obter o método de solicitação (verbo http), o caminho de rota relativo e o ip do chamador do objeto de solicitação, usando <code>req.method</code> , <code>req.path</code> e <code>req.ip</code> Lembre-se de chamar <code>next()</code> quando terminar, ou seu servidor ficará preso para sempre. Certifique-se de ter aberto o 'Logs' e veja o que acontece quando chega algum pedido…
|
||||
Dica: o Express avalia funções na ordem em que aparecem no código. Isso também é verdade para o middleware. Se você quer que ele funcione para todas as rotas, ele deve ser montado antes delas.
|
||||
</section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
|
||||
</section>
|
||||
|
||||
## Tests
|
||||
<section id='tests'>
|
||||
|
||||
```yml
|
||||
tests:
|
||||
- text: O middleware do registrador de nível raiz deve estar ativo
|
||||
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: Conheça o console do nó
|
||||
challengeType: 2
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
Durante o processo de desenvolvimento, é importante poder verificar o que está acontecendo em seu código. O nó é apenas um ambiente JavaScript. Como o JavaScript do lado do cliente, você pode usar o console para exibir informações de depuração úteis. Na sua máquina local, você veria a saída do console em um terminal. Na Glitch você pode abrir os logs na parte inferior da tela. Você pode alternar o painel de registro com o botão "Registros" (no canto superior esquerdo, sob o nome do aplicativo).
|
||||
Para começar, basta imprimir o clássico "Hello World" no console. Recomendamos manter o painel de registro aberto enquanto trabalha nesses desafios. Lendo os logs você pode estar ciente da natureza dos erros que podem ocorrer.
|
||||
</section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
Modifique o arquivo <code>myApp.js</code> para registrar "Hello World" no console.
|
||||
</section>
|
||||
|
||||
## Tests
|
||||
<section id='tests'>
|
||||
|
||||
```yml
|
||||
tests:
|
||||
- text: <code>"Hello World"</code> deve estar no console
|
||||
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 um arquivo HTML
|
||||
challengeType: 2
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
Podemos responder com um arquivo usando o método <code>res.sendFile(path)</code> .
|
||||
Você pode colocá-lo dentro do manipulador de rota <code>app.get('/', ...)</code> . Nos bastidores, este método irá definir os cabeçalhos apropriados para instruir o seu navegador sobre como lidar com o arquivo que você deseja enviar, de acordo com o seu tipo. Então ele irá ler e enviar o arquivo. Esse método precisa de um caminho de arquivo absoluto. Recomendamos que você use a variável global do nó <code>__dirname</code> para calcular o caminho.
|
||||
exemplo <code>absolutePath = __dirname + relativePath/file.ext</code> .
|
||||
O arquivo a ser enviado é <code>/views/index.html</code> . Tente "Mostrar ao vivo" seu aplicativo, você deve ver um grande título HTML (e um formulário que usaremos mais tarde ...), sem estilo aplicado.
|
||||
Nota: Você pode editar a solução do desafio anterior ou criar uma nova. Se você criar uma nova solução, lembre-se de que o Express avalia as rotas de cima para baixo. Ele executa o manipulador para o primeiro jogo. Você precisa comentar a solução anterior ou o servidor continuará respondendo com uma string.
|
||||
</section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
|
||||
</section>
|
||||
|
||||
## Tests
|
||||
<section id='tests'>
|
||||
|
||||
```yml
|
||||
tests:
|
||||
- text: Seu aplicativo deve exibir o arquivo 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 em uma rota específica
|
||||
challengeType: 2
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
Enquanto um servidor HTML exibe (você adivinhou!) HTML, uma API exibe dados. Uma API <dfn>REST</dfn> (REpresentational State Transfer) permite a troca de dados de maneira simples, sem a necessidade de os clientes conhecerem detalhes sobre o servidor. O cliente só precisa saber onde o recurso está (a URL) e a ação que deseja executar nele (o verbo). O verbo GET é usado quando você está buscando algumas informações, sem modificar nada. Atualmente, o formato de dados preferencial para mover informações pela Web é o JSON. Simplificando, o JSON é uma maneira conveniente de representar um objeto JavaScript como uma string, para que ele possa ser facilmente transmitido.
|
||||
Vamos criar uma API simples criando uma rota que responda com JSON no caminho <code>/json</code> . Você pode fazer isso normalmente, com o método <code>app.get()</code> . Dentro do manipulador de rota, use o método <code>res.json()</code> , passando um objeto como argumento. Este método fecha o loop de solicitação-resposta, retornando os dados. Nos bastidores, ele converte um objeto JavaScript válido em uma string e, em seguida, define os cabeçalhos apropriados para informar ao seu navegador que você está exibindo JSON e envia os dados de volta. Um objeto válido tem a estrutura usual <code>{key: data}</code> . Os dados podem ser um número, uma string, um objeto aninhado ou uma matriz. Os dados também podem ser uma variável ou o resultado de uma chamada de função; nesse caso, ela será avaliada antes de ser convertida em uma string.
|
||||
Sirva o objeto <code>{"message": "Hello json"}</code> como uma resposta no formato JSON, para as requisições GET para o route <code>/json</code> . Em seguida, aponte seu navegador para seu app-url / json, você deverá ver a mensagem na tela.
|
||||
</section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
|
||||
</section>
|
||||
|
||||
## Tests
|
||||
<section id='tests'>
|
||||
|
||||
```yml
|
||||
tests:
|
||||
- text: 'O endpoint <code>/json</code> deve servir o 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: Ative os recursos estáticos
|
||||
challengeType: 2
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
Um servidor HTML geralmente possui um ou mais diretórios que são acessíveis pelo usuário. Você pode colocar aí os recursos estáticos necessários para sua aplicação (folhas de estilo, scripts, imagens). No Express, você pode colocar em prática essa funcionalidade usando o middleware <code>express.static(path)</code> , em que o parâmetro é o caminho absoluto da pasta que contém os ativos. Se você não sabe o que é um middleware, não se preocupe. Vamos discutir sobre isso mais tarde em detalhes. Basicamente middlewares são funções que interceptam manipuladores de rota, adicionando algum tipo de informação. Um middleware precisa ser montado usando o método <code>app.use(path, middlewareFunction)</code> . O primeiro argumento de caminho é opcional. Se você não passar, o middleware será executado para todas as requisições.
|
||||
Monte o middleware <code>express.static()</code> para todas as solicitações com <code>app.use()</code> . O caminho absoluto para a pasta de recursos é <code>__dirname + /public</code> .
|
||||
Agora, seu aplicativo deve poder exibir uma folha de estilo CSS. De fora a pasta pública aparecerá montada no diretório raiz. Sua primeira página deve parecer um pouco melhor agora!
|
||||
</section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
|
||||
</section>
|
||||
|
||||
## Tests
|
||||
<section id='tests'>
|
||||
|
||||
```yml
|
||||
tests:
|
||||
- text: Seu aplicativo deve exibir arquivos de recursos do diretório <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: Inicie um servidor do Working Express
|
||||
challengeType: 2
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
Nas duas primeiras linhas do arquivo myApp.js você pode ver como é fácil criar um objeto de aplicativo Express. Esse objeto tem vários métodos e aprenderemos muitos deles nesses desafios. Um método fundamental é <code>app.listen(port)</code> . Ele diz ao seu servidor para escutar em uma determinada porta, colocando-o em estado de execução. Você pode vê-lo na parte inferior do arquivo. Ele está dentro dos comentários porque, por motivos de teste, precisamos que o aplicativo esteja em execução em segundo plano. Todo o código que você deseja adicionar vai entre essas duas partes fundamentais. Glitch armazena o número da porta na variável de ambiente <code>process.env.PORT</code> . Seu valor é <code>3000</code> .
|
||||
Vamos servir nossa primeira string! No Express, as rotas levam a seguinte estrutura: <code>app.METHOD(PATH, HANDLER)</code> . MÉTODO é um método http em minúsculas. PATH é um caminho relativo no servidor (pode ser uma string ou até uma expressão regular). HANDLER é uma função que o Express chama quando a rota é correspondida.
|
||||
Manipuladores assumem a <code>function(req, res) {...}</code> form <code>function(req, res) {...}</code> , em que req é o objeto request e res é o objeto response. Por exemplo, o manipulador
|
||||
<blockquote>function(req, res) {<br> res.send('Response String');<br>}</blockquote>
|
||||
servirá a string 'Response String'.
|
||||
Use o método <code>app.get()</code> para exibir a string Hello Express, para solicitações GET correspondentes ao caminho / root. Certifique-se de que seu código funciona observando os registros e, em seguida, veja os resultados no seu navegador, clicando no botão "Mostrar ao vivo" na interface do usuário do Glitch.
|
||||
</section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
|
||||
</section>
|
||||
|
||||
## Tests
|
||||
<section id='tests'>
|
||||
|
||||
```yml
|
||||
tests:
|
||||
- text: Seu aplicativo deve exibir a string "Hello 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: Use o analisador de corpo para analisar solicitações de POST
|
||||
challengeType: 2
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
Além de GET, existe outro verbo http comum, é o POST. POST é o método padrão usado para enviar dados do cliente com formulários HTML. Na convenção REST, o POST é usado para enviar dados para criar novos itens no banco de dados (um novo usuário ou uma nova postagem no blog). Não temos um banco de dados neste projeto, mas vamos aprender como lidar com solicitações POST de qualquer maneira.
|
||||
Nesse tipo de solicitações, os dados não aparecem no URL, eles estão ocultos no corpo da solicitação. Esta é uma parte da solicitação HTML, também chamada de payload. Como o HTML é baseado em texto, mesmo que você não veja os dados, isso não significa que eles sejam secretos. O conteúdo bruto de uma solicitação HTTP POST é mostrado abaixo:
|
||||
<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 você pode ver, o corpo é codificado como a string de consulta. Este é o formato padrão usado pelos formulários HTML. Com o Ajax, também podemos usar JSON para manipular dados com uma estrutura mais complexa. Há também outro tipo de codificação: multipart / form-data. Este é usado para fazer upload de arquivos binários.
|
||||
Neste exercício, usaremos um corpo com codificação de URL.
|
||||
Para analisar os dados provenientes de solicitações POST, você precisa instalar um pacote: o analisador de corpo. Este pacote permite que você use uma série de middleware, que pode decodificar dados em diferentes formatos. Veja os documentos <a href="https://github.com/expressjs/body-parser" target="_blank" >aqui</a> .
|
||||
Instale o módulo body-parser no seu package.json. Em seguida, solicite-o no topo do arquivo. Armazene-o em uma variável chamada bodyParser.
|
||||
O middleware para manipular dados codificados em URL é retornado por <code>bodyParser.urlencoded({extended: false})</code> . <code>extended=false</code> é uma opção de configuração que diz ao analisador para usar a codificação clássica. Ao usá-lo, os valores podem ser apenas strings ou matrizes. A versão estendida permite mais flexibilidade de dados, mas é superada pelo JSON. Passe para <code>app.use()</code> a função retornada pela chamada do método anterior. Como de costume, o middleware deve ser montado antes de todas as rotas que precisam dele.
|
||||
</section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
|
||||
</section>
|
||||
|
||||
## Tests
|
||||
<section id='tests'>
|
||||
|
||||
```yml
|
||||
tests:
|
||||
- text: O middleware 'body-parser' deve 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: Use o arquivo .env
|
||||
challengeType: 2
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
O arquivo <code>.env</code> é um arquivo oculto usado para transmitir variáveis de ambiente ao seu aplicativo. Este arquivo é secreto, ninguém além de você pode acessá-lo e pode ser usado para armazenar dados que você deseja manter privados ou ocultos. Por exemplo, você pode armazenar chaves de API de serviços externos ou do URI do seu banco de dados. Você também pode usá-lo para armazenar opções de configuração. Ao definir opções de configuração, você pode alterar o comportamento do seu aplicativo, sem a necessidade de reescrever algum código.
|
||||
As variáveis de ambiente podem ser acessadas no aplicativo como <code>process.env.VAR_NAME</code> . O objeto <code>process.env</code> é um objeto Node global e as variáveis são passadas como strings. Por convenção, os nomes das variáveis são todos em maiúsculas, com palavras separadas por um sublinhado. O <code>.env</code> é um arquivo de shell, portanto, você não precisa <code>.env</code> nomes ou valores entre aspas. Também é importante observar que não pode haver espaço ao redor do sinal de igual quando você está atribuindo valores às suas variáveis, por exemplo, <code>VAR_NAME=value</code> . Normalmente, você irá colocar cada definição de variável em uma linha separada.
|
||||
Vamos adicionar uma variável de ambiente como uma opção de configuração. Armazene a variável <code>MESSAGE_STYLE=uppercase</code> no arquivo <code>.env</code> . Em seguida, informe ao manipulador de rota GET <code>/json</code> que você criou no último desafio para transformar a mensagem do objeto de resposta em maiúsculas, se <code>process.env.MESSAGE_STYLE</code> for igual a <code>uppercase</code> . O objeto de resposta deve se tornar <code>{"message": "HELLO JSON"}</code> .
|
||||
</section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
|
||||
</section>
|
||||
|
||||
## Tests
|
||||
<section id='tests'>
|
||||
|
||||
```yml
|
||||
tests:
|
||||
- text: A resposta do nó de extremidade <code>/json</code> deve mudar de acordo com a variável de ambiente <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: Adicione uma descrição ao seu pacote.json
|
||||
challengeType: 2
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
A próxima parte de um bom pacote.json é o campo de descrição, onde uma descrição curta, mas informativa, sobre o seu projeto pertence.
|
||||
Se algum dia você planeja publicar um pacote para npm, lembre-se de que essa é a string que deve vender sua ideia ao usuário quando ele decidir se instala seu pacote ou não. No entanto, esse não é o único caso de uso para a descrição: é uma ótima maneira de resumir o que um projeto faz, tão importante para seus projetos normais do Node.js ajudar outros desenvolvedores, futuros mantenedores ou até mesmo seu futuro a entender o projeto rapidamente.
|
||||
Independentemente do que você planeja para o seu projeto, uma descrição é definitivamente recomendada. Vamos adicionar algo semelhante a isto:
|
||||
<code>"description": "A project that does something awesome",</code>
|
||||
Instruções
|
||||
Adicione uma descrição ao package.json em seu projeto Glitch.
|
||||
Lembre-se de usar aspas duplas para nomes de campos (") e vírgulas (,) para separar campos.
|
||||
</section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
|
||||
</section>
|
||||
|
||||
## Tests
|
||||
<section id='tests'>
|
||||
|
||||
```yml
|
||||
tests:
|
||||
- text: 'package.json deve ter uma chave de "descrição" 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: Adicione uma licença ao seu pacote.json
|
||||
challengeType: 2
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
O campo de licença é onde você informa aos usuários do seu projeto o que eles podem fazer com ele.
|
||||
Algumas licenças comuns para projetos de código aberto incluem o MIT e o BSD. http://choosealicense.com é um ótimo recurso se você quiser saber mais sobre qual licença pode se encaixar em seu projeto.
|
||||
Informações de licença não são necessárias. As leis de direitos autorais na maioria dos países dão a você a propriedade do que você cria por padrão. No entanto, é sempre uma boa prática declarar explicitamente o que os usuários podem e não podem fazer.
|
||||
Exemplo
|
||||
<code>"license": "MIT",</code>
|
||||
Instruções
|
||||
Preencha o campo de licença no package.json do seu projeto Glitch conforme achar conveniente.
|
||||
</section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
|
||||
</section>
|
||||
|
||||
## Tests
|
||||
<section id='tests'>
|
||||
|
||||
```yml
|
||||
tests:
|
||||
- text: 'package.json deve ter uma chave de "licença" 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: Adicione uma versão ao seu pacote.json
|
||||
challengeType: 2
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
A versão é junto com o nome de um dos campos obrigatórios em um package.json. Este campo descreve a versão atual do seu projeto.
|
||||
Exemplo
|
||||
<code>"version": "1.2",</code>
|
||||
Instruções
|
||||
Adicione uma versão ao pacote.json no seu projeto Glitch.
|
||||
</section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
|
||||
</section>
|
||||
|
||||
## Tests
|
||||
<section id='tests'>
|
||||
|
||||
```yml
|
||||
tests:
|
||||
- text: 'package.json deve ter uma chave "version" 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: Adicione palavras-chave ao seu pacote.json
|
||||
challengeType: 2
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
O campo de palavras-chave é onde você pode descrever seu projeto usando palavras-chave relacionadas.
|
||||
Exemplo
|
||||
<code>"keywords": [ "descriptive", "related", "words" ],</code>
|
||||
Como você pode ver, este campo é estruturado como um array de strings com aspas duplas.
|
||||
Instruções
|
||||
Adicione uma matriz de strings adequadas ao campo keywords no package.json do seu projeto Glitch.
|
||||
Uma das palavras-chave deve ser freecodecamp.
|
||||
</section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
|
||||
</section>
|
||||
|
||||
## Tests
|
||||
<section id='tests'>
|
||||
|
||||
```yml
|
||||
tests:
|
||||
- text: 'package.json deve ter uma chave "keywords" 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: 'palavras-chave campo deve ser uma 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: '"palavras-chave" devem 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 seu projeto com pacotes externos do npm
|
||||
challengeType: 2
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
Um dos maiores motivos para usar um gerenciador de pacotes é seu poderoso gerenciamento de dependências. Em vez de ter que certificar-se de que você obtém todas as dependências manualmente sempre que você configura um projeto em um novo computador, o npm instala automaticamente tudo para você. Mas como pode o npm saber exatamente o que seu projeto precisa? Conheça a seção de dependências do seu package.json.
|
||||
Na seção dependencies, os pacotes que o seu projeto requer são armazenados usando o seguinte formato:
|
||||
<code>"dependencies": {</code>
|
||||
<code>"package-name": "version",</code>
|
||||
<code>"express": "4.14.0"</code>
|
||||
<code>}</code>
|
||||
Instruções
|
||||
Adicione a versão 2.14.0 do momento do pacote ao campo dependencies do seu pacote.json
|
||||
Moment é uma biblioteca útil para trabalhar com hora e datas.
|
||||
</section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
|
||||
</section>
|
||||
|
||||
## Tests
|
||||
<section id='tests'>
|
||||
|
||||
```yml
|
||||
tests:
|
||||
- text: "dependências devem 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: 'A versão "momento" deve 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: 'Como usar o package.json, o Core de qualquer projeto Node.js ou npm Package'
|
||||
challengeType: 2
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
O arquivo package.json é o centro de qualquer projeto Node.js ou pacote npm. Ele armazena informações sobre seu projeto da mesma forma que a seção <head> em um documento HTML descreve o conteúdo de uma página da Web. O pacote.json consiste em um único objeto JSON, onde as informações são armazenadas em "chave": pares de valores. Existem apenas dois campos obrigatórios em um pacote mínimo.json - nome e versão - mas é uma boa prática fornecer informações adicionais sobre o seu projeto que podem ser úteis para futuros usuários ou mantenedores.
|
||||
O autor-campo
|
||||
Se você for ao projeto Glitch que você configurou anteriormente e olhar no lado esquerdo da sua tela, você encontrará a árvore de arquivos onde você pode ver uma visão geral dos vários arquivos em seu projeto. Sob a seção de back-end da árvore de arquivos, você encontrará o pacote.json - o arquivo que estaremos aprimorando nos próximos desafios.
|
||||
Uma das informações mais comuns neste arquivo é o autor-campo que especifica quem é o criador de um projeto. Pode ser uma string ou um objeto com detalhes de contato. O objeto é recomendado para projetos maiores, mas no nosso caso, uma string simples como o exemplo a seguir serve.
|
||||
<code>"author": "Jane Doe",</code>
|
||||
Instruções
|
||||
Adicione seu nome ao autor-campo no package.json do seu projeto Glitch.
|
||||
Lembre-se que você está escrevendo JSON.
|
||||
Todos os nomes de campos devem usar aspas duplas ("), por exemplo," autor "
|
||||
Todos os campos devem ser separados por uma vírgula (,)
|
||||
</section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
|
||||
</section>
|
||||
|
||||
## Tests
|
||||
<section id='tests'>
|
||||
|
||||
```yml
|
||||
tests:
|
||||
- text: 'package.json deve ter uma chave "author" 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: Gerenciar Dependências do npm Entendendo o Versionamento Semântico
|
||||
challengeType: 2
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
Versões dos pacotes npm na seção de dependências do seu package.json seguem o que é chamado de Semântica, um padrão da indústria para versionamento de software com o objetivo de facilitar o gerenciamento de dependências. Bibliotecas, estruturas ou outras ferramentas publicadas no npm devem usar o SemVer para comunicar claramente que tipo de mudanças os projetos que dependem do pacote podem esperar se atualizarem.
|
||||
SemVer não faz sentido em projetos sem APIs públicas - portanto, a menos que seu projeto seja semelhante aos exemplos acima, use outro formato de versão.
|
||||
Então, por que você precisa entender a SemVer?
|
||||
Saber SemVer pode ser útil quando você desenvolve softwares que usam dependências externas (o que você quase sempre faz). Um dia, a sua compreensão desses números evitará que você introduza acidentalmente alterações inesperadas em seu projeto sem entender por que as coisas “que funcionaram ontem” de repente não o fazem.
|
||||
É assim que o Versioning Semântico funciona de acordo com o site oficial:
|
||||
Dado um número de versão MAJOR.MINOR.PATCH, incremente a:
|
||||
versão MAJOR quando você faz alterações incompatíveis de API, versão
|
||||
MINOR quando adiciona funcionalidade de maneira compatível com versões anteriores e
|
||||
versão PATCH quando você faz correções de bugs compatíveis com versões anteriores.
|
||||
Isso significa que os PATCHES são correções de bugs e os MINORs adicionam novos recursos, mas nenhum deles quebra o que funcionou antes. Finalmente, os MAJORs adicionam alterações que não funcionam com versões anteriores.
|
||||
Exemplo
|
||||
Um número de versão semântica: 1.3.8
|
||||
Instruções
|
||||
Na seção dependencies do seu pacote.json, altere a versão do momento para coincidir com MAJOR versão 2, MINOR versão 10 e PATCH versão 2
|
||||
</section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
|
||||
</section>
|
||||
|
||||
## Tests
|
||||
<section id='tests'>
|
||||
|
||||
```yml
|
||||
tests:
|
||||
- text: "dependências devem 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: 'A versão "momento" deve 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: Remover um pacote de suas dependências
|
||||
challengeType: 2
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
Agora você testou algumas maneiras de gerenciar dependências do seu projeto usando a seção de dependências do package.json. Você incluiu pacotes externos adicionando-os ao arquivo e até informou ao npm que tipos de versões você deseja usando caracteres especiais como o til (~) ou o cursor (^).
|
||||
Mas e se você quiser remover um pacote externo que não precisa mais? Você já deve ter adivinhado - Apenas remova a "chave" correspondente: par de valores para isso de suas dependências.
|
||||
Esse mesmo método se aplica à remoção de outros campos no seu package.json também
|
||||
Instruções
|
||||
Remova o momento do pacote de suas dependências.
|
||||
Verifique se você tem a quantidade certa de vírgulas depois de removê-lo.
|
||||
</section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
|
||||
</section>
|
||||
|
||||
## Tests
|
||||
<section id='tests'>
|
||||
|
||||
```yml
|
||||
tests:
|
||||
- text: "'dependências' não devem 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 o Caret Caret para usar a última versão menor de uma dependência
|
||||
challengeType: 2
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
Semelhante ao modo como o til (~) que aprendemos no último desafio permite que o npm instale o último PATCH para uma dependência, o cursor (^) também permite que o npm instale atualizações futuras. A diferença é que o cursor permite tanto atualizações MINORIS quanto PATCHES.
|
||||
No momento, sua versão atual do momento deve ser ~ 2.10.2, que permite que o npm seja instalado na última versão 2.10.x. Se, em vez disso, usássemos o cursor (^) como nosso prefixo de versão, o npm teria permissão para atualizar para qualquer versão 2.xx.
|
||||
Exemplo
|
||||
<code>"some-package-name": "^1.3.8" allows updates to any 1.xx version.</code>
|
||||
Instruções
|
||||
Use o caractere de interpolação (^) para prefixar a versão do momento em suas dependências e permitir que o npm a atualize para qualquer nova versão MINOR.
|
||||
Observe que os números da versão não devem ser alterados.
|
||||
</section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
|
||||
</section>
|
||||
|
||||
## Tests
|
||||
<section id='tests'>
|
||||
|
||||
```yml
|
||||
tests:
|
||||
- text: "'dependências' devem 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: 'A versão "momento" deve corresponder a "^ 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 o caractere Tilde para sempre usar a versão de patch mais recente de uma dependência
|
||||
challengeType: 2
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
No último desafio, dissemos ao npm para incluir apenas uma versão específica de um pacote. Essa é uma maneira útil de congelar suas dependências se você precisar garantir que partes diferentes do seu projeto permaneçam compatíveis umas com as outras. Mas, na maioria dos casos de uso, você não quer perder correções de bugs, pois elas geralmente incluem patches de segurança importantes e (espero) não quebram as coisas ao fazê-lo.
|
||||
Para permitir que uma dependência npm seja atualizada para a versão PATCH mais recente, você pode prefixar a versão da dependência com o caractere til (~). Em package.json, nossa regra atual de como o npm pode atualizar o momento é usar apenas uma versão específica (2.10.2), mas queremos permitir a última versão 2.10.x.
|
||||
Exemplo
|
||||
<code>"some-package-name": "~1.3.8" allows updates to any 1.3.x version.</code>
|
||||
Instruções
|
||||
Use o til (~) para prefixar a versão do momento em suas dependências e permitir que o npm o atualize para qualquer nova versão do PATCH.
|
||||
Observe que os números da versão não devem ser alterados.
|
||||
</section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
|
||||
</section>
|
||||
|
||||
## Tests
|
||||
<section id='tests'>
|
||||
|
||||
```yml
|
||||
tests:
|
||||
- text: "'dependências' devem 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: 'A versão "momento" deve corresponder a "~ 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: Auxiliares de consulta de pesquisa em cadeia para restringir os resultados da pesquisa
|
||||
challengeType: 2
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
Se você não passar o retorno de chamada como o último argumento para Model.find () (ou para os outros métodos de pesquisa), a consulta não será executada. Você pode armazenar a consulta em uma variável para uso posterior. Esse tipo de objeto permite que você crie uma consulta usando a sintaxe de encadeamento. A pesquisa real do banco de dados é executada quando você encadeia o método .exec (). Passe seu retorno de chamada para este último método. Existem muitos helpers de consulta, aqui usaremos os mais "famosos".
|
||||
Encontre pessoas que gostam de "burrito". Ordena-os pelo nome, limita os resultados a dois documentos e oculta a idade. Cadeia .find (), .sort (), .limit (), .select () e, em seguida, .exec (). Passe o retorno de chamada concluído (err, data) para exec ().
|
||||
</section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
|
||||
</section>
|
||||
|
||||
## Tests
|
||||
<section id='tests'>
|
||||
|
||||
```yml
|
||||
tests:
|
||||
- text: Encadeamento de helpers de consulta deve ser bem-sucedido
|
||||
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: Crie um modelo
|
||||
challengeType: 2
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
Primeiro de tudo, precisamos de um esquema. Cada esquema mapeia para uma coleção do MongoDB. Ele define a forma dos documentos dentro dessa coleção.
|
||||
Esquemas são blocos de construção para modelos. Eles podem ser aninhados para criar modelos complexos, mas, nesse caso, manteremos as coisas simples.
|
||||
Um modelo permite criar instâncias de seus objetos, chamados documentos.
|
||||
Crie uma pessoa com este protótipo:
|
||||
<code>- Person Prototype -</code>
|
||||
<code>--------------------</code>
|
||||
<code>name : string [required]</code>
|
||||
<code>age : number</code>
|
||||
<code>favoriteFoods : array of strings (*)</code>
|
||||
Use os tipos básicos de esquema do mangusto. Se desejar, você também pode adicionar mais
|
||||
campos, usar validadores simples, como obrigatório ou exclusivo,
|
||||
e definir valores padrão. Veja o <a href='http://mongoosejs.com/docs/guide.html'>mangusto docs</a> .
|
||||
[C] RUD Parte I - CREATE
|
||||
Nota: Glitch é um servidor real, e em servidores reais as interações com o banco de dados acontecem nas funções do manipulador. Essas funções são executadas quando algum evento acontece (por exemplo, alguém atinge um endpoint em sua API). Vamos seguir a mesma abordagem nesses exercícios. A função done () é um retorno de chamada que nos informa que podemos prosseguir após concluir uma operação assíncrona, como inserir, pesquisar, atualizar ou excluir. Está seguindo a convenção do Nó e deve ser chamado como concluído (nulo, dados) em sucesso, ou concluído (err) em erro.
|
||||
Aviso - Ao interagir com serviços remotos, podem ocorrer erros!
|
||||
<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: Criar uma instância de um esquema de mongoose deve ser bem-sucedido
|
||||
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: Criar e salvar um registro de um modelo
|
||||
challengeType: 2
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
Crie uma instância de documento usando o construtor Person que você construiu antes. Passe para o construtor um objeto com os campos name, age e favoriteFoods. Seus tipos devem estar em conformidade com os do esquema pessoal. Em seguida, chame o método document.save () na instância do documento retornado. Passe para ele um retorno de chamada usando a convenção Node. Esse é um padrão comum, todos os métodos CRUD a seguir assumem uma função de retorno de chamada como o ú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: Criar e salvar um item do banco de dados deve ser bem-sucedido
|
||||
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: Crie muitos registros com model.create ()
|
||||
challengeType: 2
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
Às vezes, você precisa criar muitas instâncias de seus modelos, por exemplo, ao criar um banco de dados com dados iniciais. Model.create () pega uma matriz de objetos como [{name: 'John', ...}, {...}, ...] como o primeiro argumento e salva todos eles no banco de dados. Crie muitas pessoas com Model.create (), usando o argumento da função arrayOfPeople.
|
||||
</section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
|
||||
</section>
|
||||
|
||||
## Tests
|
||||
<section id='tests'>
|
||||
|
||||
```yml
|
||||
tests:
|
||||
- text: Criar muitos itens de banco de dados de uma só vez deve ser bem-sucedido
|
||||
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: Excluir muitos documentos com model.remove ()
|
||||
challengeType: 2
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
Model.remove () é útil para excluir todos os documentos que correspondem a determinados critérios. Exclua todas as pessoas cujo nome é "Mary", usando Model.remove (). Passe-o para um documento de consulta com o conjunto de campos “nome” e, claro, um retorno de chamada.
|
||||
Nota: Model.remove () não retorna o documento excluído, mas um objeto JSON contendo o resultado da operação e o número de itens afetados. Não esqueça de passá-lo para o callback done (), já que o usamos em testes.
|
||||
</section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
|
||||
</section>
|
||||
|
||||
## Tests
|
||||
<section id='tests'>
|
||||
|
||||
```yml
|
||||
tests:
|
||||
- text: A exclusão de muitos itens de uma só vez deve ser bem-sucedida
|
||||
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: Excluir um documento usando model.findByIdAndRemove
|
||||
challengeType: 2
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
Excluir uma pessoa por ela _id. Você deve usar um dos métodos findByIdAndRemove () ou findOneAndRemove (). Eles são como os métodos de atualização anteriores. Eles passam o documento removido para o cb. Como de costume, use o argumento da função personId como chave de busca.
|
||||
</section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
|
||||
</section>
|
||||
|
||||
## Tests
|
||||
<section id='tests'>
|
||||
|
||||
```yml
|
||||
tests:
|
||||
- text: A exclusão de um item deve ser bem-sucedida
|
||||
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 e configurar o mangusto
|
||||
challengeType: 2
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
Adicione mongodb e mangusto ao package.json do projeto. Então exija mangusto. Armazene seu URI do banco de dados mLab no arquivo .env privado como MONGO_URI. Conecte-se ao banco de dados usando mongoose.connect ( <Your URI> )
|
||||
</section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
|
||||
</section>
|
||||
|
||||
## Tests
|
||||
<section id='tests'>
|
||||
|
||||
```yml
|
||||
tests:
|
||||
- text: "'mongodb' dependência deve estar em 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: "'mongoose' dependência deve estar em 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: "'mangusto' deve ser conectado a um banco de dados"
|
||||
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: 'Executar atualizações clássicas executando Localizar, editar e salvar'
|
||||
challengeType: 2
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
Nos bons e velhos tempos isso era o que você precisava fazer se quisesse editar um documento e ser capaz de usá-lo de alguma forma, por exemplo, enviando-o de volta em uma resposta do servidor. O Mongoose possui um método de atualização dedicado: Model.update (). Ele é vinculado ao driver mongo de baixo nível. Ele pode editar em massa muitos documentos que atendem a determinados critérios, mas não envia de volta o documento atualizado, apenas uma mensagem de 'status'. Além disso, dificulta a validação de modelos, porque apenas chama diretamente o driver mongo.
|
||||
Encontre uma pessoa por _id (use qualquer um dos métodos acima) com o parâmetro personId como chave de busca. Adicione "hamburger" à lista de seus favoriteFoods (você pode usar Array.push ()). Então - dentro do callback de busca - salve () a Pessoa atualizada.
|
||||
[*] Dica: Isso pode ser complicado se no seu Schema você declarar favoriteFoods como Array, sem especificar o tipo (ie [String]). Em que casefavoriteFoods padrão para o tipo misto, e você tem que marcá-lo manualmente como editado usando document.markModified ('edited-field'). (http://mongoosejs.com/docs/schematypes.html - #Mixed)
|
||||
</section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
|
||||
</section>
|
||||
|
||||
## Tests
|
||||
<section id='tests'>
|
||||
|
||||
```yml
|
||||
tests:
|
||||
- text: Localizar-editar-atualizar um item deve ser bem-sucedido
|
||||
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: Executar novas atualizações em um documento usando model.findOneAndUpdate ()
|
||||
challengeType: 2
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
Versões recentes do mongoose possuem métodos para simplificar a atualização de documentos. Alguns recursos mais avançados (isto é, ganchos de pré / pós, validação) se comportam de maneira diferente com essa abordagem, portanto, o método Clássico ainda é útil em muitas situações. findByIdAndUpdate () pode ser usado ao pesquisar por Id.
|
||||
Encontre uma pessoa por Nome e defina sua idade como 20. Use o parâmetro de função personName como chave de pesquisa.
|
||||
Dica: queremos que você devolva o documento atualizado. Para fazer isso, você precisa passar o documento de opções {new: true} como o terceiro argumento para findOneAndUpdate (). Por padrão, esses métodos retornam o objeto não modificado.
|
||||
</section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
|
||||
</section>
|
||||
|
||||
## Tests
|
||||
<section id='tests'>
|
||||
|
||||
```yml
|
||||
tests:
|
||||
- text: findOneAndUpdate um item deve ter sucesso
|
||||
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: Use model.find () para pesquisar seu banco de dados
|
||||
challengeType: 2
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
Encontre todas as pessoas que possuem um determinado nome, usando Model.find () -> [Person]
|
||||
Em seu uso mais simples, Model.find () aceita um documento de consulta (um objeto JSON) como o primeiro argumento e, em seguida, um retorno de chamada. Ele retorna uma matriz de correspondências. Suporta uma gama extremamente ampla de opções de pesquisa. Verifique nos documentos. Use o argumento de função personName como chave de pesquisa.
|
||||
</section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
|
||||
</section>
|
||||
|
||||
## Tests
|
||||
<section id='tests'>
|
||||
|
||||
```yml
|
||||
tests:
|
||||
- text: Encontrar todos os itens correspondentes a um critério devem ser bem sucedidos
|
||||
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 pesquisar seu banco de dados por _id
|
||||
challengeType: 2
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
Ao salvar um documento, o mongodb adiciona automaticamente o campo _id e o configura para uma chave alfanumérica exclusiva. Pesquisar por _id é uma operação extremamente frequente, então o mangusto fornece um método dedicado para isso. Encontre a pessoa (somente !!) tendo um determinado _id, usando Model.findById () -> Person. Use o argumento da função personId como chave de busca.
|
||||
</section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
|
||||
</section>
|
||||
|
||||
## Tests
|
||||
<section id='tests'>
|
||||
|
||||
```yml
|
||||
tests:
|
||||
- text: Encontrar um item por Id deve ter sucesso
|
||||
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 retornar um único documento correspondente do seu banco de dados
|
||||
challengeType: 2
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
Model.findOne () se comporta como .find (), mas retorna apenas um documento (não uma matriz), mesmo se houver vários itens. É especialmente útil ao pesquisar por propriedades que você declarou como exclusivas. Encontre apenas uma pessoa que tenha uma certa comida em seus favoritos, usando Model.findOne () -> Person. Use o argumento de função food como chave de busca.
|
||||
</section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
|
||||
</section>
|
||||
|
||||
## Tests
|
||||
<section id='tests'>
|
||||
|
||||
```yml
|
||||
tests:
|
||||
- text: Encontrar um item deve ser bem sucedido
|
||||
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