text
stringlengths 2
104M
| meta
dict |
|---|---|
# Nodejs - Aula 01 - Exercício
autor: Ricardo Pereira
## Explique como um processo síncrono e assíncrono roda no Node.js, de um exemplo para cada.
Síncrono: O processo síncrono bloquea o node de executar qualquer outro codigo até o mesmo estar concluído. Síncrono é bloqueante para I/O.
Assíncrono: Executa todo o codigo parelamente as chamadas de I/O, nao-bloqueantes.
Exemplo Síncrono:
```
var fs = require('fs');
for(var i = 0; i < 10; i++){
fs.readFileSync('./mean.txt', 'utf8', callback);
}
```
Exemplo Assíncrono:
```
var fs = require('fs');
for(var i = 0; i < 10; i++){
fs.readFile('./mean.txt', (err, data) => {
console.log(data);
});
}
```
## Como o V8 executa Javascript? Demonstre 1 exemplo com o código ou imagem.
Ele interpreta o código javascript como uma maquina virtual e transforma em código de máquina.
Exemplo:
```
svn co http://v8.googlecode.com/svn/trunk v8-trunk
cd v8-trunk
scons
g++ ./samples/shell.cc -o v8-shell -I include libv8.a
./v8-shell
V8 version 2.0.2
> var x = 10;
> x
10
> function foo(x) { return x * x; }
> foo
function foo(x) { return x * x; }
> quit()
./v8-shell -e 'print("10*10 = " + 10*10)'
10*10 = 100
```
## Qual a diferenca entre um sistema single para um multi-thread?
Single-thread tem a instancia de um único processo.
Multi-tread tem varias instancias rodando em paralelo, conhecido como programacao concorrente.
## Como a tread pool tem um tamanho de padrao 4, o que acontece se voce enviar 5 requisicoes para o banco
Ela se torna uma Idle-thread que é pre-executada e fica aguardando a task.
## Como voce venderia o peixe do Nodejs na sua empresa para tentar convencer seu chefe da sua adocao?
Comecava a explicar o basico da historia do node e mostraria os problemas de outras ferramentas que o node resolve.
Apresentava alguns cases de sucessos e a economia que isso pôde gerar para empresa com servidores.
Logo em seguida faria uma abordagem da linha de aprendizagem do Nodejs e principalmente mostraria que poderiamos usar uma única linguagem para Back-end e Front-end.
Uma comunidade muita ativa e todas os modulos que ja estao disponiveis para serem utilizados e as empresas de servidores que possuim APIS para nodejs.
## Qual a versao do seu node
MacBook-Pro-de-Ricardo:~ ricardo$ node -v
v5.6.0
## Qual a versao do sua npm
MacBook-Pro-de-Ricardo:~ ricardo$ npm -v
3.6.0 | {
"repo_name": "Webschool-io/be-mean-instagram-nodejs-exercises",
"stars": "33",
"repo_language": "JavaScript",
"file_name": "index.jade",
"mime_type": "text/plain"
} |
# Node.js - Aula 01 - Exercício
**user:** [carloshenriqueribeiro](https://github.com/carloshenriqueribeiro)
**autor:** Carlos Henrique Oliveira Ribeiro
**date:** 2017-07-31T14:40:00
##1. Explique como um processo síncrono e assíncrono roda no Node.js, dê um exemplo para cada.
De forma geral um processamento síncrono é uma fila única de processos, ou seja, um novo processo só começa quando o atual termina.
Já no processamento assíncrono não existe essa fila única, após responder a requisição de um processo o mesmo se inicia e o próximo já é atendido e iniciada execução, trazendo ganhos enormes de desempenho e eficiência. Para que seja gerenciado o termino dos processos, que não vai ocorrer na mesma ordem que foram iniciados, cada processo possui um callback que ao terminar o dispara, seu término é tratado como se deve e é dada continuidade ao processos.
O Noje.js é por padrão assíncrono, sendo assim as funções que terminam com o sufíxo "Sync" são as funções **síncronas** e as funções que ocultam o sufíxo, são funções **assíncronas**.
Abaixo exemplos de uma execução síncrona e uma assíncrona de leitura de arquivos.
**Síncrona:**
```js
var fs = require('fs');
var conteudo = fs.readFileSync('./arq.txt', "utf8");
console.log(conteudo);
console.log('Leitura do primeiro arquivo terminou');
console.log('Ler próximo arquivo');
```
Retorno da execução:
> "1. Primeira linha do primeiro arquivo"
> "2. Segunda linha do primeiro arquivo"
> "3. Terceira linha do primeiro arquivo"
> "4. Quarta linha do primeiro arquivo"
> "Leitura do primeiro arquivo terminou"
> "Ler próximo arquivo"
**Assíncrona**
```js
'use strict'
var fs = require('fs');
fs.readFile('./index.txt',(err, result) => { //err e result são os callbacks de falha e sucesso, respectivamente
if(err) console.log(err);
console.log(result.toString());
console.log('Leitura do primeiro arquivo terminou');
})
console.log('Ler próximo arquivo');
```
Retorno da execução:
> "Ler próximo arquivo"
> "1. Primeira linha do primeiro arquivo"
> "2. Segunda linha do primeiro arquivo"
> "3. Terceira linha do primeiro arquivo"
> "4. Quarta linha do primeiro arquivo"
> "Leitura do primeiro arquivo terminou"
Como foi possível notar, na execução síncrona só foi iniciada a leitura do próximo arquivo após acabar a leitura do primeiro, já na assícrona a leitura do próximo arquivo foi iniciada antes mesmo da leitura de cada linha do primeiro.
##2. Como o V8 executa JavaScript? Demonstre 1 exemplo com código ou imagem.
- Quando V8 recebe o código em JavaScript, ele o analisa para criar árvore de sintaxe abstrata **(AST - Abstract Syntax Tree)**, uma espécie de preparação para o gerador de byte code.
- Em seguida, a AST é alimentado no gerador de byte code para produzir byte code.
- O ambiente de execução V8 então interpreta esse byte code e com a ajuda de um compilador JIT (Just-In-Time) produz o código de máquina nativo que é executado.
Na imagem abaixo confira o fluxograma desse funcionamento:
##3. Qual a diferença entre um sistema single para um multi-thread?
Thread e tarefas são a mesma coisa!
Uma thread é a divisão do processo principal de um programa representado por uma linha de instrução que o processador deverá executar.
Um sistema `single-thread` executa uma thread em um único processo. Dessa forma, é necessário esperar o termino de uma tarefa para executar outra.
Um sistema `multi-thread` possui várias threads para cada processo, podendo realiza-las simultaneamente.
##4. Como a Thread Pool tem um tamanho padrão de 4, o que acontece se você enviar 5 requisições ao banco?
A quinta requisição fica aguardando, na "Task Queue", uma das quatro primeiras terminar para entrar na `Thread Pool`.
##5. Como você venderia o peixe do Node.js na sua empresa para tentar convencer seu chefe da sua adoção?
- Necessita de bem menos investimento em hardware por ser muito mais eficiente que seus concorrentes.
- Possui Inúmeras biblicotecas open-source e mais sendo criada a cada dia, eliminando custos com software.
- O NodeJS é em linguagem JavaScript que é um linguagem muito bem difundida e conhecida pela comunidade.
- É uma plataforma extremamente eficiente, possui bibliotecas assíncronas, que com investimento em hardware muito baixo em relação a concorrentes pode atender a milhões de requisioções
##6. Qual a versão do seu `node`?
> $ node -v
> v7.7.4
##7. Qual a versão do seu `npm`?
> $ npm -v
> 4.1.2
| {
"repo_name": "Webschool-io/be-mean-instagram-nodejs-exercises",
"stars": "33",
"repo_language": "JavaScript",
"file_name": "index.jade",
"mime_type": "text/plain"
} |
# Node.js - Aula 01 - Exercício
**user:** [yesroh](https://github.com/yesroh)
**autor:** Ronaiza Cardoso
**date:** 1469727485264
## Explique como um processo síncrono e assíncrono roda no Node.js, dê um exemplo para cada.
O processo síncrono espera a resposta de cada operação, não realizando nenhuma outra operação enquanto não recebe tal resposata.
```js
// Código Síncrono
fs.writeFileSync('arquivo.txt', 'Hello World');
console.log('Executa a função síncrona');
```
Enquanto o processo assíncrono executa várias tarefas nunca esperando a resposta da operação.
```js
// Código Assíncrono
fs.writeFile('arquivo.txt', 'Hello World', function(error){
console.log('Executa a função Assíncrona');
});
```
## Como o V8 executa JavaScript? Demonstre 1 exemplo com código ou imagem.
Google criou o V8 (interpretador escrito em C++) para criar classes escondidas e assim executar o JS
[Processo de execução V8](https://www.future-processing.pl/wp-content/uploads/2015/04/threads-in-node.ja_.png)
## Qual a diferença entre um sistema single para um multi-thread?
- single-thread não esperam um bloqueio síncrono ou uma operação de longa duração
- multi-thread colocam os eventos na fila
## Como a Thread Pool tem um tamanho padrão de 4, o que acontece se você enviar 5 requisições ao banco?
Ela aguarda até que uma thread seja liberada, enquanto isso ela ficará na idle thread esperando sua vez para ser executada
## Como você venderia o peixe do Node.js na sua empresa para tentar convencer seu chefe da sua adoção?
Faria uma apresentação com os case de sucesso com a susbtituição do node pelos servidores que a minha empresa usa.
## Qual a versão do seu `node`?
```js
~$ node -v
v4.4.7
```
## Qual a versão do seu `npm`?
```js
~$ npm -v
2.15.8
``` | {
"repo_name": "Webschool-io/be-mean-instagram-nodejs-exercises",
"stars": "33",
"repo_language": "JavaScript",
"file_name": "index.jade",
"mime_type": "text/plain"
} |
# Node.js - Aula 01 - Exercício
**Autor:** Wendell Adriel Luiz Silva - [WendellAdriel](https://github.com/WendellAdriel)
**Data:** 1454965303866
## Explique como um processo síncrono e assíncrono roda no Node.js, dê um exemplo para cada.
- **Processo Síncrono:** Um processo síncrono mantém uma única fila de processos, sendo necessário terminar um processo
antes de se iniciar outro. Exemplo:
```js
var fs = require('fs');
// Faz leitura do primeiro arquivo por completo e escreve no console
var greeting = fs.readFileSync('./greeting.txt', 'utf8');
console.log(greeting);
// Faz leitura do segundo arquivo por completo e escreve no console
var hello = fs.readFileSync('./hello.txt', 'utf8');
console.log(hello);
```
- **Processo Assíncrono:** Um processo assíncrono não mantém uma fila única de processos e não precisa terminar um para
iniciar outro processo. Eles são executados simultaneamente, não sabendo em qual ordem serão terminados, dessa maneira os
processos precisam de um `listener` que irá disparar um `callback` quando aquele processo for concluído. Exemplo:
```js
'use strict';
var fs = require('fs');
/* Faz leitura do primeiro arquivo e define uma função de callback para ser
* executada quando a leitura do mesmo for concluída
*/
fs.readFile('./greeting.txt', (err, result) => {
// Caso ocorra algum erro escreve ele no console
if (err) console.log(err);
console.log(result.toString());
});
/* Faz leitura do segundo arquivo e define uma função de callback para ser
* executada quando a leitura do mesmo for concluída
*/
fs.readFile('./hello.txt', (err, result) => {
// Caso ocorra algum erro escreve ele no console
if (err) console.log(err);
console.log(result.toString());
});
```
## Como o V8 executa JavaScript? Demonstre 1 exemplo com código ou imagem.
O V8 é um interpretador escrito em C++ criado pela Google e usado no Google Chrome. Sua função é melhorar o desempenho de uma aplicação JavaScript compilando o código para linguagem de máquina, fazendo assim que o mesmo rode em uma velocidade de um código binário compilado.
## Qual a diferença entre um sistema single para um multi-thread?
- **Single Thread:** Tem um único `caminho` de execução, porém não quer dizer que não se possa executar mais de um processo dentro da mesma `thread`. Economiza uso de memória e de processamento da CPU, pois cria apenas um único processo para todos usuários.
- **Multi Thread:** Tem diversos `caminhos` de execução, podendo executar diversos processos ao mesmo tempo. Consome mais memória e mais processamento da CPU, pois cria um processo diferente para cada usuário.
## Como a Thread Pool tem um tamanho padrão de 4, o que acontece se você enviar 5 requisições ao banco?
Quando são enviadas mais requisições do que a `Thread Pool` pode aguentar, as requisições restantes ficam em uma fila de espera, aguardando a liberação de um espaço na mesma.
O valor padrão da `Thread Pool` é 4, porém esse valor pode ser alterado como podemos ver [aqui](https://github.com/joyent/libuv/blob/v0.10.19/src/unix/threadpool.c#L32).
## Como você venderia o peixe do Node.js na sua empresa para tentar convencer seu chefe da sua adoção?
Mostraria casos de sucesso de grandes empresas como **Paypal** e **Netflix** e também faria uma pequena aplicação utilizando **Node.js** e a linguagem atualmente utilizada na empresa para mostrar uma comparação entre as duas.
## Qual a versão do seu node?
```
node -v
v5.0.0
```
## Qual a versão do seu npm?
```
npm -v
3.3.6
```
| {
"repo_name": "Webschool-io/be-mean-instagram-nodejs-exercises",
"stars": "33",
"repo_language": "JavaScript",
"file_name": "index.jade",
"mime_type": "text/plain"
} |
# Node.js - Aula 01 - Exercício
**user:** [lesilva00](https://github.com/lesilva00)
**autor:** Luís Eduardo Tenório Silva
## Explique como um processo síncrono e assíncrono roda no Node.js, dê um exemplo para cada.
Um processo **síncrono** é executado seguindo uma lógica sequencial onde é necessário o término do processo para que um novo processo seja executado, similar a uma fila de execução.
### Exemplo de execução síncrona usando o NodeJS:
```js
var fs = require("fs");
var data = fs.readFileSync('/tmp/ex.txt');
console.log(data.toString());
// Executando o node no servidor
$ node sincrono.js
Arquivo txt.
```
Um processo **assíncrono** permite que novos processos sejam executados sem o término do processo atual, eliminando o comportamento de lógica sequencial. Isso significa dizer que o Node.js é uma arquitetura não bloqueante. O diferencial do Node.js a outros servidores web é que ele é projetado para funcionar principalmente de maneira assíncrona, e isso é dado através do uso da biblioteca _libuv_, uma das principais bibliotecas do Node.js.
### Exemplo de execução assíncrona usando o NodeJS:
```js
var fs = require('fs');
// A função readFile() do módulo fs é por padrão
// assíncrona, ou seja, é executada sem bloquear
// nenhum outro processo. Após o término da
// leitura, uma função de Callback é invocada.
var data = fs.readFile('/tmp/ex.txt', function(err,data){
if(err)
return console.error(err);
console.log(data.toString());
});
// Executando o node no servidor
$ node sincrono.js
Arquivo txt.
```
## Como o V8 executa JavaScript? Demonstre 1 exemplo com código ou imagem.
O V8 é um motor de interpretação de JavaScript desenvolvido em C++ pela Google como motor principal do [Chrome](https://www.google.com/chrome/). Atualmente, outros projetos de browsers implementam o V8 como principal motor javascript devido a sua alta performance (Ex: Opera, Chromium, etc). Basicamente o V8 funciona compilando um código javascript em código de máquina, permitindo executar o código final como um binário, garantindo assim uma boa performance. A imagem abaixo demonstra o funcionamento de um motor de compilação do código em JavaScript para código de máquina.
## Qual a diferença entre um sistema single para um multi-thread?
Um sistema **_multi-thread_** executa cada solicitação de um cliente em uma _thread_, criando assim diversas threads (também denominada pool de _threads_) para atender diversos usuários. Alguns exemplos de servidores que utilizam o modelo de sistemas em _multi-thread_ são o Apache e JSP. Esses sistemas possuem uma arquitetura onde várias _threads_ são pré-alocadas e ficam no aguardo de solicitações de usuários. Dessa maneira recursos como memória e processamento não são bem aproveitados.
Um sistema **_single-thread_** executa as solicitações dos clientes em uma única _thread_. O Node.js é um exemplo de sistema web que trabalha de modo _single-thread_. Cada solicitação recebida gera um evento que é processado por uma única thread denominada _Event-loop_ que observa de maneira cíclica uma fila de eventos. Quando um evento ocorre, o _Event-loop_ captura-o e executa uma função de Callback definida naquele evento. Essa função é executada de maneira assíncrona (embora possa ser executada de maneira síncrona) em um _pool_ de _threads_ pré especificado. Embora existam um conjunto de _threads_ para a execução de eventos, a captura dos eventos é realizada por uma _single-thread_.
## Como a Thread Pool tem um tamanho padrão de 4, o que acontece se você enviar 5 requisições ao banco?
Embora o tamanho padrão do _Thread Pool_ seja 4, pode-se alterar o número de _threads_ utilizadas para até 128 _threads_ (através da variável de ambiente `UV_THREADPOOL_SIZE`) ou em tempo de execução através do comando `process.env.UV_THREADPOOL_SIZE`. Quando o valor de requisições é maior que o número disponível de _threads_ no _Thread Pool_, as solicitações que não foram atendidas esperam na fila de _threads_ (_Task Queue_) até que uma thread do _Thread Pool_ esteja disponível.
## Como você venderia o peixe do Node.js na sua empresa para tentar convencer seu chefe da sua adoção?
Primeiramente faria uma pequena apresentação do que é o Node.js e suas principais diferenças quando comparado com outros modelos de servidores web disponíveis no mercado.
Após isso, apresentaria números de performance em comparação a outros servidores, número de desenvolvedores necessários para realizar um determinado projeto, número de desenvolvedores necessários para manter o projeto, nível de complexidade(número de arquivos e linhas de código) e curva de aprendizado (se necessário).
Para finalizar apresentaria os casos de sucesso da implantação do Node.js e as principais empresas que migraram seus servidores para essa nova tecnologia (ex: PayPal e Netflix) e suas principais opiniões.
## Qual a versão do seu `node`?
Versão LTS (2016)
```
ubuntu@ubuntu:~$ node -v
v4.4.7
```
## Qual a versão do seu `npm`?
```
ubuntu@ubuntu:~$ npm -v
2.15.8
```
| {
"repo_name": "Webschool-io/be-mean-instagram-nodejs-exercises",
"stars": "33",
"repo_language": "JavaScript",
"file_name": "index.jade",
"mime_type": "text/plain"
} |
# Node.js - Aula 01 - Exercício
**Autor:** Ednilson Amaral
**Data:** 15/12/2015 às 18:15
## Explique como um processo síncrono e assíncrono roda no Node.js, dê um exemplo para cada.
### Síncrono
Em um processo síncrono é executado apenas uma função por vez, não mais que isso. Um exemplo simples para entendermos, digamos que tenhamos que baixar 20 imagens de um servidor, no processo síncrono ele vai fazer a requisição para o servidor e baixar uma imagem, e, enquanto não terminar de baixar essa imagem, ele não vai fazer outra requisição para baixar a próxima imagem. Ou seja, vai demorar séculos para baixar todas as 20 imagens do servidor.
### Assíncrono
Já em um processo assíncrono, é possível executar várias funções por vez. Não possui uma ordem definida e não sabemos qual irá terminar primeiro ou por último.
Seguindo o mesmo exemplo do download das 20 imagens de um servidor, no processo assíncrono, é enviado ao servidor várias requisições ao mesmo tempo, para baixar as 20 imagens. Então, será baixado as 20 imagens ao mesmo tempo. Porém, não sabemos qual terminará por primeiro ou por último, e não terá uma ordem para baixar as imagens.
## Como o V8 executa JavaScript? Demonstre 1 exemplo com código ou imagem.
Ele compila o código JavaScript para o formato nativa de máquina, assim, permitindo que rode na velocidade de um código binário compilado.
O V8 compila e executa o código JavaScript, manipulando a alocação de memória para objetos e coletando os que não é necessário nos objetos. Essa coleta de objetos descenessários é uma das chaves para o desempenho do V8. O V8 também oferece todos os tipos de dados, operadores, objetos e funções escificadas no padrão ECMA.
## Qual a diferença entre um sistema single para um multi-thread?
Single-thread quer dizer que será executado apenas uma tarefa por vez. Então o sistema espera até que essa tarefa seja conclúida antes de iniciar outra tarefa. Cada tarefa será executado dentro de um processo, ou seja, se temos três tarefas, teremos três processos.
Nas multi-thread são executadas múltiplas tarefas de uma só vez, em um único processo.
## Como a Thread Pool tem um tamanho padrão de 4, o que acontece se você enviar 5 requisições ao banco?
Caso tenha 5 requisições ao banco, ele aguarda até que uma thread seja liberada, e então, a execute.
> Its default size is 4, but it can be changed at startup time by setting the UV_THREADPOOL_SIZE environment variable to any value (the absolute maximum is 128).
>
> [Thread pool work scheduling](http://docs.libuv.org/en/v1.x/threadpool.html?highlight=uv_threadpool_size)
## Como você venderia o peixe do Node.js na sua empresa para tentar convencer seu chefe da sua adoção?
### PHP vs Node.js
Caro chefinho, você nos solicitou um sistema imobiliário para termos uma base de apartamentos para solteiros na região metropolitana de SP, correto? Nós estudamos como faríamos e gostariamos de apresentar os motivos para que seja optado seu desenvolvimento com Node.js.
Imagine conosco:
* Milhões de solteirões na região metropolitana de SP;
* Com o marketing digital eficaz, esperamos inúmeros acessos simultâneos no site, principalmente durante à noite e madrugada;
* Queremos esse sistema funcionando o mais rápido possível, em menos de três meses;
* Não temos dinheiro para contratar muita mão-de-obra;
* Não temos tempo para entrevistar novos colaboradores;
* Etc 1;
* Etc 2;
* Etc 3;
* Etc (...);
Então, resolveremos da seguinte maneira esses impasses:
1. Se desenvolvermos com PHP:
* Teremos um certo limite, caso atinjamos um número muito alto de acessos simultâneos, e a cada nova requisição no nosso servidor, vai começar a dar BO, vai travar;
* Precisaremos contratar um backend foda em PHP, pois nós só manjamos de JavaScript. E o senhor já nos disse que não tempo e nem dinheiro pra isso;
* Se formos parar tudo pra aprender PHP pra poder desenvolver esse sistema, levaremos mais de três meses apenas para aprender esse paranaue.
2. Se desenvolvermos com Node.js:
* Nós já manjamos de JavaScript, então, podemos utilizar uma stack MEAN, por exemplo, totalmente em JavaScript para desenvolver o sistema;
* Será desenvolvido pela metade do tempo ou menos do que seria em PHP;
* Poderemos aguentar um número gigantérrimo de usuários simultâneos em nosso site, com um número gigantérrimo de requisições em nosso servidor, que ele vai aguentar, danadinho;
* Não gastará mais do que o planejado, pois já manjamos de JavaScript e Node.js é JavaScript!
Conseguiu perceber chefinho? Podemos utilizar Node.js em nosso sistema, sairá mais barato e mais rápido, e ainda, bem melhor do que seria em PHP! =D
Além de fazer essa jabazinho malandro, poderia também, lá no inicio, mostrar casos reais, como foi mostrado em aula, do PayPal, para ver exemplos reais de utilização do Node.js e seus inúmeros benefícios e vantagens.
## Qual a versão do seu `node`?
```
ednilson@EDNILSON-NB:~$ node -v
v5.2.0
```
## Qual a versão do seu `npm`?
```
ednilson@EDNILSON-NB:~$ npm -v
3.3.12
``` | {
"repo_name": "Webschool-io/be-mean-instagram-nodejs-exercises",
"stars": "33",
"repo_language": "JavaScript",
"file_name": "index.jade",
"mime_type": "text/plain"
} |
# Node.js - Aula 01 - Exercício
**user:** [celosm](https://github.com/celosm)
**autor:** Marcelo Santana Martins
**date:** 1450083112501
## Explique como um processo síncrono e assíncrono roda no Node.js, dê um exemplo para cada.
###Processo Síncrono
Um processo síncrono é executado sozinho, ou seja, quando a aplicação solicita a execução de vários processos, eles são executados apenas quando o seu antecessor finalizar.
```
var fs = require('fs');
var contents = fs.readFileSync('https://raw.githubusercontent.com/zemirco/sf-city-lots-json/master/citylots.json').toString();
console.log(contents);
```
###Processo Assíncrono
Um processo assíncrono consegue executar mais do que uma tarefa simultaneamente. Após o processo finalizar, uma funcção de _callback_ deverá ser chamada.
```
var fs = require('fs');
fs.readFile('https://raw.githubusercontent.com/zemirco/sf-city-lots-json/master/citylots.json', function(err, buf) {
if(err)
throw err;
console.log(buf.toString());
});
```
<img src="https://blognti.files.wordpress.com/2010/07/requisicoes1.jpg" />
## Como o V8 executa JavaScript? Demonstre 1 exemplo com código ou imagem.
Ele interpreta o código JavaScript e o executa. O V8 é um interpretador escrito em C++ pelo Google no qual é possível integrá-lo em qualquer aplicativo. Assim, ele não fica restrito apenas ao navegador, e pode ser executado no servidor.
<img src="http://runtimejs.org/jsconf/img/runtimejs-arch.png" />
## Qual a diferença entre um sistema single para um multi-thread?
Um sistema _Single Thread_ é capaz de executar apenas uma tarefa por vez. Enquanto a tarefa é executada, todo o sistema aguarda que a _thread_ finalize para que possa seguir adiante.
Um sistema _Multi Thread_ consegue executar várias tarefas simultaneamente. Cada solicitação vira uma _thread_ e o servidor consegue trabalhar com ela isoladamente, sem intereferir nas outras.
## Como a Thread Pool tem um tamanho padrão de 4, o que acontece se você enviar 5 requisições ao banco?
Neste caso, a quinta requisição ficara no _Idle Thread_ aguardando a liberação de uma das quatro primeiras. Na sequência, ela é jogada para a _Thread Pool_ para ser executada.
## Como você venderia o peixe do Node.js na sua empresa para tentar convencer seu chefe da sua adoção?
Acredito que a melhor forma de convencer a adoção do Node.Js seria expondo suas vantagens. Mostrando também quais grandes empresas utilizam a tecnologia (Walmart, Ebay, Linkedin, Paypal, etc) e como um mesmo sistema seria desenvolvido em um prazo e custo menores.
## Qual a versão do seu `node`?
```
marcelo@marcelo-VirtualBox:~$ node --version
v5.0.0
```
## Qual a versão do seu `npm`?
```
marcelo@marcelo-VirtualBox:~$ npm --version
3.3.6
```
| {
"repo_name": "Webschool-io/be-mean-instagram-nodejs-exercises",
"stars": "33",
"repo_language": "JavaScript",
"file_name": "index.jade",
"mime_type": "text/plain"
} |
# NodeJS - Aula 01 - Exercício
autor: Gustavo Prado
## Explique como um processo síncrono e assíncrono roda no Node.js, dê um exemplo para cada.
FORMA SÍNCRONA
Em NodeJS, os processos sincronos são bloqueantes. Portato, se existir outros processos
ou códigos a serem executados, o NodeJS aguarda o término do anterior para executar o próximo.
```js
var fs = require( 'fs' );
for (var i = 0; i <= 5; i++) {
var file = 'sync-txt' + i + '.txt'
, out = fs.writeFileSync(file, 'Hello Node.js!');
console.log(out);
}
```
Esta abordagem irá parar a execução do restante dos processos até que a tarefa seja concluída.
FORMA ASSÍNCRONA
A forma assíncrona por outro lado, executa os processos de forma paralela.
```js
var fs = require( 'fs' );
for (var i = 0; i <= 5; i++) {
var file = 'async-txt' + i + '.txt'
, fs.writeFile(file, 'Hello Node.js!', function (err, out) {
console.log(out);
});
}
```
Esta abordagem voltará imediatamente para não bloquear o restante dos processos.
## Como o V8 executa JavaScript? Demonstre 1 exemplo com código ou imagem.
O V8, engine do NodeJS, interpreta e compila a linguagem JS para C++, convertendo para funções do V8,
permitindo a execução em código nativo.
## Qual a diferença entre um sistema single para um multi-thread?
Thread é uma forma de um processo dividir a si mesmo em duas ou mais tarefas que podem ser executadas concorrencialmente.
O suporte à thread é fornecido pelo próprio sistema operacional, ou implementada através de uma biblioteca de uma determinada linguagem.
Uma thread permite, por exemplo, que o usuário de um programa utilize uma funcionalidade do ambiente enquanto outras linhas de execução realizam outros cálculos e operações.
O node utiliza apenas uma thread para executar suas tarefas, podendo outras serem criadas, desta forma economizando memória. Portanto ele não precisa criar um novo processo para cada novo usuário poupando CPU.
Enquanto um sistema multi-thread utiliza várias threads para executar suas tarefas e desta forma acaba consumindo muito mais seus recursos computacionais, tais como: memória, cpu, etc.
Um bom exemplo é o Apache, que é um servidor HTTP multi-threaded. Para cada pedido que o servidor recebe ele cria uma thread separada que lida com esse pedido.
## Como a Thread Pool tem um tamanho padrão de 4, o que acontece se você enviar 5 requisições ao banco?
A quinta requisição aguarda a liberação de uma thread para ser executada.
De acordo com a documentação da LIBUV, o tamanho padrão da thread pool é 4, mas pode ser alterado em tempo na inicialização, definindo a variável de ambiente UV_THREADPOOL_SIZE para qualquer valor, sendo o máximo 128.
## Como você venderia o peixe do Node.js na sua empresa para tentar convencer seu chefe da sua adoção?
Enfatizando as principais qualidades do NodeJS, como:
Permite criar aplicações de rede rápidas e altamente escaláveis;
As aplicações em NodeJS executam em uma única thread;
É assíncrono e baseado em eventos;
Utiliza o modelo de I/O não bloqueante;
Economia de recursos, financeiros e computacionais;
É possível trabalhar com uma mesma linguagem base, o JS, o que acaba por criar profissionais fullstack;
## Qual a versão do seu NodeJS?
```
gustavo@gustavo-Inspiron-3442:~$ node -v
v5.6.0
```
## Qual a versão do seu NPM?
```
gustavo@gustavo-Inspiron-3442:~$ npm --version
3.6.0
```
| {
"repo_name": "Webschool-io/be-mean-instagram-nodejs-exercises",
"stars": "33",
"repo_language": "JavaScript",
"file_name": "index.jade",
"mime_type": "text/plain"
} |
# Node.js - Aula 01 - Exercício
**user:** https://github.com/paulosilva92
**autor:** Paulo Roberto da Silva
**date:** Fri Feb 26 2016 22:33:04 GMT-0300 (BRT)
## Explique como um processo síncrono e assíncrono roda no Node.js, dê um exemplo para cada.
#### Assíncrono
Processos assíncronos no NodeJS fazem com que o *Event Looper* da plataforma funcione como deve funcionar, ou seja, de modo não bloqueante. Ele irá pegará um processo e irá delegar ele para seu respectivo lugar mas não ficará esperando ele ser completado para que inicie outros processos. Depois de terminada este processo ele disparará a *trigger* para sua função de *callback*, voltando para a fila que será executada pelo *Event Looper*.
##### Exemplo Assíncrono:
Utilizarei como exemplo a função assíncrona *readFile()* do módulo nativo do Node, o FS;
```js
const fs = require('fs'); //chamada do módulo
fs.readFile('./texto.html', 'utf-8', function(err, data){ //chamada da função passando o caminho do arquivo a ser lido, a codificação, e uma função de callback que será executada assim que o arquivo terminar de ser lido
if (!err) console.log(data); //após a leitura do arquivo o seu conteúdo será mostrado na tela
});
console.log('lendo o arquivo...'); // como a função acima é assíncrona essa linha será executada antes do resultado da função readFile ser mostrada
```
#### Síncrono
Processos síncronas, por outro lado, funcionam de forma bloqueante, ou seja, farão o *Event Looper* ficar esperando sua resolução para que possa ir para outros processos. Isso diminui muito o desempenho da aplicação e não é o modo ideal de se trabalhar com NodeJS.
##### Exemplo Síncrono:
```js
const fs = require('fs'); //chamada do módulo
var texto = fs.readFileSync('./texto.html', 'utf-8'); //chamada da funão síncrona de leitura de arquivos, note que ela não possui uma função de callback sendo necessário armazenar seu retorno em uma variável para poder mostrar na tela
console.log(texto); //esta linha só será executada quando a função acima terminar, ou seja, caso o arquivo seja grande todo os processo ficarão parados
```
## Como o V8 executa JavaScript? Demonstre 1 exemplo com código ou imagem.
O V8 compila o código javascript para o código nativo da máquina para depois executá-lo. Ele trabalha de forma semelhante ao compilador do Java, sendo o NodeJs semelhante a máquina virtual do Java.
## Qual a diferença entre um sistema single para um multi-thread?
Um sistema single thread trabalha com apenas uma thread. Isso faz com que haja um ganho de performance e de consumo de recursos do computador pq não será necessário abrir variás threads para diversos processos, que é como os multi threads funcionam. Sistemas multi threads tendem a consumir mais memória RAM, como no caso do Apache, que aloca uma quantidade de RAM para cada usuário que conecta, fazendo com que haja uma limitação dos recursos de cada máquina.
O Node é um sistema single thread que se utiliza de muitas ferramentas para poder fazer igual ou mais que outras plataformas muitl thread em questão de desempenho, mas com menos recursos.
## Como a Thread Pool tem um tamanho padrão de 4, o que acontece se você enviar 5 requisições ao banco?
Quando é enviado um número de requisições que excedem o tamanho da Thread Pool as requisições excedentes ficam esperando para que possam uma "vaga" seja liberada.
## Como você venderia o peixe do Node.js na sua empresa para tentar convencer seu chefe da sua adoção?
Mostraria os diversos casos de usos de grandes empresas que migraram seu backend para Node, como a Netflix e o Paypal. Mostraria também o comparativo de velocidade e consumo de recursos entre o Node e outras linguagens usuais do mercado, como Java e PHP.
## Qual a versão do seu `node`?
```
➜ ~ node -v
v5.7.0
```
## Qual a versão do seu `npm`?
```
➜ ~ npm -v
3.6.0
``` | {
"repo_name": "Webschool-io/be-mean-instagram-nodejs-exercises",
"stars": "33",
"repo_language": "JavaScript",
"file_name": "index.jade",
"mime_type": "text/plain"
} |
# NodeJS - Aula 01 - Exercício
**Autor:** Rony souza (user: rxon7)
**Data** 28/06/2016
# 1. Explique como um processo síncrono e assíncrono roda no Node.js, dê um exemplo para cada.
```
**Síncrono**: Em um processo síncrono, a medida que os usuários irão acessá-la, ela vai gerando
múltiplos processos no servidor e apenas uma função será executada por vez, como por exemplo
uma espera de um pedido no restaurante que tem apenas um garçon e só um cliente será atendido
por vez demorando muito mais para ser atendido.
**Assíncrono**: No processo assíncrono várias funções são executadas por vez. O Servidor responde a
primeira Requisição da fila e aguarda a sua chamada de retorno. o cliente envia a requisição
o nodejs responde a primeira requisição e aguarda a chamada de retorno, ao mesmo tempo atende
outras requisições e fica escutando a chamada de CALLBACK das outras requisições enviadas.
Voltando ao exemplo do restaurante, no modelo assíncrono, o garçom pegaria o pedido do cliente,
passaria para a cozinha, e enquanto a cozinha prepara o prato, o garçom atende a segunda mesa.
```
# 2. Como o V8 executa JavaScript? Demonstre 1 exemplo com código ou imagem.
O V8 compila o JavaScript para c++ alocando esses espaços na memoria criando classes escondidas, em tempo de execução,
a fim de ter uma representação interna do sistema de tipo e para melhorar o tempo de acesso as propriedades.
Exemplo:
```
# 3. Qual a diferença entre um sistema single para um multi-thread?
```
Com o single thread vocẽ econômiza mais memória, pois você pode ter a instancia de um
processo por vez, já com o multi thread você pode ter os processos e os auxiliares
do processo além dos outros threads rodando em paralelo.
```
# 4. Como a Thread Pool tem um tamanho padrão de 4, o que acontece se você enviar 5 requisições ao banco?
```
Como ele é I/O bloqueante, uma das requisições vai ter que esperar as 4 outras terminarem,
Neste caso, a quinta requisição, entrará na fila de execução, aguardando que o alguma
requisição seja entregue para que ela entre em execução.
```
# 5. Como você venderia o peixe do Node.js na sua empresa para tentar convencer seu chefe da sua adoção?
```
Mostraria cases de sucesso como o paypall e falaria de suas vantagens e da economia tanto em codigo como eu
mão de obra e equipes que já estão implementando em suas empresas e como vem ajundando no desenvolvimento rapido
e com baixo custo.
```
# 6. Qual a versão do seu `node`?
```
node -v
v6.2.0
```
# 7. Qual a versão do seu `npm`?
```
npm -v
3.8.9
``` | {
"repo_name": "Webschool-io/be-mean-instagram-nodejs-exercises",
"stars": "33",
"repo_language": "JavaScript",
"file_name": "index.jade",
"mime_type": "text/plain"
} |
# Node.js - Aula 01 - Exercício
**user:** https://github.com/FranciscoValerio
**autor:** Francisco Henrique Ruiz Valério
**date:** 2015-12-08T21:59:10
## Explique como um processo síncrono e assíncrono roda no Node.js, dê um exemplo para cada.
Assíncrono:
Exemplo:
A API Google Maps V3 (Geocoding service) trabalha de forma assíncrona, como ela recebe milhões de requisições de endereços para serem transformados em latitude e longitude. Ela não aguarda uma requisição terminar e retornar o resultado, pense isso seria muito lento para a quantidade de requisições que ela recebe. Portanto ela recebe as requisições e não espera seu resultado e vai recebendo as próximas da "fila". But what about the results???
No Node como por padrão qualquer função é assícrona sempre precisaremos de uma função que sempre será chamada após o processamento ter sido finalizado, estas chamadas de callback.
Portanto é assim que o resultado e obtido na consulta a API mencionada acima.
Síncrono:
A beleza do Node está em utilizar requisições assíncronas.
Exemplo:
Um exemplo de síncrono poderiamos pegar uma fila de pedágio. A operadora da cabine não consegue atender mais de um carro ao mesmo tempo portanto ela deverá anter um carro receber dele e liberar a passagem, após esse processo ela estara "liberada" para atender o próximo carro da fila gerando assim uma demora como bem conheçemos.
Para utilizar o Node de forma síncrona é nescessário passar duas funções como parametro, uma para tratamento de erro e outra para sucesso.
Muito cuidado com a "Síncrona" pois o Node é Single Thread isso significa que caso um processo bloqueie essa Thread o Node também irá ficar bloqueado aguardando seu termino.
## Como o V8 executa JavaScript? Demonstre 1 exemplo com código ou imagem.
https://github.com/FranciscoValerio/imagens/blob/master/img-be-mean/v8-sample.jpg
## Qual a diferença entre um sistema single para um multi-thread?
Um sistema single thread, significa que aquele sistema consegue executar apenas uma tarefa pois trabalha somente com uma thread, ou seja caso seja executado um processamento muito demorado o sistema ficará bloqueado aguardando o termino desse processamento. Já em um sistema multi-thread caso seja necessário executar um processamento que o sistema irá ficar bloqueado é aberto uma nova thread para ser executado esse processamento nessa ou seja, com isso o sistema irá ficar liberado para uso.
## Como a Thread Pool tem um tamanho padrão de 4, o que acontece se você enviar 5 requisições ao banco?
Por padrão a thread pool é de 4 no Node, a 5 requisição será incluída a idle thread oque seria essa idle thread nada mais é do que as requisições que estão aguardando uma das 4 requisições que estão na thread pool serem executadas para as mesmas poderem serem executadas.
## Como você venderia o peixe do Node.js na sua empresa para tentar convencer seu chefe da sua adoção?
Primeiramento mostraria um comparativo de JAVA com NodeJS mostrando os números de beneficíos que a empresa ganharia se migrace para Node primeiramento os ganhos no desempenho do software gerando a satisfação dos clientes. Segundo a economia de tempo de desenvolvimento devido a curva de aprendizado ser grande, e por último não menos importante mostraria a economia que Node geraria na folha de pagamento da empresa. Claro que tudo isso com muitos gráficos e percentual de redução de custo operacional.
## Qual a versão do seu `node`?
PS C:\Be-Mean\NodeJS\Aula01> node -v
v5.1.1
## Qual a versão do seu `npm`?
PS C:\Be-Mean\NodeJS\Aula01> npm -v
3.3.12
| {
"repo_name": "Webschool-io/be-mean-instagram-nodejs-exercises",
"stars": "33",
"repo_language": "JavaScript",
"file_name": "index.jade",
"mime_type": "text/plain"
} |
# Node.js - Aula 01 - Exercício
**user:** [marks88martinez](https://github.com/marks88martinez)
**autor:** Marcos Antonio Martinez Florentin
**date:** 1457436489971
## Explique como um processo síncrono e assíncrono roda no Node.js, dê um exemplo para cada.
O processo Síncrono realiza uma operação de execução, depois da execução passa a seguinte operação
```js
var fs = require('fs');
fs.writeFileSync('/path', function(err, buf) {
console.log('Codigo Sincrono');
});
```
Processo assíncrono executa várias tarefas ao mesmo tempo, ele nunca espera que uma operação seja concluída, mas sim executa todas as operações.
```js
fs.writeFile('/path', function(err, buf){
console.log('Codigo Assincrono');
});
```
## Como o V8 executa JavaScript? Demonstre 1 exemplo com código ou imagem.
O Motor de V8 do google compila o javascript em eventos não bloqueante,
Todos os códigos se executam em um única thread.
http://image.slidesharecdn.com/betabeers-mean-140329120323-phpapp01/95/full-stack-javascript-mean-betabeers-zgz-6-638.jpg?cb=1396094667
## Qual a diferença entre um sistema single para um multi-thread?
**single-thread** O processo de thread não espera um bloqueio síncrono, ou uma operação de duração. O nodejs coloca na fila de eventos.
**multi-thread** A cada requisição saô feitas em uma Thread pode assim então gerar mais processos.
## Como a Thread Pool tem um tamanho padrão de 4, o que acontece se você enviar 5 requisições ao banco?
Ele vá fazer as 4 requisições e o 5to fica no _Idle Thread_ aguardando que um seja liberado das 4 primeiras, na seqüência ele e jogado no _Thread Pool_ para ser executado
## Como você venderia o peixe do Node.js na sua empresa para tentar convencer seu chefe da sua adoção?
Nodejs é uma tecnología ágil e atual, possibilitando amplo crescimento.
As empresas que a utilizam são de êxito total, como PayPal e Nexflix que ao implementar diminuíram o tempo no desenvolvimento. Assim aumentaram para o dobro o número de requisições ao serviço comparado a outra plataforma.
## Qual a versão do seu `node`?
```js
~$ node -v
v5.4.1
```
## Qual a versão do seu `npm`?
```js
~$ npm -v
3.3.12
```
| {
"repo_name": "Webschool-io/be-mean-instagram-nodejs-exercises",
"stars": "33",
"repo_language": "JavaScript",
"file_name": "index.jade",
"mime_type": "text/plain"
} |
# Node.js - Aula 01 - Exercício:w
**user:** [sostenesfreitas](https://github.com/sostenesfreitas)
**autor:** Sóstenes Freitas de Andrade
**date:** new Date()
## Explique como um processo síncrono e assíncrono roda no Node.js, dê um exemplo para cada.
Processo assíncrono é quando é executado apenas um processo por vez, onde o Node ficará limitado aquele processo ate que o mesmo termina, para só aṕos finalizar a execução daquele determinado processo, poder iniciar a execução novo processo.
EX:
```
function exemploSincrono1(){
console.log("sicrono1");
}
function exemploSicrono2(){
console.log("sicrono2");
}
test();
test2();
```
Já o processo assíncrono que é utilizado pelo Node por padrão, é capaz de executar vários processos de uma só vez, em 'paralelo'
mas o que acontece na verdade não é que ele executa varios processos simultaneos, ele simplesmente manda executar o processo com um callback e já vai para o próximo processo, quando qualquer um dos processos que já foi mandado executar terminar seu processo ele manda o callback de retorno para o Node finalizar aquele processo.
EX:
```
function exemploAssicrono1(){
console.log("Assíncrono1");
}
function exemploAssicrono2(){
setTimeout(Assicrono, 0);
console.log("Assíncrono");
console.log("Assicronoo2");
}
exemploAssicrono2();
```
## Como o V8 executa JavaScript? Demonstre 1 exemplo com código ou imagem.
O V8 é o motor de renderização do javaScript que funcioná como uma máquina virtual que compila o código em js para o formato nativo de máquina antes de executá-lo, tendo como propósito aumentar o desempenho da aplicação.
## Qual a diferença entre um sistema single para um multi-thread?
Tem mais arquiteturas além de single-thread (ST) e multi-thread (MT). Basicamente o ST só pode tratar uma requisição de cada vez, então o processamento de cada uma não pode ser demorado, nem pode bloquear (por exemplo, ficar esperando pelo banco de dados). O MT, assumindo que se crie uma thread por requisição, pode tratar várias requisições em paralelo, mesmo que demorem ou bloqueiem.
## Como a Thread Pool tem um tamanho padrão de 4, o que acontece se você enviar 5 requisições ao banco?
Devido ao fato de a thread pool suportar apenas 4 requisições, caso acontece de a quantidade de requisição ultrapassar o tamanho padrão da thread pool, as requisições suplentes vão para a 'Task Queue'(fila de tarefas) e aguarda até que umas das threads sejam liberadas.
## Como você venderia o peixe do Node.js na sua empresa para tentar convencer seu chefe da sua adoção?
Ready for real-time: O Node.js ficou popular graças aos seus frameworks que interagem em real-time entre cliente e servidor. SockJS, Socket.IO, Engine.IO são alguns exemplos disso. Eles são compatíveis com o novo protocolo WebSockets e permitem trafegar dados através de uma única conexão bi-direcional, tratando as mensagens via eventos no JavaScript.
Big players usando: LinkedIn, Wallmart, Groupon, Microsoft e Paypal são algumas das empresas usando Node.js atualmente.
## Qual a versão do seu `node`?
miojo at corsair in ~ [19:34:13]
→ node -v
v6.2.1
## Qual a versão do seu `npm`?
miojo at corsair in ~ [19:34:45]
→ npm -v
3.9.3
```
```
```
```
| {
"repo_name": "Webschool-io/be-mean-instagram-nodejs-exercises",
"stars": "33",
"repo_language": "JavaScript",
"file_name": "index.jade",
"mime_type": "text/plain"
} |
# Node.js - Aula 01 - Exercício
**user:** [airton](https://github.com/airton)
**autor:** Airton Vancin Junior
**date:** 1455241588976
## Explique como um processo síncrono e assíncrono roda no Node.js, dê um exemplo para cada.
Processo síncrono espera que cada operação seja executada por completo, depois que é executado ele passa para a operação seguinte.
```js
// Código Síncrono
fs.writeFileSync('arquivo.txt', 'Hello World');
console.log('Executa a função síncrona');
```
Processo assíncrono ele executa varias tarefas ao mesmo tempo, ele nunca espera que uma operação seja concluída, mas sim executa todas as operações.
```js
// Código Assíncrono
fs.writeFile('arquivo.txt', 'Hello World', function(error){
console.log('Executa a função Assíncrona');
});
```
## Como o V8 executa JavaScript? Demonstre 1 exemplo com código ou imagem.
O Nodejs roda em uma JavaScript V8 VM, ou seja, JavaScript no lado do servidor. O motor JavaScript V8 compila o códigio JavaScript para código de máquina para depois executá-lo.
## Qual a diferença entre um sistema single para um multi-thread?
PHP, Ruby, ASP entre outras linguagens server-side são "multi-thread" mas o Nodejs é "single-thread"
A single-thread não tem que esperar um bloqueio síncrono ou uma operação de longa duração. O Nodejs coloca na fila de eventos e segue em frente.
## Como a Thread Pool tem um tamanho padrão de 4, o que acontece se você enviar 5 requisições ao banco?
Caso seja feita 5 requisição ao banco, ela aguarda até que uma Thread seja liberada, então essa requisição será incluída em uma Idle Thread esperando sua vez de ser jogada no Thread Pool e ser executada.
## Como você venderia o peixe do Node.js na sua empresa para tentar convencer seu chefe da sua adoção?
Citaria os cases do PayPal e Netflix que mudaram a plataforma Java para Nodejs, e ambos diminuiram o tempo e quantidade de pessoas no desenvolvimento. Assim aumentaram para o dobro o número de requisições ao serviço comparado a outra plataforma.
## Qual a versão do seu `node`?
```js
~$ node -v
v5.6.0
```
## Qual a versão do seu `npm`?
```js
~$ npm -v
3.6.0
``` | {
"repo_name": "Webschool-io/be-mean-instagram-nodejs-exercises",
"stars": "33",
"repo_language": "JavaScript",
"file_name": "index.jade",
"mime_type": "text/plain"
} |
# Nodejs - Aula 01 - Exercício
autor: Marcelo Alves
github: MalvesGO
## 1- Explique com um processo sincrono e assincrono roda no Nodejs, dê um exemplo para cada
Síncrono: No modo síncrono existe uma fila de espera que só termina assim que o usuário receber a resposta, assim o proximo usuário tem que aguardar até que o processo seja concluído.
Exemplo: A fila de um banco
<img class="center-block" src="http://paraibaja.com.br/wp-content/uploads/2014/07/13052014_1744.jpg">
Assíncrono: No modo assíncrono não existe filas então a cada requisição já obtemos a resposta imediata da solicitação.
Exemplo: Estacionamento de carros
<img class="center-block" src="http://revistagalileu.globo.com/Revista/Galileu2/foto/0,,40726009,00.jpg">
## 2- Como o V8 executa Javascript? Demonstre um exemplo com código ou imagem
O V8 foi o nome dado ao interpretador Javascript, também conhecido de VM (maquina virtual), foi desenvolvido pela Google para ser usado no navegador Google Chrome.
A principal virtude do V8 é acelerar o desempenho de aplicações compilando o codigo Javascript para o formato nativo de maquina antes de ser executando, permitindo assim que rode a velocidade de um código binário ja compilado.
<img class="center-block" src="https://sathyalog.files.wordpress.com/2014/05/toptal-blog-1_b.png?w=645">
Tendo como premissa a idéia do Nodejs é trabalhar com múltiplas requisições e permanecer leve e eficiente.
## 3- Qual a diferença entre um sistema single para um multi-thread?
A diferença entre sistemas single e multi-thread é que ao usar uma unica thread apenas uma tarefa pode ser realizada em determinado tempo e o programa deve esperar até a tarefa ser concluida, já nos sistemas multi-thread as tarefas podem ser realizadas de modo simultáneo não bloqueando novas requisições o que nos proporciona um ganho imenso em produtividade e desempenho.
## 4- Como a thread Poll tem um tamanho padrão de 4, o que acontece se enviar 5 requisiçoes ao banco?
Libuv tem um tamanho total de 4 threads por padrão e utiliza uma fila para gerenciar o acesso ao poll de threads. Nesse caso quando você tiver 5 pesquisas de longa duração simultaneas um deles vai ficar aguardando por estas pesquisas antes mesmo delas começarem.
Podemos aumentar o tamanho deste conjunto de threads através da variável de ambiente <strong>UV_THREADPOOL_SIZE</strong>, e modificarmos a variável de acordo com as necessidades do projeto <strong>process.env.UV_THREADPOOL_SIZE = 10;</strong>
## 5- Como você venderia o peixe do Nodejs na sua empresa para tentar convencer seu chefe da sua adoção?
Acho que a melhor forma de convencer uma pessoa a usar Nodejs seria mostrar com uma aplicação real rodando e demonstrar o "poder de fogo" do Javascript. Criaria um dashboard fazendo requisições nos dados da empresa e mostrar o seu funcionamento utilizando socket.io (dados em tempo real). Isso seria o pontapé inicial para tentar convencer a adoção do Nodejs.
## 6- Qual a versão do seu Node.js?
```
marcelo@marcelo-js:~/Projetos$ node -v
v0.10.41
```
## 7- Qual a versão do seu NPM?
```
marcelo@marcelo-js:~$ npm -v
1.4.29
```
| {
"repo_name": "Webschool-io/be-mean-instagram-nodejs-exercises",
"stars": "33",
"repo_language": "JavaScript",
"file_name": "index.jade",
"mime_type": "text/plain"
} |
# Node.js - Aula 01 - Exercício
**user:** [sergiokopplin](https://github.com/sergiokopplin)
**autor:** Sergio Kopplin
**date:** 1454730409490
## Explique como um processo síncrono e assíncrono roda no Node.js, dê um exemplo para cada.
Um processo síncrono em node.js consiste em executar uma função e esperar o seu fim para que desse modo o sistema possa continuar a execução de outras funções. Por exemplo:
```JS
var fs = require('fs');
var contents = fs.readFileSync('/etc/passwd').toString();
console.log(contents);
```
Nesse primeiro exemplo, apenas quando a função **readFileSync** for terminada ele executará o **console** que vem em seguida, executando ambos de forma **síncrona**.
A grande diferença entre ambos é de que o processo assíncrono pode ocorrer e o sistema continuará a executar outros processos distintos, de forma **assíncrona**, impedindo assim que o seu funcionamento sofra uma parada na execução.
```JS
var fs = require('fs');
fs.readFile('/etc/passwd', function(err, buf) {
console.log(buf.toString());
});
```
No nosso último exemplo, o javascript executará o **console** enquanto ele lê o arquivo através da função **readFile**, executando os dois ao mesmo tempo, de forma **assíncrona**.
ref: [daveeddy.com](http://www.daveeddy.com/2013/03/26/synchronous-file-io-in-nodejs/)
## Como o V8 executa JavaScript? Demonstre 1 exemplo com código ou imagem.
O v8 é um tipo de "Máquina Virtual". O objetivo do v8 é compilar a linguagem JS escrita pelo desenvolvedor para uma linguagem otimizada que o browser entenda ou que seja embarcada em uma aplicação.
No core fo v8 temos dois compiladores diferentes. "Full-codegen" que compila com mais velocidade e produz código sem otimização e o "Crankshaft" que demora mais em sua compilação mas produz código otimizado.
Na nossa imagem de exemplo temos uma pequena ideia de como uma engina JS funciona. Seguindo esses passos a engine consegue compilar o código e devolver algo que o navegador ou aplicação consegue interpretar.
Durante a compilação, a engine utiliza o C++ para conversão do código necessário.
ref: [quora.com](https://www.quora.com/How-does-a-JavaScript-engine-work)
ref: [thibaultlaurens.github.io](http://thibaultlaurens.github.io/javascript/2013/04/29/how-the-v8-engine-works/)
## Qual a diferença entre um sistema single para um multi-thread?
Na nossa imagem de exemplo podemos visualizar as "Single Threaded Process" e as "Multi-threaded Process". Basicamente, um sistema que utiliza o processamento de modo "Single" consegue executar um processo de modo único, indo de passo em passo até o final de sua execução. No caso do "Multi" o sistema pode sim executar mais de uma função ao mesmo tempo sem que isso afete cada processo individualmente, podendo então gerenciar o processamento de modo a atender a todos os processos necessários e atingir o resultado satisfatório para todos os processos.
## Como a Thread Pool tem um tamanho padrão de 4, o que acontece se você enviar 5 requisições ao banco?
Caso a thread pool receba processos além de sua capacidade, os em questão entrarão em uma fila de espera até que possam ser executados.
## Como você venderia o peixe do Node.js na sua empresa para tentar convencer seu chefe da sua adoção?
O node.js é uma linguagem atual e quem crescido muito. A motivação principal se dá quando pensamos em velocidade e performance, mas também podemos pensar nas apis disponíveis e em como a linguagem pode ser escalada e alterada com facilidade.
O nodejs tem se apresentado firme em sua utilização, e o casos de uso disponíveis na internet são mais que suficientes para saber que a linguagem é sim, poderosa e estável, e não uma linguagem passageira que não tem a força necessária para se perpetuar definitivamente.
## Qual a versão do seu `node`?
```sh
$ node -v
v5.5.0
```
## Qual a versão do seu `npm`?
```sh
$ npm -v
3.5.3
```
| {
"repo_name": "Webschool-io/be-mean-instagram-nodejs-exercises",
"stars": "33",
"repo_language": "JavaScript",
"file_name": "index.jade",
"mime_type": "text/plain"
} |
# NodeJS - Aula 01 - Exercício
**Autor:** Luan da Silva Oliveira
**User:** luanconecte
# 1. Explique como um processo síncrono e assíncrono roda no Node.js, dê um exemplo para cada.
A beleza do NodeJs está em sua assincronicidade. Esse processo faz com que ao executarmos um evento de entrada ou saída (I/O) no sistema, o mesmo não fique bloqueado, aguardando o término da operação, para só então executar uma nova atividade.
No processo síncrono acontece uma fila de processos na qual o evento sucessor depende do termino do evento antecessor para ser executado.
Para os exemplos criei um arquivo itens.txt para ser lido com File System.
itens.txt
```
item 1
item 2
item 3
```
Exemplo de processo síncrono
```js
var fs = require('fs');
console.log( fs.readFileSync("itens.txt").toString() );
console.log("item 4");
/*
result:
item 1
item 2
item 3
item 4
*/
```
Exemplo de processo assíncrono
```js
var fs = require('fs');
fs.readFile("itens.txt", [], function(err, data) {
if (err) {
throw err;
}
console.log(data.toString());
});
console.log("item 4");
/*
result:
item 4
item 1
item 2
item 3
*/
```
Como podemos perceber nos exemplos a cima, no processo síncrono o File System leu o arquivo itens.txt para só depois mostrar o item 4. No processo assíncrono o node comunicou que o arquivo itens.txt precisa ser lido, mostrou o item 4 e quando obteve a resposta do File System mostrou o conteúdo do arquivo itens.txt. Por isso a ordem da lista é diferente nas duas abordagens.
# 2. Como o V8 executa JavaScript? Demonstre 1 exemplo com código ou imagem.
O Node usa o JavaScript V8 VM (Virtual Machine) que é a engine criada pela equipe do google para ser utilizada em seu navegador Google Chrome. O V8 é um projeto open source de alta performace escrito em C++, ele funciona compilando o código JavaScript e manipulando a alocação de memória de objetos que já não são mais necessários.
<img src="http://www.haneycodes.net/wp-content/uploads/2014/03/node-processing-model.png" width="100%" />
# 3. Qual a diferença entre um sistema single para um multi-thread?
Um sistema single thread é executado utilizando uma unica thread para todo o seu funcionamento, através do event-loop que gerencia as execuções. Já um sistema multi-thread, para cada nova requisição é criado um novo processo, que por conseguinte aumenta o uso de memória e processamento da máquina.
<img src="http://softwareengineeringdaily.com/wp-content/uploads/2015/07/event-loop.jpg" width="100%">
# 4. Como a Thread Pool tem um tamanho padrão de 4, o que acontece se você enviar 5 requisições ao banco?
A quinta requisição ficará aguardando que uma das requisições anteriores saia do Thread Poll, para só então seja executada.
# 5. Como você venderia o peixe do Node.js na sua empresa para tentar convencer seu chefe da sua adoção?
Primeiramente desenvolveria algum produto simples e eficaz, que atendesse algum tipo de demanda da empresa com maior escabilidade ou performasse do que as linguagens que utilizamos atualmente (PHP, Ruby on Rails). Depois que ganhei a atenção com o novo produto, demonstro alguns cases de sucesso de outras empresas com a mesma tecnologia (LinkedIn, Wallmart, Groupon, Microsoft e Paypal). Para concluir e quem sabe ganhar a aprovação de todos demonstro alguns dos pontos fortes da linguagem:
+ Non-Blocking IO
+ Comunidade Ativa
+ Ready for real-time
É claro que surgirão questionamentos e se bem conheço meu ambiente de trabalho o que mais impactaria seria o fato de ter que aprender uma nova tecnologia, o que é um argumento válido para uma empresa onde o objetivo principal é produzir, produzir e produzir... Mas felizmente o NodeJs utiliza o JavaScript para tudo, então além de não ter que aprender uma nova linguagem vamos utilizar a mesma no client, server-side e banco de dados.
# 6. Qual a versão do seu `node`?
```
luanoliveira@luanoliveira ~/www/be-mean-instagram-nodejs-exercises/class-01 $ node -v
v5.3.0
```
# 7. Qual a versão do seu `npm`?
```
luanoliveira@luanoliveira ~/www/be-mean-instagram-nodejs-exercises/class-01 $ npm -v
3.3.12
``` | {
"repo_name": "Webschool-io/be-mean-instagram-nodejs-exercises",
"stars": "33",
"repo_language": "JavaScript",
"file_name": "index.jade",
"mime_type": "text/plain"
} |
# Node.js - Aula 01 - Exercício
**user:** [fauker](https://github.com/fauker)
**autor:** LUCAS DA SILVA MOREIRA
**date:** 1449700152468
## Explique como um processo síncrono e assíncrono roda no Node.js, dê um exemplo para cada.
**Síncrono**: No processo síncrono apenas uma função será executada por vez. Fazendo uma analogia com o mundo real, pense na fila do **Mc Donalds** que tem apenas um caixa disponível. Apenas um cliente será atendido por vez criando uma fila imensa e desagradável.
**Assíncrono**: No processo assíncrono várias funções são executadas por vez. Nunca sabemos quem terminará primeiro. Por isso, se quisermos executar algo quando uma função chegar ao seu fim, temos de fazer isso através de um **callback**. Exemplo:
```
fs.readFile('arquivo.txt', function(data) {
// faz algo
});
```
Fazendo uma analogia com o mundo real e processos assíncronos, pense na mesma fila do **Mc Donalds** mas com vários caixas funcionando. Muitos usuários são atendidos por vez.
## Como o V8 executa JavaScript? Demonstre 1 exemplo com código ou imagem.
## Qual a diferença entre um sistema single para um multi-thread?
Em um sistema que suporta apenas Single Thread, apenas uma tarefa será executada por vez, caso as tarefas sejam síncronas. E, enquanto uma tarefa está sendo executada, todo o sistema para esperando essa Thread terminar. Ou seja, o processamento é bloqueado.
Já em um sistema Multi-Thread, se uma Thread estiver sendo executada, outra Thread pode ser criada para que o processamento não seja bloqueado.
## Como a Thread Pool tem um tamanho padrão de 4, o que acontece se você enviar 5 requisições ao banco?
Caso seja feita a quinta requisição ao banco, essa requisição será incluída no **Idle Thread** esperando sua vez se ser jogada no **Thread Pool** e ser executada.
## Como você venderia o peixe do **Node.js** na sua empresa para tentar convencer seu chefe da sua adoção?
Bom, eu defenderia os casos de sucesso de empresas que adotaram o **Node.js**, como o Paypal, Netflix etc. Também eu poderia fazer a mesma aplicação que hoje está em produção, só que em Nodejs e comparar os ganhos. Com o argumento da comparação de ganhos eu acho que qualquer chefe, investidor ficaria convencido.
## Qual a versão do seu `node`?
```
node -v
v5.0.0
```
## Qual a versão do seu `npm`?
```
npm -v
3.3.6
``` | {
"repo_name": "Webschool-io/be-mean-instagram-nodejs-exercises",
"stars": "33",
"repo_language": "JavaScript",
"file_name": "index.jade",
"mime_type": "text/plain"
} |
# Node.js - Aula 01 - Exercício
**user:** [leolimadev](https://github.com/leolimadev)
**autor:** LEONARDO CASSURIAGA LIMA
**date:** Tue Dec 15 2015 22:27:28 GMT-0200
## Explique como um processo síncrono e assíncrono roda no Node.js, dê um exemplo para cada.
Um processo síncrono bloqueia o event loop enquanto processa, ele não pede para o kernel fazer uma gravação síncrona no sistema de arquivos.
Exemplo:
fs.readFileSync('/arquivo.txt', "utf8");
Note que como a execução é síncrona não existe a chamada de um callback, diferente do exemplo abaixo que é assincrono.
Um processo assincrono não bloqueia o event loop enquanto processa, não fazendo outros processos aguardarem pelo fim da execução.
fs.readFile('/arquivo.txt', function (err, data) {
if (err) throw err;
console.log(data);
});
## Como o V8 executa JavaScript? Demonstre 1 exemplo com código ou imagem.
Javascript é uma linguagem baseada em protótipos com tipagem dinamica. O V8 trabalha criando classes escondidas conforme a necessidade de representar
o tipo que a propriedade esta sendo acessada. Isto ajuda muito na otimização, visto que o V8 consegue a partir disto agrupar objetos com as mesmas propriedades.
Referências:
https://developers.google.com/v8/design?hl=en
http://thibaultlaurens.github.io/javascript/2013/04/29/how-the-v8-engine-works/
## Qual a diferença entre um sistema single para um multi-thread?
Em um sistema single thread todas as requisições são enfileiradas, para uma requisição iniciar, a anterior deve ter sido finalizada.
Em um sistema mult thread mais de uma requisição pode ser inciada simultaneamente.
## Como a Thread Pool tem um tamanho padrão de 4, o que acontece se você enviar 5 requisições ao banco?
A quinta requisição entra em uma fila de espera até que uma das outras quatro libere o acesso a esta.
## Como você venderia o peixe do Node.js na sua empresa para tentar convencer seu chefe da sua adoção?
Node é baseado em javascript, a linguagem que todo desenvolvedor de aplicações web e hibridas deveria ter um bom nível de conhecimento.
Tirando as particularidades do javascript, qualquer desenvolvedor de outra linguagem back-end ou programador javascript front-end terá uma curva
de aprendizagem pequena versus a produtividade possível.
É uma linguagem rápida, fácil de escalar que além de ser open source já esta sendo adotada por grandes players de mercado como netflix, pay pal e wallmart.
Alguns destes players divulgam com frequência números tanto de dedempenho quanto de produtividade ganhos com a adoção do NodeJS.
## Qual a versão do seu `node`?
v5.0.0
## Qual a versão do seu `npm`?
3.3.6 | {
"repo_name": "Webschool-io/be-mean-instagram-nodejs-exercises",
"stars": "33",
"repo_language": "JavaScript",
"file_name": "index.jade",
"mime_type": "text/plain"
} |
# NodeJS - Aula 01 - Exercício
**Autor**: Igor luíz
**Github**: [Halfeld](https://github.com/Halfeld)
**Data**: 1455743835692
#### 1. Explique como um processo síncrono e assíncrono roda no Node.js, dê um exemplo para cada.
**síncrono**: Aqui os processos são realizados um depois do outro, ou seja, tendo dois processos, o segundo só começa quando o primeiro terminar.
**assíncrono**: Aqui os processos são realizados paralelamente, ou seja, tendo dois processos, eles executam juntos.
#### 2. Como o V8 executa JavaScript? Demonstre 1 exemplo com código ou imagem.
O V8 transforma o código escrito em javacript e compila para linguagem de maquina, manipulando alocação de memória.
_Exemplo:_
>**I/O**
>Código JavaScript ==> V8 ==> libuv ==> Sistema Operacional
>
>**Callback**
>Sistema Operacional ==> libuv ==> V8 ==> Código JavaScript
#### 3. Qual a diferença entre um sistema single para um multi-thread?
Com o _single thread_ vocẽ econômiza mais memória, pois você pode ter a instancia de um processo por vez, já com o _multi-thread_ você pode ter os processos e os auxiliares do processo além dos outros threads rodando em paralelo.
#### 4. Como a Thread Pool tem um tamanho padrão de 4, o que acontece se você enviar 5 requisições ao banco?
Como ele é I/O bloqueante, 1 das requisições vai ter que esperar as 4 outras terminarem, entretando um _cluster_ resolveria o problema.
#### 5. Como você venderia o peixe do Node.js na sua empresa para tentar convencer seu chefe da sua adoção?
Demonstraria o funcionamento do Node de forma simples e com linguagem mais coloquial o possível(tratando de alguém que não sacasse dos paranauê), resaltando como ele poderia dimuir o tempo de trabalho, dor de cabeça e aumentando eficiência e satifação do clientes dele.
#### 6. Qual a versão do seu `node`?
v5.5.0
#### 7. Qual a versão do seu `npm`?
3.3.12 | {
"repo_name": "Webschool-io/be-mean-instagram-nodejs-exercises",
"stars": "33",
"repo_language": "JavaScript",
"file_name": "index.jade",
"mime_type": "text/plain"
} |
# Node.js - Aula 01 - Exercício
**user:** [viniciusmazzeo](https://github.com/viniciusmazzeo)
**autor:** Vinicius Moreira Mazzeo
**date:**
## Explique como um processo síncrono e assíncrono roda no Node.js, dê um exemplo para cada.
Processos síncronos funcionam de forma sincronizada, há uma ordem definida, um processo novo só pode ser executando após o atual ser terminando.
Como exemplo uma fila de banco com apenas um caixa, você tem uma fila de clientes e eles são atendidos apenas um por vez, o próximo cliente só é atendido quando o atendimento do atual cliente terminar.
**síncrono**
```js
function a(){
console.log("a");
}
function b(){
console.log("b");
}
a();
b();
```
As funções serão executadas em ordem, primeiro a, depois b.
Já um processo assíncrono não precisa esperar a sua vez para ser executado ele já é executando sem esperar o atual terminar, gerando um ganho de desempenho da aplicação.
Com o mesmo exemplo do banco, um processo assíncrono funciona da seguinte forma, ao chegar no banco as pessoas retiram senhas em um ordem mas como neste banco possui vários caixas apenas podem ser atendidas simultaneamente, ela não precisa esperar o atendimento anterior terminar pois já é possível ser atendida ao mesmo tempo.
**assíncrono**
```js
function a(){
console.log("Assíncrono aqui");
}
function b(){
setTimeout(a, 0);
console.log("b");
}
b();
```
O resultado sera
b
Assíncrono aqui
## Como o V8 executa JavaScript? Demonstre 1 exemplo com código ou imagem.
O V8 foi feito em C++ ele é um interpretador de JavaScript, com o V8 podemos executar o JavaScript no servidor.
Ele recebe o código JavaScript, compila esse código para um código nativo de máquina assim podendo executá-lo.
Fazendo uma comparação o V8 seria como um Vitual Machine do Java, graças a ele conseguimos executar nosso script feito em JS no servidor.
## Qual a diferença entre um sistema single para um multi-thread?
Single thread ele gera apenas uma processo gerenciando este únicos processo, com isso gera uma economia de processamento de memória, os sistemas multi-thred gera uma nova thered para casa processo, para cada requisição, com isso acaba gerando um consumo de memória e processamento maior.
## Como a Thread Pool tem um tamanho padrão de 4, o que acontece se você enviar 5 requisições ao banco?
Caso seja feita 5 requisições, a quinta fica aguardando o término de uma das requisições para assim entrar na thread pool.
## Como você venderia o peixe do Node.js na sua empresa para tentar convencer seu chefe da sua adoção?
Mostraria que os custos seriam reduzido, pois o node é assíncrono com isso reduziria o consumo de memória e processamento automaticamente reduzindo custos.
Mostraria a melhora de desempenho que o Node poderia trazer.
Por possuir muitas bibliotecas opensource e a cada dia surge uma nova, assim reduzindo custos com softwares de terceiros.
A aplicação seria desenvolvida em JavaScript uma linguagem difundida no mercado.
## Qual a versão do seu `node`?
```js
~$ node -v
v6.2.2
```
## Qual a versão do seu `npm`?
```js
~$ npm -v
3.9.5
``` | {
"repo_name": "Webschool-io/be-mean-instagram-nodejs-exercises",
"stars": "33",
"repo_language": "JavaScript",
"file_name": "index.jade",
"mime_type": "text/plain"
} |
# Node.js - Aula 01 - Exercício
**user:** https://github.com/VagnerSilva
**autor:** Vagner Pereira Silva
**date:** 26/03/2016
## Explique como um processo síncrono e assíncrono roda no Node.js, dê um exemplo para cada.
Assíncrono: Independe do término de execução de alguma atividade. São funções executadas de forma tardia, cujo chamamos de callback.
No nodejs quase todas as funções são assíncronas.
```js
fs.readFile('./Index.html', function read(err, data) {
console.log(data)
}
```
Síncrono: seu processamento e realizado de forma sequencial, ou seja, o início de uma tarefa depende do termino da outra.
No nodejs as funções síncronas utilização o "prefixo" sync
ex:.
```js
var data = fs.readFileSync(filename, "utf8");
console.log(data);
```
## Como o V8 executa JavaScript? Demonstre 1 exemplo com código ou imagem.
## Qual a diferença entre um sistema single para um multi-thread?
No multi-theard temos um thread para cada requisição, no single, como o nome mesmo sugere temos apenas uma thread, tratando as requisições.
## Como a Thread Pool tem um tamanho padrão de 4, o que acontece se você enviar 5 requisições ao banco?
Por padrão a thread pool é de 4 no Node, mas pode ser configurada para até 128 threads.
No caso de os valores de requisição ser maior, as requisições excedentes ficam na fila aguardando as demais serem executadas.
## Como você venderia o peixe do Node.js na sua empresa para tentar convencer seu chefe da sua adoção?
Fazendo um exemplo básico e mostrando suas vantagens.
## Qual a versão do seu `node`?
C:\>node -v
v5.7.1
## Qual a versão do seu `npm`?
C:\>npm -v
3.6.0
| {
"repo_name": "Webschool-io/be-mean-instagram-nodejs-exercises",
"stars": "33",
"repo_language": "JavaScript",
"file_name": "index.jade",
"mime_type": "text/plain"
} |
#NodeJS - Aula 01 - Exercícios
autor: Dariano Soares
##1. Explique como um `processo síncrono e assíncrono` roda no Node.js, dê um exemplo para casa.
Um procedimento **Sícrono** é aquele em que uma operação ocorre após o término de outra.
```js
console.log('1');
correr();
console.log('3');
function carrer(){
console.log('2');
}
```
Um procedimento **assíncrono** não bloqueia a execução do código. Se um procedimento leva certo tempo para ser encerrado, a linha após esse procedimento será executada antes dele terminar.
```js
console.log('1');
correr();
console.log('3');
function correr(){
setTimeout(function(){
console.log('2');
}, 10);
}
```
Referência -> Livro Construindo Aplicações com NodeJS, William Bruno Moraes.
##2. Como o v8 executa JavaScript? Demostre 1 exemplo com código ou imagem.
##3. Qual a diferença entre um sitema `single` para um `multi-thread`?
Em **Single Thread** cada aplicação terá instância de um unico processo. Uma tarefa será executa enquanto a outra fica aguardando o termino da primeira para ser executada na seguência.
Em **Multi Thread** uma aplicação pode ter varias tarefas sendo executada em paralelo usando mais de um processo do sistema.
##4. Como a `Thread Pool` tem um tamanho `padrão de 4`, o que acontece se você `enviar 5 requisições` ao banco?
A 5 requisição fica na Idle Thread esperando a finalização de uma das 4 requisições para ser redirecionada a Thread Pool.
##5. Como você `venderia o peixe do Node.js` na sua empresa para tentar convencer seu chefe da sua adoção?
> * Grandes empresas já adotaram o NodeJs em seus projetos. Empresas como Walmart, Linkdin, Pay Pal, Uber estão usando o NodeJs.
> * Existe uma comunidade participativa.
> * Existem muitos modulos prontos que facilitam o desenvolvimento podendo aumentar a produtividade.
> * O Nodejs utiliza o Google V8 JavaScript Engine e você desenvolve usando javascript, com isso é possível ter uma única linguagem em todo o sistema tanto no front-end, back-end e no banco de dados.
> * O Nodejs é open source e multiplataforma.
> * Permite uma maneira simples de desenvolver programas de rede que precisem escalar.
##6. Qual a versão do seu `node`?
v5.1.0
##7. Qual a versão do seu `npm`?
3.3.12 | {
"repo_name": "Webschool-io/be-mean-instagram-nodejs-exercises",
"stars": "33",
"repo_language": "JavaScript",
"file_name": "index.jade",
"mime_type": "text/plain"
} |
# Node.js - Aula 01 - Exercício
autor: Angelo Rogério Rubin
## Explique como um processo síncrono e assíncrono roda no Node.js, dê um exemplo para cada.
Por exemplo, se você quiser ler um arquivo no node você pode fazê-lo de forma assíncrona:
var fs = require('fs');
fs.readFile('/path', function(err, buf) {
console.log(buf.toString());
});
O node continuará a executar qualquer código javascript que encontre durante a leitura do arquivo. Uma vez que todo o javascript foi executado e o arquivo foi lido, ele executará a função anônima e imprimirá o conteúdo do arquivo.
Você pode fazer a mesma tarefa de forma síncrona:
var fs = require('fs');
var contents = fs.readFileSync('/path').toString();
console.log(contents);
No código acima o conteúdo será definido para a variável contents e nenhum código javascript será executado enquanto o arquivo está sendo lido.
A primeira abordagem é feita de forma assíncrona e voltará imediatamente para não bloquear o código executado.
A segunda é feita de forma síncrona e irá parar a execução do código até que a tarefa seja concluída.
## Como o V8 executa JavaScript? Demonstre 1 exemplo com código ou imagem.
O trabalho da engine (motor) V8 do google é compilar o javascript para código nativo da maquina, para depois executá-lo.
## Qual a diferença entre um sistema single para um multi-thread?
Thread é uma forma de um processo dividir a si mesmo em duas ou mais tarefas que podem ser executadas concorrencialmente. O suporte à thread é fornecido pelo próprio sistema operacional, no caso da linha de execução ao nível do núcleo (em inglês: Kernel-Level Thread (KLT)), ou implementada através de uma biblioteca de uma determinada linguagem, no caso de uma User-Level Thread (ULT).
Uma thread permite, por exemplo, que o usuário de um programa utilize uma funcionalidade do ambiente enquanto outras linhas de execução realizam outros cálculos e operações.
O node utiliza apenas uma thread para executar suas tarefas, podendo outras serem criadas, desta forma economizando memória. Portanto ele não precisa criar um novo processo para cada novo usuário poupando CPU.
Enquanto um sistema multi-thread utiliza várias threads para executar suas tarefas e desta forma acaba consumindo muito mais seus recursos computacionais, tais como: memória, cpu, etc.
Um bom exemplo é o Apache, ele é um servidor HTTP multi-threaded, para cada pedido que o servidor recebe ele cria uma thread separada que lida com esse pedido.
## Como a Thread Pool tem um tamanho padrão de 4, o que acontece se você enviar 5 requisições ao banco?
A quinta requisição aguarda a liberação de uma thread para ser executada.
Segundo a documentação da [libuv](http://docs.libuv.org/en/v1.x/threadpool.html) o tamanho padrão da thread pool é 4, mas pode ser alterado em tempo de inicialização, definindo a variável de ambiente UV_THREADPOOL_SIZE para qualquer valor (o máximo absoluto é de 128).
## Como você venderia o peixe do Node.js na sua empresa para tentar convencer seu chefe da sua adoção?
Citando os pontos fortes do node:
+ Permite criar aplicações de rede rápidas e escaláveis;
+ Utiliza o modelo de I/O não bloqueante e baseado em eventos;
+ As aplicações Node.js executam em uma única thread;
+ Assíncronicidade;
+ Você pode trabalhar com a mesma linguagem (javascript) no Front, Back-End e Base de Dados.
## Qual a versão do seu `node`?
PS C:\Projetos\be-mean-instagram-nodejs-exercises> node --version
v0.12.4
## Qual a versão do seu `npm`?
PS C:\Projetos\be-mean-instagram-nodejs-exercises> npm --version
2.10.1 | {
"repo_name": "Webschool-io/be-mean-instagram-nodejs-exercises",
"stars": "33",
"repo_language": "JavaScript",
"file_name": "index.jade",
"mime_type": "text/plain"
} |
## Class 01 - Estevan Jantsk
1. Explique como um processo síncrono e assíncrono roda no Node.js, dê um exemplo de cada.
##### Async
```javascript
var filesystem = require("fs");
filesystem.readFile("arquivoex.txt", "utf8", function(error, data) {
console.log(data);
});
```
No exemplo acima, a função readFile recebe como parâmetro o nome do arquivo que será lido e como callback uma função. Sendo executada de forma assíncrona outras leituras de arquivos poderiam ser executadas ao mesmo tempo. Sempre que a leitura do arquivo termina, a função de callback irá printar o seu conteúdo no log. Por ser async, o desempenho da aplicação não irá prejudicar no sistema.
##### Sync
```javascript
var filesystem = require("fs");
var data = filesystem.readFileSync("arquivoex.txt", "utf8");
console.log(data);
```
Já neste outro exemplo, a função readFileSync irá receber como parâmetro o nome do arquivo que seá lido, porém como ela é executada de forma síncrona os códigos abaixo dela não serão executados enquanto ela não terminar de ler o arquivo, isso é extremamente ruim, pois não irá possibitar outras tarefas serem executadas enquanto essa outra não terminar.
2. Como o V8 executa JavaScript? Demonstre 1 exemplo com código ou imagem.
javascript code -> Chrome V8 Engine -> Native Machine Code
O V8 compila código feito em JS para código nativo de máquina antes de executá-lo.
3. Qual a diferença entre um sistema single para um multi-thread?
Depende, no caso do Node, ele é single thread no entanto ele conta com o event loop que faz todo o gerenciamento de recebimento de operações, cadastramentos de callbacks e quando a operação estiver completa disparar o callback para quem fez a requisição. Já para um sistema multi thread, cada operação vira uma thread e cada thread tem um custo de memória que pode impactar no funcionamento e disponibilidade do seu sistema.
4. Como a Thread Pool tem um tamanho padrão de 4, o que acontece se você enviar 5 requisições ao banco?
Se todas as threads estiverem ocupadas os próximos requests começarão a serem enfileirados e executados de acordo com a disponibilidade.
5. Como você venderia o peixe do Node.js na sua empresa para tentar convencer seu chefe da sua adoção?
Com certeza iria mostrar o case de sucesso do Paypal que mostra como eles ganharam demais ao migrado do java para node.js.
Pontos interessantes: redução de código (linhas escritas), redução na quantidade de arquivos (comparado aos XML's da vida do Java), velocidade no desenvolvimento e também a redução na quantidade de pessoas que precisaria para realizar um projeto. E principalmente por ser TUDO JAVASCRIPT s2.
6. Qual a versão do seu 'node'?
```sh
node -v
v4.4.4
```
7. Qual a versão do seu 'npm'?
```sh
npm -v
2.15.1
``` | {
"repo_name": "Webschool-io/be-mean-instagram-nodejs-exercises",
"stars": "33",
"repo_language": "JavaScript",
"file_name": "index.jade",
"mime_type": "text/plain"
} |
# Node.js - Aula 01 - Exercício
**user:** [mauriciord](https://github.com/mauriciord)
**autor:** Maurício Reatto Duarte
**date:** 15/07/2016
## Explique como um processo síncrono e assíncrono roda no Node.js, dê um exemplo para cada.
Em termos simples, programação **síncrona** é fazer uma coisa a seguir à outra, sendo de execução sequencial e linear. Quando há comandos a serem executados, são efetuados somente após o término do comando anterior.
### Exemplo de processo síncrono com nodeJS
```js
var fs = require('fs');
var arquivo = "./index.html";
var rdf = fs.readFileSync(arquivo, "utf8");
res.writeHead(200, {"Content-type":"text/html"});
res.write(rdf);
res.end();
```
*Você pode observar que o javascript aguardou o leitura do arquivo*
Já a programação **assíncrona**, é quando a rotina acaba sendo não bloqueante, ou seja, no caso do nodeJS, é enviada ao _Event Loop_ e o resto dos comandos continuam a executar normalmente.
### Exemplo de processo assíncrono com nodeJS
```js
var fs = require('fs');
var arquivo = "arquivo.txt";
fs.readFile(arquivo, function(err, data){
if(err) return console.error(err);
console.log(data.toString());
});
console.log('Vamos ver qual aparece antes');
```
## Como o V8 executa JavaScript? Demonstre 1 exemplo com código ou imagem.
## Qual a diferença entre um sistema single para um multi-thread?
Sistema single-thread, conforme o nome sugere, temos apenas uma thread tratando as requisições com um único processamento(isso evita gasto de processamento), porém elas são tratadas no _Event Loop_.
Já no caso da Multi-thread, para cada processamento no servidor, é gerado uma thread, tendo assim um gasto maior de processamento.
## Como a Thread Pool tem um tamanho padrão de 4, o que acontece se você enviar 5 requisições ao banco?
Será executada apenas quando uma das quatro terminar, liberando espaço para essa nova requisição. O limite padrão é 4, porém com expansão até 128 requisições.
# Como você venderia o peixe do Node.js na sua empresa para tentar convencer seu chefe da sua adoção?
Primeiramente, eu explicaria para ele sobre o menor gasto de processamento, por ser S.T. e que isso poderia reduzir gastos com servidores. Depois para reforçar, iria demonstrar os casos de uso das famosas e medias empresas que usaram Node.js e que obtiveram resultados satisfatórios.
## Qual a versão do seu `node`?
v6.3.0
## Qual a versão do seu `npm`?
3.10.3
| {
"repo_name": "Webschool-io/be-mean-instagram-nodejs-exercises",
"stars": "33",
"repo_language": "JavaScript",
"file_name": "index.jade",
"mime_type": "text/plain"
} |
# Node.js - Aula 01 - Exercício
**user:** [Pauloxt1](https://github.com/Pauloxt1)<br>
**autor:** Paulo Roberto<br>
**date:** 1452734591897
## Explique como um processo síncrono e assíncrono roda no Node.js, dê um exemplo para cada.
<b>Síncrono:</b> Supondo que uma pessoa fez uma requisição via htttp, em um processo sícrono o Node teria que esperar essa
requisão ser completada para ai sim atender outras requisições.<br>
<b>Assíncrono:</b> É o oposto do síncrono, pegando o mesmo exemplo da requisão http, nesse caso o Node pode atender outras
requisições, mesmo que uma não esteja completa. Ele iria atender as requisições e devolver as respostas de acordo com que
ficassem prontas tudo isso assíncronicamente.
## Como o V8 executa JavaScript? Demonstre 1 exemplo com código ou imagem.
Como você pode ver o motor V8 é responsável pela parte de Event Loop, que é responsável por redirecionar todas as requisições e respostas
pro seus devidos lugares, de forma assíncrona, sendo assim simultaneamente uma requisição não precisa esperar outra ser completada
até ser levada a seu devido lugar ou receber sua resposta.
## Qual a diferença entre um sistema single para um multi-thread?
<b>Single:</b> Coloca todas requisições em uma única thread, diminuindo gastos de processamento.<br>
<b>Multi:</b> Gera uma thread para cada requisição no servidor, tendo assim uma maior gasto de processamento.
## Como a Thread Pool tem um tamanho padrão de 4, o que acontece se você enviar 5 requisições ao banco?
A quinta só será executada, quando 1 das 4 forem executadas. Liberando espaço para próxima.<br>
<b>Lembrando que o limite é 4 por default, porém pode ser expandido até 128 requisições.</b>
## Como você venderia o peixe do Node.js na sua empresa para tentar convencer seu chefe da sua adoção?
Simplesmente mostrando dados de empresas que migraram de outras técnologias para o nodeJS, o ganho de perfomace que eles
obtiveram e também a diminuição de tempo gasto em produção.
## Qual a versão do seu `node`?
```
paulo@Paulo:~/Documentos/testando$ node -v
v5.4.1
```
## Qual a versão do seu `npm`?
```shell
paulo@Paulo:~/Documentos/testando$ npm -v
3.3.12
```
| {
"repo_name": "Webschool-io/be-mean-instagram-nodejs-exercises",
"stars": "33",
"repo_language": "JavaScript",
"file_name": "index.jade",
"mime_type": "text/plain"
} |
# Node.js - Aula 01 - Exercício
**user:** https://github.com/rafael-pessoni
**autor:** Rafael Bertanha Pessoni
## Explique como um processo síncrono e assíncrono roda no Node.js, dê um exemplo para cada.
#### Processos Síncronos:
Os síncronos bloqueiam a Thread de execução do node, fazendo com que o node consiga responder somente 1 Request por vez.
Um ótimo exemplo para isso é o atendimento de um restaurante, no modelo síncrono, o garçom pegaria o pedido do cliente na mesa, passaria este pedido para a cozinha, e esperaria a finalização deste pedido para ir atender a segunda mesa.
#### Processos Assíncronos:
Os processos assíncronos não bloqueiam a Thread de execução do node, permitindo assim que ele trabalhe na resposta de mais de um Request simultaneamente. A maior vantagem deste modelo está em situações onde, dentro da resposta do Request existe um grande processamento de I/O por exemplo, esse processamento é feito por componentes externos ao node, então, ele não precisa esperar esse processamento terminar para começar a trabalhar em outro Request.
Voltando ao exemplo do restaurante, no modelo assíncrono, o garçom pegaria o pedido do cliente, passaria para a cozinha, e enquanto a cozinha prepara o prato, o garçom atende a segunda mesa.
## Como o V8 executa JavaScript? Demonstre 1 exemplo com código ou imagem.
Sempre que algo acontece no node um evento é disparado, esse evento então entra no final da fila de eventos(Event Queue), o Event Loop pega o primeiro item da fila e o direciona aos componentes da thread pool, e é nesse momento que a principal característica do node entra em ação, ele não espera até que o elemento da thread pull termine seu processamento, ele continua se trabalho pegando o próximo elemento da fila, quando o elemento da Thread Pool termina o processamento, um novo evento entra na Event Queue, esse evento é chamado de callback
## Qual a diferença entre um sistema single para um multi-thread?
Um bom exemplo para isso seria o funcionamento de um posto de combustível, imagine um posto de combustível com uma única bomba, todos os carro teriam que se enfileirar para serem atendidos, este é o funcionamento de um sistema sigle-thread, já no multi-thread, vários clientes podem ser atendidos de uma única vez, como em um posto convencional, neste exemplo cada bomba de combustível representa um processador, ou core de processador.
O node é single thread, mas como é assíncrono também, ele consegue atender a varias requisições ao mesmo tempo, o problema está em quando ele é forçado a fazer algo síncrono, toda essa velociada é jogada fora.
## Como a Thread Pool tem um tamanho padrão de 4, o que acontece se você enviar 5 requisições ao banco?
Elas são enfileiradas para serem atendidas assim que uma for resolvida, mas este tamanho pode ser configurado
## Como você venderia o peixe do Node.js na sua empresa para tentar convencer seu chefe da sua adoção?
Mostrando os grandes casos de sucesso, e também, a sua superioridade diante de alguns cenários
## Qual a versão do seu `node`?
[rafael.pessoni@localhost nodejs]$ node --version
v0.10.41
## Qual a versão do seu `npm`?
[rafael.pessoni@localhost nodejs]$ npm --version
3.6.0
| {
"repo_name": "Webschool-io/be-mean-instagram-nodejs-exercises",
"stars": "33",
"repo_language": "JavaScript",
"file_name": "index.jade",
"mime_type": "text/plain"
} |
# Node.js - Aula 01 - Exercício
**Autor:** Eric Lessa
**User:** [falconeric](https://github.com/falconeric)
**Data:** 1465880788
## Explique como um processo síncrono e assíncrono roda no Node.js, dê um exemplo para cada.
Processos síncronos são processos bloqueantes, só permitirão que outros processos sejam executados após que este tenha terminado. Na documentação do Node.JS temos um exemplo de processo assíncro, veja:
```
const fs = require('fs');
fs.unlinkSync('/tmp/hello');
console.log('successfully deleted /tmp/hello');
```
neste exemplo o log só será exibido quando **fs.unlinkSync** terminar de executar.
Processos assíncronos em Node.JS não esperam que um processo seja concluido para iniciar outro, quando um processo é concluido é emitido um evento informando o resultado, chamamos esse evento de callback. Veja o exemplo de um processo assíncrono:
```
const fs = require('fs');
fs.unlink('/tmp/hello', (err) => {
if (err) throw err;
console.log('successfully deleted /tmp/hello');
});
```
o exemplo acima retirado da documentação do Node.JS apresenta uma forma melhorada da versão síncrona, desta vez é passado um callback para o método **fs.unlink** que informa o resultado da operação.
## Como o V8 executa JavaScript? Demonstre 1 exemplo com código ou imagem.
Em termos simples, o v8 pega o código-fonte, divide em strings, converte em bytecode que um compilador pode entender, e então executa.
V8 compila código javascript diretamente em código máquina quando executado pela primeira vez. Sem bytecodes intermediários, sem interpretador. O acesso as propriedades é tratado pelo código em cache que pode ser corrigido com outras instruções de máquina enquanto V8 é executado.
Durante a execução inicial do código para acessar uma propriedade de um determinado objeto, V8 define o objeto atual uma classe escondida. V8 otimiza o acesso à propriedade, prevendo que esse objeto também será usado por todos os objetos futuros acessados na mesma seção do código e use as informações na classe para corrigir o código em cache para usar a classe escondida. Se V8 previu corretamente o valor da propriedade é atribuído (ou forçado) em uma única operação. Se a previsão estiver incorreta, V8 corrige o código para remover a otimização.
Por exemplo, o código JavaScript para acessar a propriedade *x* de um objeto *Point* é:
```
point.x
```
Em V8, o código de máquina gerado para acessar *x* é:
```
# ebx = the point object
cmp [ebx,<hidden class offset>],<cached hidden class>
jne <inline cache miss>
mov eax,[ebx, <cached x offset>]
```
Se o objeto classe escondido não corresponde à classe escondida em cache, a execução salta para o sistema de execução V8 que lida com erros de cache e corrige o código em cache embutido. Se houver uma correspondência, o que é o caso comum, o valor da propriedade x é simplesmente recuperado.
**referência:** [Chrome V8](https://developers.google.com/v8/design#dynamic-machine-code-generation)
## Qual a diferença entre um sistema single para um multi-thread?
Em sistemas single-thread quando executamos um programa temos um fluxo único(thread) de controle sequencial.
Em sistemas multi-thread podemos ter multiplas threads sendo processadas ao mesmo tempo
>Thread é uma forma de um processo dividir a si mesmo em duas ou mais tarefas que podem ser executadas concorrencialmente.
## Como a Thread Pool tem um tamanho padrão de 4, o que acontece se você enviar 5 requisições ao banco?
A quinta requisição vai ter que aguardar uma das outras quatro requisições terminar. Isso não significa que o event-loop será bloqueado ele continua atendendo novas requisições maaaas elas terão que aguardar.
## Como você venderia o peixe do Node.js na sua empresa para tentar convencer seu chefe da sua adoção?
Falaria das vantagens do Node.js em relação a tecnologia utilizada pela nossa empresa e que os custos da operação para migrar de tecnologia se refletiriam em economia de gastos no futuro, falaria da baixa curva de aprendizado e alta disponibilidade de profissionais javascript citaria cases de sucesso de grandes empresas que migraram para o Node.js.
## Qual a versão do seu `node`?\
v4.4.4
## Qual a versão do seu `npm`?
2.15.1
| {
"repo_name": "Webschool-io/be-mean-instagram-nodejs-exercises",
"stars": "33",
"repo_language": "JavaScript",
"file_name": "index.jade",
"mime_type": "text/plain"
} |
# Node.js - Aula 01 - Exercício
autor: Igor Vidotto Felipe
#### 1 - Explique como um processo síncrono e assíncrono roda no Node.js, dê um exemplo para cada.
###### Processo Síncrono
Os processos síncronos invocam chamadas de I/O bloqueante, isso significa que para cada operação de I/O o sistema ficará bloqueado executando este processo e não poderá executar outro até que este termine.
Um exemplo seria um forno pequeno, no qual poderíamos cozinhar apenas uma coisa por vez.
###### Processos Assíncronos
Os processos assíncronos invocam chamadas de I/O "não-bloqueantes", ou seja, enquanto este processo está executando o sistema não vai ter que esperar ele terminar para que possa iniciar o processamento de outro. No entanto essa abordagem não nos permite saber quando esse processo irá finalizar sua execução, por isso devemos usar funções de *callback*, que serão invocadas quando este processo efetivamente for finalizado.
Em contraste com o exemplo do processo síncrono, podemos citar aqui um forno maior, o que nos permitiria cozinhar várias coisas de uma só vez, todavia teríamos que colocar um dispositivo para informar quando cada prato ficasse pronto (*callback*).
#### 2 - Como o V8 executa JavaScript? Demonstre 1 exemplo com código ou imagem.
O V8 compila e executa o código fonte JavaScript, manipula alocação de memória para objetos, e faz uma limpeza na memória de objetos que não são mais necessários.
O JavaScript é mais comumente utilizado para script *client-side* num navegador, sendo usado para manipular os objetos do *Document Object Model (DOM)*, por exemplo. O DOM, no entanto não é fornecido pelo motor do JavaScript, mas sim por um navegador. O mesmo acontece com o V8 - O Google Chrome que fornece o DOM. Porém o V8 fornece todos os tipos de dados, operadores, objetos e funções especificados no padrão ECMA.
O V8 ainda permite que qualquer aplicação `C++` exiba seus próprios objetos e funções para o código JavaScript.
Podemos encontrar exemplos de como o V8 trabalha com JavaScript no site [Google Developers](https://developers.google.com/v8/). Eis um [código](http://v8-io12.appspot.com/#30) utilizado no evento Google I/O "Breaking the JavaScript Speed Limit with V8" para exemplificar as atuações desse motor.
#### 3 - Qual a diferença entre um sistema single para um multi-thread?
Um sistema **single-thread** pode ter a instância de um único processo por vez ao passo que o **multi-thread** pode conter vários processos com seus subcomponentes ou threads em paralelo, sendo que quando uma thread está fazendo uma operação de I/O as tarefas restantes podem fazer uso da CPU.
A princípio isso pode parecer uma grande desvantagem para o Node.js, porém um sistema multi-thread corre o risco de sofrer um [*deadlock*](http://www.devmedia.com.br/introducao-ao-deadlock/24794), algo que uma aplicação em Node.js não precisa se preocupar, e ainda mais, há a possibilidade de implementar a programação concorrente no Node.js por meio do [*cluster*](https://nodejs.org/dist/latest-v5.x/docs/api/cluster.html), que é um módulo nativo dele.
#### 4 - Como a Thread Pool tem um tamanho padrão de 4, o que acontece se você enviar 5 requisições ao banco?
As 4 threads dessa *Thread Pool* tratarão do processamento de 4 requisições. Pelo fato dessas requisições serem **I/O bloqueante** (síncronas) a requisição que não foi atribuída à uma thread terá que esperar a liberação de alguma das 4 para que somente então possa ser processada.
#### 5 - Como você venderia o peixe do Node.js na sua empresa para tentar convencer seu chefe da sua adoção?
Primeiro eu mostraria as vantagens que existem no modelo *Single-Threaded* com *Event-Loop* do Node.js em relação ao *Multi-Threaded* de outras plataformas, baseando-se na forma em que servidor responde às requisições dos *clients*, evitando gargalos comuns que existem em outras plataformas, como consumo excessivo de memória e risco do sistema sofrer um *deadlock*. Mostrando ainda que também é possível trabalhar de forma concorrente com o módulo *cluster* nativo do Node.js.
Numa arquitetura comum, ficaria muito custoso montar um servidor para suportar várias requisições simultâneas, todavia o Node.js faz o uso máximo do poder de processamento de um servidor e utiliza pouca memória, o que quer dizer que o hardware do servidor não precisa ser excelente para suportar um alto número de requisições e proporcionar uma resposta rápida a elas.
#### 6 - Qual a versão do seu `node`?
```
node -v
v5.2.0
```
#### 7 - Qual a versão do seu `npm`?
```
npm -v
3.3.12
```
| {
"repo_name": "Webschool-io/be-mean-instagram-nodejs-exercises",
"stars": "33",
"repo_language": "JavaScript",
"file_name": "index.jade",
"mime_type": "text/plain"
} |
# Node.js - Aula 01 - Exercício
autor: Carlos Alberto de Araujo Barreto
## Explique como um processo síncrono e assíncrono roda no Node.js, dê um exemplo para cada.
Por padrão no node as funções são assíncronas, assim ele trabalha comcall backs pós finalização de processamento dos processos assíncronos.
Abaixo serão listados exemplos dos dois casos.
### Síncrono
A tarefa é executada de maneira que deixa a thread "presa" na sua execução, enquanto não finalizar essa tarefa a thread não é liberada.
Exemplo:
```
var arquivo = require("fs");
// Abaixo a função readFileSync lê completamente o conteúdo do arquivo e então exibe os dados via console
// Como essa função é síncrona o sistema só passa para a próxima linha de código quando terminar de ler completamente o arquivo.
var data = arquivo.readfileSync("exemplo.txt", "utf8");
console.lod(data);
```
### Assíncrono
A tarefa é executada de forma paralela, assim várias tarefas são executadas "simultaneamente". Como o node usa uma Thread somente as tarefas são executadas numa fila
chamada event loop onde cada tarefa é executada em um determinado tempo, não deixando a thread presa a tarefa.
Exemplo: Função Assíncrona de leitura de arquivo
```
var arquivo = require("fs");
// Abaixo o módulo de sistema de arquivos pega o nome do arquivo, os dados de referencia para o callback handler
// da função anonima. Então o objeto do sistema estará apto para processar qualquer outra operação
arquivo.readFile("exemplo.txt", "utf8", function(error, data) // Aqui o módulo de sistema de arquivos
{
console.log(data);
});
```
## Como o V8 executa JavaScript? Demonstre um exemplo com código ou imagem
O V8 compila o código de javascript para código nativo de máquina para depois executá-lo.
## Qual a diferença entre um sistema single thread para um multi-thread
A thread é responsável por executar tarefas, e uma thread pode apenas executar uma thread por vez(single thread).
No caso da multi-thread existem várias threads capazes de executar várias tarefas ao mesmo tempo.
## Como a thread pool tem um tamanho padrão de 4, o que acontece se você enviar 5 requisições ao banco?
Como a thread pool funciona como uma fila cíclica, a 5 requisição só será executada após uma das 4 threads terminar de executar.
## Como você venderia o peixe do Node.js na sua empresa para tentar convencer seu chefe da sua adoção?
Defendendo as características marcantes do node:
1 - Modularização de seus componentes
2 - Usa a javascript engine V8
3 - Possui um tempo de resposta rápido para volume de requisições entrada/saída
4 - Alta escalabilidade
5 - Alto desempenho com requisições assíncronas
## Qual a versão do seu node?
```
root@carlos-VirtualBox:/home/carlos# node -v
v5.2.0
```
## Qual a versão do seu npm?
```
root@carlos-VirtualBox:/home/carlos# npm -v
3.3.12
```
| {
"repo_name": "Webschool-io/be-mean-instagram-nodejs-exercises",
"stars": "33",
"repo_language": "JavaScript",
"file_name": "index.jade",
"mime_type": "text/plain"
} |
# Node.js - Aula 01 - Exercício
**autor:** Geriel Castro
## Explique como um processo síncrono e assíncrono roda no Node.js, dê um exemplo para cada.
####Processo Assíncrono
Um processo assíncrono consegue executar tarefas simultâneas. Após o processo finalizar, uma função de _callback_ deverá ser chamada.
Um detalhe importante sobre assincronismo é que, na maioria dos casos, os callbacks possuem como parâmetro uma variável de erro, que serve para impedir a execução dos callbacks subsequentes, caso haja algum problema.
```
function bar(){
console.log("Default: Hoegaarden");
}
function garcom(){
setTimeout(bar, 0);
console.log("Garçom? Me traz uma cerveja por favor!");
console.log("...");
}
garcom();
```
####Processo Síncrono
Processo executado apenas quando o seu antecessor finalizar. Como uma fila (Primeiro a entrar é o primeiro a sair, depois é chamado o próximo) é basicamente isso.
O primeiro a ser executado precisa finalizar o processo para executar o segundo e assim sucessivamente.
```
function garcom(){
console.log("Garçom? Me traz uma cerveja por favor!");
}
function bar(){
console.log("Default: Hoegaarden");
}
garcom();
bar();
```
<img src="http://i.stack.imgur.com/SFYbr.jpg" />
## Como o V8 executa JavaScript? Demonstre 1 exemplo com código ou imagem.
Ele interpreta o código JavaScript e o executa. O V8 é um interpretador escrito em C++ pelo Google no qual é possível integrá-lo em qualquer aplicativo. Assim, ele não fica restrito apenas ao navegador, e pode ser executado no servidor.
<img src="http://runtimejs.org/jsconf/img/runtimejs-arch.png" />
## Qual a diferença entre um sistema single para um multi-thread?
Um sistema _Single Thread_ é capaz de executar apenas uma tarefa por vez. Enquanto a tarefa é executada, todo o sistema aguarda que a _thread_ finalize para que possa seguir adiante.
Um sistema _Multi Thread_ consegue executar várias tarefas simultaneamente. Cada solicitação vira uma _thread_ e o servidor consegue trabalhar com ela isoladamente, sem intereferir nas outras.
## Como a Thread Pool tem um tamanho padrão de 4, o que acontece se você enviar 5 requisições ao banco?
Neste caso, a quinta requisição ficara no _Idle Thread_ aguardando a liberação de uma das quatro primeiras. Na sequência, ela é jogada para a _Thread Pool_ para ser executada.
## Como você venderia o peixe do Node.js na sua empresa para tentar convencer seu chefe da sua adoção?
Acredito que a melhor forma de convencer seria mostrando as vantagens que traria a empresa ao adota-lo. Mostraria tambem algumas empresas que possivelmente ja estão utilizando e como vem ajudando no desenvolvimento rapido e com menos custo.
## Qual a versão do seu `node`?
```
MacBook-Air-de-Geriel:be-mean-instagram-nodejs-exercises geriel$ node -v
v5.0.0
```
## Qual a versão do seu `npm`?
```
MacBook-Air-de-Geriel:be-mean-instagram-nodejs-exercises geriel$ npm -v
3.3.12
```
| {
"repo_name": "Webschool-io/be-mean-instagram-nodejs-exercises",
"stars": "33",
"repo_language": "JavaScript",
"file_name": "index.jade",
"mime_type": "text/plain"
} |
# Node.js - Aula 01 - Exercício
**user:** [higordiego](https://github.com/higordiego)
**autor:** Higor Diego Alves Ferreira Pinheiro
**date:** Wed Jan 27 2016 15:00:06 GMT-0300 (BRT)
## Explique como um processo síncrono e assíncrono roda no Node.js, dê um exemplo para cada.
Assíncrono:
Exemplo:
Quando um processo não depende do outro para terminar.
Exemplo: O garçom atende varias mesas sem precisar esperar na cozinha que o pedido seja feito, ele só
aguarda chamar ou seja (callback).
Síncrono:
Quando um processo depende do outro para acabar para passar do próximo.
Exemplo: Fila de pão, o atendente não consegue entregar e atender o cliente para pegar o pão sem que o primeiro cliente
já tenha sido atendido.
## Como o V8 executa JavaScript? Demonstre 1 exemplo com código ou imagem.
![Imagem V8]
(http://static.17ky.net/Images/20151215/6358579084581674429956854.png)
## Qual a diferença entre um sistema single para um multi-thread?
Single Thread: Sistema consegue executar apenas uma thread, assim fica dependendo de um processo terminar para ir para o outro.
Multi-thread: Trabalha com varias threads, caso o sistema trave um processamento ele inicia uma nova assim liberando o uso.
## Como a Thread Pool tem um tamanho padrão de 4, o que acontece se você enviar 5 requisições ao banco?
Em caso da quinta requisição será incluída uma thread na espera, até vagar uma thread para entrar em execução.
## Como você venderia o peixe do Node.js na sua empresa para tentar convencer seu chefe da sua adoção?
Mostraria o custo da tecnologia e tendências de mercado hoje, com base em perfomance e desempenho.
## Qual a versão do seu `node`?
nodejs $ node -v
v5.5.0
## Qual a versão do seu `npm`?
nodejs $ npm -v
3.3.12
| {
"repo_name": "Webschool-io/be-mean-instagram-nodejs-exercises",
"stars": "33",
"repo_language": "JavaScript",
"file_name": "index.jade",
"mime_type": "text/plain"
} |
# NodeJS - Aula 01 - Exercício
**Autor:** Fábio Calheiros (conta: fabiocalheiros)
**Data** 1450308789659
# 1. Explique como um processo síncrono e assíncrono roda no Node.js, dê um exemplo para cada.
```
Síncrono: Em um processo síncrono, a medida que os usuários irão acessá-la, ela vai gerando múltiplos processos no servidor. Um sistema de arquitetura síncrono vai enfileirar cadarequisição que são realizadas ao mesmo tempo e depois ele vai processando, uma a uma. Este modelo não permite múltiplos processamentos ao mesmo tempo. Enquanto uma requisição é processada, as demais ficam em espera, ou seja, a aplicação bloqueia os demais processos de fazer I/O no servidor, mantendo-os em um pequeno período de tempo numa fila de requisições ociosas.
Exemplo Síncrono:
var fs = require('fs'),
filenames,
i,
processId;
filenames = fs.readdirSync(".");
for (i = 0; i < filenames.length; i++) {
console.log(filenames[i]);
}
console.log("Ready.");
processId = process.getuid();
Assíncrono: O Servidor responde a primeira Requisição da fila e aguarda a sua chamada de retorno.
Ao mesmo tempo que atende a outras requisições ele fica atento a chamada de CALLBACK das outras requestes enviadas anteriormente.
Exemplo Assíncrono:
var fs = require('fs'),
processId;
fs.readdir(".", function (err, filenames) {
var i;
for (i = 0; i < filenames.length; i++) {
console.log(filenames[i]);
}
console.log("Ready.");
});
processId = process.getuid();
```
# 2. Como o V8 executa JavaScript? Demonstre 1 exemplo com código ou imagem.
O V8 compila o JavaScript para c++ alocando esses espaços na memoria criando classes escondidas, em tempo de execução,
a fim de ter uma representação interna do sistema de tipo e para melhorar o tempo de acesso as propriedades.
Exemplo:
https://www.future-processing.pl/wp-content/uploads/2015/04/threads-in-node.ja_.png
```
# 3. Qual a diferença entre um sistema single para um multi-thread?
```
Single-threded tem apenas uma thread que está executando todo o código no aplicativo, baseado em uma fila.
Multi-threaded tem mais de uma uma thread em execução ao mesmo tempo e pode ser executado simultaneamente, cada qual com usa fila de execuções.
```
# 4. Como a Thread Pool tem um tamanho padrão de 4, o que acontece se você enviar 5 requisições ao banco?
```
Neste caso, a quinta requisição, entrará na fila de execução, aguardando que o alguma requisição seja entregue para que ela entre em execução.
Para alterarmos isso, podemos usar a variavel "UV_THREADPOOL_SIZE" que torna posivel alterar a quantidade de Thread Pools que nossa aplicação vai receber.
Exemplo: UV_THREADPOOL_SIZE = 5
```
# 5. Como você venderia o peixe do Node.js na sua empresa para tentar convencer seu chefe da sua adoção?
```
Na verdade já vendi o peixe para o meu chefe.
Em uma conversa outro dia, expliquei a ele as novas tendências de como o node funciona.
Toquei em diversos assuntos como:
- o tempo de resposta é muito menor do que um site feito em php.
- A conversão de mídias, como mobile, desktop e web, por se tratar de código javascript é relativamente facil
- Mencionei um problema que tivemos recentemente com uploads de vídeos, onde o node possui recursos que não so possibilita isso, como também não salva o arquivo no servidor e sim em um banco de dados.
- Mencionei que ferramentas como o paypal, popkorn time, spotify, netiflix, todas elas utilizam nodejs.
- Expliquei também como o node é eficiente quando se trata de escabilidade, ou seja a medida de que a aplicação cresça é possivel como o mongoDb por exemplo dividir essas informações em variados servidores.
```
# 6. Qual a versão do seu `node`?
```
fabio@fabio-Inspiron-7520:~$ node -v
v5.2.0
```
# 7. Qual a versão do seu `npm`?
```
fabio@fabio-Inspiron-7520:~$ npm -v
3.3.12
``` | {
"repo_name": "Webschool-io/be-mean-instagram-nodejs-exercises",
"stars": "33",
"repo_language": "JavaScript",
"file_name": "index.jade",
"mime_type": "text/plain"
} |
#Node.js - Aula 01 - Exercício
##1. Explique como um processo síncrono e assíncrono roda no Node.js, dê um exemplo para cada.
De forma geral um processamento síncrono é uma fila única de processos, ou seja, um novo processo só começa quando o atual termina.
Já no processamento assíncrono não existe essa fila única, após responder a requisição de um processo o mesmo se inicia e o próximo já é atendido e iniciada execução, trazendo ganhos enormes de desempenho e eficiência. Para que seja gerenciado o termino dos processos, que não vai ocorrer na mesma ordem que foram iniciados, cada processo possui um callback que ao terminar o dispara, seu término é tratado como se deve e é dada continuidade ao processos.
Abaixo exemplos de uma execução síncrona e uma assíncrona de leitura de arquivos.
**Síncrona:**
```js
var fs = require('fs');
var conteudo = fs.readFileSync('./arq.txt', "utf8");
console.log(conteudo);
console.log('Leitura do primeiro arquivo terminou');
console.log('Ler próximo arquivo');
```
Retorno da execução:
> "1. Primeira linha do primeiro arquivo"
> "2. Segunda linha do primeiro arquivo"
> "3. Terceira linha do primeiro arquivo"
> "4. Quarta linha do primeiro arquivo"
> "Leitura do primeiro arquivo terminou"
> "Ler próximo arquivo"
**Assíncrona**
```js
'use strict'
var fs = require('fs');
fs.readFile('./index.txt',(err, result) => { //err e result são os callbacks de falha e sucesso, respectivamente
if(err) console.log(err);
console.log(result.toString());
console.log('Leitura do primeiro arquivo terminou');
})
console.log('Ler próximo arquivo');
```
Retorno da execução:
> "Ler próximo arquivo"
> "1. Primeira linha do primeiro arquivo"
> "2. Segunda linha do primeiro arquivo"
> "3. Terceira linha do primeiro arquivo"
> "4. Quarta linha do primeiro arquivo"
> "Leitura do primeiro arquivo terminou"
Como foi possível notar, na execução síncrona só foi iniciada a leitura do próximo arquivo após acabar a leitura do primeiro, já na assícrona a leitura do próximo arquivo foi iniciada antes mesmo da leitura de cada linha do primeiro.
##2. Como o V8 executa JavaScript? Demonstre 1 exemplo com código ou imagem.
Application => V8 => Node API => EVENT LOOP => WORKER THREAD / Retorna o Callback => EVENT LOOP => Node API => V8 => Application.
##3. Qual a diferença entre um sistema single para um multi-thread?
**Single-thread** Apenas uma tarefa pode ser feito em um tempo e o programa espera até que uma tarefa é concluída antes de iniciar outra.
**Multi-thread** Aplicações multi-thread permitem que você execute várias threads ao mesmo tempo, cada uma executando uma etapa por exemplo.
##4. Como a Thread Pool tem um tamanho padrão de 4, o que acontece se você enviar 5 requisições ao banco?
A quinta requisição vai para o Idle Thread, e espera até ser colocada no thread pool. Digamos que a primeira requisição foi executada, então a quinta requisição poderá ir para o thread pool.
##5. Como você venderia o peixe do Node.js na sua empresa para tentar convencer seu chefe da sua adoção?
Sei do que estou falando. Faz com Node!
##6. Qual a versão do seu node?
v6.3.1
##7. Qual a versão do seu npm?
3.3.12
| {
"repo_name": "Webschool-io/be-mean-instagram-nodejs-exercises",
"stars": "33",
"repo_language": "JavaScript",
"file_name": "index.jade",
"mime_type": "text/plain"
} |
# Node.js - Aula 01 - Exercício
autor: Bruno Lima da Silva
## 1. Explique como um processo síncrono e assíncrono roda no Node.js, dê um exemplo para cada.
Quando um processo chega no Event Loop e é assíncrono, o mesmo é enviado para onde deve ser executado, por exemplo, uma requisição de leitura de arquivos no computador, e enquanto o sistema operacional trata essa requisição o Node.JS continua executando outros processos e tarefas. Quando a requisição termina é disparado uma trigger para o callback do processo assíncrono, e então esse processo retorna para a fila para ser executado no Event Loop. Ou seja, basicamente diz que qualquer leitura ou escrita de dados não espera seu processo finalizar para continuar o script, nesse caso os processos ocorrem paralelamente à execução.
Quando um processo chega no Event Loop e é síncrono, o mesmo é enviado para onde deve ser executado, por exemplo, uma requisição de leitura de arquivos no computador, porém, enquanto o sistema operacional trata essa requisição o Node.JS tem que aguardar o retorno sem executar outros processos ou tarefas, deixando a aplicação mais lenta e consumindo mais recursos do servidor/computador. Só após acontecer o retorno da requisição de leitura de arquivos o Node.JS executa o processo sínocrono e demais tarefas e processos que ele receba.
## 2. Como o V8 executa JavaScript? Demonstre 1 exemplo com código ou imagem.
O Moto V8 é um interpretador de JavaScript desenvolvido pelo Google e o trabalho dele é basicamnete compilar o código de JavaScript para o código nativo de máquina para depois executá-lo. Com isso ele levou a velocidade dos códigos compilados para o JavaScript.
## 3. Qual a diferença entre um sistema single para um multi-thread?
Em um sistema multi-thread, como por exemplo o Apache, você tem um processo novo para cada usuário conectado ou um procesos novo para cada requisição feita.
Em um sistema single-thread você possui apenas uma thread.
## 4. Como a Thread Pool tem um tamanho padrão de 4, o que acontece se você enviar 5 requisições ao banco?
A quinta requisição é pré-processada no Event Loop e quando as quatro primeiras requisição são retornadas pelo banco de dados a quinta requisição é enviada ao banco e quando for finalizada retornará para o Event Loop.
## 5. Como você venderia o peixe do Node.js na sua empresa para tentar convencer seu chefe da sua adoção?
## 6. Qual a versão do seu `node`?
node -v
v6.9.1
## 7. Qual a versão do seu `npm`?
npm -v
3.10.8
| {
"repo_name": "Webschool-io/be-mean-instagram-nodejs-exercises",
"stars": "33",
"repo_language": "JavaScript",
"file_name": "index.jade",
"mime_type": "text/plain"
} |
# Node.js - Aula 01 - Exercício
**user:** [davidsonsns](https://github.com/davidsonsns)
**autor:** Davidson da Silva Nascimento
**date:** 1453972359356
## 1. Explique como um processo síncrono e assíncrono roda no Nodejs, dê um exemplo para cada.
#### Síncrono
Uma operação ocorre após o término de outra, de forma **ordenada**. O processo é interrompido até que o procedimento em andamento seja finalizado.
> Cada passo é realizado após o término do passo anterior, ou seja, nenhuma operação é executada antes que a operação anterior seja finalizada
No exemplo abaixo é realizado o download de todas as imagens da API [HTTP Status Cats](https://http.cat/), onde é demonstrado através do tempo gasto como as requisições com processos síncronos podem vir a ser muito mais demorados.
Isso ocorre devido o fato de que cada imagem é "baixada", uma após a outra, e também neste caso se ocorrer algum tipo de problema é impossibilida a continuidade dos downloads.
```js
console.time('tempo gasto');
var fs = require('fs');
var request = require('request');
var URL = "https://http.cat/";
var statusCodes = [
100, 101, 200, 201, 202, 204, 206, 207, 300, 301,
302, 303, 304, 305, 307, 400, 401, 402, 403, 404,
405, 406, 408, 409, 410, 411, 412, 413, 414, 415,
416, 417, 418, 422, 423, 424, 425, 426, 429, 431,
444, 450, 451, 500, 502, 503, 506, 507, 508, 509,
599
]
function salvarImagem(error, response, body) {
if (response.error) {
console.log('Error: '+response.error);
}
if (!error && response.statusCode == 200) {
fs.writeFileSync(response.request.href.slice(URL.length) + ".jpg", body);
console.log("CAT Error: " + this.statusCodes[this.indice] + " SALVO");
if ((this.indice + 1) < statusCodes.length) {
var requisicao = {statusCodes: this.statusCodes, indice: this.indice + 1};
request({uri: URL + this.statusCodes[requisicao.indice], encoding:null}, salvarImagem.bind(requisicao));
}
}
}
var requisicao = {statusCodes: statusCodes, indice: 0};
request({uri: URL + statusCodes[0], encoding:null}, salvarImagem.bind(requisicao));
process.on('exit', function () {
console.timeEnd('tempo gasto');
});
```
#### Assíncrono
Não existe sincronismo, ou seja, podem ser realizados diversos procedimentos em paralelo. Cada resposta é retornada quando tiver sido concluído cada procedimento.
> Cada processo é tratado via [callback](http://www.tutorialspoint.com/nodejs/nodejs_callbacks_concept.htm), via tratamento de evento
O exemplo apresentado abaixo possui a mesma idéia que o anterior, porém implementado de forma assíncrona. Através dos registros do *LOG* pode ser visto que os downloads são realizados de forma não ordenada, ou seja, todas as imagens são disparadas e a medida que cada uma é finalizada **individualmente** é exibido apenas a mensagem de salvo.
```js
console.time('tempo gasto');
var fs = require('fs');
var request = require('request');
var URL = "https://http.cat/";
var statusCodes = [
100, 101, 200, 201, 202, 204, 206, 207, 300, 301,
302, 303, 304, 305, 307, 400, 401, 402, 403, 404,
405, 406, 408, 409, 410, 411, 412, 413, 414, 415,
416, 417, 418, 422, 423, 424, 425, 426, 429, 431,
444, 450, 451, 500, 502, 503, 506, 507, 508, 509,
599
]
function salvarImagem(error, response, body) {
if (response.error) {
console.log('Error: '+response.error);
}
if (!error && response.statusCode == 200) {
nome_arq = response.request.href.slice(URL.length);
fs.writeFile(nome_arq + ".jpg", body, function (err) {
if (err) throw err;
console.log("CAT Error: " + nome_arq + " SALVO");
});
}
}
for (var i=0; i < statusCodes.length; i++) {
request({uri: URL + statusCodes[i], encoding: null}, salvarImagem);
}
process.on('exit', function () {
console.timeEnd('tempo gasto');
});
```
> **Comparar** evento síncrono e assíncrono é **completamente desleal**, a diferença de tempo gasto é surreal entre os dois pra executar a mesma atividade. Porém cada aplicação possui sua **particularidade** e deve ser implementado o que lhe melhor atender
Foram utilizados alguns recursos do JS e do Node.js que são novos para mim, e pode ser para você também hihi, os links para melhor entendimento podem se encontrados clicando [AQUI](#referências).
## 2. Como o V8 executa JavaScript? Demonstre 1 exemplo com código ou imagem.
A maioria dos motores de JavaScript usam uma estrutura de dados como dicionários, para o armazenamento para propriedades de objeto, ou seja, cada acesso a uma propriedade requer uma pesquisa dinâmica para resolver o estabelecimento na memória. Essa abordagem se faz acessando propriedades em JavaScript tipicamente muito mais lento do que acessar variáveis de instância em linguagens de programação como Java e Smalltalk. Nestas linguagens, variáveis de instância estão localizados em deslocamentos fixos determinados pelo compilador devido ao layout do objeto fixo definido pela classe do objeto. O acesso é simplesmente uma questão de uma carga de memória, muitas vezes necessitando de apenas uma única instrução.
Para reduzir o tempo necessário para acessar as propriedades de JavaScript, o V8 não usa pesquisa dinâmica para propriedades de acesso. Em vez disso, o V8 cria dinamicamente classes ocultas.
O V8 cria as classes ocultas em tempo de execução, a fim de ter uma representação interna do sistema de tipo e para melhorar o tempo de acesso da propriedade. E um objeto muda de classe oculta quando uma nova propriedade é adicionado.
Veja, por exemplo, uma função "Point" e a criação de dois objetos "point":
```js
function Point(x, y) {
this.x = x;
this.y = y;
}
var p = new Point(11, 22);
var q = new Point(33, 44);
```
Se o esquema são os mesmos, o que é o caso aqui, "p" e "q" pertencem à mesma classe oculta criada pelo V8.
Agora vamos supor que nós queremos adicionar uma propriedade "z" ao nosso objeto "q", logo após a sua declaração (o que é perfeitamente bem com uma linguagem de tipagem dinâmica).
Como V8 vai lidar com este cenário? Na verdade, V8 cria uma nova classe oculta toda vez que a função de construtor declara uma propriedade e mantém o controle do changement na classe oculta. Por quê? Porque se dois objetos são criados ("p" e "q") e se um membro é adicionado ao segundo objeto ("q") após a criação, V8 precisa manter a última classe oculta criado (para o primeiro objeto "p ") e criar um novo (para o segundo objeto" q ") com o novo membro.
Pode parecer ineficiente criar uma nova classe oculta sempre que uma propriedade é adicionada. No entanto, devido às transições das classes, as classes ocultas podem ser reutilizados. Toda vez que uma nova classe oculta é criada, a anterior é atualizado com uma transição de classe indicando que classe oculta tem de ser usado em vez disso.
Veja exemplo abaixo:
Apesar do JavaScript ser mais dinâmico do que a maioria das linguagens orientadas a objeto, o comportamento de tempo de execução da maioria dos programas de JavaScript resulta em um alto grau de compartilhamento de estrutura utilizando a abordagem acima. Há duas vantagens para o uso de classes ocultas: acesso a propriedade não requer uma consulta do dicionário, e eles permitem o V8 usar a otimização baseada em classe clássico, inline caching.
## 3. Qual a diferença entre um sistema single para um multi-thread?
> Thread ... é uma forma de um processo dividir a si mesmo em duas ou mais tarefas que podem ser executadas concorrencialmente ([Wikipédia](https://goo.gl/aRBe6y))
##### Single-thread
O conceito de Single-thread(Thread única) é o processamento de um comando por vez, ou seja, inicia na etapa 1 e continua sequencialmente (etapa 2, etapa 3, o passo 4) até atingir a etapa final.
Um exemplo poderia ser um servidor web servindo apenas um pedido de cliente de cada vez. O que pode tornar o período de espera de outros clientes ser muito longo.
##### Multi-thread
Permitem que você execute várias threads ao mesmo tempo, cada uma executando um passo por exemplo.
Nesta situação, um servidor web pode criar multíplas threads para atender a diversos clientes. O que aumenta a capacidade de resposta à solicitações de clientes.
## 4. Como a Thread Poll tem um tamanho padrão de 4, o que acontece se enviar 5 requisiçoes ao banco?
A última requisição aguarda na Task Queue(pilha de tarefas) até que alguma tarefa seja completada e sair da Thread Pool. Para assim tomar seu lugar e entrar na Thread Pool.
## 5. Como você venderia o peixe do Nodejs na sua empresa para tentar convencer seu chefe da sua adoção?
Man, é JavaScript no servidor, só isso já é maravilhoso. Não teremos que aprender nenhuma nova linguagem que o Google ou Facebook nem muito menos a Apple criou. É JavaScript, essa linguagem que é o Café com Leite para todos (pelo menos eu acho) os desenvolvedores Web. A comunidade é gigantescamente gigantesca.
A quantidade de módulos é enorme, o que nos possibilita trabalhar com infinitos recursos I/O no servidor. Com isso podemos, com uma grande facilidade, trabalhas com protocolos como o HTTP, HTTPS, DNS, WebSockets sem nenhum problema e com poucas linhas de código. Além de manipulação de arquivo, criptografia, ou onde sua mente te levar.
A manipulação do JSON é mamata já que utilizaremos o JavaScript.
Alta escalabilidade já que possui uma característica marcante de Threads Não-Bloqueantes. Algo que não somos muito acostumados já que utilizamos .NET, JAVA e PHP.
Pra finalizar e não ter discurssão, nada mais nada menos do que LinkedIn, Wallmart, Groupon, Paypal, Netflix e até mesmo a Microsoft o utiliza.
Então o que me diz? Vamos viver de presente? De algo que de fato esta agitando a comunidade?
## 6. Qual a versão do seu `node`?
```js
davidson@davidson ~ $ node -v
v5.4.0
```
## 7. Qual a versão do seu `npm`?
```js
davidson@davidson ~ $ npm -v
3.3.12
```
## Referências
[Console module Node.js](https://nodejs.org/api/console.html)
[bind() function JS](https://developer.mozilla.org/pt-BR/docs/Web/JavaScript/Reference/Global_Objects/Function/bind)
[Node.js: síncrono versus assíncrono](https://www.youtube.com/watch?v=-43EEc3C3cA)
[V8 - Design Elements](https://github.com/v8/v8/wiki/Design%20Elements)
[How the V8 engine works?](http://thibaultlaurens.github.io/javascript/2013/04/29/how-the-v8-engine-works/)
| {
"repo_name": "Webschool-io/be-mean-instagram-nodejs-exercises",
"stars": "33",
"repo_language": "JavaScript",
"file_name": "index.jade",
"mime_type": "text/plain"
} |
# Node.js - Aula 01 - Exercício
**user:** [matheusjkweber](http://github.com/matheusjkweber)
**autor:** Matheus Jose Krumenauer Weber
**date:** 1456355702659
## Explique como um processo síncrono e assíncrono roda no Node.js, dê um exemplo para cada.
```
No Node.js um processo síncrono funciona seguindo uma série de tarefas síncronas, realiza uma e depois vai para outra e depois para outra numa ordem pré determinada, como no exemplo do garçom do vídeo onde o mesmo atende um cliente e só vai atender o segundo quando todas as tarefas do primeiro tiver terminada.
Em um processo assíncrono, o mesmo realizará uma série de tarefas conforme as respostas do servidor, no exemplo do garçom ele irá atender o primeiro cliente e já irá atender o segundo cliente, mesmo que as tarefas do primeiro não tiverem sido terminadas, e quando a cozinha enviar uma mensagem para o garçom o mesmo voltará para o primeiro cliente para terminar as tarefas com ele(isso se a cozinha não mandar terminar as tarefas do segundo primeiro).```
```
## Como o V8 executa JavaScript? Demonstre 1 exemplo com código ou imagem.
```
O V8 compila e executa o código Javascript já fazendo uma limpeza na memória de objetos não mais necessários.
<img src="http://image.slidesharecdn.com/nodesecuritypresentationv3asfws-121126133358-phpapp02/95/asfws-2012-nodejs-security-old-vulnerabilities-in-new-dresses-par-sven-vetsch-7-638.jpg?cb=1353936909">
```
## Qual a diferença entre um sistema single para um multi-thread?
```
A diferença de um sistema single thread é que todo o sistema funcionará numa unica thread, ou seja, todo o programa rodará de uma só vez, ao contrário do multi-thread que pode dividir esse programa em diversas threads com funções para parar, iniciar, retomar, entre outras. Um sistema multi-thread é muito util para que o usuário não precise ficar esperando uma tarefa finalizar para iniciar outra, visto que a mesma pode ser jogada para a thread pool e iniciar outra, e só depois retomar aquela thread.
```
## Como a Thread Pool tem um tamanho padrão de 4, o que acontece se você enviar 5 requisições ao banco?
```
Essa requisição terá que aguardar alguma das outras 4 ser liberada para que essa entre.
## Como você venderia o peixe do Node.js na sua empresa para tentar convencer seu chefe da sua adoção?
Explicaria que desenvolver o nosso sistema em Node.js melhoraria muito o desempenho e a segurança do mesmo, visto que o mesmo utiliza o mesmo motor do Google Chrome para funcionar. Também explicaria como o mesmo funciona com requisições assíncronas, possui bibliotecas poderosas, um bom controle de threads, entre outras.
Também falaria que é a mesma linguagem utilizada para desenvolver o Netflix e o Paypal.
```
## Qual a versão do seu `node`?
```
v5.7.0
```
## Qual a versão do seu `npm`?
```
3.6.0
```
| {
"repo_name": "Webschool-io/be-mean-instagram-nodejs-exercises",
"stars": "33",
"repo_language": "JavaScript",
"file_name": "index.jade",
"mime_type": "text/plain"
} |
# Node.js - Aula 02 - Exercício
**user:** [fernandobd42](https://github.com/fernandobd42)
**autor:** Fernando Lucas
**date:** 1467347548312
## Estrutura
## Quais são os 4 verbos que utilizamos para o CRUD?
CRUD - (Create, Retrive/Read, Update, Delete)
-Create (POST)
-Retrive/Read (GET)
-Update (PUT)
-Delete (DELETE)
## Para que foram inventados os Status Codes? Dê exemplo de 1 código por grupo e a imagem do [Cat Status Code](https://http.cat/).
Para padronizar o retorno das requisições HTTP cliente-servidor.
###1XX Informação###
###2XX Sucesso###
###3XX Redirecionamento###
###4XX Erro do cliente###
###5XX Erro do servidor###
## Explique o que é cada parâmetro da função recebida no `createServer`.
Request recebe os parâmetros utilizados pelo usuário na requisição.
Response manipula a responsta a ser enviada ao usuário.
## O que é e para que serve a Querystring?
Querystring é um padrão que utiliza o método GET para receber valores na url.
## Escreva no código do `server.js` uma forma de entregar um JSON de sucesso em 4 rotas diferentes:
```
'use strict';
var date = (new Date()).toJSON();
const http = require('http')
, SUCCESS = {
version: 1.0
, name: 'Be MEAN'
, created_at: date }
, ERROR = {
message: 'Não encontrado'
};
http.createServer(function(req, res){
switch (req.url) {
case"/api/v1/pokemons/create":
res.writeHead(200, {'Content-type': 'application/json; charset=utf-8'});
res.write(JSON.stringify(SUCCESS));
break;
case "/api/v1/pokemons/read":
res.writeHead(200, {'Content-type': 'application/json; charset=utf-8'});
res.write(JSON.stringify(SUCCESS));
break;
case "/api/v1/pokemons/update":
res.writeHead(200, {'Content-type': 'application/json; charset=utf-8'});
res.write(JSON.stringify(SUCCESS));
break;
case "/api/v1/pokemons/delete":
res.writeHead(200, {'Content-type': 'application/json; charset=utf-8'});
res.write(JSON.stringify(SUCCESS));
break;
default:
res.writeHead(400, {'Content-type': 'application/json; charset=utf-8'});
res.write(JSON.stringify(ERROR));
break;
}
res.end();
}).listen(3000, function(){
console.log('Servidor rodando em localhost:3000');
});
``` | {
"repo_name": "Webschool-io/be-mean-instagram-nodejs-exercises",
"stars": "33",
"repo_language": "JavaScript",
"file_name": "index.jade",
"mime_type": "text/plain"
} |
# Node.js - Aula 01 - Exercício
**user:** [falconeric](https://github.com/falconeric)
**autor:** Eric Lessa
**Data:** 1466310895
## Quais são os 4 verbos que utilizamos para o CRUD?
Para o CRUD utilizamos seguintes verbos http: Post (**C**reate), Get (**R**etrieve), Put (**U**pdate) e Delete (**D**elete).
## Para que foram inventados os Status Codes? Dê exemplo de 1 código por grupo e a imagem do [Cat Status Code](https://http.cat/).
Os códigos de retorno HTTP foram criados para a identificação do retorno do servidor. Compostos por 3 dígitos padronizam a identificação do retorno.
**1xx Informacional**
**2xx Sucesso**
**3xx Redirecionamento**
**4xx Erro do Cliente**
**5xx Erro do Servidor**
## Explique o que é cada parâmetro da função recebida no `createServer`.
**Request:** Objeto com as informações de requisição do cliente, como URL, Headers e outras.
**Response:** O objeto response é usado para retornar a solicitação do cliente. Deve inicialmente chamar o método *response.writeHead()*, este método envia um HTTP status code e uma coleção de response headers ao cliente, após escrevermos os headers podemos escrever html utilizando o método *response.write()*, depois devemos chamar *response.end()*
## O que é e para que serve a Querystring?
Querystring são conjuntos de chave/valor anexados a URL.
Basicamente servem para recuperarmos valores de uma requisição.
## Escreva no código do `server.js` uma forma de entregar um JSON de sucesso em 4 rotas diferentes:
```
//server.js
'use strict';
var date = (new Date()).toJSON();
const http = require('http')
, SUCCESS = {
version: 1.0
, name: 'Be MEAN'
, created_at: date
}
, ERROR = {
message: ":/ Não encontrado!"
}
;
http.createServer(function(request, response) {
switch (request.url) {
case '/api/pokemons/create':
response.writeHead(200, {'Content-type': 'application/json; charset=utf-8'});
SUCCESS.url = request.url;
response.write(JSON.stringify(SUCCESS));
break;
case '/api/pokemons/read':
response.writeHead(200, {'Content-type': 'application/json; charset=utf-8'});
SUCCESS.url = request.url;
response.write(JSON.stringify(SUCCESS));
break;
case '/api/pokemons/update':
response.writeHead(200, {'Content-type': 'application/json; charset=utf-8'});
SUCCESS.url = request.url;
response.write(JSON.stringify(SUCCESS));
break;
case '/api/pokemons/delete':
response.writeHead(200, {'Content-type': 'application/json; charset=utf-8'});
SUCCESS.url = request.url;
response.write(JSON.stringify(SUCCESS));
break;
default:
response.writeHead(404, {'Content-type': 'application/json; charset=utf-8'});
response.write(JSON.stringify(ERROR));
}
response.end();
}).listen(3000, function(){
console.log('Servidor rodando em localhost:3000');
});
```
| {
"repo_name": "Webschool-io/be-mean-instagram-nodejs-exercises",
"stars": "33",
"repo_language": "JavaScript",
"file_name": "index.jade",
"mime_type": "text/plain"
} |
# Node.js - Aula 02 - Exercício
**User:** [higordiego](https://github.com/higordiego)
**Autor:** Higor Diego
**Date:** Thu Jan 28 2016 18:53:31 GMT-0300 (BRT)
## Quais são os 4 verbos que utilizamos para o CRUD?
C - Crear - POST
R - Leitura - GET
U - Alterar - PUT
D - Deletar - DELETE
## Para que foram inventados os Status Codes? Dê exemplo de 1 código por grupo e a imagem do [Cat Status Code](https://http.cat/).
O 'Status Code' foi inventado para padronização de erro e facilitando a conversa de cliente e servidor.
* **1XX** - Informação
* **2XX** - Sucesso
* **3XX** - Redirecionamento
* **4XX** - Cliente Error
* **5XX** - Servidor error
## Explique o que é cada parâmetro da função recebida no `createServer`.
Requisão - São os parametros da requisão do feita pelo o usuário.
Resposta - Contém o retorno do servidor ( resposta requerida pelo o usuário )
## O que é e para que serve a Querystring?
QueryString o conjunto de parametro enviado para o servidor, serve para passar parametros para o servidor (na requisição.) obtendo resposta.
## Escreva no código do `server.js` uma forma de entregar um JSON de sucesso em 4 rotas diferentes:
```js
'use strict';
var http = require('http');
var primeira = {
status: 01,
messagem: 'Primeira pagina'
},
segunda = {
status: 02,
messagem: 'Segunda pagina'
},
terceira = {
status: 03,
messagem: 'Terceira Pagina'
},
quarta = {
status: 04,
messagem: 'Quarta pagina'
},
error = {
status: false,
messagem: 'Quarta pagina'
};
http.createServer(function(req, res){
var method = req.method
, url = req.url;
switch(url){
case '/t1':
if(method == 'GET'){
res.writeHead(200, { 'Content-Type': 'application/json; charset=utf-8' });
res.write(JSON.stringify(primeira));
}else{
res.writeHead(200, { 'Content-Type': 'application/json; charset=utf-8' });
res.write(error);
}
break;
case '/t2':
if(method == 'POST'){
res.writeHead(200, { 'Content-Type': 'application/json; charset=utf-8' });
res.write(JSON.stringify(segunda));
}else{
res.writeHead(200, { 'Content-Type': 'application/json; charset=utf-8' });
res.write(error);
}
break;
case '/t3':
if(method == 'PUT'){
res.writeHead(200, { 'Content-Type': 'application/json; charset=utf-8' });
res.write(JSON.stringify(terceira));
}else{
res.writeHead(200, { 'Content-Type': 'application/json; charset=utf-8' });
res.write(error);
}
break;
case '/t4':
if(method == 'POST'){
res.writeHead(200, { 'Content-Type': 'application/json; charset=utf-8' });
res.write(JSON.stringify(quarta));
}else{
res.writeHead(200, { 'Content-Type': 'application/json; charset=utf-8' });
res.write(error);
}
break;
default:
res.writeHead(404, { 'Content-Type': 'application/json; charset=utf-8' });
res.write('error: 404');
break;
}
}).listen(3000,function(){
console.log('servidor rodando porta http://localhost:3000');
});
```
| {
"repo_name": "Webschool-io/be-mean-instagram-nodejs-exercises",
"stars": "33",
"repo_language": "JavaScript",
"file_name": "index.jade",
"mime_type": "text/plain"
} |
# Node.js - Aula 02 - Exercício
**user:** [Zowder](https://github.com/Zowder)
**autor:** Emídio de Paiva Neto
## Quais são os 4 verbos que utilizamos para o CRUD?
>* Create(POST) - Read/Retrieve(GET) - Update(PUT) - Delete(DELETE)
## Para que foram inventados os Status Codes? Dê exemplo de 1 código por grupo e a imagem do [Cat Status Code](https://http.cat/).
Surgiu com a necessidade de padronização de retorno do servidor, facilitando o entendimento de cada um.
* **1XX - Informacional**
* **2XX - Sucesso**
* **3XX - Redirecionamento**
* **4XX- Erro de cliente**
* **5XX - Erro de servidor**
## Explique o que é cada parâmetro da função recebida no `createServer`.
**Request:** Parâmetro da requisição feita pelo usuário.
**Response:** Parâmetro que retorna as informações para o usuário.
## O que é e para que serve a Querystring?
>Na Internet, uma string de consulta (também chamado de querystring HTTP) faz parte do conjunto de caracteres de entrada automaticamente na barra de endereço de um site dinâmico quando um usuário faz uma solicitação de informação de acordo com certos critérios.
Exemplo:
http://example.com/over/there?name=ferret
## Escreva no código do `server.js` uma forma de entregar um JSON de sucesso em 4 rotas diferentes:
```js
//server.js
'use strict';
var date = (new Date()).toJSON();
const http = require('http')
, SUCCESS = {
version: '1.0'
, name: 'Be MEAN'
, returned_at: date
}
, ERROR = {
message: "Não encontrado!"
}
;
http.createServer(function(req, response){
switch(req.url){
case "/api/pokemons/create" :
response.writeHead(200, {'Content-Type': 'application/json; charset=utf-8'});
response.end(JSON.stringify([SUCCESS, {info: "Create: Ok"}]));
break;
case "/api/pokemons/update" :
response.writeHead(200, {'Content-Type': 'application/json; charset=utf-8'});
response.end(JSON.stringify([SUCCESS, {info: "Update: Ok"}]));
break;
case "/api/pokemons/read" :
response.writeHead(200, {'Content-Type': 'application/json; charset=utf-8'});
response.end(JSON.stringify([SUCCESS, {info: "Retrieve: Ok"}]));
break;
case "/api/pokemons/delete" :
response.writeHead(200, {'Content-Type': 'application/json; charset=utf-8'});
response.end(JSON.stringify([SUCCESS, {info: "Delete: Ok"}]));
break;
default:
response.writeHead(404, {'Content-Type' : 'application/json; charset=utf-8'})
response.end(JSON.stringify(ERROR));
break;
}
response.end();
}).listen(3000, function(){
console.log('Servidor rodando em localhost:3000');
});
```
| {
"repo_name": "Webschool-io/be-mean-instagram-nodejs-exercises",
"stars": "33",
"repo_language": "JavaScript",
"file_name": "index.jade",
"mime_type": "text/plain"
} |
# Node.js - Aula 02 - Exercício
**user:** [mauriciord](https://github.com/mauriciord)
**autor:** Maurício Reatto Duarte
## Quais são os 4 verbos que utilizamos para o CRUD?
- Create - Criar
- Read/Retrieve - Ler/Recuperar
- Update - Atualizar
- Delete - Excluir
## Para que foram inventados os Status Codes? Dê exemplo de 1 código por grupo e a imagem do [Cat Status Code](https://http.cat).
Esses _Status Codes_ foram criados para que houvesse uma forma de padronizar o retorno das requisições HTTP.
#### 1XX - Informacional
Resposta provisória para informar o cliente de que a solicitação foi recebida e não rejeitada pelo servidor.
.
#### 2XX - Sucesso
Pedido aceito para processamento, mas ainda não se encontra concluído. É uma resposta à fim de que o servidor possa aceitar o pedido de outro processo.
#### 3XX - Redirecionamento
Informa que a solicitação está temporariamente em uma URI diferente. O cliente deve continuar com essa URI para solicitações futuras.
#### 4XX- Erro de cliente
Solicitação foi atendida, porém não será executada.
#### 5XX - Erro de servidor
O servidor é usado como _Gateway_ ou _Proxy_
## Explique o que é cada parâmetro da função recebida no `createServer`.
A função recebida no `createServer` é uma função anônima, do qual é passado dois parâmetros.
```js
http.createServer(function(req, res){
. . .
});
```
#### `request`
Objeto do qual corresponde a solicitação enviada pelo cliente, como por exemplo, a URL, cabeçalhos HTTP, etc.
#### `response`
Objeto de resposta do qual é utilizado para devolver os dados ao cliente.
## O que é e para que serve a Querystring?
Valores enviados pela _URL_ via `GET`. Na maioria das vezes, são de forma simples e pequena entre cliente/servidor, seguindo o padrão de `'key' : 'value'`
Exemplo:
```
.../caminho?nome=pikachu&tipo=eletrico
```
## Escreva no código do `server.js` uma forma de entregar um JSON de sucesso em 4 rotas diferentes:
- /api/pokemons/create
- /api/pokemons/read
- /api/pokemons/update
- /api/pokemons/delete
~~~js
'use strict';
const date = (new Date()).toJSON();
const http = require('http'),
SUCCESS = {
version: 1.1,
code: 200,
name: 'BE MEAN',
created_at: date
},
ERROR = {
message: 'Não encontrado!'
};
http.createServer(function(req, res){
const url = req.url;
switch(url){
case "/api/pokemons/create":
create();
break;
case "/api/pokemons/read":
read();
break;
case "/api/pokemons/update":
update();
break;
case "/api/pokemons/delete":
delete();
break;
default:
res.writeHead(404, { 'Content-Type': 'application/json;' });
res.write(JSON.stringify(ERROR));
break;
}
res.end();
}).listen(3000, function() {
console.log('Servidor ON em http://localhost:3000/');
});
function create(){
res.writeHead(200, { 'Content-Type': 'application/json;' });
res.write(JSON.stringify(SUCCESS));
}
function read(){
res.writeHead(200, { 'Content-Type': 'application/json;' });
res.write(JSON.stringify(SUCCESS));
}
function update(){
res.writeHead(200, { 'Content-Type': 'application/json;' });
res.write(JSON.stringify(SUCCESS));
}
function delete(){
res.writeHead(200, { 'Content-Type': 'application/json;' });
res.write(JSON.stringify(SUCCESS));
}
~~~
| {
"repo_name": "Webschool-io/be-mean-instagram-nodejs-exercises",
"stars": "33",
"repo_language": "JavaScript",
"file_name": "index.jade",
"mime_type": "text/plain"
} |
# Node.js - Aula 02 - Exercício
autor: Igor Vidotto Felipe
#### 1 - Quais são os 4 verbos que utilizamos para o CRUD?
* POST
* GET
* PUT
* DELETE
#### 2 - Para que foram inventados os Status Codes? Dê exemplo de 1 código por grupo e a imagem do Cat Status Code.
Os *Status Codes*, também chamados de [*Response Codes*](https://developer.mozilla.org/en-US/docs/Web/HTTP), foram criados para responder uma requisição do cliente. O servidor envia um número de três dígitos se a requisição foi processada corretamente, sendo que esse número é determinado pelo estado do servidor mediante a requisição realizada.
#### 1XX Informacional
###### 100 - Continue
Essa resposta provisória indica que tudo até agora está OK e que o cliente deve continuar com a requisição ou apenas ignorar, se sua requisição já foi finalizada.
#### 2XX Sucesso
###### 201 - Created
A requisição foi realizada com sucesso e um novo recurso foi criado como resultado. Esta é uma resposta enviada tipicamente após uma requisição de *PUT*.
#### 3XX Redirecionamento
###### 304 - Not Modified
Se o cliente executou uma requisição de condição *GET* e o acesso é permitido, mas o documento não foi modificado, o servidor deve responder com o mesmo status code. A resposta 304 não deve conter uma *message-body*, e deste modo é sempre terminada pela primeira linha vazia após os campos do *header*.
#### 4XX Erro do Cliente
###### 400 - Bad Request
A requisição não foi entendida pelo servidor devido a sintaxe mal estruturada. O cliente não deve repetir a requisição sem antes modificá-la.
#### 5XX Erro de Servidor
###### 502 - Bad Gateway
O servidor, enquanto agindo como um *gateway* ou *proxy*, recebeu uma resposta inválida do servidor *upstream* que acessou na tentativa de completar a requisição.
#### 3 - Explique o que é cada parâmetro da função recebida no `createServer`.
Essa função é uma função de *callback* que recebe dois parâmetros: **request**, que é o parâmetro que contém a requisição do cliente e **response**, que o servidor utiliza para providenciar a resposta de acordo com a requisição do cliente.
#### 4 - O que é e para que serve a Querystring?
São as variáveis e valores que são obtidos através de formulários ou requisições do usuário e que são enviados à **url**, como `?name=Igor`, por exemplo. No Node.js, existe um módulo nativo chamado `url`, que é responsável por fazer *parser* e formatação de urls.
A função `url.parse()` retorna um objeto com vários atributos da url, dentre eles o atributo **query** que é o responsável por retornar a **query string** em formato JSON.
#### 5 - Escreva no código do `server.js` uma forma de entregar um JSON de sucesso em 4 rotas diferentes:
* /api/pokemons/create
* /api/pokemons/read
* /api/pokemons/update
* /api/pokemons/delete
```js
// server.js
'use strict';
var date = (new Date()).toJSON();
var http = require('http')
, url = require('url')
, SUCESS =
{ version: '1.0'
, name: 'Exercício 02 Node.js'
, returned_at: date
}
;
http.createServer(function(request, response){
var pathname = url.parse(request.url).pathname
, routes =
[ '/api/pokemons/create'
, '/api/pokemons/read'
, '/api/pokemons/update'
, '/api/pokemons/delete'
]
;
for(var key in routes){
if (routes[key] === pathname) {
response.writeHead(200, {'Content-Type': 'application/json; charset=utf-8'});
response.write(JSON.stringify(SUCESS));
}
}
response.end();
}).listen(3000, function(){
console.log('Servidor rodando em localhost:3000');
});
```
| {
"repo_name": "Webschool-io/be-mean-instagram-nodejs-exercises",
"stars": "33",
"repo_language": "JavaScript",
"file_name": "index.jade",
"mime_type": "text/plain"
} |
# NodeJS - Aula 02 - Exercício
**User:** [daniofilho](https://github.com/daniofilho)
**Autor:** Dânio Filho
**Date:** 1452553737957
## Quais são os 4 verbos que utilizamos para o CRUD?
Os principais métodos/verbos são:
- POST
- GET
- PUT
- DELETE
## Para que foram inventados os Status Codes? Dê exemplo de 1 código por grupo e a imagem do [Cat Status Code](https://http.cat/).
Os Status Codes são códigos de 3 digitos que seguem um certo padrão e que são retornados para especificar qual foi o resultado de uma requisição.
### 1XX - Informacional ###
Mostra que a informação recebida está sendo processada. Não diz que finalizou ou quando o fará, apenas mostra que está em processo.
Exemplo:
### 2XX - Sucesso ###
Avisa que a requisição foi processada com sucesso. Esta á a informação padrão que se recebe ao carregar um site, por exemplo.
Exemplo:
### 3XX - Redirecionamento ###
Retorna a informação de que aquela url especificada foi movida para outro local.
Exemplo:
### 4XX - Erro do cliente ###
Informa que houve algum problema na requisição, mas foi causado pelo lado do cliente.
Exemplo:
### 5XX - Erro do servidor ###
Informa que houve algum problema na requisição, mas foi causado pelo lado do servidor.
Exemplo:
## Explique o que é cada parâmetro da função recebida no `createServer`.
O **request** exibe as informações da requisição feita pelo cliente/usuário e o **response** é o retorno que ele receberá.
## O que é e para que serve a Querystring?
São parâmetros que são enviados junto com a URL via GET. Esses parâmetros seguem o padrão de `'key': 'value'` e servem para requisitar algo para o servidor.
## Escreva no código do `server.js` uma forma de entregar um JSON de sucesso em 4 rotas diferentes:
~~~ js
'use strict';
var date = (new Date()).toJSON();
const http = require('http'),
SUCCESS = {
version: 1.1,
code: 200,
name: 'Be MEAN',
created_at: date
},
ERROR = {
message: "Não encontrado!"
};
http.createServer(function(req, res){
let url = req.url;
switch(url){
case "/api/pokemons/create":
create();
break;
case "/api/pokemons/read":
read();
break;
case "/api/pokemons/update":
update();
break;
case "/api/pokemons/delete":
delete();
break;
default:
res.writeHead(404, { 'Content-Type': 'application/json;' });
res.write(JSON.stringify(ERROR));
break;
}
res.end();
}).listen(3000, function(){
console.log('Servidor rodando em localhost:3000');
});
function create(){
res.writeHead(200, { 'Content-Type': 'application/json;' });
res.write(JSON.stringify(SUCCESS));
}
function read(){
res.writeHead(200, { 'Content-Type': 'application/json;' });
res.write(JSON.stringify(SUCCESS));
}
function update(){
res.writeHead(200, { 'Content-Type': 'application/json;' });
res.write(JSON.stringify(SUCCESS));
}
function delete(){
res.writeHead(200, { 'Content-Type': 'application/json;' });
res.write(JSON.stringify(SUCCESS));
}
~~~
| {
"repo_name": "Webschool-io/be-mean-instagram-nodejs-exercises",
"stars": "33",
"repo_language": "JavaScript",
"file_name": "index.jade",
"mime_type": "text/plain"
} |
# Node.js - Aula 02 - Exercício
**user:** [Rafael Jourdan](https://github.com/rafaeljourdan)<br>
**autor:** Rafael Jourdan<br>
**date:** 09/01/2017
## Quais são os 4 verbos que utilizamos para o CRUD?
* POST
* GET
* PUT
* DELETE
## Para que foram inventados os Status Codes? Dê exemplo de 1 código por grupo e a imagem do [Cat Status Code](https://http.cat/).
As `Status Codes` foram criadas para responder uma requisição do cliente<br>
**1XX: Servidor recebeu cabeçalhos**
**2XX: Resposta OK do servidor, tudo OK**
**3XX: Redirecionamento temporário**
**4XX: Recurso não encontrado (Erro usuário)**
**5xx: Erro interno no servidor**
## Explique o que é cada parâmetro da função recebida no `createServer`.
* Request: Requisição que contém a solicitação do cliente: cabeçalhos, campos, parâmetros query string, etc.
* Response: Utilizado para devolver dados de volta para o cliente.
## O que é e para que serve a Querystring?
Parâmetros enviados via URL ou FORMULÁRIO com <b>method='get'</b>
`?var1=1&var2=true&var3=teste`
```
<form action="/salvar" method="get">
<input type="text" name="nome" />
<input type="submit" value="salvar" />
</form>
```
## Escreva no código do `server.js` uma forma de entregar um JSON de sucesso em 4 rotas diferentes:
```js
'use strict';
const http = require('http');
const apiVersion = '/api/v1';
var server = http.createServer(function(req,res){
res.writeHead(200, {'Content-Type': 'application/json; charset=utf-8'});
switch(req.url){
case apiVersion + '/create':
retornoJson(res, 'rota create');
break;
case apiVersion + '/read':
retornoJson(res, 'rota read');
break;
case apiVersion + '/update':
retornoJson(res, 'rota update');
break;
case apiVersion + '/delete':
retornoJson(res, 'rota delete');
break;
default:
res.writeHead(404, {'Content-Type': 'application/json;charset=utf-8'});
retornoJson(res, 'ERRO: Rota não encontrada ou não autorizado.');
break;
}
res.end();
});
server.listen(3000, function(){
console.log('Servidor levantando na 3000');
});
function retornoJson(response, mensagem){
var json = {
'mensagem': mensagem,
'data': new Date()
};
return response.write(JSON.stringify(json));
}
``` | {
"repo_name": "Webschool-io/be-mean-instagram-nodejs-exercises",
"stars": "33",
"repo_language": "JavaScript",
"file_name": "index.jade",
"mime_type": "text/plain"
} |
# Node.js - Aula 02 - Exercício
**user:** [dayvsonsales]https://github.com/dayvsonsales
**autor:** Dayvson SAles
## Quais são os 4 verbos que utilizamos para o CRUD?
- Create - POST
- Retrieve/Read - GET
- Update - PUT
- Delete - DELETE
## Para que foram inventados os Status Codes? Dê exemplo de 1 código por grupo e a imagem do [Cat Status Code](https://http.cat/).
Padronizar o retorno das requisições HTTP. Facilitando o entendimento por meio dos clients/bots.
100 - Continue - https://http.cat/100
200 - OK - https://http.cat/200
301 - Movido permanentemente - https://http.cat/301
404 - Not found - https://http.cat/404
500 - Erro interno no servidor - https://http.cat/500
## Explique o que é cada parâmetro da função recebida no `createServer`.
Request - variável de acesso aos parâmetros de requisição pelo client
Response - variável que possui metódos para envio de resposta ao client
## O que é e para que serve a Querystring?
Padrão do protocolo HTTP para enviar informações através de requisições.
Por exemplo:
http://exemplo.com/?tipo=1&codigo=104
## Escreva no código do `server.js` uma forma de entregar um JSON de sucesso em 4 rotas diferentes:
```
(...)
const SUCCESS = {
error: false, data: "", msg: ""
},
ERROR = { error: true, msg: "Not found"}
;
var server = http.createServer(function(request, response){
switch(request.url){
case "/" :
response.writeHead(200, {'Content-Type': 'application/json; charset=utf-8'});
response.end(index);
break;
case "/api/pokemons/create" :
response.writeHead(200, {'Content-Type': 'application/json; charset=utf-8'});
response.end(JSON.stringify({error: false, msg: "Inserido com sucesso!", data: {name: "pokemon"}}));
break;
case "/api/pokemons/update" :
response.writeHead(200, {'Content-Type': 'application/json; charset=utf-8'});
response.end(JSON.stringify({error: false, msg: "Atualizado com sucesso!", data: {name: "pokemon"}}));
break;
case "/api/pokemons/read" :
response.writeHead(200, {'Content-Type': 'application/json; charset=utf-8'});
response.end(JSON.stringify({error: false, data: {name: "pokemon"}}));
break;
case "/api/pokemons/delete" :
response.writeHead(200, {'Content-Type': 'application/json; charset=utf-8'});
response.end(JSON.stringify({error: false, msg: "Excluido com sucesso!"}));
break;
default:
response.writeHead(404, {'Content-Type' : 'application/json; charset=utf-8'})
response.end(JSON.stringify(ERROR));
break;
}
});
(...)
``` | {
"repo_name": "Webschool-io/be-mean-instagram-nodejs-exercises",
"stars": "33",
"repo_language": "JavaScript",
"file_name": "index.jade",
"mime_type": "text/plain"
} |
# NodeJS - Aula 02 - Exercício
**Autor:** Rafael Crispim Ignácio
**Data** 1451226657631
# 1. Quais são os 4 verbos que utilizamos para o CRUD?
```js
- Create - POST
- Retrieve/Read - GET
- Update - PUT
- Delete - DELETE
```
# 2. Para que foram inventados os Status Codes? Dê um exemplo de 1 código por grupo e a imagem do Cat Status Code
Os `Status Codes` foram criados para identificarmos como uma requisição foi recebida pelo servidor.
```
101 - Switching protocols
```
```
200 - OK
```
```
301 - Moved Permanently
```
```
404 - Not Found
```
```
500 - Internal Server Error
```
# 3. Explique o que é cada parâmetro da função recebida no 'createServer'.
```js
function(request, response) {
...
}
```
- request
Representa a requisição recebida, ela contém os dados presentes no client. É deste parâmetro que capturamos as querystrings para processar uma busca ou autenticação. Também é possível verificar os headers recebidos assim como algumas outras configurações.
- response
Representa a resposta que será devolvida ao usuário. Neste parametro temos acesso as configurações do documento através dos headers e do conteúdo que será exibido. Este parâmetro é o que controla o que será retornado ao cliente ao fim de uma requisição.
# 4. O que é e para que serve a Querystring?
```
Querystring é a maneira que temos para transitar informações utilizando o protocolo http. Desta maneira podemos enviar parâmetros para o servidor para serem processados, como por exemplo uma busca ou uma autenticação.
```
# 5. Escreva no código do 'server.js' uma forma de entregar um JSON de sucesso em 4 rotas diferentes:
```js
'use strict';
var date = (new Date()).toJSON();
const http = require('http')
, SUCCESS = {
version: '1.0',
name: 'Be MEAN',
returned_at: date
}
, ERROR = {
message: "Não encontrado!"
};
http.createServer(function(request, response){
switch (request.url) {
case '/api/pokemons/create':
case '/api/pokemons/read':
case '/api/pokemons/update':
case '/api/pokemons/delete':
response.writeHead(200, {'Content-Type': 'text/html; charset=utf-8'});
response.write(JSON.stringify(SUCESS));
break;
default:
response.writeHead(404, {'Content-Type': 'text/html; charset=utf-8'});
response.write(JSON.stringify(ERROR));
}
response.end();
}).listen(3000, function(){
console.log('localhost:3000');
});
```
| {
"repo_name": "Webschool-io/be-mean-instagram-nodejs-exercises",
"stars": "33",
"repo_language": "JavaScript",
"file_name": "index.jade",
"mime_type": "text/plain"
} |
# Node.js - Aula 02 - Exercício
**user:** [jeffersondanielss](https://github.com/jeffersondanielss)
**autor:** Jefferson Daniel Santos Silva
## Quais são os 4 verbos que utilizamos para o CRUD?
+ CREATE
+ RETRIVE/READ
+ UPDATE
+ DELETE
## Para que foram inventados os Status Codes? Dê exemplo de 1 código por grupo e a imagem do [Cat Status Code](https://http.cat/).
##### 100
Quando o servidor recebeu os cabeçalhos da solicitação.
##### 200
O modelo de resposta para solicitações http de sucesso.
##### 404
Indica que o recurso requisitado não foi encontrado.
##### 503
O servidor está em manutenção ou não consegue dar conta dos processamentos de recursos.
## Explique o que é cada parâmetro da função recebida no `createServer`.
request: O objeto de solicitação contém informações sobre a solicitação do cliente, tais como a URL, cabeçalhos HTTP, e muito mais.
response: Utilizado para devolver dados de volta para o cliente.
## O que é e para que serve a Querystring?
A querystring é um conjunto de parametros passados para o browser que é enviado para um programa de consulta e serve para recuperar informações específicas a partir de um banco de dados.
## Escreva no código do `server.js` uma forma de entregar um JSON de sucesso em 4 rotas diferentes:
```
'use strict';
var date = (new Date()).toJSON();
const http = require('http')
, SUCCESS = {
version: '1.0'
, name: 'Be MEAN'
, returned_at: date
}
, ERROR = {
message: 'Não encontrado'
}
http.createServer(function( req, res ){
function success() {
res.writeHead(200, {'Content-Type': 'application/json'});
res.write(JSON.stringify(SUCCESS));
}
switch(req.url) {
case '/api/pokemons/create':
success();
break;
case '/api/pokemons/read':
success();
break;
case '/api/pokemons/update':
success();
break;
case '/api/pokemons/delete':
success();
break;
default:
res.writeHead(400, {'Content-Type': 'application/json; charset=utf-8'});
res.write(JSON.stringify(ERROR));
break;
}
res.end();
}).listen(3000, function(){
console.log( 'Servidor rodando em localhost:3000' )
});
``` | {
"repo_name": "Webschool-io/be-mean-instagram-nodejs-exercises",
"stars": "33",
"repo_language": "JavaScript",
"file_name": "index.jade",
"mime_type": "text/plain"
} |
# NodeJS - Aula 02 - Exercício
autor: Wellerson Roberto
## 1) Quais são os 4 verbos que utilizamos para o CRUD?
Create - POST
Read - GET
Update - PUT
Delete - DELETE
## 2) Para que foram inventados os Status Codes? Dê exemplo de um código por grupo e a imagem do Cat Status Code.
Foi inventado para o servidor informar, de maneira padronizada, se sua requisição foi atentidada ou não e o por que.
101 -> Trocando protocolos. O socilicitante pediu ao servidor para mudar os protocolos e o servidor irá fazê-lo. [Http.cat](https://http.cat/101)
204 -> Sem conteúdo. O servidor processou a requisição corretamente, mas não retornou nenhum conteúdo. [Http.cat](https://http.cat/204)
301 -> Movido permanentemente. Esta e todas as futuras requisições foram movidas permanentemente. [Http.cat](https://http.cat/301)
414 -> URI muito longa para o servidor processar. [Http.cat](https://http.cat/414)
508 -> Loop detectado. O servidor detectou um loop infinito enquanto processava a requisição. [Http.cat](https://http.cat/508)
## 3) Explique o quê é cada parâmetro da função recebida no 'createServer'
São passados dois parâmetros para a função recebida no createServer. O primeiro, normalmente chamado de **request** ou apenas **req**, é uma instância de **http.IncomingMessage** e é um objeto que possui informações acerca da requisição que foi feita. Nele você pode obter, por exemplo, o cabeçalho da requisição, o verbo/método, a url, a versão do HTTP... Já o segundo parâmetro, normalmente chamado de **response** ou apenas **res**, é uma instância de **http.ServerResponse**, sendo responsável por manipular a resposta que será enviada para o cliente. Ao enviar uma informação para o cliente, por exemplo, o objeto **response** será acionado, através de seus métodos **write**, **writeHead** e **end**.
## 4) O quê é e para que serve o Query String?
O **Query String** é parte de uma URL que pode conter dados que serão enviados ao servidor em um formato de chave/valor. Serve basicamente para enviar dados ao servidor. É também muito usado em APIS Web, para enviar dados que serão usados numa consulta, como por exemplo o formato que você quer recuperar uma informação.
```
http://example.com/geoserver/wfs?service=wfs&version=1.1.0&request=GetCapabilities
```
A Query String inicia-se após o **?** de uma URL. Depois, cada campo segue a estrutura "campo = valor", sem aspas mesmo para os campos de texto. Na URL acima, a Query String possui 3 campos/valores.
```
campo -> valor
service -> wfs
version -> 1.1.0
request -> GetCapabilities
```
## 5) Escreva no código do "server.js" uma forma de entregar um JSON de sucesso em 4 rotas diferentes
```
'use strict';
const http = require('http')
, date = new Date().toJSON()
, SUCCESS = {
version: 1,
name: 'Be Mean',
date: date
},
ERROR = {
message: "Não encontrado!"
};
http.createServer(function (req, response) {
switch(req.url){
case "/api/pokemons/create":
case "/api/pokemons/read":
case "/api/pokemons/update":
case "/api/pokemons/delete":
response.writeHead(200, { 'Content-Type': 'application/json' });
response.write(JSON.stringify(SUCCESS));
break;
default:
response.writeHead(404, { 'Content-Type': 'application/json;charset=utf-8' });
response.write(JSON.stringify(ERROR));
}
response.end();
}).listen(3000, function () {
console.log('Estou pronto!');
});
```
| {
"repo_name": "Webschool-io/be-mean-instagram-nodejs-exercises",
"stars": "33",
"repo_language": "JavaScript",
"file_name": "index.jade",
"mime_type": "text/plain"
} |
# Node.js - Aula 02 - Exercício
**user:** charles7421
**autor:** Charles de Freitas Garcia
## Quais são os 4 verbos que utilizamos para o CRUD?
* CREATE
* READ
* UPDATE
* DELETE
## Para que foram inventados os Status Codes? Dê exemplo de 1 código por grupo e a imagem do [Cat Status Code](https://http.cat/).
* São códigos de retorno HTTP, para padronizar a identificação oo retorno das requisições. São formados por 3 dígitos, com o primeiro digito, sendo o de identificação do tipo.
* 1XX - Informativos
** 100 - Continuar
* 2XX - Sucesso
** 200 - OK
* 3XX - Redirecionamento
** 302 - Encontrado
* 4XX - Erro de Cliente
** 404 - Não encontrado
* 5XX - Erro de Servidor
** 500 - Erro interno do servidor
## Explique o que é cada parâmetro da função recebida no `createServer`.
"http.createServer(function(request, response)"...
* Request : É a informação que chega ao servidor através do navegador.
* Response: É a resposta que deve chegar ao navegador através do servidor.
## O que é e para que serve a Querystring?
* QueryString é um conjunto de chave/valor e serve para passar paramêtros para servidor via URL.
## Escreva no código do `server.js` uma forma de entregar um JSON de sucesso em 4 rotas diferentes:
```js
'use strict';
var date = (new Date()).toJSON();
const http = require('http')
, SUCCESS = {
version: '1.0'
, name: 'Be Mean'
, returned_at: date
}
, ERROR = {
message: "Não encontrado."
};
http.createServer(function(req, res) {
switch(req.url) {
case '/api/pokemons' + '/create':
res.writeHead(200, { 'Content-Type' : 'application/json; charset=utf-8' });
res.write(JSON.stringify(SUCCESS));
break;
case '/api/pokemons' + '/read' :
res.writeHead(200, { 'Content-Type' : 'application/json; charset=utf-8' });
res.write(JSON.stringify(SUCCESS));
break;
case '/api/pokemons' + '/update':
res.writeHead(200, { 'Content-Type' : 'application/json; charset=utf-8' });
res.write(JSON.stringify(SUCCESS));
break;
case '/api/pokemons' + '/delete':
res.writeHead(200, { 'Content-Type' : 'application/json; charset=utf-8' });
res.write(JSON.stringify(SUCCESS));
break;
default:
res.writeHead(404, { 'Content-Type' : 'application/json; charset=utf-8' });
res.write(JSON.stringify(ERROR));
}
res.end();
}).listen(3000, function() {
console.log('Servidor rodando em localhost:3000');
});
| {
"repo_name": "Webschool-io/be-mean-instagram-nodejs-exercises",
"stars": "33",
"repo_language": "JavaScript",
"file_name": "index.jade",
"mime_type": "text/plain"
} |
# Node.js - Aula 02 - Exercício
**user:** [gpanassol](https://github.com/gpanassol)
**autor:** Gabriel Panassol
## Quais são os 4 verbos que utilizamos para o CRUD?
- GET
- PUT
- DELETE
- OPTIONS
## Para que foram inventados os Status Codes? Dê exemplo de 1 código por grupo e a imagem do [Cat Status Code](https://http.cat/).
O Status Codes foram inventados para apresentar ao usuário um codigo/mensagem identificando uma determinada situação do servidor. Os principais são:
## 1XX - Informacional
## 2XX - Sucesso
## 3XX - Redirecionamento
## 4XX- Erro de cliente
## 5XX - Erro de servidor
## Explique o que é cada parâmetro da função recebida no `createServer`.
### Request
O Request é a requisição feita pelo servidor ao usuário. Nele contém as informações que foram solicitas, os paramêtros e caminhos necessários para aquela requisição.
### Response
O Response é a resposta fornecida do servidor para o usuário. Por exemplo, uma validação, alterações ou até mesmo uma mensagem de erro.
## O que é e para que serve a Querystring?
A QueryString é usada para passa paramêtro para o servidor. Por exemplo, um metodo especifica à ser executado, paramêtro de acessos entre outros. Veja um exemplo:
```
http://localhost:8080/validaNomeEIdade?nome=Gabriel&idade=29
```
## Escreva no código do `server.js` uma forma de entregar um JSON de sucesso em 4 rotas diferentes:
```
'use strict';
var date = (new Date()).toJSON();
const http = require('http')
, SUCCESS = {
version: '1.0'
, name: 'Be MEAN'
, returned_at: date
}
, ERROR = {
message: "Não encontrado!"
}
;
http.createServer(function(req, res){
switch(req.url) {
case '/api/pokemons/create':
case '/api/pokemons/read':
case '/api/pokemons/update':
case '/api/pokemons/delete':
res.writeHead(200, {'Content-Type': 'application/json'});
res.write(JSON.stringify(SUCCESS));
break;
default:
res.writeHead(404, {'Content-Type': 'application/json; charset=utf-8'});
res.write(JSON.stringify(ERROR));
}
res.end();
}).listen(3000, function(){
console.log('Servidor rodando em localhost:3000');
});
``` | {
"repo_name": "Webschool-io/be-mean-instagram-nodejs-exercises",
"stars": "33",
"repo_language": "JavaScript",
"file_name": "index.jade",
"mime_type": "text/plain"
} |
```md
# Node.js - Aula 02 - Exercício
**user:** [josecarlosweb](https://github.com/josecarlosweb)
**autor:** SEU NOME COMPLETO
## Quais são os 4 verbos que utilizamos para o CRUD?
C - Create - Criar/Inserir/Salvar
R - Retrieve - Recuperar/Pegar
U - Update - Atualizar
D - Delete - Apagar
## Para que foram inventados os Status Codes? Dê exemplo de 1 código por grupo e a imagem do [Cat Status Code](https://http.cat/).
Os Status Code são uma maneira de informar o status da comunicação entre cliente e servidor. Utilizando de códigos numéricos, uma aplicação no servidor ou no cliente podem identificar ou informar quando um determinado evento aconteceu (Ex. erro, endereço movido, não autorizado dentre outros).
Exemplo do erro 500 (erro interno do servidor):
## Explique o que é cada parâmetro da função recebida no `createServer`.
A função createServer recebe uma função de _callback_ que tem dois parâmetros:
1. request: Chamado sempre há uma solicitação. Note-se que pode haver vários pedidos por conexão (no caso de conexões keep-alive). request é uma instância de http.IncomingMessage
2. response é uma instância de http.ServerResponse. Chamado quando é recebida uma resposta a esse pedido. Este evento é executado apenas uma vez.
## O que é e para que serve a Querystring?
É uma forma de passar variáveis e valores via URL, ou seja, via requisição GET.
## Escreva no código do `server.js` uma forma de entregar um JSON de sucesso em 4 rotas diferentes:
```js
//server js
'use strict';
var date = (new Date()).toJSON();
const http = require('http'),
metadados = {
version: 1.0,
returned_at: date,
}
, CREATE = {
name: 'CREATE A POKEMON',
meta: metadados,
}
, READ = {
name: 'READ A POKEMON',
meta: metadados,
}
, UPDATE = {
name: 'UPDATE A POKEMON',
meta: metadados,
}
, DELETE = {
name: 'DELETE A POKEMON',
meta: metadados,
}
, ERROR = {
message: "Erro! Digite uma url válida"
};
http.createServer(function(req, res){
res.writeHead(200, {'Content-Type':'application/json; charset=utf-8'});
var write = ERROR;
switch(req.url){
case '/api/pokemons/create': write = CREATE; break;
case '/api/pokemons/read': write = READ; break;
case '/api/pokemons/update': write = UPDATE; break;
case '/api/pokemons/delete': write = DELETE; break
default: res.writeHead(404, {'Content-Type':'application/json; charset=utf-8'}); break;
}
res.write(JSON.stringify(write));
res.end();
}).listen(3000, function(){
console.log("Server Js na porta 3000");
})
``` | {
"repo_name": "Webschool-io/be-mean-instagram-nodejs-exercises",
"stars": "33",
"repo_language": "JavaScript",
"file_name": "index.jade",
"mime_type": "text/plain"
} |
# Node.js - Aula 02 - Exercício
**user:** [ajoao88](https://github.com/ajoao88)
**autor:** João Paulo S de Araújo
**date:** 1454895260625
## Quais são os 4 verbos que utilizamos para o CRUD?
CRUD | Descrição | Verbo |
-----|-----------|-------|
C|Create|POST
R|Retrieve|GET
U|Update|PUT
D|Delete|DELETE
## Para que foram inventados os Status Codes? Dê exemplo de 1 código por grupo e a imagem do [Cat Status Code](https://http.cat/).
Para padronizar a comunicação entre cliente e servidor, com os **status codes** fica clara a resposta do servidor para a requisição feita, permitindo tratá-la adequadamente.
##### 101 - Mudando protocolos
Isso significa que o solicitante pediu ao servidor para mudar os protocolos e o servidor está reconhecendo que irá fazê-lo
##### 204 - Nenhum Conteúdo
O servidor processou a solicitação com sucesso, mas não é necessário nenhuma resposta.
##### 301 - Movido permanentemente
Esta e todas as solicitações futuras devem ser direcionada para o URI .
##### 402 - Pagamento Necessário
Reservado para uso futuro. A intenção original era que esse código pudesse ser usado como parte de alguma forma de dinheiro digital ou de micro pagamento regime, mas isso não aconteceu, e esse código não é usado normalmente.
##### 500 - Erro interno no servidor
O servidor ainda não suporta a funcionalidade ativada
## Explique o que é cada parâmetro da função recebida no `createServer`.
Existem dois parâmetros ao criar um servidor com a função `createServer`, `request` e `response`.
`Resquest` é um objeto do tipo **http.IncommingMessage**,
Armazena os dados da requisição do cliente.
`Response` é um objeto do tipo **http.ServerResponse**
É o callback que será retornado para o cliente que fez a requisição.
## O que é e para que serve a Querystring?
`Querystring` é um modelo de passagem de informações entre cliente e servidor, nele são enviados conjuntos de propriedade e valor, onde a propriedade e valor são separados por "=" e os conjuntos são separados por "&".
São enviado via **url** no final do endereço após um "?".
Ex.: http://enderecoweb/?nome=joao&idade=28
No final do endereço é introduzido um ponto de interrogação e logo em seguida os pares de propriedade e seu valor.
## Escreva no código do `server.js` uma forma de entregar um JSON de sucesso em 4 rotas diferentes:
- /api/pokemons/create
- /api/pokemons/read
- /api/pokemons/update
- /api/pokemons/delete
```js
'use strict';
const http = require('http')
, url = require('url')
, SUCCESS = {
version: '1.5'
, name: ''
, returned_at: new Date().toJSON()
}
, ERROR = {
message: "Sinto muito, endereço não encontrado"
}
;
var rotas = {
create: function(){SUCCESS.name = 'João Paulo - Exercício 02 - Rota: /api/pokemons/create'}
, read: function(){SUCCESS.name = 'João Paulo - Exercício 02 - Rota: /api/pokemons/read'}
, update: function(){SUCCESS.name = 'João Paulo - Exercício 02 - Rota: /api/pokemons/update'}
, delete: function(){SUCCESS.name = 'João Paulo - Exercício 02 - Rota: /api/pokemons/delete'}
};
http.createServer(function(req, res){
rotas.parametros = url.parse(req.url, true);
try{
var rota = req.url.replace(/\/api\/pokemons\//i, '');
rotas[rota]();
res.writeHead(200, {'Content-Type': 'application/json;charset=utf-8'});
res.write(JSON.stringify(SUCCESS));
}catch(e){
res.writeHead(404, {'Content-Type': 'application/json; charset=utf-8'});
res.write(JSON.stringify(ERROR));
}
res.end();
}).listen(3000, function(){
console.log('Servidor escutando em localhost:3000');
});
```
| {
"repo_name": "Webschool-io/be-mean-instagram-nodejs-exercises",
"stars": "33",
"repo_language": "JavaScript",
"file_name": "index.jade",
"mime_type": "text/plain"
} |
# Node.js - Aula 02 - Exercício
**user:** [Cerezini](https://github.com/Cerezini)
**autor:** Mateus Cerezini Gomes
## Quais são os 4 verbos que utilizamos para o CRUD?
- POST = Create
- GET = Read/Retrieve
- PUT = Update
- DELETE
## Para que foram inventados os Status Codes? Dê exemplo de 1 código por grupo e a imagem do [Cat Status Code](https://http.cat/).
Os status codes informam sobre o processamento (sucesso, erros, informações) da requisição através do *header* da resposta.
### 1XX - Informação
### 2XX - Sucesso
### 3XX - Redirecionamento
### 4XX - Erro no Cliente
### 5XX - Erro no Servidor
## Explique o que é cada parâmetro da função recebida no `createServer`.
- **Request** é o objeto que contém os dados do pedido feito ao servidor.
- **Response** é o objeto resposta com as informações requeridas no pedido que será retornado ao cliente.
## O que é e para que serve a Querystring?
A *querystring* é uma string com os parâmetros de busca passados em uma chamada HTTP GET, ou seja, são informações necessárias para retornar o(s) objeto(s) desejado(s) na chamada GET.
Ex: Gostaria de receber todos os carros feitos em 2008 da cor azul, logo a *querystring* teria algo como `carro?ano=2008&cor=azul`.
## Escreva no código do `server.js` uma forma de entregar um JSON de sucesso em 4 rotas diferentes:
- /api/pokemons/create
- /api/pokemons/read
- /api/pokemons/update
- /api/pokemons/delete
```js
// server.js
'use strict';
var date = (new Date()).toJSON();
const http = require('http')
, url = require('url')
, SUCCESS = {
version: '1.0'
, name: 'Be MEAN'
, returned_at: date
}
, ERROR = {
message: 'Não encontrado'
};
http.createServer(function(req, res){
var route = url.parse(req.url, true).pathname;
switch (route) {
case '/api/pokemons/create':
res.writeHead(200, {'Content-Type': 'application/json'});
res.write(JSON.stringify(SUCCESS));
break;
case '/api/pokemons/read':
res.writeHead(200, {'Content-Type': 'application/json'});
res.write(JSON.stringify(SUCCESS));
break;
case '/api/pokemons/update':
res.writeHead(200, {'Content-Type': 'application/json'});
res.write(JSON.stringify(SUCCESS));
break;
case '/api/pokemons/delete':
res.writeHead(200, {'Content-Type': 'application/json'});
res.write(JSON.stringify(SUCCESS));
break;
default:
res.writeHead(404, {'Content-Type': 'application/json; charset=utf-8'});
res.write(JSON.stringify(ERROR));
break;
}
res.end();
}).listen(3000, function(){
console.log('Servidor rodando em localhost:3000');
});
```
| {
"repo_name": "Webschool-io/be-mean-instagram-nodejs-exercises",
"stars": "33",
"repo_language": "JavaScript",
"file_name": "index.jade",
"mime_type": "text/plain"
} |
# Node.js - Aula 02 - Exercício
**user:** https://github.com/paulosilva92
**autor:** Paulo Roberto da Silva
**date:** Sat Feb 27 2016 15:29:13 GMT-0300 (BRT)
## Quais são os 4 verbos que utilizamos para o CRUD?
São os métodos :
Post: que seria a parte de Create(C).
Get: que corresponde ao Read(R).
Put: que seria o Update(U)
Delete: que seria o Delete(D)
## Para que foram inventados os Status Codes? Dê exemplo de 1 código por grupo e a imagem do Cat Status Code.
Para facilitar a comunicação entre servidor e cliente através de códigos com diferente significados pré-determinados.
##### 101 - Switching Protocols
;
##### 202 - Accepted
;
##### 303 - See Other
;
##### 409 - Conflict
;
##### 506 - Variant Also Negotiates
;
## Explique o que é cada parâmetro da funçãorecebida no `createServer`
##### request
É o parametro que irá receber toda as informações a respeito da requisição feita no servidor, como cabeçalhos, url, body.
##### reponse
É o objeto que armazenará todas as informações que o servidor enviará na sua resposta da requisição. Esse é o objeto que modificaremos com as informações que queremos que o servidor envie para o cliente que fez determinada requisição.
## O que é e para que serve a Querystring?
A QueryString é um modelo clássico de manutenção do estado da página. Elas são nada mais do que conjuntos de pares/valores anexados a URL. Seu uso é simples, após a URL de determinada página, adicionamos o primeiro valor usando a seguinte sintaxe: ?Chave=Valor. Para passarmos mais de um conjunto, os mesmos devem ser concatenados usando o caractere coringa `&`.
## Escreva no código do `server.js` uma forma de entregar um JSON de sucesso em 4 rotas diferentes:
```js
'use strict';
var date = (new Date()).toJSON();
const http = require('http')
,url = require('url')
,SUCCESS = {
version: 1.0
,name: 'Be Mean'
,created_at: date
}
,ERROR = {
message : 'deu merda'
};
var rotas = {
create: function(){
SUCCESS.name = 'Pokemon Criado'
},
read: function(){
SUCCESS.name = 'Pokemon Lido'
},
update: function(){
SUCCESS.name = 'Pokemon Atualizado'
},
delete: function(){
SUCCESS.name = 'Pokemon Deletado'
}
}
http.createServer(function(req, res){
rotas.parametros = url.parse(req.url, true);
try{
// remove a descrição /api/pokemons
var rota = req.url.replace(/\/api\/pokemons\//gi, '');
rotas[rota]();
res.writeHead(200, {'Content-Type': 'application/json'});
res.write(JSON.stringify(SUCCESS));
}catch(e){
res.writeHead(404, {'Content-Type': 'application/json; charset=utf-8'});
res.write(JSON.stringify(ERROR));
}
res.end();
}).listen(3000, function(){
console.log('Servidor rodando em localhost:3000');
});
```
| {
"repo_name": "Webschool-io/be-mean-instagram-nodejs-exercises",
"stars": "33",
"repo_language": "JavaScript",
"file_name": "index.jade",
"mime_type": "text/plain"
} |
# Node.js - Aula 02 - Exercício
**Autor:** Diego Ferreira
**Data:** 1456489472714
## Quais são os 4 verbos que utilizamos para o CRUD?
Uma operação de CRUD, realiza as operações de CREATE, READ, UPDATE, DELETE, em uma requisição estes métodos são representados pelos seguintes verbos:
CREATE -> POST (envia uma requisição para o servidor passando parâmetro),
READ -> GET ( solicita alguma informação de um recurso do servidor),
UPDATE -> PUT ( envia uma requisição passando parâmetros, para atualização de um recurso já existente.),
DELETE -> DELETE ( Remove o recurso especificado )
## Para que foram inventados os Status Codes? Dê exemplo de 1 código por grupo e a imagem do [Cat Status Code](https://http.cat/).
Os status cod foram criados para padronizar a conversa entre cliente e servidor, padronizando códigos e status com o intuito de identificar de maneira mais clara o resultado do processamento de uma requisição.
Os status foram divididos em 5 grupos, 1XX, 2XX, 3XX, 4XX, 5XX, conforme abaixo:
* 1XX - Informativos
Ex.:
100 - Continue
Esta é uma resposta provisória usada para informar ao cliente que a parte inicial da solicitação foi recebida e não foi rejeitada pelo servidor. Diante deste status o cliente deve continuar enviando o restante do pedido ou, se o pedido já foi concluído, ignorar esta resposta.
* 2XX - SUCESSO
Ex.:
200 - OK
Requisição efetuada com sucesso.
* 3XX - Redirecionamento
Ex.:
301 - Movido Permanentemente
Indica que o recurso solicitado foi movido permanentemente para outro endereço.
* 4XX - Erro do Cliente
Ex.:
403 - Forbidden
O servidor entendeu a solicitação mais recusou a responder.
* 5XX - Erro do Servidor
Ex.:
503 - Service Unavaliable
O servidor não consegue processar a requisição devido a uma sobrecarga ou manutenção no servidor.
## Explique o que é cada parâmetro da função recebida no `createServer`.
A função create server recebe 2 parâmetros resquest e reponse.
###### Request
Variável que recebe os dados da requisição enviada pelo cliente.
###### Response
Variável para responder para o cliente as informações ou mensagens de erro provenientes da requisição realizada.
## O que é e para que serve a Querystring?
QueryString é um padrão que permite passar parametros e valores na URL em uma requisição, utilizando o método GET.
## Escreva no código do `server.js` uma forma de entregar um JSON de sucesso em 4 rotas diferentes:
/api/pokemons/create - /api/pokemons/read - /api/pokemons/update - /api/pokemons/delete
```
'use strict';
const http = require('http'),
SUCCESS = {
version:1.0,
name: 'BE MEAN',
created_at: Date.now()},
ERROR = { message: "URL solicitada não encontrada"};
http.createServer (function(req,resp){
switch ( req.url ) {
case '/api/pokemons/create':
sucesso(resp);
break;
case '/api/pokemons/read':
sucesso(resp);
break;
case '/api/pokemons/update':
sucesso(resp);
break;
case '/api/pokemons/delete':
sucesso(resp);
break;
default:
error(resp);
}
resp.end();
}).listen(3000,function(){
console.log("Servidor rodando na porta 3000!!!");
});
function cabecalho(requestCode, resp){
resp.writeHead(requestCode, {'Content-Type':'application/json;charset=utf-8'});
}
function sucesso(resp){
cabecalho(200, resp);
resp.write(JSON.stringify(SUCCESS));
}
function error(resp){
cabecalho(404, resp);
resp.write(JSON.stringify(ERROR));
}
```
## Bibliografia
https://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html
| {
"repo_name": "Webschool-io/be-mean-instagram-nodejs-exercises",
"stars": "33",
"repo_language": "JavaScript",
"file_name": "index.jade",
"mime_type": "text/plain"
} |
# Node.js - Aula 02 - Exercício
**user:** [gustavoprado013](https://github.com/gustavoprado013)
**autor:** Gustavo Prado
## Quais são os 4 verbos que utilizamos para o CRUD?
- Create - Criar
- Retrieve/Read - Recuperar/Ler
- Update - Atualizar
- Delete - Excluir
## Para que foram inventados os Status Codes? Dê exemplo de 1 código por grupo e a imagem do [Cat Status Code](https://http.cat).
Os Status Codes foram criado para padronizar o retorno da requisições via HTTP para:
* Informação.
- 100 (continue): O cliente deve continuar com o pedido, é uma resposta provisória para informar o cliente que a solicitação foi recebida e não foi rejeitada pelo servidor. Cat Status Code (https://http.cat/100).
* Sucesso.
- 202 (accepted): O pedido foi aceito para processamento, porém o processamento ainda não foi concluído. É uma resposta intencionalmente nao comprometedora para que o servidor possa aceitar um pedido de algum outro processo. Cat Status Code (https://http.cat/202).
* Redirecionamento.
- 302 (found): É utilizado para informar que o recurso solicitado está temporáriamente em uma URI diferente. O cliente deve continuar usando a URI solicitada para futuras solicitações. Cat Status Code (https://http.cat/302).
* Erro do cliente.
- 403 (Forbidden): O servidor entendeu a solicitação mais não a executará. Ou seja o servidor proibido essa solicitação e deve ser enviado o motivo de ter proibido na entity. Se desejar ser público o 404 pode ser usado no lugar. Cat Status Code (https://http.cat/403).
* Erro do servidor.
- 502 (Bad Gateway): O servidor é usado como GateWay ou Proxy. recebe uma responsta inválida do servidor superior, ao tentar executar a solicitação. Cat Status Code (https://http.cat/502).
## Explique o que é cada parâmetro da função recebida no `createServer`.
É passada uma função anônima onde a mesma é executada somente naquele momento e retorna para o cliente que realizou a requisição e é passado os seguintes parâmetros para a mesma:
- request: É o parâmetro onde os dados da requisição chegam para nosso servidor.
- response: É o nosso callback e o que será retornado para a requisição solicitada.
## O que é e para que serve a Querystring?
A querystring é um conjunto de caracteres de entrada para um computador ou browser da Web e enviado para um programa de consulta para recuperar informações específicas a partir de um banco de dados.
Na Internet, uma string de consulta (também chamado de querystring HTTP) faz parte do conjunto de caracteres de entrada automaticamente na barra de endereço de um site dinâmico quando um usuário faz uma solicitação de informação de acordo com certos critérios.
Em uma URL (Uniform Resource Locator), a querystring possui um símbolo de separação, geralmente um ponto de interrogação (?). Os dados aparecem logo após este símbolo de separação. Por exemplo, considere o seguinte URL:
http://www.example.com?name=Gustavo&materia=JS&age=20
A querystring neste exemplo consiste de um campo ou variável, tecnicamente chamada de chave neste contexto (no exemplo é a palavra "name"), seguido por um sinal de igual (=), seguido pelo valor (no exemplo é o nome "angelo"). Cada chave e seu valor correspondente, indicado como uma equação, é chamado de par chave-valor. A querystring pode conter vários pares de chave-valores. Quando há mais de um par chave-valor, eles são tipicamente separados por um e comercial (&).
## Escreva no código do `server.js` uma forma de entregar um JSON de sucesso em 4 rotas diferentes:
```js
'use strict';
var date = (new Date()).toJSON();
var http = require('http')
, SUCCESS = {
version: '1.0'
, name: 'Be MEAN'
, returned_at: date
}
, ERROR = {
message: "Not Found!"
};
var url = require('url');
http.createServer(function(req, res) {
var url_parse = url.parse(req.url);
switch(url_parse.pathname) {
case '/api/pokemons/create':
case '/api/pokemons/read':
case '/api/pokemons/update':
case '/api/pokemons/delete':
res.writeHead(200, { 'Content-Type': 'application/json; charset=utf-8'});
res.write(JSON.stringify(SUCCESS));
break;
default:
res.writeHead(404, { 'Content-Type': 'application/json; charset=utf-8'});
res.write(JSON.stringify(ERROR));
}
res.end();
}).listen(3000, function() {
console.log('Servidor rodando em localhost:3000');
});
```
| {
"repo_name": "Webschool-io/be-mean-instagram-nodejs-exercises",
"stars": "33",
"repo_language": "JavaScript",
"file_name": "index.jade",
"mime_type": "text/plain"
} |
# Node.js - Aula 02 - Exercício
**User:** [DouglasHennrich](https://github.com/DouglasHennrich)
**Autor:** Douglas Hennrich
**Date:** 1449889648726
## Quais são os 4 verbos que utilizamos para o CRUD?
* **C** reate - `POST`
* **R** etrieve - `GET`
* **U** pdate - `PUT`
* **D** elete - `DELETE`
## Para que foram inventados os Status Codes? Dê exemplo de 1 código por grupo e a imagem do [Cat Status Code](https://http.cat/).
Os `Status Codes` foram inventados para padronizar os tipos de retorno do servidor, facilitando o entendimento deles.
* **1XX** - Information
* **2XX** - Successful
* **3XX** - Redirection
* **4XX** - Client Error
* **5XX** - Server Error
## Explique o que é cada parâmetro da função recebida no `createServer`.
* **Request** - Contêm os parâmetros da requisição feita pelo Usuário
* **Response** - Contêm métodos para escrever respostas para o Usuário
## O que é e para que serve a Querystring?
* **O que é** - Conjunto de `key`/`value` anexados a URL
* **Para o que serve** - Passar parâmetros para o servidor através do método `GET`
## Escreva no código do `server.js` uma forma de entregar um JSON de sucesso em 4 rotas diferentes:
```js
'use strict';
var date = (new Date()).toJSON();
const http = require('http')
, SUCCESS = {
version: 1.0
, code: 200
, name: 'Be MEAN'
, created_at: date
}
, ERROR = {
message: "Method Not Allowed"
, code: 405
}
;
http.createServer(function(req, res){
let url = req.url
, method = req.method
;
switch(url){
case "/api/pokemons/create":
if(method === "POST"){
res.writeHead(200, { 'Content-Type': 'application/json; charset=utf-8' });
res.write(JSON.stringify(SUCCESS));
}else{
res.writeHead(405, { 'Content-Type': 'application/json; charset=utf-8' });
res.write(JSON.stringify(ERROR));
}
break;
case "/api/pokemons/read":
if(method === "GET"){
res.writeHead(200, { 'Content-Type': 'application/json; charset=utf-8' });
res.write(JSON.stringify(SUCCESS));
}else{
res.writeHead(405, { 'Content-Type': 'application/json; charset=utf-8' });
res.write(JSON.stringify(ERROR));
}
break;
case "/api/pokemons/update":
if(method === "PUT"){
res.writeHead(200, { 'Content-Type': 'application/json; charset=utf-8' });
res.write(JSON.stringify(SUCCESS));
}else{
res.writeHead(405, { 'Content-Type': 'application/json; charset=utf-8' });
res.write(JSON.stringify(ERROR));
}
break;
case "/api/pokemons/delete":
if(method === "DELETE"){
res.writeHead(200, { 'Content-Type': 'application/json; charset=utf-8' });
res.write(JSON.stringify(SUCCESS));
}else{
res.writeHead(405, { 'Content-Type': 'application/json; charset=utf-8' });
res.write(JSON.stringify(ERROR));
}
break;
default:
res.writeHead(404, { 'Content-Type': 'application/json; charset=utf-8' });
ERROR.message = "Not Found";
ERROR.code = 404
res.write(JSON.stringify(ERROR));
break;
}
res.end();
})
.listen(3000, function(){
console.log('Servidor rodando em localhost:3000');
});
```
| {
"repo_name": "Webschool-io/be-mean-instagram-nodejs-exercises",
"stars": "33",
"repo_language": "JavaScript",
"file_name": "index.jade",
"mime_type": "text/plain"
} |
# Node.js - Aula 02 - Exercício
**user:** [lesilva00](https://github.com/lesilva00)
**autor:** Luís Eduardo Tenório Silva
## Quais são os 4 verbos que utilizamos para o CRUD?
Create (Criar), Read (Ler), Udpate(Atualizar) e Delete(Deletar).
## Para que foram inventados os Status Codes? Dê exemplo de 1 código por grupo e a imagem do [Cat Status Code](https://http.cat/).
Os Status Codes foram criados para informar ao cliente o estado do servidor e de sua solicitação. Esses Status Codes são definidos pelo servidor web no cabeçalho das respostas HTTP que serão passadas aos clientes ou indexadores.
####**1XX:** Informacional
Responsável para informar o usuário algumas ações do servidor
Mudando protocolos: 
####**2XX:** Sucesso
Responsável por informar que a ação solicitada pelo usuário foi recebida, compreendida, aceita e processada com êxito
OK: 
####**3XX:** Redirecionamento
Responsável por informar que a ação necessita de redirecionamento para ser completada. Esse redirecionamento vai desde a mudança de localização temporária da página, mudança permanente, redirecionamento de gateway entre outros.
Movido temporariamente: 
####**4XX:** Erro do Cliente
Responsável de informar a existência de um erro provindo da solicitação do cliente.
Não encontrado: 
####**5XX:** Erro do Servidor
Responsável por informar a existência de um erro provindo do servidor. Geralmente esses erros ocorrem devido a uma má configuração do ambiente ou a problemas internos.
Bad gateway: 
## Explique o que é cada parâmetro da função recebida no `createServer`.
**Request:**
Contém dados da requisição do cliente (Ex: url).
**Response:**
Dados de resposta a solicitação realizada pelo usuário. Aqui é comum definir o Status Code da solicitação e a página que será carregada pelo usuário.
## O que é e para que serve a Querystring?
Conjunto formado por chave/valor que contém informações gerais da solicitação do cliente.
## Escreva no código do `server.js` uma forma de entregar um JSON de sucesso em 4 rotas diferentes:
- /api/pokemons/create
- /api/pokemons/read
- /api/pokemons/update
- /api/pokemons/delete
```js
'use strict';
var date = (new Date()).toJSON();
var http = require('http');
var url = require('url');
const SUCCESS = {
version:'1.0',
name:'Success',
returned_at:date
}
, ERROR = {
message:'Não encontrado'
}
http.createServer(function(req,res){
var urlInitial = '/api/pokemons/'
var result = url.parse(req.url,true);
switch(result.pathname){
case urlInitial+'create':
res.writeHead(200,{'Content-Type':'application/json; charset=utf-8'});
res.write(JSON.stringify(SUCCESS));
break;
case urlInitial+'read':
res.writeHead(200,{'Content-Type':'application/json; charset=utf-8'});
res.write(JSON.stringify(SUCCESS));
break;
case urlInitial+'update':
res.writeHead(200,{'Content-Type':'application/json; charset=utf-8'});
res.write(JSON.stringify(SUCCESS));
break;
case urlInitial+'delete':
res.writeHead(200,{'Content-Type':'application/json; charset=utf-8'});
res.write(JSON.stringify(SUCCESS));
break;
default:
res.writeHead(404,{'Content-Type':'application/json; charset=utf-8'});
res.write(JSON.stringify(ERROR));
}
res.end();
}).listen(8080,function(){
console.log('Servidor rodando na porta 8080, pressione ^C para sair...');
});
```
| {
"repo_name": "Webschool-io/be-mean-instagram-nodejs-exercises",
"stars": "33",
"repo_language": "JavaScript",
"file_name": "index.jade",
"mime_type": "text/plain"
} |
# Node.js - Aula 02 - Exercício
**user:** [FrancisoValerio]https://github.com/FranciscoValerio
**autor:** Francisco Henrique Ruiz Valério
## Quais são os 4 verbos que utilizamos para o CRUD?
- Create
- Retrieve/Read
- Update
- Delete
## Para que foram inventados os Status Codes? Dê exemplo de 1 código por grupo e a imagem do [Cat Status Code](https://http.cat/).
Os Status Codes foram criado para padronizar o retorno da requisições via HTTP para:
* Informação.
- 100 (continue): O cliente deve continuar com o pedido, é uma resposta provisória para informar o cliente que a solicitação foi recebida e não foi rejeitada pelo servidor. Cat Status Code (https://http.cat/100).
* Sucesso.
- 202 (accepted): O pedido foi aceito para processamento, porém o processamento ainda não foi concluído. É uma resposta intencionalmente nao comprometedora para que o servidor possa aceitar um pedido de algum outro processo. Cat Status Code (https://http.cat/202).
* Redirecionamento.
- 302 (found): É utilizado para informar que o recurso solicitado está temporáriamente em uma URI diferente. O cliente deve continuar usando a URI solicitada para futuras solicitações. Cat Status Code (https://http.cat/302).
* Erro do cliente.
- 403 (Forbidden): O servidor entendeu a solicitação mais não a executará. Ou seja o servidor proibido essa solicitação e deve ser enviado o motivo de ter proibido na entity. Se desejar ser público o 404 pode ser usado no lugar. Cat Status Code (https://http.cat/403).
* Erro do servidor.
- 502 (Bad Gateway): O servidor é usado como GateWay ou Proxy. recebe uma responsta inválida do servidor superior, ao tentar executar a solicitação. Cat Status Code (https://http.cat/502).
## Explique o que é cada parâmetro da função recebida no `createServer`.
É passada uma função anônima onde a mesma é executada somente naquele momento e retorna para o cliente que realizou a requisição e é passado os seguintes parâmetros para a mesma:
- request: É o parâmetro onde os dados da requisição chegam para nosso servidor.
- response: É o nosso callback e o que será retornado para a requisição solicitada.
## O que é e para que serve a Querystring?
Querystring é padrão adotado pelo protocolo HTTP e serve para transportar informações do cliente para o servidor.
Utiliza-se do seguinte padrão:
variavel=conteudo
## Escreva no código do `server.js` uma forma de entregar um JSON de sucesso em 4 rotas diferentes:
'use strict';
var date = ( new Date()).toJSON();
const http = require('http')
, url = require('url')
, SUCCESS = {
version: "1.0"
, name: 'Be MEAN'
, created_at: date
}
, ERROR = {
message: "Não econtrado!"
};
http.createServer( function ( request, response ){
var url_parse = url.parse(request.url);
switch(url_parse.pathname) {
case '/delete':
case '/query':
case '/edit':
case '/new':
response.writeHead(200, { 'Content-Type': 'application/json; charset=utf-8'});
response.write(JSON.stringify(SUCCESS));
break;
default:
response.writeHead(404, { 'Content-Type': 'application/json; charset=utf-8'});
response.write(JSON.stringify(ERROR));
}
response.end();
}).listen(3000, function(){
console.log('Servidor rodando em localhost:3000');
}); | {
"repo_name": "Webschool-io/be-mean-instagram-nodejs-exercises",
"stars": "33",
"repo_language": "JavaScript",
"file_name": "index.jade",
"mime_type": "text/plain"
} |
# Node.js - Aula 02 - Exercício
**user:** [yesroh](https://github.com/yesroh)
**autor:** Ronaiza Cardoso
**Date:** 1469731861509
## Quais são os 4 verbos que utilizamos para o CRUD?
- Create
- Retrieve
- Update
- Delete
## Para que foram inventados os Status Codes? Dê exemplo de 1 código por grupo e a imagem do [Cat Status Code](https://http.cat/).
Serve para informar o que o servidor esta respondendo.
## 1XX - Informação
## 2XX - Sucesso
## 3XX - Redirecionamento
## 4XX- Erro de cliente
## 5XX - Erro de servidor
## Explique o que é cada parâmetro da função recebida no `createServer`.
- request: informações de requisição feita pelo cliente;
- response: informações de resposta do servidor para o cliente.
## O que é e para que serve a Querystring?
Querystring é uma forma de passar os valores pela url, assim podemos pegar os valores da nossa url com nosso request.
## Escreva no código do `server.js` uma forma de entregar um JSON de sucesso em 4 rotas diferentes:
```js
'use strict';
var date = (new Date()).toJSON();
const http = require('http')
, SUCCESS = {
version: '1.0'
, name: 'Be MEAN'
, returned_at: date
}
, ERROR = {
message: "Não encontrado!"
}
;
http.createServer(function(req, res){
switch(req.url) {
case '/rota/v1':
case '/rota/v2':
case '/rota/v3':
case '/rota/v4':
res.writeHead(200, {'Content-Type': 'application/json'});
res.write(JSON.stringify(SUCCESS));
break;
default:
res.writeHead(404, {'Content-Type': 'application/json; charset=utf-8'});
res.write(JSON.stringify(ERROR));
}
res.end();
}).listen(3000, function(){
console.log('Servidor rodando em localhost:3000');
});
``` | {
"repo_name": "Webschool-io/be-mean-instagram-nodejs-exercises",
"stars": "33",
"repo_language": "JavaScript",
"file_name": "index.jade",
"mime_type": "text/plain"
} |
# Node.js - Aula 02 - Exercício
**user:** [felipelopesrita](https://github.com/felipelopesrita)
**autor:** Felipe José Lopes Rita
## Quais são os 4 verbos que utilizamos para o CRUD?
Para a criação do CRUD, utilizaremos os verbos POST para o CREATE, GET para Retrive/Read, PUT para UPDATE e DELETE para DELETE (esse ficou meio redundante)
## Para que foram inventados os Status Codes? Dê exemplo de 1 código por grupo e a imagem do [Cat Status Code](https://http.cat/).
Os códigos de retorno são padronizados e tem como intuito direcionar a identificação do conteúdo de retorno ao cliente. Por exemplo, uma aplicação pode facilmente estar escrita em russo (aplicações de ak-47 e vodkas), mas se ao acessá-la ela retornar o código `404` sei que a uri que requisitei não existe, mesmo não falando russo.
**1XX**
São códigos que indicam apenas informações a respeito da requisição, como por exemplo o código 101: Mudando protocolos. Esse código significa que foi requisitado uma mudança de protocolo e que o servidor reconheceu isso e irá fazê-la.
**2XX**
Código para informa que a requisição foi recebida, aceita e executada com sucesso, como o status 200, OK, padrão de resposta para requisições HTTP realizadas com êxito.
**3XX**
Informa ao cabeçalho HTTP que será necessária uma mudança de página(redirecionamento). Um fato interessante é que o servidor só pode fazer esse redirecionamento automaticamente, isto é, sem uma interação com o usuário, quando o verbo da requisição é o GET ou HEAD.
Um exemplo desse status é o 301, que informa que a solicitação corrente, bem como todas as futuras, devem ser direcionadas ao URI.
**4XX**
Essa classe de status são utilizadas para indicar possíveis erros cometidos pelo cliente, como por exemplo o 404, onde o cliente tenta acessar o serviço através de uma uri inexistente, ou mesmo o erro 400, que indica que a requisição não pode ser realizada devido à sintaxe incorreta no pedido
**5XX**
Indicam erros internos do servidor, apresentados durante o processamento da requisição, como por exemplo o erro 503, que informa que o serviço requisitado está indisponível devido a uma manutenção ou a uma sobrecarga do sistema.
## Explique o que é cada parâmetro da função recebida no `createServer`
```js
function (request. response){}
```
**Request**
Armazena os dados referentes a requisição http efetuada, para que seja possível determinar o que deve ser feito.
**Response**
É um objeto de resposta utilizado para retornar os dados requisitados pelo cliente
## O que é e para que serve a Querystring?
São um ou diversos conjuntos de pares de valores(chave=valor) contidos numa requisição http. E são utilizados para transportar valores de forma rápida e fácil, para que eles possam ser usados como parâmetros de uma requisição.
## Escreva no código do `server.js` uma forma de entregar um JSON de sucesso em 4 rotas diferentes:
```js
'use strict';
var date = (new Date()).toJSON()
, rotes =
{ 'create': 'Rota acessada: Create'
, 'read': 'Rota acessada: Read'
, 'update': 'Rota acessada: Update'
, 'delete': 'Rota acessada: Delete'
}
;
const http = require('http')
, url = require('url')
, SUCCESS = {
version: 1.0
, name: 'Be Mean'
, created_at: date
}
, ERROR = {
'message': 'Nâo encontrado'
}
;
http.createServer(function(req, res){
try {
res.writeHead(200, {'Content-Type': 'application/json'});
var x = req.url.replace(/\/api\/pokemons\//gi, '');
SUCCESS.rote = rotes[x];
res.write(JSON.stringify(SUCCESS));
}
catch(e) {
res.writeHead(404, {'Content-Type': 'application/json'});
console.log(e);
res.write(JSON.stringify(ERROR))
}
res.end();
}).listen(3000, function(){
console.log('Servidor rodando em localhost:3000');
});
```
## Referências
[HTTP Status Codes](http://www.restapitutorial.com/httpstatuscodes.html#)
[HTTP response codes](https://developer.mozilla.org/en-US/docs/Web/HTTP/Response_codes) | {
"repo_name": "Webschool-io/be-mean-instagram-nodejs-exercises",
"stars": "33",
"repo_language": "JavaScript",
"file_name": "index.jade",
"mime_type": "text/plain"
} |
# Node.js - Aula 02 - Exercício
**user:** [rxon7](https://github.com/rxon7)
**autor:** Rony Souza
## Quais são os 4 verbos que utilizamos para o CRUD?
- Create
- Retrieve
- Update
- Delete
## Para que foram inventados os Status Codes? Dê exemplo de 1 código por grupo e a imagem do [Cat Status Code](https://http.cat/).
Serve para padronizar o retorno do servidor
## 1XX - Informacional
## 2XX - Sucesso
## 3XX - Redirecionamento
## 4XX- Erro de cliente
## 5XX - Erro de servidor
## Explique o que é cada parâmetro da função recebida no `createServer`.
`createServer` é uma função anônima, que é executada automaticamente.
**Request:** É a informação chegando no servidor através do navegador.
**Response:** É a informação chegando no navegador através do servidor.
## O que é e para que serve a Querystring?
Querystring é uma forma de passar os valores pela url e Serve para alterarmos o estado de uma página web.
## Escreva no código do `server.js` uma forma de entregar um JSON de sucesso em 4 rotas diferentes:
```js
var http = require('http');
var STATUS = {};
function setStatus(action, message){
STATUS = {
action: action,
message: message,
date_at: new Date().toJSON()
};
}
http.createServer((req, res) => {
res.writeHead(200, {'Content-Type': 'application/json; charset=utf-8'});
switch(req.url){
case '/api/pokemons/create':
setStatus('CREATE', 'Criando um Pokémon.');
break;
case '/api/pokemons/read':
setStatus('READ', 'Retornando um Pokémon.');
break;
case '/api/pokemons/update':
setStatus('UPDATE', 'Atualizando um Pokémon.');
break;
case '/api/pokemons/delete':
setStatus('DELETE', 'Excluindo um Pokémon.');
break;
default:
res.writeHead(404, {'Content-Type': 'application/json'});
setStatus('ERROR', 'Not found');
break;
}
res.write(JSON.stringify(STATUS));
res.end();
}).listen(3300, () => {
console.log('O servidor está rodando em localhost:3300.');
});
``` | {
"repo_name": "Webschool-io/be-mean-instagram-nodejs-exercises",
"stars": "33",
"repo_language": "JavaScript",
"file_name": "index.jade",
"mime_type": "text/plain"
} |
# Node.js - Aula 02 - Exercício
**user:** [davidsonsns](https://github.com/davidsonsns)
**autor:** Davidson da Silva Nascimento
**date:** Date.now()
## Quais são os 4 verbos que utilizamos para o CRUD?
- **C** <kbd>POST</kbd> Criar, inserir
- **R** <kbd>GET</kbd> Recuperar, obter
- **U** <kbd>PUT</kbd> Atualizar
- **D** <kbd>DELETE</kbd> Excluir
## Para que foram inventados os Status Codes? Dê exemplo de 1 código por grupo e a imagem do [Cat Status Code](https://http.cat/).
Informar ao cliente, através de códigos com significados já pré-definidos, sobre o status da requisição ao servidor. A causa de um erro inesperado poderá ser gerado por ambas as partes.
##### `1xx` Informação
O servidor recebeu os cabeçalhos da solicitação, e que o cliente deve proceder para enviar o corpo do pedido
##### `2xx` Sucesso
O pedido foi aceito para processamento, mas o tratamento não foi concluído
##### `3xx` Redirecionamento
Indica várias opções para o recurso que o cliente pode acompanhar
##### `4xx` Erro de cliente
O pedido não pode ser entregue devido à sintaxe incorreta
##### `5xx` Erro de servidor
O servidor detectou um loop infinito ao processar o pedido (enviado em vez de 208)
## Explique o que é cada parâmetro da função recebida no `createServer`.
Suponhamos a seguinte assinatura:
```js
http.createServer(function(request, response){}
```
#### `request`
Objeto de solicitação que contém informações sobre a solicitação do cliente, tais como a URL, cabeçalhos HTTP, e muito mais.
Segue exemplo onde retornamos a rota informada:
```js
request.url
```
#### `response`
Objeto de resposta que é utilizada para devolver dados de volta para o cliente.
Abaixo segue exemplo onde enviamos um código de status HTTP e uma coleção de cabeçalhos de resposta de volta ao cliente:
```js
response.writeHead(200,{"Content-Type":"text/html"});
```
## O que é e para que serve a Querystring?
Conjunto de pares/valores anexados a URL via `GET`. Utilizada para facilitar, na maioria das vezes, o envio de dados estruturados de forma simples e pequena entre cliente/servidor.
Exemplo de URL com QueryString:
```js
.../rota?name=Davidson&sobrenome=Nascimento
```
Exemplo de tratamento no Node.js:
```js
...
http.createServer(function(request, response){
var queryString = url.parse(request.url, true);
for(var key in queryString.query){
response.write(key + ": " + result.query[key]);
}
}
...
//imprimirá: Davidson Nascimento
```
## Escreva no código do `server.js` uma forma de entregar um JSON de sucesso em 4 rotas diferentes:
- /api/pokemons/create
- /api/pokemons/read
- /api/pokemons/update
- /api/pokemons/delete
```js
var date = (new Date()).toJSON();
const http = require('http')
, url = require('url')
, SUCCESS = {
version: '1.0'
, name: ''
, returned_at: date
}
, ERROR = {
message: "Não encontrado!"
}
;
var rotas = {
create: function(){
SUCCESS.name = 'Be MEAN ENTROU NA ROTA /api/pokemons/create'
},
read: function(){
SUCCESS.name = 'Be MEAN ENTROU NA ROTA /api/pokemons/read'
},
update: function(){
SUCCESS.name = 'Be MEAN ENTROU NA ROTA /api/pokemons/update'
},
delete: function(){
SUCCESS.name = 'Be MEAN ENTROU NA ROTA /api/pokemons/delete'
}
}
http.createServer(function(req, res){
rotas.parametros = url.parse(req.url, true);
try{
// remove a descrição /api/pokemons
var rota = req.url.replace(/\/api\/pokemons\//gi, '');
rotas[rota]();
res.writeHead(200, {'Content-Type': 'application/json'});
res.write(JSON.stringify(SUCCESS));
}catch(e){
res.writeHead(404, {'Content-Type': 'application/json; charset=utf-8'});
res.write(JSON.stringify(ERROR));
}
res.end();
}).listen(3000, function(){
console.log('Servidor rodando em localhost:3000');
});
```
| {
"repo_name": "Webschool-io/be-mean-instagram-nodejs-exercises",
"stars": "33",
"repo_language": "JavaScript",
"file_name": "index.jade",
"mime_type": "text/plain"
} |
# Node.js - Aula 02 - Exercício
# autor: Angelo Rogério Rubin
# data: 1449870839155
## Quais são os 4 verbos que utilizamos para o CRUD?
- Create - Criar
- Retrieve/Read - Recuperar/Ler
- Update - Atualizar
- Delete - Excluir
## Para que foram inventados os Status Codes? Dê exemplo de 1 código por grupo e a imagem do [Cat Status Code](https://http.cat).
Os Status Codes foram criado para padronizar o retorno da requisições via HTTP para:
* Informação.
- 100 (continue): O cliente deve continuar com o pedido, é uma resposta provisória para informar o cliente que a solicitação foi recebida e não foi rejeitada pelo servidor. Cat Status Code (https://http.cat/100).
* Sucesso.
- 202 (accepted): O pedido foi aceito para processamento, porém o processamento ainda não foi concluído. É uma resposta intencionalmente nao comprometedora para que o servidor possa aceitar um pedido de algum outro processo. Cat Status Code (https://http.cat/202).
* Redirecionamento.
- 302 (found): É utilizado para informar que o recurso solicitado está temporáriamente em uma URI diferente. O cliente deve continuar usando a URI solicitada para futuras solicitações. Cat Status Code (https://http.cat/302).
* Erro do cliente.
- 403 (Forbidden): O servidor entendeu a solicitação mais não a executará. Ou seja o servidor proibido essa solicitação e deve ser enviado o motivo de ter proibido na entity. Se desejar ser público o 404 pode ser usado no lugar. Cat Status Code (https://http.cat/403).
* Erro do servidor.
- 502 (Bad Gateway): O servidor é usado como GateWay ou Proxy. recebe uma responsta inválida do servidor superior, ao tentar executar a solicitação. Cat Status Code (https://http.cat/502).
## Explique o que é cada parâmetro da função recebida no `createServer`.
É passada uma função anônima onde a mesma é executada somente naquele momento e retorna para o cliente que realizou a requisição e é passado os seguintes parâmetros para a mesma:
- request: É o parâmetro onde os dados da requisição chegam para nosso servidor.
- response: É o nosso callback e o que será retornado para a requisição solicitada.
## O que é e para que serve a Querystring?
A querystring é um conjunto de caracteres de entrada para um computador ou browser da Web e enviado para um programa de consulta para recuperar informações específicas a partir de um banco de dados.
Na Internet, uma string de consulta (também chamado de querystring HTTP) faz parte do conjunto de caracteres de entrada automaticamente na barra de endereço de um site dinâmico quando um usuário faz uma solicitação de informação de acordo com certos critérios.
Em uma URL (Uniform Resource Locator), a querystring possui um símbolo de separação, geralmente um ponto de interrogação (?). Os dados aparecem logo após este símbolo de separação. Por exemplo, considere o seguinte URL:
http://www.example.com?name=angelo
A querystring neste exemplo consiste de um campo ou variável, tecnicamente chamada de chave neste contexto (no exemplo é a palavra "name"), seguido por um sinal de igual (=), seguido pelo valor (no exemplo é o nome "angelo"). Cada chave e seu valor correspondente, indicado como uma equação, é chamado de par chave-valor. A querystring pode conter vários pares de chave-valores. Quando há mais de um par chave-valor, eles são tipicamente separados por um e comercial (&).
## Escreva no código do `server.js` uma forma de entregar um JSON de sucesso em 4 rotas diferentes:
'use strict';
var date = (new Date()).toJSON();
var http = require('http')
, SUCCESS = {
version: '1.0'
, name: 'Be MEAN'
, returned_at: date
}
, ERROR = {
message: "Not Found!"
};
var url = require('url');
http.createServer(function(req, res) {
var url_parse = url.parse(req.url);
switch(url_parse.pathname) {
case '/api/pokemons/create':
case '/api/pokemons/read':
case '/api/pokemons/update':
case '/api/pokemons/delete':
res.writeHead(200, { 'Content-Type': 'application/json; charset=utf-8'});
res.write(JSON.stringify(SUCCESS));
break;
default:
res.writeHead(404, { 'Content-Type': 'application/json; charset=utf-8'});
res.write(JSON.stringify(ERROR));
}
res.end();
}).listen(3000, function() {
console.log('Servidor rodando em localhost:3000');
}); | {
"repo_name": "Webschool-io/be-mean-instagram-nodejs-exercises",
"stars": "33",
"repo_language": "JavaScript",
"file_name": "index.jade",
"mime_type": "text/plain"
} |
# Node.js - Aula 02 - Exercício
**user:** [vitorcapretz](https://github.com/vitorcapretz)
**autor:** Vitor Capretz
**date:** 1465758182466
## 1. Quais são os 4 verbos que utilizamos para o CRUD?
O CRUD consiste nas 4 principais operações de um sistema, são elas:
* Create - Inserção de novos dados. Ex.: `POST`
* Read - Leitura de dados já inseridos. Ex.: `GET`
* Update - Alteração de dados inseridos. Ex.: `PUT`
* Delete - Exclusão de dados. Ex.: `DELETE`
## 2. Para que foram inventados os Status Codes? Dê exemplo de 1 código por grupo e a imagem do `Cat Status Code`.
Cada Status Code representa um tipo de possível retorno de uma requisição, ao fazer uma requisição podemos facilmente comprender se tudo funcionou como esperávamos ou qual foi o comportamento dela.
#### 101 - Continue
#### 202 - Accepted
#### 301 - Moved Permanently
#### 416 - Requested Range Not Satisfiable
#### 500 - Internal Server Error
## 3. Explique o que é cada parâmetro da função recebida no `createServer`.
Os parâmetros são:
* Request - Parâmetro do tipo Objeto, onde são enviadas as informações necessárias para o servidor, incluindo cabeçalho, URL, tipo de requisição, etc.
* Response - Parâmetro do tipo Objeto, contém as informações retornadas do servidor para a nossa requisição.
## 4. O que é e para que serve a `Querystring`?
A Querystring fica normalmente no fim da URL e contém variáveis separadas por `&`. Ela pode ser usada para enviar informações para um `GET` de informações em uma API.
Exemplo: `meusite.com.br/api/users/?name=Vitor`
## 5. Escreva no código do server.js uma forma de entregar um JSON de sucesso em 4 rotas diferentes:
```js
'use strict';
let date = (new Date()).toJSON();
const http = require('http');
const successJson = {
version: 1.0,
name: 'Be MEAN',
returned_at: date
};
const errorJson = {
message: 'Não encontrado!'
};
http.createServer(function(req, res){
let req_url = req.url;
switch(req_url){
case "/api/pokemons/create":
case "/api/pokemons/read":
case "/api/pokemons/update":
case "/api/pokemons/delete":
res.writeHead(200, {'Content-type': 'application/json; charset=utf-8'});
res.write(JSON.stringify(successJson));
break;
default:
res.writeHead(400, {'Content-type': 'application/json; charset=utf-8'});
res.write(JSON.stringify(errorJson));
break;
}
res.end();
}).listen(3000, function(){
console.log('Server running on localhost:3000');
});
```
| {
"repo_name": "Webschool-io/be-mean-instagram-nodejs-exercises",
"stars": "33",
"repo_language": "JavaScript",
"file_name": "index.jade",
"mime_type": "text/plain"
} |
# Node.js - Aula 02 - Exercício
**user:** [souzacristsf](https://github.com/souzacristsf)<br/>
**autor:** Michel Ferreira Souza<br/>
**date:** 1457296166387<br/>
## Quais são os 4 verbos que utilizamos para o CRUD?
+ create
+ read
+ update
+ delete
## Para que foram inventados os Status Codes? Dê exemplo de 1 código por grupo e a imagem do [Cat Status Code](https://http.cat/).
O `Status Code` foi criado para identificar o erro retornado de uma requisição, padronizando o tipo de retorno.
####100
O cliente deve continuar com seu pedido. Esta resposta provisória é usada para informar o cliente que a parte inicial da solicitação foi recebida e ainda não foi rejeitado pelo servidor.<br/>
####200
O pedido foi bem sucedido.<br/>
####301
O recurso solicitado foi atribuído um novo endereço permanente e quaisquer futuras referências a este recurso deverá usar um dos endereços devolvidos.<br/>
####402
Este código é reservado para o uso futuro. <br/>
####503
O servidor é atualmente incapaz de lidar com o pedido devido a uma sobrecarga temporária ou manutenção do servidor.<br/>
## Explique o que é cada parâmetro da função recebida no `createServer`.
```js
function (request. response){}
```
*request* requisição feita do lado clienta para o servidor.
*response* analisada a requisição é retornado uma resposta do servidor.
## O que é e para que serve a Querystring?
*Querystring* é um conjunto de valores anexados a **URL** para um propósito no lado servidor.
## Escreva no código do `server.js` uma forma de entregar um JSON de sucesso em 4 rotas diferentes:
```js
'use strict';
const PORT=9000;
const http = require('http')
, date = (new Date()).toJSON()
, SUCCESS = {
version: 1
, name: 'Be Mean'
, date: date
}
, ERROR = {
message: "Não encontrado!"
}
;
var server = http.createServer(function(request, response){
switch (request.url) {
case "/api/pokemons/create":
case "/api/pokemons/read":
case "/api/pokemons/update":
case "/api/pokemons/delete":
response.writeHead(200, {'Content-type': 'application/json; charset=utf-8'});
response.write(JSON.stringify(SUCCESS));
break;
default:
response.writeHead(400, {'Content-type': 'application/json; charset=utf-8'});
response.write(JSON.stringify(ERROR));
break;
}
response.end();
});
server.listen(PORT, function(){
console.log(server);
console.log('Servidor rodando em localhost: ' + PORT);
});
``` | {
"repo_name": "Webschool-io/be-mean-instagram-nodejs-exercises",
"stars": "33",
"repo_language": "JavaScript",
"file_name": "index.jade",
"mime_type": "text/plain"
} |
# Nodejs - Aula 02 - Exercício
autor: Ricardo Pereira
##1. Quais são os 4 verbos que utilizamos para o CRUD?
C = Create(POST)
R = Read(GET)
U = Update(PUT)
D = Delete(DELETE)
##2. Para que foram inventados os Status Codes? Dê exemplo de 1 código por grupo e a imagem do Cat Status Code.
Foi criado para dar padrões de resposta e para ter uma orientação melhor dos acontecimentos do servidor, uma leitura mais legível para o homem.
1xx Informational
2xx Success
3xx Redirection
4xx Cliente Error
5xx Server Error
##3. Explique o que é cada parâmetro da função recebida no 'createServer'.
request: reponsável de receber as requisições, url e seus parâmetro por exemplo.
response: responsável de escrever e gerar status do servidor para o cliente.
##4. O que é e para que serve a Querystring?
QueryString em World Wide Web (WWW) é um padrão utilizado para transportar valores em uma uniform resource locator (URL).
Elas são um conjuntos de pares/valores anexados a URL.
##5. Escreva no código do 'server.js' uma forma de entregar um JSON de sucesso em 4 rotas diferentes.
```
'use strict';
const http = require('http')
, SUCCESS = {
name: '<h1>Be MEAN</h1>',
}
, ERROR = {
message: "<h1>Not found</h1>"
};
http.createServer((req, res) => {
let urls = [ '/api/pokemons/create',
'/api/pokemons/read',
'/api/pokemons/update',
'/api/pokemons/delete'];
switch (req.url) {
case urls[0]:
case urls[1]:
case urls[2]:
case urls[3]:
res.writeHead(200, {'Content-Type': 'text/html; charset=UTF-8'});
res.write(SUCCESS.name);
break;
default:
res.writeHead(404, {'Content-Type': 'text/html; charset=UTF-8'});
res.write(ERROR.message);
}
res.end();
}).listen(3000, () => {
console.log('Server start in port 3000');
});
``` | {
"repo_name": "Webschool-io/be-mean-instagram-nodejs-exercises",
"stars": "33",
"repo_language": "JavaScript",
"file_name": "index.jade",
"mime_type": "text/plain"
} |
# Node.js - Aula 02 - Exercício
**User:** [xereda](https://github.com/xereda)
**Autor:** Jackson Ricardo Schroeder
**Date:** 1464932419174
#### 1 - Quais são os 4 verbos que utilizamos para o CRUD?
* **[ C ]** - `POST` // create
* **[ R ]** - `GET` // read/retrieve
* **[ U ]** - `PUT` // update
* **[ D ]** - `DELETE` // delete
#### 2 - Para que foram inventados os Status Codes? Dê exemplo de 1 código por grupo e a imagem do [Cat Status Code](https://http.cat/).
Os _Status Codes_ foram introduzidos para que a comunicação entre um cliente e o servidor de internet fosse padronizada. É baseado numa lista de códigos com 3 algarismos cada, normalizando, dessa forma, os possíveis tipos de retorno de um servidor HTTP.
#### 1XX Informacional
###### 100 - Continue
#### 2XX Sucesso
###### 206 - Partial Content
#### 3XX Redirecionamento
###### 304 - Not Modified
#### 4XX Erro do Cliente
###### 409 - Conflict
#### 5XX Erro de Servidor
###### 502 - Bad Gateway
#### 3 - Explique o que é cada parâmetro da função recebida no `createServer`.
* **Request:** - Parâmetro que contém as informações da requisição feita ao script em questão.
* **Response:** - Parâmetro que estabelece um canal de comunicação com o client da requisição. É um handle para fazer as saídas, ou mais precisamente, o retorno, para o "requisitante".
#### 4 - O que é e para que serve a Querystring?
É uma parte da URL que contém informações da requisição no formato chave/valor. Utilizamos ela com o metodo `GET`.
#### 5 - Escreva no código do `server.js` uma forma de entregar um JSON de sucesso em 4 rotas diferentes:
* /api/pokemons/create
* /api/pokemons/read
* /api/pokemons/update
* /api/pokemons/delete
```js
// server.js
"use strict";
var date = (new Date()).toJSON();
const http = require("http");
const SUCCESS = { version: 1.0, name: "Be MEAN", returned_at: date };
const ERROR = { message: "Método inválido para esta rota!" };
const ROTA = { message: "Rota inexistente!" };
const ContentType = { "Content-Type": "application/json; charset=utf-8" };
var server = http.createServer(function(req, res) {
let url = req.url;
let method = req.method;
switch (url) {
case "/api/pokemons/create":
if (method === "POST") {
res.writeHead(200, ContentType);
res.write(JSON.stringify(SUCCESS));
}
else {
res.writeHead(405, ContentType);
res.write(JSON.stringify(ERROR));
}
break;
case "/api/pokemons/read":
if (method === "GET") {
res.writeHead(200, ContentType);
res.write(JSON.stringify(SUCCESS));
}
else {
res.writeHead(405, ContentType);
res.write(JSON.stringify(ERROR));
}
break;
case "/api/pokemons/update":
if (method === "PUT") {
res.writeHead(200, ContentType);
res.write(JSON.stringify(SUCCESS));
}
else {
res.writeHead(405, ContentType);
res.write(JSON.stringify(ERROR));
}
break;
case "/api/pokemons/delete":
if (method === "DELETE") {
res.writeHead(200, ContentType);
res.write(JSON.stringify(SUCCESS));
}
else {
res.writeHead(405, ContentType);
res.write(JSON.stringify(ERROR));
}
break;
default:
res.writeHead(404, ContentType);
res.write(JSON.stringify(ROTA));
}
res.end();
});
server.listen(3000, function() {
console.log("Servidor rodando em localhost:3000");
});
```
| {
"repo_name": "Webschool-io/be-mean-instagram-nodejs-exercises",
"stars": "33",
"repo_language": "JavaScript",
"file_name": "index.jade",
"mime_type": "text/plain"
} |
# Node.js - Aula 02 - Exercício
**user:** [filipe1309](https://github.com/filipe1309)
**autor:** Filipe Leuch Bonfim
## Quais são os 4 verbos que utilizamos para o CRUD?
- [**C**] = POST
- [**R**] = GET
- [**U**] = PUT
- [**D**] = DELETE
## Para que foram inventados os Status Codes? Dê exemplo de 1 código por grupo e a imagem do [Cat Status Code](https://http.cat/).
Os `Status Codes` foram inventados com o intuito de padronizar os retornos das requisições entre o cliente e o servidor, assim podendo ser útil para ajudar a identificar a causa de problemas quando uma página web ou outro recurso não carrega como deveria.
#### 1XX - Informacional
#### 2XX - Sucesso
#### 3XX - Redirecionamento
#### 4XX - Erro do cliente
#### 5XX - Erro do servidor
## Explique o que é cada parâmetro da função recebida no `createServer`.
#### Request
O `request` é um objeto que contêm informações sobre o `request` emitido pelo cliente, como por exemplo o cabeçalho HTTP, a URL, etc.
#### Response
O `responce` é um objeto, com diversos métodos, utilizado para retornar dados para o cliente.
## O que é e para que serve a Querystring?
#### O que é?
`Querystring` é a parte da URL que contem dados. Estes dados são passados como parâmetros no formato de `chave=valor`.
#### Para quer serve?
Serve para passar dados através da URL, utilizando o método `GET`.
## Escreva no código do `server.js` uma forma de entregar um JSON de sucesso em 4 rotas diferentes:
```js
'use strict';
var date = (new Date()).toJSON();
const http = require('http')
, SUCCESS = {
version: '1.0'
, name: 'Be MEAN'
, returned_at: date
}
, ERROR = {
message: "Não encontrado!"
}
;
http.createServer(function(req, res){
var url_route = '/api/pokemons/';
var responseStatusCode = 404;
var responseObj = ERROR;
switch (req.url) {
case url_route+'create':
case url_route+'read':
case url_route+'update':
case url_route+'delete':
responseStatusCode = 200;
responseObj = SUCCESS;
break;
}
res.writeHead(responseStatusCode, {'Content-Type': 'application/json; charset=utf-8'});
res.write(JSON.stringify(responseObj));
res.end();
}).listen(3000, function(){
console.log('Servidor rodando em localhost:3000');
});
```
| {
"repo_name": "Webschool-io/be-mean-instagram-nodejs-exercises",
"stars": "33",
"repo_language": "JavaScript",
"file_name": "index.jade",
"mime_type": "text/plain"
} |
# Node.js - Aula 02 - Exercício
**user:** [pedrohills](http://github.com/pedrohills)
**autor:** Pedro Henrique
## Quais são os 4 verbos que utilizamos para o CRUD?
GET, POST, PUT e DELETE.
## Para que foram inventados os Status Codes? Dê exemplo de 1 código por grupo e a imagem do [Cat Status Code](https://http.cat/).
São compostos, por padrão, por 3 digitos. Os Status Codes são divididos em 5 grupos, os de 100, 200, 300, 400 e 500.
1XX = Informacional: Serve apenas para informar que a informação foi recebida e que o processo continua.
Exemplo de código: 100 - Continuar: Apenas sinaliza para o usuário continuar com a requisição.
2XX = Bem Sucedido:
Exemplo de código: 200 - OK: Significa que a página web existe e que as operações foram realizadas com sucesso.
3XX = Redirecionamento: Notifica ao cabeçalho que houve uma mudança de página...
Exemplo de código: 302 - Movido Temporariamente: Serve para mover, mas temporariamente.
4XX = Erro do Cliente: Erros 4XX devem ser tratados com cuidado. Pois quando há este tipo de erro no cabeçalho o conteúdo não estará acessivel ao usuário nem para os sistemas de busca para indexação.
Exemplo de código: 401 - Não autorizado: Quando o usuário não tem acesso à página especifica (usuário não autenticado)
Exemplo de código: 404 - Não encontrado: Famoso código que é retornado quando uma página ou arquivo especifico não existe no servidor..
5XX = Erro do Servidor: Acontece quando o servidor não consegue processar a requisição por algum motivo... Este erro também não permite a indexação da página.
Exemplo de código: 503 - Serviço indisponível: É possível ser um erro temporário. Uma manutenção ou uma grande quantidade de requisições realizadas ao servidor que ocasionou em sua queda...
## Explique o que é cada parâmetro da função recebida no `createServer`.
No createServer passamos uma função anônima com dois parâmetros, são eles:
request: O request representa a requisição que é requisitada.
response: O response representa a resposta que é recebida.
## O que é e para que serve a Querystring?
São os valores passados pela URL. Serve para passarmos valores para nosso GET.
Exemplo http://localhost:3000?variavel=valor
## Escreva no código do `server.js` uma forma de entregar um JSON de sucesso em 4 rotas diferentes:
```javascript
// server.js
'use strict';
var date = (new Date()).toJSON();
const http = require('http');
http.createServer(function(req, res){
if(req.url === '/api/v1'){
res.writeHead(200, {'Content-Type': 'application/json; charset=utf-8'});
res.write(JSON.stringify({"message": "Página v1 encontrada!"}));
} else if(req.url === '/api/v2'){
res.writeHead(200, {'Content-Type': 'application/json; charset=utf-8'});
res.write(JSON.stringify({"message": "Página v2 encontrada!"}));
} else if(req.url === '/api/v3'){
res.writeHead(200, {'Content-Type': 'application/json; charset=utf-8'});
res.write(JSON.stringify({"message": "Página v3 encontrada!"}));
} else if(req.url === '/api/v4'){
res.writeHead(200, {'Content-Type': 'application/json; charset=utf-8'});
res.write(JSON.stringify({"message": "Página v4 encontrada!"}));
} else if(req.url === '/api/v5'){
res.writeHead(200, {'Content-Type': 'application/json; charset=utf-8'});
res.write(JSON.stringify({"message": "Página v5 encontrada!"}));
} else {
res.writeHead(404, {'Content-Type': 'application/json; charset=utf-8'});
res.write(JSON.stringify({"message": "Nenhuma página encontrada!"}));
}
res.end();
}).listen(3000, function(){
console.log('Servidor rodando em localhost:3000');
});
```
| {
"repo_name": "Webschool-io/be-mean-instagram-nodejs-exercises",
"stars": "33",
"repo_language": "JavaScript",
"file_name": "index.jade",
"mime_type": "text/plain"
} |
# NodeJS - Aula 02 - Exercício
**Autor:** Luan da Silva Oliveira
**User:** luanconecte
# 1 - Quais são os 4 verbos que utilizamos para o CRUD?
+ POST - CREATE
+ GET - RETRIVE/READ
+ PUT - UPDATE
+ DELETE - DELETE
# 2 - Para que foram inventados os Status Codes? Dê exemplo de 1 código por grupo e a imagem do [Cat Status Code](https://http.cat/).
São códigos padrão de estado de uma aplicação, foram desenvolvidos para responder a uma requisição do cliente. O código é formado de três dígitos e separados em cinco grupos:
+ 1XX Informacional
<img src="https://http.cat/100" width="100%">
Isso significa que o servidor recebeu os cabeçalhos da solicitação, e que o cliente deve proceder para enviar o corpo do pedido (no caso de haver um pedido um corpo deve ser enviado, por exemplo, um POST pedido). Se o corpo é grande o pedido, enviando-os para um servidor, quando o pedido já foi rejeitada com base em cabeçalhos inadequado é ineficiente. Para ter um cheque do servidor se o pedido pode ser aceite com base no pedido de cabeçalhos sozinho, o cliente deve enviar Esperar: 100-continue como um cabeçalho no seu pedido inicial e verifique se a 100 Continuar código de status é recebido em resposta antes de permanente (ou receber 417 Falha na expectativa e não continuar).
+ 2XX Sucesso
<img src="https://http.cat/206" width="100%">
O servidor está entregando apenas parte do recurso devido a um cabeçalho intervalo enviados pelo cliente. O cabeçalho do intervalo é usado por ferramentas como wget para permitir retomada de downloads interrompidos, ou dividir um download em vários fluxos simultâneos.
+ 3XX Redirecionamento
<img src="https://http.cat/304" width="100%">
Indica que o recurso não foi modificado desde o último pedido. Normalmente, o cliente fornece um cabeçalho HTTP como o Se-Modificado-Desde cabeçalho para proporcionar um tempo contra o qual para comparar. Usando este poupa largura de banda e de reprocessamento no servidor e cliente, uma vez que apenas os dados do cabeçalho devem ser enviados e recebidos em comparação com a totalidade da página que está sendo reprocessados pelo servidor, em seguida, enviado novamente utilizando mais largura de banda do servidor e cliente .
+ 4XX Erro do Cliente
<img src="https://http.cat/413" width="100%">
A solicitação é maior do que o servidor está disposto ou capaz de processar.
+ 5XX Erro de Servidor
<img src="https://http.cat/503" width="100%">
O servidor está em manutenção ou não consegue dar conta dos processamentos de recursos devido à sobrecarga do sistema. Isto deve ser uma condição temporária.
# 3 - Explique o que é cada parâmetro da função recebida no `createServer`.
A função recebe uma função de callback que recebe dois parâmetros:
request: Parâmetro que representa a requisição do cliente;
response: Parâmetro que representa a resposta do servidor;
# 4 - O que é e para que serve a Querystring?
Querystring é um conjunto de chave/valor passados através da URL:
htttp://127.0.0.1:3000?nome=Luan&idade=22&sexo=Masculino
No node através da função url.parser(request.url) conseguimos recuperar uma série de atributos que dizem respeito a URL da requisição, dentre eles o atributo query que trás um objeto com todos valores passados.
query: { nome: 'Luan', idade: '22', sexo: 'Masculino' },
# 5 - Escreva no código do `server.js` uma forma de entregar um JSON de sucesso em 4 rotas diferentes:
```js
// server.js
'use strict';
var http = require("http")
, url = require('url');
const hostname = '127.0.0.1'
, port = 1337
, routes = [
'/api/pokemons/create'
, '/api/pokemons/read'
, '/api/pokemons/update'
, '/api/pokemons/delete'
];
http.createServer((req, res) => {
routes.forEach(function(element, index){
if ( url.parse(req.url).pathname == element ) {
res.writeHead(200, { 'Content-Type': 'application/json; charset=utf-8' });
res.write(JSON.stringify({
route: element
, created_at: Date.now()
}));
}
});
res.end();
}).listen(port, hostname, () => {
console.log(`Server running at http://${hostname}:${port}/`);
});
``` | {
"repo_name": "Webschool-io/be-mean-instagram-nodejs-exercises",
"stars": "33",
"repo_language": "JavaScript",
"file_name": "index.jade",
"mime_type": "text/plain"
} |
# Node.js - Aula 02 - Exercício
**User:** [gkal19](https://github.com/gkal19)
**Autor:** Gabriel Kalani
## Quais são os 4 verbos que utilizamos para o CRUD?
C - Create
R - Retrieve/Read
U - Update
D - Delete
## Para que foram inventados os Status Codes? Dê exemplo de 1 código por grupo e a imagem do [Cat Status Code](https://http.cat/).
As `Status Codes` foram criadas para responder uma requisição do cliente<br>
**(Informação)**
**2(Sucesso)**
**3(Redirecionamento)**
**4(Erro de request)**
**5(Erro no servidor)**
## Explique o que é cada parâmetro da função recebida no `createServer`.
Request;
Response;
## O que é e para que serve a Querystring?
São variáveis e valores que são obtidos através de formulários ou requisições do usuário e que são enviados à url.
Nela podemos transferir dados do URL pelo GET.
`?campo=value&campo=value`
## Escreva no código do `server.js` uma forma de entregar um JSON de sucesso em 4 rotas diferentes:
```js
const http = require('http');
http.createServer((req, res) => {
res.writeHead(200, {'Content-Type': 'application/json;charset=utf-8'});
switch(req.url){
case '/create':
createJson(res, 1, 'CREATE', req.url);
break;
case '/read':
createJson(res, 2, 'READ', req.url);
break;
case '/update':
createJson(res, 3, 'UPDATE', req.url);
break;
case '/delete':
createJson(res, 4, 'DELETE', req.url);
break;
default:
res.writeHead(404, {'Content-Type': 'application/json;charset=utf-8'});
createJson(res, null, 'UM ERRO ENCONTRADO!!', req.url);
break;
}
res.end();
}).listen(3000, () => {
console.log('Servidor levantando na 3000');
});
function createJson(response, id, mensagem, url){
const json = {
'id': id,
'mensagem': mensagem,
'url': url,
'data': new Date()
};
return response.write(JSON.stringify(json));
}
```
| {
"repo_name": "Webschool-io/be-mean-instagram-nodejs-exercises",
"stars": "33",
"repo_language": "JavaScript",
"file_name": "index.jade",
"mime_type": "text/plain"
} |
# Node.js - Aula 02 - Exercício
**User:** [Geriel Castro](https://github.com/geriel)
**Autor:** Geriel Castro
**Date:**
#### 1 - Quais são os 4 verbos que utilizamos para o CRUD?
* **C** - `POST`
* **R** - `GET`
* **U** - `PUT`
* **D** - `DELETE`
#### 2 - Para que foram inventados os Status Codes? Dê exemplo de 1 código por grupo e a imagem do [Cat Status Code](https://http.cat/).
Para padronizar e facilitar o entendimento dos servidores, foi criado um padrão de Estatus ( *Status Codes* ), dessa forma, fica explícito os tipos de retorno que cada mensagem vem do servidor.
#### 1XX Informacional
###### 100 - Continue
#### 2XX Sucesso
###### 206 - Partial Content
#### 3XX Redirecionamento
###### 304 - Not Modified
#### 4XX Erro do Cliente
###### 409 - Conflict
#### 5XX Erro de Servidor
###### 502 - Bad Gateway
#### 3 - Explique o que é cada parâmetro da função recebida no `createServer`.
* **Request** - Parâmetro que contém a requisição do usuário.
* **Response** - Servidor utiliza como resposta para usuário.
#### 4 - O que é e para que serve a Querystring?
É a maneira utilizada para passar parametros para outras páginas através da URL. Utilizamos ela com o metodo `GET`.
#### 5 - Escreva no código do `server.js` uma forma de entregar um JSON de sucesso em 4 rotas diferentes:
* /api/pokemons/create
* /api/pokemons/read
* /api/pokemons/update
* /api/pokemons/delete
```js
'use strict';
var date = (new Date()).toJSON();
const http = require('http')
, SUCCESS = {
version: 1.0
, name: 'Geriel Castro - Be Mean'
, created_at: date
}
, ERROR = {
message: "Não Encontrada"
}
;
http.createServer(function(req, resp){
var url = req.url;
switch(url){
case "/api/pokemons/create":
resp.writeHead(200, {'Content-Type': 'application/json; charset=utf-8'});
resp.write(JSON.stringify(SUCCESS));
break;
case "/api/pokemons/read":
resp.writeHead(200, {'Content-Type': 'application/json; charset=utf-8'});
resp.write(JSON.stringify(SUCCESS));
break;
case "/api/pokemons/update":
resp.writeHead(200, {'Content-Type': 'application/json; charset=utf-8'});
resp.write(JSON.stringify(SUCCESS));
break;
case "/api/pokemons/delete":
resp.writeHead(200, {'Content-Type': 'application/json; charset=utf-8'});
resp.write(JSON.stringify(SUCCESS));
break;
default:
resp.writeHead(404, {'Content-Type': 'application/json; charset=utf-8'});
ERROR.message = "Pagina não encontrada!";
p.write(JSON.stringify(ERROR));
break;
}
resp.end();
})
.listen(3000, function(){
console.log('Servidor rodando em localhost:3000');
});
```
| {
"repo_name": "Webschool-io/be-mean-instagram-nodejs-exercises",
"stars": "33",
"repo_language": "JavaScript",
"file_name": "index.jade",
"mime_type": "text/plain"
} |
# NodeJs - Exercício 02 - resolvido
autor: Carlos Alberto Araujo Barreto
## 01 - Quais são os 4 verbos que utilizamos para o CRUD?
Create: Criar - **POST**
Retrieve/Read: Recuperar/Ler - **GET**
Update: Atualizar - **PUT**
Delete: Deletar - **DELETE**
## 02 - Para que foram inventados os Status Codes? Dẽ exemplo de 1 código por grupo e a imagem do Cat Status Code.
Os status codes foram desenvolvidos para padronizar os retornos de requisições HTTP.
100 - Continuar: o servidor que recebeu os cabeçalhos da solicitação, e que o cliente deve proceder para enviar o corpo do pedido.
204 - Nenhum conteúdo: O servidor processou a solicitação com sucesso, mas não é necessário nenhuma resposta.
301 - Movido: Esta e todas as solicitações futuras devem ser direcioandas para o URI.
409 - Conflito: Indica que a solicitação não pôde ser processada por causa do conflito no pedido, como um conflito de edição.
503 - Serviço indisponível: O servidor está em manutenção ou não consegue dar conta dos processamentos de recursos devido à sobrecarga do sistema. Isto deve ser uma condição temporária.
## 03 - Explique o que é cada parâmetro de função recebida no 'createServer'.
Recebe uma função anônima como parâmetro com os seguintes argumentos:
### Request
Dados da requisição feita pelo usuário
### Response
Dados do callback que será retornado para o usuário
## 04 - O que é e para que serve a Querystring?
É a string que contém os valores recebidos via query na URL.
Ela serve para passar informações através das páginas usando o método GET.
## 05 - Escreva no código do 'server.js' uma forma de entregar um JSON de sucesso em 4 rotas diferentes.
```
'use strict';
var date = (new Date()).toJSON();
const http = require('http')
, SUCESSO = {message: 'Be-Mean NodeJS', responseDate: date}
, ERRO = {message: 'Página não encontrada', responseDate: date};
http.createServer(function(request, response){
switch(request.url){
case '/api/caso1':
response.writeHead(200, {'Content-Type': 'application/json; charset=utf-8'});
response.write(JSON.stringify(SUCESSO));
break;
case '/api/caso2':
response.writeHead(200, {'Content-Type': 'application/json; charset=utf-8'});
response.write(JSON.stringify(SUCESSO));
break;
case '/api/caso3':
response.writeHead(200, {'Content-Type': 'application/json; charset=utf-8'});
response.write(JSON.stringify(SUCESSO));
break;
case '/api/caso4':
response.writeHead(200, {'Content-Type': 'application/json; charset=utf-8'});
response.write(JSON.stringify(SUCESSO));
break;
default:
response.writeHead(200, {'Content-Type': 'application/json; charset=utf-8'});
response.write(JSON.stringify(ERRO));
}
response.end();
}).listen(3000, function(){
console.log('Servidor rodando em localhost: 3000');
});
```
| {
"repo_name": "Webschool-io/be-mean-instagram-nodejs-exercises",
"stars": "33",
"repo_language": "JavaScript",
"file_name": "index.jade",
"mime_type": "text/plain"
} |
# Node.js - Aula 02 - Exercício
**user:** [gilsondev](https://github.com/gilsondev)
**autor:** Gilson da Silva Borges Filho
**date:** 1457204474567
## Quais são os 4 verbos que utilizamos para o CRUD?
**GET**: Verbo usado para listar todos os recursos disponíveis de uma rota específica
ou então de um recurso selecionado. Exemplo:
```bash
GET /products - Lista todos os produtos
GET /products/1 - Retorna o produto de número 1
```
**POST**: Verbo usado para criar um novo recurso no servidor. Dependendo da necessidade,
ele é usado também para atualizar um recurso existente.
```bash
POST /products - Cria um novo recurso de produto no servidor
POST /products/1 - Atualiza um produto do servidor
```
**PUT**: Verbo usado para atualizar um recurso no servidor.
```bash
PUT /products/1 - Atualiza os dados de um recurso selecionado
```
**DELETE**: Remove um recurso armazenado no servidor.
```bash
DELETE /products/1 - Remove o recurso "Produto 1" no servidor
```
## Para que foram inventados os status codes? Dê exemplo de 1 código por grupo e a imagem do *Cat Status Code*
Foram criados para definir o status do processamento do servidor, se foi de sucesso ou erro por exemplo.
Ele possui um padrão no formato desse código. Dentro do status code, temos alguns grupos como:
#### 1xx - Informacional
Traz informações do que foi feito no processamento. Ele não é muito usado atualmente.
Exemplo:
- 100 CONTINUE: Solicita que o cliente continue com a requisição feita, já que
a primeira parte dela já foi recebida.
#### 2xx - Sucesso
Esse grupo indica que a requisição feita pelo cliente foi executado, recebido ou aceito com sucesso.
Exemplo:
- 200 OK: A requisição foi aceita
- 201 CREATED: A requisição foi aceita e resultou em um novo recurso.
#### 3xx - Redirecionamento
Aqui é quando uma ação que precisa ser feito para que ocorra um redirecionamento de
um recurso para outro.
Exemplo:
- 301 MOVED PERMANENTLY: Efetua um redirecionamento completo, mudando a URI
- 304 NOT MODIFIED: Quando efetua alguma requisição de alguma informação, mas
que não houve nenhuma mudança. Ocorre muito em arquivos estáticos.
#### 4xx - Erro no Cliente
Nesse grupo possui códigos que identificam erros cometidos pelo cliente.
Exemplo:
- 404 NOT FOUND: Recurso solicitado não encontrado
- 400 BAD REQUEST: A requisição construida possui algum erro que não é possivel
ser aceito.
#### 5xx - Erro no Servidor
Diferente do último, são códigos de define os tipos de erros cometidos pelo servidor.
Exemplo:
- 500 INTERNAL SERVER ERROR: Indica que ocorreu algum erro no processamento do servidor,
impossibilitando uma resposta esperada.
- 505 HTTP VERSION NOT SUPPORTED: Quando alguma requisição é feito usando determinada
versão do protocolo HTTP que o servidor não tem suporte para processá-la.
## Explique o que é cada parametro da função recebida no `createServer`.
Dentro do createServer você manda uma função anônima com dois parametros:
- request: O objeto que possui a requisição do cliente;
- response: Resposta a ser montada pelo servidor e enviado ao cliente.
## O que é e para que serve a Querystring?
Querystring um formato para recebimendo de valores na url. Segue um exemplo:
```
http://host.com/routername?param1=value1¶m2=value2o
```
Assim você o servidor recebe na requisição dessa URL:
chave: param1
valor: value1
chave: param2
valor: value2
## Escreva no código do `server.js` uma forma de entregar um JSON de sucesso em 4 rotas diferentes.
```javascript
'use strict';
const json_head = {'Content-Type': 'application/json'};
const http = require('http')
, SUCCESS = {
message: 'Its success',
, status: 200
}
, ERROR = {
message: 'Its not found'
, status: 404
}
;
var render_success = function(req, res) {
res.writeHead(200, json_head);
res.write(JSON.stringify(SUCCESS));
};
var render_error = function(req, res) {
res.writeHead(404, json_head);
res.write(JSON.stringify(ERROR));
};
var server = http.createServer(function(req, res) {
if(req.url === '/router/a') {
render_success(req, res);
}
else if(req.url === '/router/b') {
render_success(req, res);
}
else if(req.url === '/router/c') {
render_success(req, res);
}
else if(req.url === '/router/d') {
render_success(req, res);
}
else {
render_error(req, res);
}
});
```
| {
"repo_name": "Webschool-io/be-mean-instagram-nodejs-exercises",
"stars": "33",
"repo_language": "JavaScript",
"file_name": "index.jade",
"mime_type": "text/plain"
} |
# Node.js - Aula 02 - Exercício
autor: Bruno Lima da Silva
## 1. Quais são os 4 verbos que utilizamos para o CRUD?
C - Create - Post (Criar)
R - Retrieve/Read - Get (Ler)
U - Update - Put (Atualizar)
D - Delete - Delete (Deletar)
## 2. Para que foram inventados os Status Codes? Dê exemplo de 1 código por grupo e a imagem do Cat Status Code.
Os Status Codes foram inventados para que toda requisição feita possa receber um código de resposta e padronizar o retorno do servidor, onde com esse código é possivel saber se uma operação foi realizada com sucesso, se foi movide ou se não foi encontrada.
- 101 Switching Protocols (Mudando protocolos): Isso significa que o solicitante pediu ao servidor para mudar os protocolos e o servidor está reconhecendo que irá fazê-lo.
https://http.cat/101
- 201 Create (Criado): O pedido foi cumprido e resultou em um novo recurso que está sendo criado.
https://http.cat/201
- 304 Not Modified (Não modificado): O recurso não foi alterado.
https://http.cat/304
- 403 Forbidden (Proibido): O servidor entende a requisição, mas se recusa em atendê-la. O cliente não deve tentar fazer uma nova requisição.
https://http.cat/403
- 503 Service Unavailable (Servidor indisponível): O servidor não é capaz de processar a requisição pois está temporariamente indisponível.
https://http.cat/503
## 3. Explique o que é cada parâmetro da função recebida no `createServer`.
Request: Request é a requisição que o usuário está fazendo para o servidor
Response: Response é a resposta que o servidor está retornando para a requisição do usuário.
## 4. O que é e para que serve a Querystring?
QueryString é um modelo clássico de manutenção do estado da página. É composto porque chaves e valores anexados na URL.
Serve para passar parâmetros para o servidor através do método GET.
## 5. Escreva no código do `server.js` uma forma de entregar um JSON de sucesso em 4 rotas diferentes sem if:
## - /api/pokemons/create
## - /api/pokemons/read
## - /api/pokemons/update
## - /api/pokemons/delete
```js
'use strict';
var date = (new Date()).toJSON();
const http = require('http');
const SUCCESS = {
version: 1.0,
name: 'Be MEAN',
returned_at: date
};
const ERROR = {
message: 'Não encontrado'
};
http.createServer(function(request, response) {
switch(request.url) {
case '/api/pokemons/create':
response.writeHead(200, {'Content-Type': 'application/json'});
response.write(JSON.stringify(SUCCESS));
break;
case '/api/pokemons/read':
response.writeHead(200, {'Content-Type': 'application/json'});
response.write(JSON.stringify(SUCCESS));
break;
case '/api/pokemons/update':
response.writeHead(200, {'Content-Type': 'application/json'});
response.write(JSON.stringify(SUCCESS));
break;
case '/api/pokemons/delete':
response.writeHead(200, {'Content-Type': 'application/json'});
response.write(JSON.stringify(SUCCESS));
break;
default:
response.writeHead(404, {'Content-Type': 'application/josn'});
response.write(JSON.stringify(ERROR));
break;
}
response.end();
}).listen(3000, function() {
console.log('Servidor rodando em localhost:3000');
});
```
| {
"repo_name": "Webschool-io/be-mean-instagram-nodejs-exercises",
"stars": "33",
"repo_language": "JavaScript",
"file_name": "index.jade",
"mime_type": "text/plain"
} |
# Node.js - Aula 02 - Exercício
**user:** [joseasousa](https://github.com/joseasousa/)
**autor:** Jose Alves De Sousa Neto
## Quais são os 4 verbos que utilizamos para o CRUD?
C - Create - Criar/Inserir/Salvar
R - Retrieve - Recuperar/Pegar
U - Update - Atualizar
D - Delete - Apagar
## Para que foram inventados os Status Codes? Dê exemplo de 1 código por grupo e a imagem do [Cat Status Code](https://http.cat/).
Os `statos code` é uma das informações que vem na resposta, onde e definido o resultado da requisição
### 101 Mudando protocolos
Isso significa que o solicitante pediu ao servidor para mudar os protocolos e o servidor está
reconhecendo que irá fazê-lo. 102 Processamento Como uma solicitação WebDAV pode conter muitos
sub-pedidos que envolvam operações de arquivo,
pode demorar muito tempo para concluir o pedido. Este código indica que o servidor recebeu e está
processando o pedido, mas nenhuma resposta ainda não está disponível. Isso impede que o cliente o
tempo limite e supondo que o pedido foi perdido.
### 206 Conteúdo parcial
O servidor está entregando apenas parte do recurso devido a um cabeçalho intervalo enviados pelo
cliente. O cabeçalho do intervalo é usado por ferramentas como wget para permitir retomada de
downloads interrompidos, ou dividir um download em vários fluxos simultâneos.
### 305 Use Proxy (desde HTTP/1.1)
Muitos clientes HTTP (como o Mozilla e Internet Explorer) podem não tratar corretamente as
respostas com este código de status, principalmente por razões de segurança.
### 402 Pagamento necessário
Reservado para uso futuro. A intenção original era que esse código pudesse ser usado como
parte de alguma forma de dinheiro digital ou de micro pagamento regime, mas isso não
aconteceu, e esse código não é usado normalmente.
### https://http.cat/502
Em regra, o erro quando há uma configuração imprecisa entre os computadores de back-end,
possivelmente incluindo o servidor Web no site visitado. Antes de analisar este problema,
é necessário limpar o cache do navegador, completamente.
Se estiver navegando na Web e observar este problema em todos os websites visitados, então 1)
o seu provedor de serviço de Internet tem uma falha/sobrecarga em um equipamento principal ou 2)
tem algo de errado com a sua conexão interna à Internet, por exemplo, o firewall não está
funcionando corretamente. Se for o primeiro caso, somente o seu provedor pode ajudar. Se for
o segundo, você precisa corrigir o que quer que esteja prevenindo que você acesse a Internet.
Se tiver este problema somente em alguns websites visitados, provavelmente existe um problema
nos sites. Por exemplo, uma das peças dos equipamentos estão falhando ou estão sobrecarregadas.
Entre em contato com os responsáveis destes sites.
## Explique o que é cada parâmetro da função recebida no `createServer`.
ele recebe uma função anonima com 2 parametros request e response
`request`: recebe informação da solicitação feita ao servidor
`response`: é a resposta dada para a requisição
## O que é e para que serve a Querystring?
A QueryString é um modelo clássico de manutenção do estado da página. Elas são nada mais
do que conjuntos de pares/valores anexados a URL.
Seu uso é simples, após a URL de determinada página, adicionamos o primeiro valor usando a
seguinte sintaxe: ?Chave=Valor. Para passarmos mais de um conjunto, os mesmos devem ser
concatenados usando o caractere coringa &
## Escreva no código do `server.js` uma forma de entregar um JSON de sucesso em 4 rotas diferentes:
```js
var date = (new Date()).toJSON();
const http = require('http')
, SUCCESS = {
version: '1.0'
, name: 'BE MEAN'
, returned_at: date.toString().
replace(/T/, ' ').
replace(/\..+/, '')
}
, ERROR = {
message: 'Rota Inexistente'
}
http.createServer((req, res) => {
success = () => {
res.writeHead(200, { 'Content-Type': 'application/json; charset=utf-8' });
res.write(JSON.stringify(SUCCESS));
}
error = () => {
res.writeHead(400, { 'Content-Type': 'application/json; charset=utf-8' });
res.write(JSON.stringify(ERROR));
}
switch (req.url) {
case '/api/r1':
success();
break;
case '/api/r2':
success();
break;
case '/api/r3':
success();
break;
case '/api/r4':
success();
break;
default:
error();
break;
}
res.end();
}).listen(3000, () => {
console.log('Servidor rodando na porta 3000')
});
``` | {
"repo_name": "Webschool-io/be-mean-instagram-nodejs-exercises",
"stars": "33",
"repo_language": "JavaScript",
"file_name": "index.jade",
"mime_type": "text/plain"
} |
# Node.js - Aula 02 - Exercício
**user:** [airton](https://github.com/airton)
**autor:** Airton Vancin Junior
## Quais são os 4 verbos que utilizamos para o CRUD?
- Create
- Retrieve
- Update
- Delete
## Para que foram inventados os Status Codes? Dê exemplo de 1 código por grupo e a imagem do [Cat Status Code](https://http.cat/).
Serve para informar o que o servidor esta respondendo.
## 1XX - Informacional
## 2XX - Sucesso
## 3XX - Redirecionamento
## 4XX- Erro de cliente
## 5XX - Erro de servidor
## Explique o que é cada parâmetro da função recebida no `createServer`.
`createServer` é uma função anônima, que é executada automaticamente.
- request: informações de requisição feita pelo cliente;
- response: informações de resposta do servidor para o cliente.
## O que é e para que serve a Querystring?
Querystring é uma forma de passar os valores pela url, assim podemos pegar os valores da nossa url com nosso request.
## Escreva no código do `server.js` uma forma de entregar um JSON de sucesso em 4 rotas diferentes:
```js
'use strict';
var date = (new Date()).toJSON();
const http = require('http')
, SUCCESS = {
version: '1.0'
, name: 'Be MEAN'
, returned_at: date
}
, ERROR = {
message: "Não encontrado!"
}
;
http.createServer(function(req, res){
switch(req.url) {
case '/rota/v1':
case '/rota/v2':
case '/rota/v3':
case '/rota/v4':
res.writeHead(200, {'Content-Type': 'application/json'});
res.write(JSON.stringify(SUCCESS));
break;
default:
res.writeHead(404, {'Content-Type': 'application/json; charset=utf-8'});
res.write(JSON.stringify(ERROR));
}
res.end();
}).listen(3000, function(){
console.log('Servidor rodando em localhost:3000');
});
``` | {
"repo_name": "Webschool-io/be-mean-instagram-nodejs-exercises",
"stars": "33",
"repo_language": "JavaScript",
"file_name": "index.jade",
"mime_type": "text/plain"
} |
# Node.js - Aula 02 - Exercício
**user:** [PabloDinella](https://github.com/PabloDinella/)
**autor:** Pablo Rocha Dinella
**date:** 1453992406579
## Quais são os 4 verbos que utilizamos para o CRUD?
|CRUD | HTTP |
|----------|--------|
|Create | POST |
|Read | GET |
|Update | PUT |
|Delete | DELETE |
## Para que foram inventados os Status Codes? Dê exemplo de 1 código por grupo e a imagem do [Cat Status Code](https://http.cat/).
Para informar qual o retorno do servidor.
### 100 - Switching protocols
### 202 - Accepted
### 307 - Temporary Redirect
### 414 - Requested URI too long
### 507 - Insuficient storage
## Explique o que é cada parâmetro da função recebida no `createServer`.
São dois parâmetros:
**request**
- Objeto que contém informações relacionadas à requisição do cliente, como o cabeçalho http, url, etc.
**response**
- Objeto que contém informações relacionadas à resposta ao cliente.
## O que é e para que serve a Querystring?
É uma parte da URL, que tem informação em forma de pares de chave/valor que o cliente envia ao servidor.
Exemplo: `http://www.google.com/pagina?chave=valor`
## Escreva no código do `server.js` uma forma de entregar um JSON de sucesso em 4 rotas diferentes:
```javascript
// server.js
'use strict';
var date = (new Date()).toJSON();
const http = require('http')
, SUCESS = {
version: 1.0
, name: 'Be MEAN é nóis'
, created_at: date
}
, ERROR = {
message: 'Deu ruim! Não encontrado...'
}
;
http.createServer(function(req, res){
if (req.url === '/api/v1') {
res.writeHead(200,{'Content-Type':'application/json; charset=utf-8'});
res.write(JSON.stringify(SUCESS));
}
else if (req.url === '/api/v1b') {
res.writeHead(200,{'Content-Type':'application/json; charset=utf-8'});
res.write(JSON.stringify(SUCESS));
}
else if (req.url === '/api/v1c') {
res.writeHead(200,{'Content-Type':'application/json; charset=utf-8'});
res.write(JSON.stringify(SUCESS));
}
else if (req.url === '/api/v1d') {
res.writeHead(200,{'Content-Type':'application/json; charset=utf-8'});
res.write(JSON.stringify(SUCESS));
}
else {
res.writeHead(404,{'Content-Type':'application/json; charset=utf-8'});
res.write(JSON.stringify(ERROR));
}
res.end()
}).listen(3000, function(){
console.log('Server rodando em localhost:3000');
});
```
| {
"repo_name": "Webschool-io/be-mean-instagram-nodejs-exercises",
"stars": "33",
"repo_language": "JavaScript",
"file_name": "index.jade",
"mime_type": "text/plain"
} |
# Node.js - Aula 02 - Exercício
**Autor:** Mauricio Gravena de Oliveira
**Data:** 01/09/2016
## 1. Quais são os 4 verbos que utilizamos para o CRUD?
Create | Read | Update | Delete
## 2. Para que foram invetados os Staus Code? Dê exemplos de 1 código por grupo e a imagem do Cat Status Code.
Foram inventados para ajudar no diagnótico da troca de mensagens pelo protocolo HTTP.
### **Success 1xx**
#### **Switching Protocols 101**
### **Success 2xx**
#### **CREATED 201**
### **Error 4xx, 5xx**
#### **Internal Error 500**
### **Redirection 3xx**
#### **Not Modified 304**
## 3. Explique o que é cada parâmetro da função recebida no 'createServer'.
O "req"(request) é reponsável por tratar o pedido do cliente, já o "res"(response) devolve uma reposta baseada no pedido.
## 4. O que é e para que serve a Querystring?
É uma módulo nativo, que fornece métodos para tratamento e formatação de URL
## 5. Escreva no código do 'server.js' uma forma de entregar um JSON de sucesso em 4 rotas diferentes: ("/api/pokemons/create", "/api/pokemons/read", "api/pokemons/update", "/api/pokemons/delete")
```js
'use strict';
var date = (new Date()).toJSON();
const http = require('http');
const SUCCESS = {
version: 1.0,
name: 'Be Mean',
created_at: date
};
const ERROR = {
message: "Não encontrado!"
};
const create = (res) => {
res.writeHead(200, {
'Content-Type': 'application/json'
});
res.write(JSON.stringify(SUCCESS));
}
const read = (res) => {
res.writeHead(200, {
'Content-Type': 'application/json'
});
res.write(JSON.stringify(SUCCESS));
}
const update = (res) => {
res.writeHead(200, {
'Content-Type': 'application/json'
});
res.write(JSON.stringify(SUCCESS));
}
const del = (res) => {
res.writeHead(200, {
'Content-Type': 'application/json'
});
res.write(JSON.stringify(SUCCESS));
}
const err = (res) => {
res.writeHead(404, {
'Content-Type': 'application/json'
});
res.write(JSON.stringify(ERROR));
}
var server = http.createServer((req, res) => {
let url = req.url;
switch(url) {
case '/api/pokemons/create':
create(res);
break;
case '/api/pokemons/read':
read(res);
break;
case '/api/pokemons/update':
update(res);
break;
case '/api/pokemons/delete':
del(res);
break;
default:
err(res);
break;
}
res.end();
}).listen(3000, () => {
console.log('Servidor rodando... localhost:3000');
});
```
| {
"repo_name": "Webschool-io/be-mean-instagram-nodejs-exercises",
"stars": "33",
"repo_language": "JavaScript",
"file_name": "index.jade",
"mime_type": "text/plain"
} |
# Node.js - Aula 02 - Exercício
####Robson Fagundes - [https://robsonfagundes.github.io](robsonfagundes.github.io) - robsonfagundes@gmail.com
## 1. Quais são os 4 verbos que utilizamos para o CRUD?
- **C**reate - Criar ou adicionar novas entradas = `POST`
- **R**ead (**R**etrieve) - Ler, recuperar ou ver entradas existentes = `GET`
- **U**pdate - Atualizar ou editar entradas existentes = `PUT`
- **D**elete (**D**estroy) - Remover entradas existentes = `DELETE`
## 2. Para que foram inventados os Status Codes? Dê exemplo de 1 código por grupo e a imagem do [Cat Status Code](https://http.cat/).
Os `Status Codes` foram inventados para padronizar os tipos de retorno do servidor, facilitando o entendimento deles.
* **1XX** - Information
* **2XX** - Successful
* **3XX** - Redirection
* **4XX** - Client Error
* **5XX** - Server Error
## 3. Explique o que é cada parâmetro da função recebida no `createServer`.
Os parâmetros recebidos pelo **createServer** são: request e response. A definição de ambos é bem simples, **Request** é a informação chegando no servidor através do navegador (Input), já o **Response** é a informação chegando no navegador através do servidor (Output).
Principais propriedades de cada um desses objetos:
**Request:**
- Corpo do HTTP response;
- Número de Bytes enviados pelo cliente;
- Coleção de cabeçalhos;
- Porta servidor utilizada;
- Estado do servidor;
- Nome do servidor;
- Verificação de conexão SSL.
**Response:**
- Corpo do request HTTP;
- Código da página para o corpo Request;
- Versão do HTTP;
- Caminho do HTTP;
- Tamanho do Buffer;
## 4. O que é e para que serve a Querystring?
Na Web, uma **Querystring** ou string de consulta, é a parte de um Uniform Resource Locator (URL) que contém dados que não se encaixa convenientemente em uma estrutura hierárquica do caminho. A querystring inclui campos comumente adicionados a uma base URI por um navegadores ou por uma aplicação, por exemplo, como parte de um formulário HTML.
#####Exemplo de URL contendo uma querystring:
http://example.com/be-mean-instagram/node?name=aula2
- Quando um servidor recebe um pedido de uma página web, ele pode executar uma ação ou evento, passando a querystring, que neste caso é **`name=aula2`**. O ponto de interrogação **`.../node?`** é usado como um separador para informar a URL que há uma querystring mas não faz parte da string de consulta.
## 5. Escreva no código do `server.js` uma forma de entregar um JSON de sucesso em 4 rotas diferentes:
```js
'use strict';
var date = (new Date()).toJSON();
var http = require('http'),
SUCCESS = {
version: 'NodeJS - Exercício 0.2',
name: 'WebSchool.io/be-mean-instagram-nodejs-exercises/class-02',
returned_at: date
},
ERROR = {
message: "request not found!"
};
var url = require('url');
http.createServer(function(req, res) {
var url_parse = url.parse(req.url);
switch(url_parse.pathname) {
case '/api/pokemons/create':
case '/api/pokemons/read':
case '/api/pokemons/update':
case '/api/pokemons/delete':
res.writeHead(200, {'Content-Type': 'application/json; charset=utf-8'});
res.write(JSON.stringify(SUCCESS));
break;
default:
res.writeHead(404, {'Content-Type': 'application/json; charset=utf-8'});
res.write(JSON.stringify(ERROR));
}
res.end();
}).listen(3000, function() {
console.log('Server be-mean-instagram Node running on 127.0.0.1:3000');
});
```
```
robsonfagundes@Dell-3500:/media/robsonfagundes/SSD-Dados/Personal Projects/WebSchool.io/be-mean-instagram-nodejs-exercises/class-02$ node server
Server be-mean-instagram running on 127.0.0.1:3000
```
[](https://raw.githubusercontent.com/robsonfagundes/be-mean-instagram-nodejs-exercises/master/class-02/img/class2.png "server.js class 2 em ação") | {
"repo_name": "Webschool-io/be-mean-instagram-nodejs-exercises",
"stars": "33",
"repo_language": "JavaScript",
"file_name": "index.jade",
"mime_type": "text/plain"
} |
# Node.js - Aula 02 - Exercício
**Autor:** Wendell Adriel Luiz Silva - [WendellAdriel](https://github.com/WendellAdriel)
**Data:** 1455123299354
## Quais são os 4 verbos que utilizamos para o CRUD?
- **Create:** `POST`
- **Retrieve:** `GET`
- **Update:** `PUT`
- **Delete:** `DELETE`
## Para que foram inventados os Status Codes? Dê exemplo de 1 código por grupo e a imagem do [Cat Status Code](https://http.cat).
Foram inventados a fim de padronizar os retornos possíveis utilizados por servidores.
- **1XX:** Códigos de informação
- **2XX:** Códigos de sucesso
- **3XX:** Códigos de redirecionamento
- **4XX:** Códigos de erro do `cliente`
- **5XX:** Códigos de erro do `servidor`
## Explique o que é cada parâmetro da função recebida no `createServer`.
- **request:** parâmetro com todos dados da requisição feita pelo usuário.
- **response:** parâmetro com métodos utilizados para devolver uma resposta ao usuário.
## O que é e para que serve a Querystring?
- **O que é:** uma parte da URL que contém um ou mais parâmetros passados como `chave=valor`.
- **Para que serve:** para passar dados (parâmetros) necessários para o servidor através do método `GET`.
## Escreva no código do server.js uma forma de entregar um JSON de sucesso em 4 rotas diferentes:
```js
'use strict';
var now = (new Date()).toJSON();
const http = require('http')
, API_ROUTE = '/api/pokemons/'
, SUCCESS = {
message : 'Route OK'
, returned_at : now
}
, ERROR = {
message : 'Warning: Route NOT OK!!!'
, returned_at : now
};
http.createServer(function(req, res) {
switch(req.url) {
case API_ROUTE + 'create':
case API_ROUTE + 'read':
case API_ROUTE + 'update':
case API_ROUTE + 'delete':
res.writeHead(200, { 'Content-Type' : 'application/json' });
res.write(JSON.stringify(SUCCESS));
break;
default:
res.writeHead(404, { 'Content-Type' : 'application/json' });
res.write(JSON.stringify(ERROR));
break;
}
res.end();
}).listen(3000, function() {
console.log('Servidor rodando em localhost:3000');
});
```
| {
"repo_name": "Webschool-io/be-mean-instagram-nodejs-exercises",
"stars": "33",
"repo_language": "JavaScript",
"file_name": "index.jade",
"mime_type": "text/plain"
} |
# Node.js - Aula 02 - Exercício
**User:** [matheusjkweber](https://github.com/matheusjkweber)
**Autor:** Matheus José Krumenauer Weber
**Date:** 1456532077731
## Quais são os 4 verbos que utilizamos para o CRUD?
Post para o create, get para o retrieve, put para o update e delete para o delete.
## Para que foram inventados os Status Codes? Dê exemplo de 1 código por grupo e a imagem do [Cat Status Code](https://http.cat/).
Os `Status Codes` foram inventados para padronizar os tipos de retorno do servidor, facilitando o entendimento deles.
- 1xx - Informação
<img src="https://http.cat/101">
- 2xx - Sucesso
<img src="https://http.cat/204">
- 3xx - Redirecionamento
<img src="https://http.cat/300">
- 4xx - Erro no lado do cliente
<img src="https://http.cat/404">
- 5xx - Erro no lado do servidor
<img src="https://http.cat/500">
## Explique o que é cada parâmetro da função recebida no `createServer`.
Request que possui os parâmetros utilizados na requisição do usuário e Response que possui os métodos utilizados para o envio de respostas ao usuário.
## O que é e para que serve a Querystring?
São valores passados após o nome da url, servem para passar parametros de uma página para outra.
## Escreva no código do `server.js` uma forma de entregar um JSON de sucesso em 4 rotas diferentes:
```js
'use strict';
var date = (new Date()).toJSON();
const http = require('http')
, SUCCESS = {
version: '1.0'
, name: 'Be MEAN'
, returned_at: date
}
, ERROR = {
message: "Não encontrado!"
}
;
http.createServer(function(req, res){
if(req.url === '/api/v1') {
res.writeHead(200, {'Content-Type': 'application/json'});
res.write(JSON.stringify(SUCCESS));
} else if (req.url === '/api/v2'){
res.writeHead(204, {'Content-Type': 'application/json'});
res.write(JSON.stringify(SUCCESS));
}else if (req.url === '/api/v3'){
res.writeHead(200, {'Content-Type': 'application/json'});
res.write(JSON.stringify(SUCCESS));
}
else {
res.writeHead(404, {'Content-Type': 'application/json; charset=utf-8'});
res.write(JSON.stringify(ERROR));
}
res.end();
}).listen(3000, function(){
console.log('Servidor rodando em localhost:3000');
});
```
| {
"repo_name": "Webschool-io/be-mean-instagram-nodejs-exercises",
"stars": "33",
"repo_language": "JavaScript",
"file_name": "index.jade",
"mime_type": "text/plain"
} |
# Node.js - Aula 02 - Exercício
**user:** [hc3](https://github.com/hc3)
**autor:** Eliel das Virgens
**date:** 20/03/2015
##01.Quais são os 4 verbos que utilizamos para o CRUD
-CREATE , READ , UPDATE , DELETE.
##02.Para que foram inventados os status codes? de um exemplo de 1 código por grupo e a imagem do cat Status Code.
-Servem para padronizar erros que acontecem
### 100 - Switching protocols
### 202 - Accepted
### 307 - Temporary Redirect
### 414 - Requested URI too long
### 507 - Insuficient storage
##03.Explique o que é cada parâmetro da função recebida no createServer
-Request métodos para lidar com a requisição do cliente
-Response métodos para lidar com a resposta do servidor
##04.Oque é e para que serve a QueryString
é um conjunto de chave valor anexado a URL e com ela podemos passar parametros para o servidor
##05.Escreva o código do server.js uma forma de entregar um JSON de sucesso em 4 rotas diferentes
```
'use strict';
var date = (new Date()).toJSON();
const http = require('http')
, SUCCESS = {
version: 1.0
, code: 200
, name: 'MEAN'
, created_at: date
}
, ERROR = {
message: "DEU MERDA"
, code: 405
};
http.createServer(function(req, res){
let url = req.url
, method = req.method;
switch(url){
case "/api/cliente/create":
if(method === "POST"){
res.writeHead(200, { 'Content-Type': 'application/json; charset=utf-8' });
res.write(JSON.stringify(SUCCESS));
}else{
res.writeHead(405, { 'Content-Type': 'application/json; charset=utf-8' });
res.write(JSON.stringify(ERROR));
}
break;
case "/api/cliente/read":
if(method === "GET"){
res.writeHead(200, { 'Content-Type': 'application/json; charset=utf-8' });
res.write(JSON.stringify(SUCCESS));
}else{
res.writeHead(405, { 'Content-Type': 'application/json; charset=utf-8' });
res.write(JSON.stringify(ERROR));
}
break;
case "/api/cliente/update":
if(method === "PUT"){
res.writeHead(200, { 'Content-Type': 'application/json; charset=utf-8' });
res.write(JSON.stringify(SUCCESS));
}else{
res.writeHead(405, { 'Content-Type': 'application/json; charset=utf-8' });
res.write(JSON.stringify(ERROR));
}
break;
case "/api/cliente/delete":
if(method === "DELETE"){
res.writeHead(200, { 'Content-Type': 'application/json; charset=utf-8' });
res.write(JSON.stringify(SUCCESS));
}else{
res.writeHead(405, { 'Content-Type': 'application/json; charset=utf-8' });
res.write(JSON.stringify(ERROR));
}
break;
default:
res.writeHead(404, { 'Content-Type': 'application/json; charset=utf-8' });
ERROR.message = "Not Found";
ERROR.code = 404
res.write(JSON.stringify(ERROR));
break;
}
res.end();
}).listen(3000, function(){
console.log('Servidor rodando em localhost:3000');
});
``` | {
"repo_name": "Webschool-io/be-mean-instagram-nodejs-exercises",
"stars": "33",
"repo_language": "JavaScript",
"file_name": "index.jade",
"mime_type": "text/plain"
} |
# Node.js - Aula 02 - Exercício
**user:** [diegolopesdev](http://github.com/diegolopesdev)
**autor:** Diego Lopes do Nascimento
## Quais são os 4 verbos que utilizamos para o CRUD?
* C - Create - Criar (POST)
* R - Retrieve / Read - Recuperar / Ler (GET)
* U - Update - Atualizar (PUT)
* D - Delete - Deletar (DELETE)
## Para que foram inventados os Status Codes? Dê exemplo de 1 código por grupo e a imagem do [Cat Status Code](https://http.cat/).
Para informar e padronizar o retorno das requisições HTTP entre o Cliente e o Servidor.
Exemplo de retorno do 100: https://http.cat/100 [100](https://http.cat/100)
Exemplo de retorno do 201: https://http.cat/201 [201](https://http.cat/201)
Exemplo de retorno do 301: https://http.cat/301 [301](https://http.cat/301)
Exemplo de retorno do 404: https://http.cat/404 [404](https://http.cat/404)
Exemplo de retorno do 500: https://http.cat/500 [500](https://http.cat/500)
## Explique o que é cada parâmetro da função recebida no `createServer`.
A função *createServer*, do módulo HTTP, recebe uma função anônima que possui dois parâmetros: req (request) e res (response) e que retorna um objeto da classe *EventEmitter*.
*request* - É uma instância da classe *http.IncomingMessage* e possui informações sobre a requisição feita ao servidor.
*response* - É uma instância da classe *http.ServerResponse* e é responsável por manipular a resposta que será enviada ao cliente.
## O que é e para que serve a Querystring?
*QueryString* é um padrão que o protocolo HTTP utiliza para transporte de informações do cliente para o servidor, como um conjunto de valores anexados a URL através de uma requisição GET.
Exemplo: http://www.meusite.com/pokemon/search?name=Mea&limit=10.
O servidor receberá uma requisição que contém duas variáveis nessa requisição: *Name* e *Limit*. Nesse exemplo, eu poderia listar na pesquisa todos os pokémons que começam com "Mea" e limitando o resultado em 10 items.
## Escreva no código do `server.js` uma forma de entregar um JSON de sucesso em 4 rotas diferentes:
```
var http = require('http');
var STATUS = {};
function setStatus(action, message){
STATUS = {
action: action,
message: message,
date_at: new Date().toJSON()
};
}
http.createServer((req, res) => {
res.writeHead(200, {'Content-Type': 'application/json; charset=utf-8'});
switch(req.url){
case '/api/pokemons/create':
setStatus('CREATE', 'Você está criando um Pokémon.');
break;
case '/api/pokemons/read':
setStatus('READ', 'Você está retornando um Pokémon.');
break;
case '/api/pokemons/update':
setStatus('UPDATE', 'Você está atualizando um Pokémon.');
break;
case '/api/pokemons/delete':
setStatus('DELETE', 'Você está excluindo um Pokémon.');
break;
default:
res.writeHead(404, {'Content-Type': 'application/json'});
setStatus('ERROR', 'Not found');
break;
}
res.write(JSON.stringify(STATUS));
res.end();
}).listen(3300, () => {
console.log('O servidor está rodando em localhost:3300.');
});
```
## Envio
[Veja na nossa Wiki](https://github.com/Webschool-io/be-mean-instagram/wiki/Exerc%C3%ADcios)
1. Crie o repositório específico do módulo. Ex.: be-mean-instagram-nodejs
2. Crie a solução do exercício localmente nesse repositório, usando sempre o padrão `class-X-resolved-githubuser-Nome-Completo-Com-Hifens-Nos-Espaços.md`
3. Dê um `fork` no repositório oficial [https://github.com/Webschool-io/be-mean-instagram-nodejs-exercises](https://github.com/Webschool-io/be-mean-instagram-nodejs-exercises)
4. Vá até a pasta do módulo desejado e **COLE** seu arquivo na pasta `exercises`
5. Execute um `git add NOME_DO_SEU_ARQUIVO.md` depois o `git commit -m 'SEU NOME - Node.js - Exercicio X resolvido'`
5. Crie um **Pull Request** enviando **APENAS** o seu arquivo sem modificar mais nada.
6. Na mensagem do commit/pull request favor seguir o padrão: Nome Completo - Node.js - Exercicio X resolvido
7. Levante as mão para o céu e agradeça se acaso tiver ... #brinks
| {
"repo_name": "Webschool-io/be-mean-instagram-nodejs-exercises",
"stars": "33",
"repo_language": "JavaScript",
"file_name": "index.jade",
"mime_type": "text/plain"
} |
# Node.js - Aula 02 - Exercício
**user:** [viniciusmazzeo](https://github.com/viniciusmazzeo)
**autor:** Vinicius Moreira Mazzeo
## Quais são os 4 verbos que utilizamos para o CRUD?
- Create
- Retrieve/Read
- Update
- Delete
## Para que foram inventados os Status Codes? Dê exemplo de 1 código por grupo e a imagem do [Cat Status Code](https://http.cat/).
O Status Codes foram inventados para identificar o retorno do servidor, para identificar qual o status dele.
Estes códigos são formados por 3 dígitos por padrão.
## 1XX - Informacional
## 2XX - Sucesso
## 3XX - Redirecionamento
## 4XX- Erro de cliente
## 5XX - Erro de servidor
## Explique o que é cada parâmetro da função recebida no `createServer`.
`createServer` é uma função anônima, é uma caracterísca importante do JavaScript, ela responde para o cliente que fez a requisição.
Ela é executada apenas neste momento.
- request: requisições feitas pelo cliente;
- response: respostas do servidor para o cliente.
## O que é e para que serve a Querystring?
Querystring é como podemos passar os valores através da url, com isso podemos capturar estes valores através desta mesma url.
## Escreva no código do `server.js` uma forma de entregar um JSON de sucesso em 4 rotas diferentes:
```js
'use strict';
const http = require('http')
, SUCCESS = {
name: '<h1>É TEEETRAAAAAAAA</h1>',
}
, ERROR = {
message: "<h1>Não foi dessa vez!</h1>"
};
http.createServer((req, res) => {
let rota = [ '/api/pokemons/create',
'/api/pokemons/read',
'/api/pokemons/update',
'/api/pokemons/delete'];
switch (req.url) {
case rota[0]:
case rota[1]:
case rota[2]:
case rota[3]:
res.writeHead(200, {'Content-Type': 'text/html; charset=UTF-8'});
res.write(SUCCESS.name);
break;
default:
res.writeHead(404, {'Content-Type': 'text/html; charset=UTF-8'});
res.write(ERROR.message);
}
res.end();
}).listen(3000, function(){
console.log('Servidor rodando em localhost:3000');
});
``` | {
"repo_name": "Webschool-io/be-mean-instagram-nodejs-exercises",
"stars": "33",
"repo_language": "JavaScript",
"file_name": "index.jade",
"mime_type": "text/plain"
} |
# NodeJS - Aula 02 - Exercício
**Autor**: Igor luíz
**Github**: [Halfeld](https://github.com/Halfeld)
**Data**: 1456024583434
#### 1. Quais são so 4 verbos que utilizamos para o CRUD?
+ C = GET
+ R = POST
+ U = PUT
+ D = DELETE
#### 2. Para que foram inventados os Status Codes? Dê exemplo de 1 código por grupo e a imagem do _Cat Status Code_
Para a identificação correta de retorno.
##### 101
##### 204
##### 303
##### 402
##### 500
#### 3. Explique o que é cada parâmetro da função recebida no `createServer`
+ **request**: Requisição feita pelo navegador.
+ **response**: Resposta para o navegador.
#### 4. O que é e para que serve a `QueryString`?
É um protocolo que é usando para transportar dados entre cliente e o servidor.
#### 5. Escreva no código do `server.js` uma forma de entregar um JSON de sucesso em 4 rotas diferentes
+ `/api/pokemons/create`
+ `/api/pokemons/read`
+ `/api/pokemons/update`
+ `/api/pokemons/delete`
```js
'use strict';
var date = (new Date()).toJSON();
const http = require('http');
const SUCCESS = {
version: 1.0,
name: 'Be MEAN',
created_at: date
};
const ERROR = {
message: "Não encontrado"
};
http.createServer(function(req, res) {
switch(req.url) {
case '/api/pokemons/create':
res.writeHead(200, {'Content-Type': 'application/json; charset=utf-8;'});
res.write(JSON.stringify(SUCCESS));
break;
case '/api/pokemons/read':
res.writeHead(200, {'Content-Type': 'application/json; charset=utf-8;'});
res.write(JSON.stringify(SUCCESS));
break;
case '/api/pokemons/update':
res.writeHead(200, {'Content-Type': 'application/json; charset=utf-8;'});
res.write(JSON.stringify(SUCCESS));
break;
case '/api/pokemons/delete':
res.writeHead(200, {'Content-Type': 'application/json; charset=utf-8;'});
res.write(JSON.stringify(SUCCESS));
break;
default:
res.writeHead(404, {'Content-Type': 'application/json; charset=utf-8;'});
res.write(JSON.stringify(ERROR));
}
res.end();
}).listen(3000, function() {
console.log('Servidor rodando em localhost:3000');
});
```
| {
"repo_name": "Webschool-io/be-mean-instagram-nodejs-exercises",
"stars": "33",
"repo_language": "JavaScript",
"file_name": "index.jade",
"mime_type": "text/plain"
} |
# Node.js - Aula 02 - Exercício
**User:** [Pauloxt1](https://github.com/Pauloxt1)<br>
**Autor:** Paulo Roberto
## Quais são os 4 verbos que utilizamos para o CRUD?
<b>C</b>reate
```js
// Exemplo create com mongoDB
Paulo(mongod-3.2.1) test> use crud
switched to db crud
Paulo(mongod-3.2.1) crud> db.users.insert({nome:'Paulo', senha:123})
Inserted 1 record(s) in 238ms
WriteResult({
"nInserted": 1
})
```
<b>R</b>ead
```js
// Exemplo read com mongoDB
Paulo(mongod-3.2.1) crud> db.users.find()
{
"_id": ObjectId("56996261515cfa181e3a3e8d"),
"nome": "Paulo",
"senha": 123
}
```
<b>U</b>pdate
```js
// Exemplo update com mongoDB
Paulo(mongod-3.2.1) crud> db.users.update({nome:'Paulo'},{$set:{senha:321}});
Updated 1 existing record(s) in 3ms
WriteResult({
"nMatched": 1,
"nUpserted": 0,
"nModified": 1
});
```
<b>D</b>elete
```js
Paulo(mongod-3.2.1) crud> db.users.remove({})
Removed 1 record(s) in 1ms
WriteResult({
"nRemoved": 1
})
```
## Para que foram inventados os Status Codes? Dê exemplo de 1 código por grupo e a imagem do [Cat Status Code](https://http.cat/).
Para padronizar as respostas vinda do servidor.<br>
<b>1(Informação):</b><br>
<b>2(Sucesso):</b><br>
<b>3(Redirecionamento):</b><br>
<b>4(Erro de request):</b><br>
<b>5(Erro no servidor):</b><br>
## Explique o que é cada parâmetro da função recebida no `createServer`.
<b>Request:</b> Objeto com as informações da requisição feita pelo cliente.<br>
<b>Response:</b> Objeto responsável por gera a resposta do servidor para o cliente.
## O que é e para que serve a Querystring?
É uma forma de passa dados via URL pelo GET, seguem o seguinte padrão `?campo=value&campo=value`.
## Escreva no código do `server.js` uma forma de entregar um JSON de sucesso em 4 rotas diferentes:
```js
const http = require('http');
http.createServer(function(req,res){
res.writeHead(200, {'Content-Type': 'application/json;charset=utf-8'});
switch(req.url){
case '/create':
createJson(res, 1, 'Parte de create do CRUD', req.url);
break;
case '/read':
createJson(res, 2, 'Parte de read do CRUD', req.url);
break;
case '/update':
createJson(res, 3, 'Parte de update do CRUD', req.url);
break;
case '/delete':
createJson(res, 4, 'Parte de delete do CRUD', req.url);
break;
default:
res.writeHead(404, {'Content-Type': 'application/json;charset=utf-8'});
createJson(res, null, 'Ação de CRUD não encontrada', req.url);
break;
}
res.end();
}).listen(3000, function(){
console.log('Servidor levantando na 3000');
});
function createJson(response, id, mensagem, url){
var json = {
'id': id,
'mensagem': mensagem,
'url': url,
'data': new Date()
};
return response.write(JSON.stringify(json));
}
```
| {
"repo_name": "Webschool-io/be-mean-instagram-nodejs-exercises",
"stars": "33",
"repo_language": "JavaScript",
"file_name": "index.jade",
"mime_type": "text/plain"
} |
# Node.js - Aula 02 - Exercício
**User:** ronal2do
**Author:** Ronaldo Lima
**Date:** 1468002892280
## Quais são os 4 verbos que utilizamos para o CRUD?
* C - Create - Criar
* R - Read ou Retrieve - Ler ou Recuperar
* U - Update - Atualizar
* D - Delete - Excluir
## Para que foram inventados os Status Codes? Dê exemplo de 1 código por grupo e a imagem do [Cat Status Code](https://http.cat).
Os Status Codes foram criado para informar o atendimento ou não da requisição HTTP:
* Informação.
- 101 (Mudando protocolos): Isso significa que o solicitante pediu ao servidor para mudar os protocolos e o servidor está reconhecendo que irá fazê-lo. 102 Processamento (WebDAV) (RFC 2518) Como uma solicitação WebDAV pode conter muitos sub-pedidos que envolvam operações de arquivo, pode demorar muito tempo para concluir o pedido. Este código indica que o servidor recebeu e está processando o pedido, mas nenhuma resposta ainda não está disponível. Isso impede que o cliente o tempo limite e supondo que o pedido foi perdido. Cat Status Code (https://http.cat/101).
* Sucesso.
- 202 (Aceito):O pedido foi aceito para processamento, mas o tratamento não foi concluído. O pedido poderá ou não vir a ser posta em prática, pois pode ser anulado quando o processamento ocorre realmente. Cat Status Code (https://http.cat/202).
* Redirecionamento.
- 304 (Não modificado ): Indica que o recurso não foi modificado desde o último pedido. Normalmente, o cliente fornece um cabeçalho HTTP como o Se-Modificado-Desde cabeçalho para proporcionar um tempo contra o qual para comparar. Usando este poupa largura de banda e de reprocessamento no servidor e cliente, uma vez que apenas os dados do cabeçalho devem ser enviados e recebidos em comparação com a totalidade da página que está sendo reprocessados pelo servidor, em seguida, enviado novamente utilizando mais largura de banda do servidor e cliente. Cat Status Code (https://http.cat/304).
* Erro do cliente.
- 409 (Conflito): Indica que a solicitação não pôde ser processada por causa do conflito no pedido, como um conflito de edição. Cat Status Code (https://http.cat/409).
* Erro do servidor.
- 500 (Bad Gateway): O servidor é usado como GateWay ou Proxy. recebe uma responsta inválida do servidor superior, ao tentar executar a solicitação. Cat Status Code (https://http.cat/500).
[fonte Wikipedia](https://pt.wikipedia.org/wiki/Lista_de_c%C3%B3digos_de_status_HTTP)
## Explique o que é cada parâmetro da função recebida no `createServer`.
* O parâmetro `request` recebe os dados da requisição.
* O parâmetro `response` retorna como callback os dados da requisição.
## O que é e para que serve a `QueryString`?
Querystring é a maneira utilizada para passarmos parametros para outras páginas através da barra de endereços sem a necessidade de um formulário.
Exemplos de uso
`localhost:3000/teste?name=Suissa` ou `http://www.site.com?query=Parametro`
Sendo que podemos concatenas mais parametros com o uso do `&`.
Ex. `http://www.site.com?query=Key&otherQuery=OtherKey&more=One`
Saída:
* query: Key
* otherQuery: OtherKey
* more: One
## Escreva no código do `server.js` uma forma de entregar um JSON de sucesso em 4 rotas diferentes:
```js
'use strict';
var date = (new Date()).toJSON();
const http = require('http')
, SUCCESS = {
version: 1.0
, code: 200
, name: 'Be MEAN'
, created_at: date
}
, ERROR = {
message: "Method Not Allowed"
, code: 405
}
;
http.createServer(function(req, res){
let url = req.url;
switch(url){
case "/api/pokemons/create" :
response.writeHead(200,
{'Content-Type': 'application/json; charset=utf-8'});
response.end(JSON.stringify(
[SUCCESS, {info: "Create: Ok"}]));
break;
case "/api/pokemons/update" :
response.writeHead(200,
{'Content-Type': 'application/json; charset=utf-8'});
response.end(JSON.stringify(
[SUCCESS, {info: "Update: Ok"}]));
break;
case "/api/pokemons/read" :
response.writeHead(200,
{'Content-Type': 'application/json; charset=utf-8'});
response.end(JSON.stringify(
[SUCCESS, {info: "Retrieve: Ok"}]));
break;
case "/api/pokemons/delete" :
response.writeHead(200,
{'Content-Type': 'application/json; charset=utf-8'});
response.end(JSON.stringify(
[SUCCESS, {info: "Delete: Ok"}]));
break;
default:
res.writeHead(404, { 'Content-Type': 'application/json; charset=utf-8' });
ERROR.message = "Not Found";
ERROR.code = 404
res.write(JSON.stringify(ERROR));
break;
}
res.end();
})
.listen(3000, function(){
console.log('Servidor rodando em localhost:3000');
});
``` | {
"repo_name": "Webschool-io/be-mean-instagram-nodejs-exercises",
"stars": "33",
"repo_language": "JavaScript",
"file_name": "index.jade",
"mime_type": "text/plain"
} |
# Node.js - Aula 02 - Exercício
**user:** [Marcos](https://github.com/marks88martinez)
**autor:** Marcos Antonio Martinez Florentin
## Quais são os 4 verbos que utilizamos para o CRUD?
- Create, Retrieve, Update, Delete
## Para que foram inventados os Status Codes? Dê exemplo de 1 código por grupo e a imagem do [Cat Status Code](https://http.cat/).
Serve para padronizar a comunicação entre cliente e servidor, sabendo assim qual é a resposta que ela retorna.
## 1XX - Informação - Continue
## 2XX - Sucesso - ok
## 3XX - Redirecionamento - Temporary Redirect
## 4XX- Erro de cliente - Unauthorized
## 5XX - Erro de servidor - Internal Serve Error
## Explique o que é cada parâmetro da função recebida no `createServer`.
#Request:
Requisição feita pelo cliente;
#Response:
Resposta do servidor para o cliente.
## O que é e para que serve a Querystring?
Usada normalmente para armazenar valores de variáveis, tais valores são armazenados no final da URL.
## Escreva no código do `server.js` uma forma de entregar um JSON de sucesso em 4 rotas diferentes:
```js
'use strict';
var date = (new Date()).toJSON();
const http = require('http'),
V1 = {
version:'1.0',
name:'Rota1',
created_at: date
},V2 = {
version:'2.0',
name:'Rota2',
created_at: date
},V3 = {
version:'3.0',
name:'Rota3',
created_at:date
},V4 = {
version:'4.0',
name:'Rota4',
created_at:date
},ERROR = {
message : "DEU MERDA FI!!!!"
};
http.createServer(function(req, res){
switch (req.url) {
case '/api/v1':
res.writeHead(200, {'Content-Type':'application/json'});
res.write(JSON.stringify(V1));
break;
case '/api/v2':
res.writeHead(200, {'Content-Type':'application/json'});
res.write(JSON.stringify(V2))
break;
case '/api/v3':
res.writeHead(200, {'Content-Type':'application/json'});
res.write(JSON, stringify(V3));
break;
case '/api/v4':
res.writeHead(200, {'Content-Type':'application/json'});
res.write(JSON.stringify(V4));
break;
default:
res.writeHead(404, {'Content-Type': 'application/json; charset=utf-8'});
res.write(JSON.stringify(ERROR));
}
res.end();
}).listen(3000, function(){
console.log('Servidor esta funcionando en localhost:3000');
});
```
| {
"repo_name": "Webschool-io/be-mean-instagram-nodejs-exercises",
"stars": "33",
"repo_language": "JavaScript",
"file_name": "index.jade",
"mime_type": "text/plain"
} |
# Node.js - Aula 02 - Exercício
**user:** [maurienefirmino](https://github.com/maurienefirmino)
**autor:** Mauriene Firmino do Nascimento Júnior
**date:** 1474200477235
## Quais são os 4 verbos que utilizamos para o CRUD?
Para o Create = verbo POST.
Para o Reatrive/Read = verbo GET.
Para o Update = verbo PUT.
Para o Delete = verbo DELETE.
## Para que foram inventados os Status Codes? Dê exemplo de 1 código por grupo e a imagem do [Cat Status Code](https://http.cat/).
Foram inventados para existir um feedback para o cliente sobre o que acontece nas requisiçõs.
#### 101 - Mudando protocolos
Isso significa que o solicitante pediu ao servidor para mudar os protocolos e o servidor está reconhecendo que irá fazê-lo
#### 201 - Criado
A requisição gerou um novo registro.
#### 301 - Movido permanentemente
A url requisitada não está disponivel na mesma.
#### 401 - Não autorizado
O conteúdo requisitado necessita de alguma autenticação.
#### 500 - Erro interno no servidor
Erro que pode significar diversos erros internos.
## Explique o que é cada parâmetro da função recebida no `createServer`.
Resquest = É um objeto que armazena os dados da requisição do cliente.
Response = É um objeto callback que será retornado para o cliente que fez a requisição.
## O que é e para que serve a Querystring?
É uma maneira de se passar dados usando a url. Usando `?` seguido das proriedades e dos valores, sendo que quando se tem mais de uma propriedade usa-se `&` para concatenar-los.
Ex.: http://localhost/api/create?name=teste&age=25
## Escreva no código do `server.js` uma forma de entregar um JSON de sucesso em 4 rotas diferentes:
```
'use strict';
const http = require('http')
, url = require('url')
, SUCCESS = {
version: '1.0'
, name: 'be MEAN'
, returned_at: new Date().toJSON()
}
, ERROR = {
message: "Rota não econtrada"
};
http.createServer(function(req, res){
switch(req.url){
case '/api/pokemons/create':
res.writeHead(200,{'Content-Type':'application;json'});
res.write(JSON.stringify(SUCCESS));
break;
case '/api/pokemons/read':
res.writeHead(200,{'Content-Type':'application;json'});
res.write(JSON.stringify(SUCCESS));
break;
case '/api/pokemons/update':
res.writeHead(200,{'Content-Type':'application;json'});
res.write(JSON.stringify(SUCCESS));
break;
case '/api/pokemons/delete':
res.writeHead(200,{'Content-Type':'application;json'});
res.write(JSON.stringify(SUCCESS));
break;
default:
res.writeHead(400,{'Content-Type':'application;json;charset=utf-8'});
res.write(JSON.stringify(ERROR));
break;
}
res.end();
}).listen(3000, function(){
console.log('Servidor executando em localhost:3000');
});
``` | {
"repo_name": "Webschool-io/be-mean-instagram-nodejs-exercises",
"stars": "33",
"repo_language": "JavaScript",
"file_name": "index.jade",
"mime_type": "text/plain"
} |
# Node.js - Aula 02 - Exercício
**user:** [victorvoid](https://github.com/VictorVoid)
**autor:** Victor Igor Gomes Martins
**date:** 1453957583405
## Quais são os 4 verbos que utilizamos para o CRUD?
1. POST
2. GET
3. PUT
4. DELETE
## Para que foram inventados os Status Codes? Dê exemplo de 1 código por grupo e a imagem do [Cat Status Code](https://http.cat/).
*Status Codes* eles são códigos de retorno do nosso servidor, ele possui uma padronização para poder saber a informação que ele trás.
1º Exemplo: 100
2º Exemplo: 200
3º Exemplo: 301 Movido
4º Exemplo: 404
5º Exemplo: 500
## Explique o que é cada parâmetro da função recebida no *createServer*.
Ela recebe uma função anônima com dois parâmetros:
1. request
2. response
`request`: recebe informação da solicitação feita ao servidor
`response`: a resposta dada requisição solicitada
## O que é e para que serve a Querystring ?
QueryString é os valores que passamos por parâmetro na url, como por exemplo:
http://localhost:3000/name=1&idade=12
Como o próprio nome diz, é de uma certa forma uma query, onde serve para pegar seu
valor e trabalhar no código.
## Escreva no código do `server.js` uma forma de entregar um JSON de sucesso em 4 rotas diferentes:
```js
'use strict';
var date = (new Date()).toJSON();
const http = require('http')
, SUCCESS = {
version: '1.0'
, name : 'Victor Igor'
, returned_at: date
}
, ERRO = {
message: 'Não encontrado !!!'
}
;
http.createServer((request, response)=>{
var routes = ['/api/pokemons/create', '/api/pokemons/read',
'/api/pokemons/update', '/api/pokemons/delete'
];
function successRes(){
response.writeHead(200, {'Content-Type': 'application/json'});
response.write(JSON.stringify(SUCCESS));
}
function erroRes(){
response.writeHead(404, {'Content-Type':'application/json;charset=utf-8'});
response.write(JSON.stringify(ERRO));
}
switch (request.url) {
case routes[0]:
successRes();
break;
case routes[1]:
successRes();
break;
case routes[2]:
successRes();
break;
case routes[3]:
successRes();
break;
default:
erroRes();
}
response.end();
}).listen(3000,()=>{
console.log('Servidor rodando em http://localhost:3000');
});
```
| {
"repo_name": "Webschool-io/be-mean-instagram-nodejs-exercises",
"stars": "33",
"repo_language": "JavaScript",
"file_name": "index.jade",
"mime_type": "text/plain"
} |
# NodeJS - Aula 02 - Exercício
autor: Fábio Calheiros (conta: fabiocalheiros)
# 1. Quais são os 4 verbos que utilizamos para o CRUD?
```
- Create - POST
- Retrieve/Read - GET
- Update - PUT
- Delete - DELETE
```
# 2. Para que foram inventados os Status Codes? Dê um exemplo de 1 código por grupo e a imagem do Cat Status Code
```
Os Status codes, servem para obtermos resposta de uma requisição.
100 - Informacional (https://http.cat/100)
200 - Sucesso(OK) (https://http.cat/200)
301 - Movido permanamentemente (https://http.cat/301)
404 - Não encontrado (https://http.cat/404)
503 - Serviço indisponível (https://http.cat/503)
```
# 3. Explique o que é cada parâmetro da função recebida no 'createServer'.
```
// utilizando o protocolo http, cria-se um função anônima que recebe dois parâmetros
// req - requisição (Parametro enviado)
// res - nome da função de retorno
http.createServer(function(req, res){
// veririca se a url informada é = '/api/v1'
if(req.url === '/api/v1'){
// retorna um cabeçalho de resposta OK no formato json
res.writeHead(200, {'Content-Type': 'application/json'});
// Escreve o retorno transformando a mensagem de SUCESSO em uma string
res.write(JSON.stringify(SUCCESS))
}else{
// Caso não encontre a url, monta uma cabeçalho com o erro de página não encontrada
res.writeHead(404, {'Content-Type': 'application/json; charset=utf-8'});
// Escreve o retorno transformando a mensagem de ERRO em uma string
res.write(JSON.stringify(ERROR))
}
// finaliza a resposta
res.end();
// quando o server for iniciado com sucesso
}).listen(3000, function(){
// escreve a mensagem que o servidor está rodando na porta 3000
console.log('Servidor rodando em localhost:3000');
});
```
# 4. O que é e para que serve a Querystring?
```
Querystring é uma leitura de url obtida através do método request.url que retorna uma string sobre o que foi digitado no endereço url do seu browser.
A querystring serve para obertermos os valores informados pelo usuário e fazer as rotas, ou inserir os valores de acordo com o que foi recebido.
```
# 5. Escreva no código do 'server.js' uma forma de entregar um JSON de sucesso em 4 rotas diferentes:
```
'use strict';
var date = (new Date()).toJSON();
const http = require('http')
, SUCCESS = {
version: '1.0'
, name: 'Be MEAN'
, returned_at: date
}
, ERROR = {
message: "Não encontrado!"
};
http.createServer(function(request, response){
var result = request.url;
var rotas = [ '/api/pokemons/create', '/api/pokemons/read', '/api/pokemons/update', '/api/pokemons/delete'];
for(var key in rotas){
if (rotas[key] === result) {
response.writeHead(200, {'Content-Type': 'text/html; charset=utf-8'});
response.write(JSON.stringify(SUCESS));
response.end();
}else{
response.writeHead(404, {'Content-Type': 'text/html; charset=utf-8'});
response.write(JSON.stringify(ERROR));
response.end();
}
}
response.end();
}).listen(3000, function(){
console.log('Servidor rodando em localhost:3000');
});
``` | {
"repo_name": "Webschool-io/be-mean-instagram-nodejs-exercises",
"stars": "33",
"repo_language": "JavaScript",
"file_name": "index.jade",
"mime_type": "text/plain"
} |
# Node.js - Aula 02 - Exercício
**user:** [augustoody](https://github.com/AugustoOdy)
**autor:** Augusto Ody
**date:** 1454765252713
## Quais são os 4 verbos que utilizamos para o CRUD?
- **POST**
- **GET**
- **PUT**
- **DELETE**
## Para que foram inventados os Status Codes? Dê exemplo de 1 código por grupo e a imagem do [Cat Status Code](https://http.cat/).
Os *Status codes* foram inventados para retornar ao cliente o que ocorreu com sua requisição.
# Class 1XX (Informação)
# Class 2XX (Sucesso)
# Class 3XX (Redirecionamento)
# Class 4XX (Erro de cliente)
# Class 5XX (Erro de servidor)
## Explique o que é cada parâmetro da função recebida no `createServer`.
*Request:* Informações da requisição feita pelo cliente.
*Response:* Retorno das informações requeridas pelo `request`.
## O que é e para que serve a Querystring?
*Querystrings* são um conjunto dados, que utilizam chaves e valores anexados na URL. Sua utilização é principalmente para passagem de valores.
Sintaxe:
```
http://site.com/?arg1=value1&arg2=value2&arg3=value3
```
Sendo o primeiro informado após o simbolo `?`, e os seguintes com `&`.
## Escreva no código do `server.js` uma forma de entregar um JSON de sucesso em 4 rotas diferentes:
```js
'use strict';
var date = (new Date()).toJSON();
const http = require('http')
, SUCCESS = {
version: '1.0'
, name: 'Be MEAN'
, returned_at: date
}
, USERS = [
{ name: 'Docand Whitsandy' }
, { name: 'Adas Footfair' }
, { name: 'Cading Weed-fair' }
, { name: 'Boli Hay-gardner' }
, { name: 'Mismé Butcherward' }
, { name: 'Diding Blowerbottom' }
, { name: 'Latle Brace-man' }
, { name: 'Agolbel Goodboffin' }
, { name: 'Goever Butchergammidge' }
, { name: 'Inggo Chubb-brace' }
]
, PHOTOS = [
{ path: '/image/1.jpg' }
, { path: '/image/2.jpg' }
, { path: '/image/3.jpg' }
]
, ERROR = {
message: "Não encontrado!"
}
;
http.createServer(function(req, res){
switch (req.url) {
case '/api/v1':
res.writeHead(200, {'Content-Type': 'application/json'});
res.write(JSON.stringify(SUCCESS));
break;
case '/api/v1/users':
res.writeHead(200, {'Content-Type': 'application/json'});
res.write(JSON.stringify(USERS));
break;
case '/api/v1/photos':
res.writeHead(200, {'Content-Type': 'application/json'});
res.write(JSON.stringify(PHOTOS));
break;
case '/api/v1/single':
res.writeHead(200, {'Content-Type': 'application/json'});
res.write(JSON.stringify({USERS}));
break;
default:
res.writeHead(404, {'Content-Type': 'application/json'});
res.write(JSON.stringify(ERROR));
}
res.end();
}).listen(3000, function(){
console.log('Servidor rodando em localhost:3000');
});
```
| {
"repo_name": "Webschool-io/be-mean-instagram-nodejs-exercises",
"stars": "33",
"repo_language": "JavaScript",
"file_name": "index.jade",
"mime_type": "text/plain"
} |
# Node.js - Aula 02 - Exercício
**Autor:** Ednilson Amaral
**Data:** 1450649579988
## Quais são os 4 verbos que utilizamos para o CRUD?
* Create > POST;
* Retrieve/Read > GET;
* Update > PUT;
* Delete > DELETE.
## Para que foram inventados os Status Codes? Dê exemplo de 1 código por grupo e a imagem do Cat Status Code.
Toda vez que é enviada uma requisição para o servidor, é enviada como resultado um código de número inteiro, contendo 3 dígitos. Isso, com o intuito de entender a requisição e realizar ou não a requisição. Esse código de 3 dígitos é chamado de **status code**.
Esses códigos são divididos em grupos. Tais grupos são divididos pelo primeiro dígito do código, conforme os exemplos abaixo:
### 1xx Informações
Esse grupo serve apenas para informar que a informação foi recebida e que o processo irá continuar.
### 2xx Sucesso
Esse grupo significa que a requisição foi recebida com sucesso.
### 3xx Redirecionamento
Esse grupo serve para avisar diretamente no cabeçalho do HTTP uma mudança de página.
### 4xx Erro do Cliente
Esse grupo serve para nos dizer que o conteúdo não está acessível para o usuário (visitante) e nem para os motores de busca.
### 5xx Erro de Servidor
Esse grupo serve para mostrar que alguma coisa aconteceu para que o servidor não tenha atendido a requisição, devido à algum erro.
## Explique o que é cada parâmetro da função recebida no `createServer`.
```js
var http = require('http');
http.createServer(function(request, response){
response.writeHead(200, {"Content-Type": "text/plain"});
response.write("Be MEAN");
response.end();
}).listen(3000, function(){
console.log('Servidor rodando em localhost:3000');
});
```
* Request: possui a requisição do usuário para o servidor;
* Response: é quando o servidor irá dar a resposta da requisição do usuário.
## O que é e para que serve a Querystring?
`index.html?nome=Ednilson&idade=23`
No link acima, vemos a variável `nome=Ednilson` e a variável `idade=23`, logo após o `?`. Essas variáveis e valores são *querystring*. Elas são enviadas via **URL**. São enviadas através de formulários via `GET`.
## Escreva no código do `server.js` uma forma de entregar um JSON de sucesso em 4 rotas diferentes.
```js
'use strict';
var date = (new Date()).toJSON();
var http = require('http')
, url = require('url')
, SUCCCESS =
{ version: '1.0'
, name: 'JSON para 4 rotas diferentes'
, returned_at: date
}
, ERROR = {
message: "Deu alguma merda, mano!"
}
;
http.createServer(function(request, response){
var pathname = url.parse(request.url).pathname
, routes = [
'/api/pokemons/create'
, '/api/pokemons/read'
, '/api/pokemons/update'
, '/api/pokemons/delete'
]
;
for(var key in routes){
if (routes[key] === pathname) {
response.writeHead(200, {'Content-Type': 'application/json; charset=UTF-8'});
response.write(JSON.stringify(SUCCESS));
} else {
response.writeHead(404, {'Content-Type': 'application/json; charset=UTF-8'});
response.write(JSON.stringfy(ERROR));
}
}
response.end();
}).listen(3000, function(){
console.log('Servidor rodando em localhost:3000');
});
```
| {
"repo_name": "Webschool-io/be-mean-instagram-nodejs-exercises",
"stars": "33",
"repo_language": "JavaScript",
"file_name": "index.jade",
"mime_type": "text/plain"
} |
# Node.js - Aula 02 - Exercício
# autor: Sergio Kopplin
# data: 1454721080991
## Quais são os 4 verbos que utilizamos para o CRUD?
- POST
- GET
- PUT
- DELETE
## Para que foram inventados os Status Codes? Dê exemplo de 1 código por grupo e a imagem do [Cat Status Code](https://http.cat).
Os Status Codes são códigos de retorno e foram críados para formar um padrão de direcionamento para a identificação correta de retorno das requisições HTTP.
* Grupo Informação.
- 100 (continue):O Cliente DEVE continuar com a requisição pois ela foi recebida pelo servidor e o mesmo não a rejeitou. (https://http.cat/100).
* Grupo Sucesso.
- 202 (accepted): A requisição foi sucedida e a informação retornada dependerá do tipo de método utilizado na requisição. (https://http.cat/202).
* Grupo Redirecionamento.
- 301 (moved permanently): A fonte do recurso está em uma diferente URI e as referências futuras deverão utilizar umas das URIS retornadas. (https://http.cat/301).
* Grupo Erro do cliente.
- 400 (bad request): A requisição não pode ser entendida pelo servidor devido a um problema de syntax. O Cliente não deverá repetir a requisição sem antes modificá-la.. (https://http.cat/400).
* Grupo Erro do servidor.
- 500 (internal server erros): O servidor encontrou um problema inesperado e isso o impediu de responder a requisição. (https://http.cat/500).
## Explique o que é cada parâmetro da função recebida no `createServer`.
A função **createServer** é uma função anônima que é executada automaticamente e que recebe 2 parâmetros, request e response.
No request nós temos as informações da requisição por parte do cliente e no response nós temos as informações da requisição por parte do servidor.
## O que é e para que serve a Querystring?
A QueryString é um modelo do qual nós passamos valores para o servidor pela url.
Ex: http://example.com/over/there?name=ferret.
Nesse exemplo, passamos a variável name com o valor ferret.
ref: [en.wikipedia.org](https://en.wikipedia.org/wiki/Query_string)
## Escreva no código do `server.js` uma forma de entregar um JSON de sucesso em 4 rotas diferentes:
```JS
'use strict';
var date = (new Date()).toJSON();
const http = require('http')
, SUCCESS = {
version: 1.0
, name: 'Be MEAN'
, created_at: date }
, ERROR = {
message: 'Não encontrado'
};
http.createServer(function(req, res){
switch (req.url) {
case "/api/v1/pokemons/create":
res.writeHead(200, {'Content-type': 'application/json; charset=utf-8'});
res.write(JSON.stringify(SUCCESS));
break;
case "/api/v1/pokemons/read":
res.writeHead(200, {'Content-type': 'application/json; charset=utf-8'});
res.write(JSON.stringify(SUCCESS));
break;
case "/api/v1/pokemons/update":
res.writeHead(200, {'Content-type': 'application/json; charset=utf-8'});
res.write(JSON.stringify(SUCCESS));
break;
case "/api/v1/pokemons/delete":
res.writeHead(200, {'Content-type': 'application/json; charset=utf-8'});
res.write(JSON.stringify(SUCCESS));
break;
default:
res.writeHead(400, {'Content-type': 'application/json; charset=utf-8'});
res.write(JSON.stringify(ERROR));
break;
}
res.end();
}).listen(3000, function(){
console.log('Servidor rodando em localhost:3000');
});
```
| {
"repo_name": "Webschool-io/be-mean-instagram-nodejs-exercises",
"stars": "33",
"repo_language": "JavaScript",
"file_name": "index.jade",
"mime_type": "text/plain"
} |
# Node.js - Aula 02 - Exercício
**user:** [lucasduarte](https://github.com/lucasduarte)
**autor:** Lucas Duarte Anício
## Quais são os 4 verbos que utilizamos para o CRUD?
- Create
- Read
- Update
- Delete
## Para que foram inventados os Status Codes? Dê exemplo de 1 código por grupo e a imagem do [Cat Status Code](https://http.cat/).
####**1XX:** Informacional
####**2XX:** Sucesso
####**3XX:** Redirecionamento
####**4XX:** Erro do Cliente
####**5XX:** Erro do Servidor
## Explique o que é cada parâmetro da função recebida no `createServer`.
- **Request:**
Contem dados da requisição recebida do cliente
- **Response:**
Possui dados para responder a requisição efetuada pelo cliente
## O que é e para que serve a Querystring?
É um conjunto de chave/valor que serve para recuperar dados nas páginas
## Escreva no código do `server.js` uma forma de entregar um JSON de sucesso em 4 rotas diferentes:
```js
'use strict';
var date = (new Date()).toJSON()
, rotas = [ 'create', 'read', 'update', 'delete' ];
const http = require('http')
, SUCCESS = {
version: '1.0'
, name: 'Be MEAN'
, returned_at: date
}
, ERROR = {
message: "Não encontrado!"
};
http.createServer(function(req, res){
var method = req.url.replace('/api/pokemons/', '');
if(req.url === '/api/pokemons/' + method && rotas.indexOf(method) > -1) {
res.writeHead(200, {'Content-Type': 'application/json'});
SUCCESS.metodo = method;
res.write(JSON.stringify(SUCCESS));
}
else {
res.writeHead(404, {'Content-Type': 'application/json; charset=utf-8'});
res.write(JSON.stringify(ERROR));
}
res.end();
}).listen(3000, function(){
console.log('Servidor rodando em localhost:3000');
});
```
| {
"repo_name": "Webschool-io/be-mean-instagram-nodejs-exercises",
"stars": "33",
"repo_language": "JavaScript",
"file_name": "index.jade",
"mime_type": "text/plain"
} |
#NodeJS - Aula 02 - Exercícios
autor: Dariano Soares
##1. Quai são os 4 verbos que utilizamos para o `CRUD`?
- **Create - POST**
- **Retrieve - GET**
- **Update - PUT**
- **Delete - DELETE**
##2. Para que foram iventados os Status Code? Dê exemplos de 1 código por grupo e a imagem do `Cat Status Code`.
O **Status Code** é uma representação numérica da resposta. Um inteiro de três dígitos que informa o stado do retorno.
**1xx** - Indica uma resposta provisória.
Ex: **100 Continuar** significa que o servidor recebeu os cabeçalhos da solicitação.
**2xx** - Indica que a requisição foi recebida, entendida e aceita.
Ex: **201 Criado** para quando algo for criado.
**3xx** - Indica que futuras ações precisam ser feitas para que a requisição seja completada.
Ex: **301 Movido** para redirecionamentos permanentes, quando algum recurso for movido de lugar por tempo indeterminado ou para sempre.
**4xx** - Indica algum erro do cliente.
Ex: **403 Proibido** para indicar uma ação proibida.
**5xx** - Indica algum erro no servidor.
Ex: **500** erro genérico interno no servidor.
Referência -> Livro Construindo Aplicações com NodeJS, William Bruno Moraes
##3. Explique o que é cada parâmetro da função recebida no `createServer`.
Os dois parâmetros da função **createServer** são os objetos **request** e **response**, que representam uma requisição HTTP, que consiste sempre em um pedido e uma resposta respectivamente.
Referência -> Livro Construindo Aplicações com NodeJS, William Bruno Moraes
##4. O que é e para que serve a `Querystring`?
**Querystring** é o padrão que o protocolo HTTP utiliza para transporte de informações do cliente para o servidor.
Devemos utilizar a query para filtrar dados. A sintaxe de uma query string é <busca>=<valor>. Indicamos que vamos concatenar mais uma busca após outra com o caracter &(e comercial). O início da query string é indicado pelo caractere ? (interrogação).
```
ex: ?<query>=<value>&<query2>=<value2>&<query3>=<value3>
```
Referência -> Livro Construindo Aplicações com NodeJS, William Bruno Moraes
##5. Escreva no código do `server.js` uma forma de entregar um JSON de sucesso em 4 rotas diferentes:
```js
'use strict';
const date = (new Date()).toJSON();
const http = require('http'),
SUCCESS = {
version: 1.0,
name: 'Be MEAN',
returned_at: date
},
ERROR = {
menssage: 'Não encontrado!'
};
let server = http.createServer(function(req, res) {
var url_parse = url.parse(req.url);
switch(url_parse.pathname) {
case '/api/pokemons/create':
case '/api/pokemons/read':
case '/api/pokemons/update':
case '/api/pokemons/delete':
res.writeHead(200, { 'Content-Type': 'application/json; charset=utf-8'});
res.write(JSON.stringify(SUCCESS));
break;
default:
res.writeHead(404, { 'Content-Type': 'application/json; charset=utf-8'});
res.write(JSON.stringify(ERROR));
}
res.end();
});
server.listen(3000, function() {
console.log('Servidor rodando na porta 3000.');
});
``` | {
"repo_name": "Webschool-io/be-mean-instagram-nodejs-exercises",
"stars": "33",
"repo_language": "JavaScript",
"file_name": "index.jade",
"mime_type": "text/plain"
} |