REST é um jeito de fazer a internet funcionar. Ele é baseado em um conjunto de regras que definem como os sites devem se comunicar.

O REST, que significa Representational State Transfer, é um modelo de arquitetura muito comum para o desenvolvimento de serviços web na internet. Para entender o que isso significa, pense em como a web funciona. Quando você navega na internet, acessa diferentes páginas da web, realiza compras online ou interage com aplicativos, tudo isso envolve a comunicação entre o seu dispositivo e servidores remotos. O REST é a estrutura que torna essa comunicação possível e eficaz.

A ideia principal do REST é que tudo na web é considerado um “recurso”. Recursos podem ser coisas como perfis de usuários, fotos, produtos em uma loja online, ou qualquer outra informação que você deseja compartilhar ou acessar online. Cada recurso é identificado por um endereço único, chamado de URI (Uniform Resource Identifier), que é semelhante a um URL.

Para interagir com esses recursos, o REST utiliza os métodos HTTP, como GET, POST, PUT e DELETE.

• GET é usado para acessar uma cópia de um recurso.
• POST é usado para criar um novo recurso.
• PUT é usado para atualizar um recurso existente.
• DELETE é usado para excluir um recurso.

REST é uma abordagem comum na criação de APIs, que são como pontes de comunicação entre diferentes sites.

Um exemplo prático de API REST é a API do Facebook. Essa API possibilita que desenvolvedores construam aplicativos que se integram aos recursos do Facebook, como fotos, publicações e lista de amigos. Ela é como um conjunto de regras que permite que aplicativos se conectem ao Facebook e usem suas funcionalidades.

Exemplo de Rest Api

Vou dar um exemplo simples de uma API REST que lida com recursos de “Usuários” usando os métodos HTTP GET, POST, PUT e DELETE. Se você quiser você pode praticar criando a sua própria API, eu descrevo como nesse outro artigo.

1. Obter todos os usuários (HTTP GET):

Para recuperar a lista de todos os usuários, você envia uma solicitação HTTP GET para o endpoint /users da sua API. O servidor entende o pedido e retorna uma lista de todos os usuários cadastrados. Cada usuário é como uma carta de apresentação em formato digital, com um número de identificação (ID), nome e email. É como uma lista telefônica, mas digital.

Solicitação (GET /users):

Resposta (200 OK):

[
  {
    "id": 1,
    "nome": "João",
    "email": "joao@email.com"
  },
  {
    "id": 2,
    "nome": "Maria",
    "email": "maria@email.com"
  }
]

2. Obter um usuário específico (HTTP GET):

Quando você quer saber detalhes de um usuário em particular, basta fazer uma solicitação HTTP GET para o endpoint /users/{id}, onde {id} é o ID do usuário. O servidor responde com os detalhes do usuário específico que você pediu.

Solicitação (GET /users/1):

Resposta (200 OK):

{
  "id": 1,
  "nome": "João",
  "email": "joao@email.com"
}

3. Criar um novo usuário (HTTP POST):

Quando um usuário novo se cadastra, você envia um pedido POST para o servidor com os detalhes desse usuário para o endpoint /users. Você fornece os detalhes do usuário no corpo da solicitação em formato JSON. O servidor cria o novo usuário e responde com um “cartão de visita” do usuário recém-criado, incluindo um novo número de identificação (ID).

Solicitação (POST /users):

{
  "nome": "Carlos",
  "email": "carlos@email.com"
}

Resposta (201 Created):

{
  "id": 3,
  "nome": "Carlos",
  "email": "carlos@email.com"
}

4. Atualizar um usuário (HTTP PUT):

Quando alguém quer mudar suas informações, você envia uma solicitação HTTP PUT com o ID do usuário e os detalhes atualizados para o endpoint /users/{id}. O servidor faz as atualizações e retorna os novos detalhes do usuário.

Solicitação (PUT /users/3):

{
  "nome": "Carlos Silva",
  "email": "carlos.silva@email.com"
}

Resposta (200 OK):

{
  "id": 3,
  "nome": "Carlos Silva",
  "email": "carlos.silva@email.com"
}

5. Excluir um usuário (HTTP DELETE):

Se alguém decidir sair do clube, faz um pedido DELETE com o ID do usuário que quer remover para o endpoint /users/{id} com o ID do usuário que você deseja remover. O servidor processa a exclusão e não envia uma resposta com corpo, só o código HTTP 204 No Content, que é tipo “Feito, usuário excluído!”.

Solicitação (DELETE /users/3):

Resposta (204 No Content):
(Indica que o usuário foi removido com sucesso)

Estes exemplos ilustram como as operações básicas de criação, leitura, atualização e exclusão (CRUD) podem ser realizadas em uma API REST para recursos de usuários. Claro, em aplicações reais, há muito mais a considerar, como segurança e autenticação, mas esses são os conceitos fundamentais. É como lidar com um registro de membros de um clube, só que digital!

O que é JSON

Com você deve ter percebido, acima estamos usando um formato de dados chamado JSON (JavaScript Object Notation). JSON é uma forma de organizar informações que lembra muito as estruturas de dados que usamos no dia a dia. É como um tradutor que permite que computadores e aplicativos entendam informações em um formato que seja fácil de ler e escrever.

No exemplo da API de usuários, usamos JSON para representar informações sobre os usuários. Por exemplo, quando criamos um novo usuário, enviamos os detalhes desse usuário, como nome e email, em um formato JSON no corpo da solicitação. O servidor entende esse JSON, processa as informações e cria o novo usuário.

JSON é composto por pares chave-valor, onde uma “chave” é o nome do atributo e o “valor” é o conteúdo associado a essa chave. No exemplo, a chave “nome” tem o valor “Carlos Silva” e a chave “email” tem o valor “carlos.silva@email.com”. Essa estrutura torna fácil representar dados complexos de maneira organizada.

Além disso, JSON é um formato amplamente aceito na web e em muitas APIs, tornando-se uma escolha popular para transmitir dados. É legível tanto por humanos quanto por máquinas, o que o torna ideal para a comunicação de dados entre clientes e servidores em sistemas distribuídos, como as APIs REST que usamos como exemplo.

Conclusão

Em resumo, o REST é como a cola que mantém a internet unida, permitindo que sites e aplicativos conversem entre si. Pense nisso como um conjunto de regras que torna a comunicação na web mais eficaz.

Quando você navega na internet, faz compras online ou usa aplicativos, tudo isso envolve seu dispositivo conversando com servidores remotos. O REST é a base disso, tratando tudo na web como “coisas” (ou recursos) com endereços exclusivos, como URLs.

Ele usa métodos simples, como GET para pegar informações, POST para criar coisas novas, PUT para atualizar e DELETE para apagar. É como as peças de um quebra-cabeça que se encaixam perfeitamente.

Além disso, o uso do JSON, uma maneira organizada de apresentar dados, torna a comunicação fácil tanto para nós quanto para as máquinas. É como falar a mesma língua para que todos possam entender.

Resumindo, o REST e o JSON são como os melhores amigos dos desenvolvedores na construção de aplicativos e serviços online, criando experiências interativas e conectadas na internet. Ao dominar esses conceitos, os desenvolvedores podem construir sistemas sólidos e escaláveis na era digital. É como desvendar os segredos da web!

Mongoose

Vamos usar o pacote mongoosejs. Se você já tem um projeto Node.js no qual você está trabalhando, instale-o usando:

$ npm install mongoose

Se você estiver começando do zero, você pode dar uma olhada no minha introdução sobre Node.js ou comece criando uma nova pasta, e com seu terminal dentro da pasta, execute o comando npm init -y para iniciar um novo projeto Node.js, e então execute o comando npm install mongoose.

Conectando ao MongoDB

Crie um novo arquivo server.js. Você primeiro vai precisar do pacote mongoose no seu projeto.

const mongoose = require('mongoose');

Crie um URL para o servidor MongoDB. Se você estiver usando MongoDB localmente, a URL será algo como mongodb://localhost:27017, 27017 é a porta padrão do MongoDB. E crie uma outra variável com o nome do seu banco de dados.

O pacote vem com um método chamado connect() que vai nos ajudar na conexão com MongoDB. Vamos usar esse método para criar uma instância do banco de dados.

const mongoose = require('mongoose');
const server = 'mongodb://localhost:27017'
const database = 'myDatabase';
mongoose.connect(`${server}/${database}`,
   { useNewUrlParser: true, useUnifiedTopology: true }
);

O pacote Mongoose tem algumas depreciações no projeto, devido a mudanças no MongoDB, por isso precisamos usar as flags {useNewUrlParser: true, useUnifiedTopology: true }, se quiser ver mais detalhes, basta clicar aqui.

Podemos então testar se a conexão foi bem sucedida ou não.

const mongoose = require('mongoose');
const server = 'mongodb://localhost:27017'
const database = 'myDatabase';
mongoose.connect(`${server}/${database}`,
   { useNewUrlParser: true, useUnifiedTopology: true }
).then(() => {
   console.log("Successfully connect to MongoDB.");
})
   .catch(err => {
      console.error("Connection error", err);
      process.exit();
   });

No terminal, rode o comando node server.js. Você dever ver essa mensagem no seu terminal:

Successfully connect to MongoDB.

Criando uma coleção

Tudo em mongoose começa com um Schema. Cada esquema mapeia para uma coleção. Coleções são uma das estruturas básicas do MongoDB. MongoDB define a forma dos documentos dentro dessa coleção.

  const Schema = mongoose.Schema;
  const UserSchema = new Schema({
    name:  String
  });

Criando um documento

Uma instância de um model é chamado de documento. Vamos então utilizar o nosso método model() para criar nosso documento.

const User = mongoose.model('User', UserSchema);

O primeiro argumento é o nome singular da coleção para a qual seu modelo está destinado. O segundo argumento, é o objeto Schema da nossa coleção que definimos antes, UserSchema.

Mongoose vai procurar automaticamente a versão plural, em letras minúsculas, do nome do seu modelo.

Inserindo dados em um documento

Com o nosso documento User criado, salvar os dados no banco de dados é simples. Vamos criar uma nova instância do documento e passar os dados que queremos inserir, no nosso exemplo, o nosso model aceita apenas o atributo name. Podemos então utilizar o método save() diretamente no nosso model para persistir os dados.

const user = new User({ name: 'John' });
user.save()
   .then(() => console.log('User Created'))
   .catch(() => console.log('User model Error'))

Você pode testar usando o comando, node server.js no seu terminal. Você deve ver essa mensagem.

Successfully connect to MongoDB.
User Created

Você pode adicionar vários itens usando o método create(), passando um Array como primeiro parâmetro. Esse método executa o método save() para cada item do Array.

const userArray = [{ name: 'Alice' }, { name: 'Paul' }]
User.create(userArray)
   .then(() => console.log('User Created'))
   .catch(() => console.log('User model Error'))

Encontre todos os documentos de uma coleção

Mongoose tem um método muito simples pra resolver isso. Com o método find() sendo chamado no seu modelo, você consegue recuperar todos os documentos da sua coleção.

User.find()
   .then(users => { console.log(users) })
   .catch(error => { console.log("User Find Error", error) })

O seu resultado no terminal após rodar o comando node server.js deve ser algo assim:

Successfully connect to MongoDB.
[ { _id: '5f05a2b58415d87a550de613', name: 'Alice', __v: 0 },
  { _id: '5f05a2b58415d87a550de614', name: 'Paul', __v: 0 },
  { _id: '5f05a4c99f222e7e9c96d825', name: 'John', __v: 0 } ]

Encontre um documento específico

Você consegue filtrar os documentos passando a lista de parâmetros dentro do método find(). Esse processo é parecido com o WHERE do SQL.

Como temos apenas um atributo nos nossos documentos, vamos filtrar pelo nome de cada usuário.

User.find({ name: 'John' })
   .then(user => { console.log(user); })
   .catch(error => { console.log("User Find Error", error) })

E o seu resultado deve ser esse:

Successfully connect to MongoDB.
[ { _id: '5f05a4c99f222e7e9c96d825', name: 'John', __v: 0 } ]

Se você precisar encontrar mais de um documento você pode usar o operador $in.

User.find({ name: { $in: ['John', 'Paul'] } })
   .then(users => { console.log(users); })
   .catch(error => { console.log("User Find Error", error) })

Successfully connect to MongoDB.
[ { _id: '5f05a2b58415d87a550de614', name: 'Paul', __v: 0 },
  { _id: '5f05a4c99f222e7e9c96d825', name: 'John', __v: 0 } ]

Atualizar um documento existente

Abaixo está um exemplo de como usar save() para atualizar o nome do usuário.

async function update(name, newName) {
   try {
      const user = await User.findOne({ name: name });
      if (user) {
         user.name = newName;
         await user.save();
         console.log('User Updated');
      }
      console.log('User not Found!');
      return;
   } catch (error) {
      console.log('Update Error', error);
      return;
   }
}
update('Paul', 'Peter');

Este simples exemplo tem algumas nuances. Primeiro, o método save() é um método de um documento, o que significa que você deve ter um documento para utiliza-lo. Você precisa usar o método create() ou usar find() para obter um documento.

Estou utilizando o método findOne() por que ele retorna apenas um documento, o método find() retorna um Array, mesmo que encontre apenas uma correspondência.

Em segundo lugar, os documentos têm rastreamento de mudanças. Quando você chama doc.save(), Mongoose sabe que você alterou a propriedade name e transforma sua chamada save() em updateOne({ $set: { name } }).

Se prefere usar Promises, você pode eliminar o uso da função, fazendo assim:

User.findOne({ name: "Paul" })
   .then(user => {
      if (user) {
         user.name = 'Peter';
         user.save();
         console.log('User Updated');
      }
      console.log('User not Found!');
   })
   .catch(error => {
      console.log('Update Error', error);
   })

Deletando um documento

O método que vamos usar é o deleteOne(), esta método chama a função Collection#deleteOne() do MongoDB Driver. A promise devolvida resolve para um objeto que contém 3 propriedades:

• ok: 1 se não ocorrerem erros
• deletedCount: o número de documentos deletados
• n: o número de documentos deletados. Igual a deletedCount.

User.deleteOne({ name: 'John' })
   .then(response => { console.log(response) })
   .catch(error => { console.log('Delete Error', error); })

O resultado desse nosso exemplo no terminal:

{ n: 1, ok: 1, deletedCount: 1 }

Finalizando a conexão

Uma vez terminadas as operações, podemos chamar o método de close():

mongoose.connection.close();

Se gostou desse artigo, não deixe de se inscrever na newsletter e fique informado sempre que tiver conteúdo novo!

E se ainda ficou alguma dúvida, ou se você tiver alguma sugestão, você pode deixar o seu comentário logo aqui em abaixo! Até a próxima.

O Que é Node js

Node.js é um ambiente de código aberto, multiplataforma e gratuito que executa código JavaScript fora de um navegador web. Com ele podemos construir aplicações web em geral, desde web sites até APIs e micro serviços.

Isso é possível graças a união de três componentes principais:

• Ambiente de tempo de execução de JavaScript fornecido pelo próprio Node.js
• O motor de interpretação e execução de JavaScript presente no Google Chrome, chamado de V8
• E a biblioteca libuv.

As aplicações Node.js são escritas em JavaScript, e podem ser executadas dentro do runtime Node.js em OS X, Microsoft Windows, e Linux.

Ambiente de Tempo de Execução Javascript

Um ambiente de tempo de execução é o ambiente de execução fornecido a uma aplicação ou software pelo sistema operacional. Em um ambiente de tempo de execução, a aplicação pode enviar instruções ou comandos para o processador e acessar outros recursos do sistema, como a memória RAM, o que de outra forma não é possível, pois a maioria das linguagens de programação utilizadas são linguagens de alto nível.

O ambiente runtime fornece um estado para que a máquina utilizada tenha acesso a recursos como bibliotecas de software, variáveis de sistema e variáveis de ambiente, e fornece todos os serviços e suporte necessários aos processos envolvidos na execução da aplicação ou programa.

Motores de interpretação

Um motor JavaScript é um programa ou um intérprete que executa o código JavaScript. Um motor JavaScript pode ser implementado como um intérprete padrão, ou compilador just-in-time que compila JavaScript para bytecode de alguma forma.

Cada grande browser tem o seu próprio motor. Você consegue ver a lista completa nesse link.

• Chrome V8 – Como você provavelmente adivinhou, esse é o motor que roda no Google Chrome. É um projeto de código aberto escrito em C++. O V8 também é usado pelo Opera, NodeJS, e Couchbase.
• SpiderMonkey – O mecanismo de código aberto implementado em C++. É mantido pela Fundação Mozilla. Você pode encontrá-lo no Firefox.
• JavaScriptCore ou Nitro – A engine desenvolvida pela Apple. É usado no Safari.
• Chakra – Desenvolvido pela Microsoft como a engine JavaScript para o navegador Edge.

O motor que realmente nos interessa aqui é o V8, é ele que está por trás do Node js. Ele foi inicialmente projetado para aumentar o desempenho de execução do JavaScript dentro do browser.

A fim de obter velocidade, o V8 traduz o código JavaScript em código de máquina (mais eficiente), ao invés de usar um intérprete. Ele compila código JavaScript em código de máquina na execução, implementando um compilador JIT (Just-In-Time) como muitos motores JavaScript modernos fazem, como SpiderMonkey ou Rhino (Mozilla). A principal diferença aqui é que o V8 não produz bytecode ou qualquer código intermediário.

Biblioteca libuv

Como os próprios criadores denominam:

libuv é uma biblioteca de suporte multiplataforma com foco em I/O assíncrona. Foi desenvolvida principalmente para uso pelo Node.js.

Libuv Github

É uma biblioteca escrita em C que é usada para abstrair operações de I/O sem bloqueio, para uma interface consistente em todas as plataformas suportadas. Além disso a biblioteca conta com diversas outras características como:

• Soquetes assíncronos TCP e UDP
• Resolução DNS assíncrona
• Operações assíncronas de arquivos e sistemas de arquivos
• Eventos do sistema de arquivos

Como Fazer Download do Node js?

Para começar a construir suas aplicações Node.js, o primeiro passo é a instalação. O framework está disponível para uma variedade de sistemas operacionais, desde Windows até Ubuntu e OS X.

Acesse o site https://nodejs.org/en/download/ e faça o download dos arquivos necessários para o seu sistema operacional. Nesse exemplo, vamos baixar os arquivos de configuração de 64 bits para Windows.

Como Instalar o Node js?

Após finalizar o download vamos ao passo para instalação. Basta clicar no ícone logo abaixo, que o processo de instalação vai começar.

A instalação é bem simples, não são muitos detalhes. A primeira tela que você vai ver, será essa da imagem abaixo, para prosseguir basta clicar no botão “Next”.

Na segunda tela, você deve aceitar os termos de licença de uso para prosseguir com a instalação.

Você pode definir um local diferente para instalação do Node js, caso seja necessário. Se não for necessário mudar o local de instalação do Node js você pode avançar essa etapa.

A a instalação do Node js vem acompanhada com com alguns outros pacotes muito importantes, como o npm(gerenciador de pacotes Javascript). Se por algum motivo você não precisar de algum desses pacotes, você pode simplesmente remover da instalação do Node js. Do contrário, deixe tudo como está e avance para a próxima etapa.

Alguns módulos npm precisam ser compilados a partir do C/C++ durante a instalação. Se você quiser ser capaz de instalar tais módulos, algumas ferramentas (Python e Visual Studio Build Tools) precisam ser instaladas.

Para o nosso tutorial, essas ferramentas não serão necessárias. Podemos avançar.

Se todas as suas configurações para instalação do Node js estiverem corretas, basta clicar em “Install“.

Agora é só aguardar a finalização da instalação do Node js.

E é isso, o Node js está pront para ser executado.

Arquitetura básica de Node.js

Antes de iniciar alguns exemplos de código, é importante ter uma idéia sobre a arquitetura do Node js. Neste sessão nós vamos discutir como Node Js funciona por dentro. Como Node js lida com solicitações simultâneas seguindo um modelo Single-Thread.

Modelo Single Thread com Event Loop

Talvez algumas pessoas não estejam familiarizadas com alguma das nomenclaturas, e por ser muito importante para entender a estrutura básica do Node js, vamos revisar alguns pontos principais.

Processo

Um processo é um programa em execução, ou seja, um programa em execução e é criado quando um programa inicia a execução. Um processo pode ter várias threads.

Thread

Na ciência da computação, uma thread é um pequeno conjunto de instruções projetado para ser programado e executado pela CPU, independentemente do processo pai e é normalmente uma parte do sistema operacional.

A principal diferença é que as threads dentro de um mesmo processo são executados em um espaço de memória compartilhada, enquanto os processos são executados em espaços de memória separados.

Single Thread e Multi Thread

Os processos single thread executam todas as instruções em uma única seqüência. Em outras palavras, apenas um comando é processado por vez.

O oposto de processos single threads são processos multi threads. Estes processos permitem a execução de múltiplas partes de um programa ao mesmo tempo.

Node js single-threaded

Uma aplicação Node js roda em uma única thread e o loop de eventos(event loop) também roda na mesma thread. Assim, podemos dizer que o Node js é single-threaded, mas existem algumas bibliotecas no Node js que não são single-threaded.

É ai que entra em cena a biblioteca libuv. Ela é responsável por lidar com tarefas relacionadas ao sistema operacional, como as tarefas baseadas em I/O assíncronos dos sistemas operacionais, redes, concorrência, etc.

Quando Node requisita a execução de processos simultâneos, a biblioteca Libuv configura um conjunto de quatro threads para realizar as operações, utilizando a potência de todos os núcleos da CPU. Considerando que a nossa máquina tenha quatro núcleos, cada thread do pool é atribuída a cada núcleo.

Isto resulta em uma thread por núcleo. Com esta configuração, todas as quatro threads executarão o seu processo em cada núcleo em paralelo.

Se quiser entender mais, visite esse artigo, que explica com ainda mais detalhes.(Em inglês)

Node js Event Loop

Node.js é uma plataforma baseada em eventos. Isto significa que tudo que acontece no Node é a reação a um evento. Uma transação passando por Node atravessa uma cascata de callbacks.

Independentemente do desenvolvedor, tudo isso é tratado pela biblioteca libuv que fornece um mecanismo chamado loop de eventos.

Como citei antes, há apenas um thread que executa o código JavaScript e que é onde o loop de eventos está rodando. A execução de callbacks (saiba que todo código executado pelo do usuário em uma aplicação Node.js em execução é um callback) é feita pelo loop de evento.

A Libuv por padrão cria uma pool com quatro threads para descarregar o trabalho assíncrono. Os sistemas operacionais atuais já fornecem interfaces assíncronas para muitas tarefas de I/O.

Sempre que possível, a libuv irá utilizar essas interfaces assíncronas, evitando o uso do pool de threads. O mesmo se aplica a subsistemas de terceiros, como bancos de dados.

Em resumo: Somente se não houver outra forma, a pool de threads será utilizada para I/O assíncrona.

De uma forma simplificada o sistema node js funciona assim. De um lado temos a sua aplicação que enviando request para o seu servidor em node js, a motor V8 então traduz o código JavaScript em código de máquina, api do Node js se comunica com a biblioteca libuv que executa os processos de I/O do sistema operacional utilizando um loop de eventos, se necessário, fazendo uso da thread pool.

Node Modules

Módulos no Node.js são uma funcionalidade simples ou complexa organizada em um ou vários arquivos JavaScript que podem ser reutilizados em toda a aplicação Node.js.

O Node.js inclui três tipos de módulos:

• Módulos Core
• Módulos Locais
• Módulos de Terceiros

Cada módulo no Node.js tem seu próprio contexto, portanto não podem interferir com outros módulos ou poluir o escopo global. Além disso, cada módulo pode ser colocado em um arquivo javascript separado em uma pasta separada.

O Node.js implementa o padrão de módulos CommonJS. O CommonJS é um grupo de voluntários que definem padrões JavaScript para servidores web, desktop e aplicativos.

Criando uma aplicação em Node Js

O que faremos agora é criar uma pequena aplicação utilizando Node js, que vai transforma o seu computador em um servidor.

Como Começar

Uma vez que você tenha baixado e instalado o Node.js no seu computador, vamos tentar exibir alguma mensagem no navegador.

O primeiro passo é criar um arquivo principal, que vamos chamar de app.js. Insira o código abaixo no documento:

const http = require('http');

const hostname = '127.0.0.1';
const port = 3000;

const server = http.createServer((req, res) => {
  res.statusCode = 200;
  res.setHeader('Content-Type', 'text/plain');
  res.end('Debug Everything');
});

server.listen(port, hostname, () => {
  console.log(`Server running at http://${hostname}:${port}/`);
});

Salve o arquivo em alguma pasta de fácil acesso. Depois disso, você precisa abrir uma janela do seu terminal, navegar até a pasta onde você salvou o seu arquivo e rodar o comando node app.js, você provavelmente verá uma mensagem igual a essa no seu terminal indicando que a sua aplicação está rodando na porta :3000.

$ node app.js
Server running at http://127.0.0.1:3000/

Agora, seu computador funciona como um servidor!

Se alguém tentar acessar seu computador na rota http://localhost:3000, receberá a mensagem “Debug Everything”

O Node.js tem um módulo embutido chamado HTTP, que permite ao Node.js transferir dados através do Hyper Text Transfer Protocol (HTTP).

Nós estamos incluindo o módulo HTTP, usando o método require(), na primeira linha.

const http = require('http');

Aqui estamos definindo o hostname e a porta em que o servidor vai rodar:

const hostname = '127.0.0.1';
const port = 3000;

O módulo HTTP pode criar um servidor HTTP que escuta as portas do servidor e dá uma resposta para o cliente. Podemos então usar o método createServer() para criar um servidor HTTP.

A função passada para o método http.createServer(), será executada quando alguém tentar acessar o computador na porta 3000.

const server = http.createServer((req, res) => {
  res.statusCode = 200;
  res.setHeader('Content-Type', 'text/plain');
  res.end('Debug Everything');
});

E na última linha, estamos usando o método listen() para começar a escutar a porta 3000 naquele hostname.

server.listen(port, hostname, () => {
  console.log(`Server running at http://${hostname}:${port}/`);
});

Conclusão

A intenção de post era apresentar a você a estrutura básica do Node js, e como ele funciona por dentro.

Existem muitos assuntos que podem ser abordados quando falamos de Node js existe todo um ecosistema de módulos como o Express e AdonisJS que expandem ainda mais a capacidade do Node js, mas vamos deixar isso para futuros posts.

Espero que o conteúdo tenha sido útil. Deixe nos comentários as suas dúvidas e sugestões para o proximo post!

Até a próxima!