Node.

js
Origem: Wikipédia, a enciclopédia livre.

Node.js é um interpretador de JavaScript assíncrono com código

aberto orientado a eventos, criado por Ryan Dahl em 2009, focado
em migrar a programação do Javascript do cliente (frontend) para
os servidores, criando aplicações de alta escalabilidade (como um
servidor web)[1], manipulando milhares de conexões/eventos
simultâneas em tempo real numa única máquina física.[2]
O Node.js (ambiente de execução Javascript no servidor) foi
implementado baseado no interpretador V8 JavaScript
Engine (interpretador de JavaScript em C++ com código aberto do
Google, utilizado no Chrome), com desenvolvimento mantido pela
fundação Node.js em parceria com a Linux Foundation.
1.1 Introdução ao Node.js
Node.js é um interpretador de Javascript baseado no motor de JavaScript V8 do Chrome
que está sendo adotado no mundo inteiro por sua facilidade no desenvolvimento e
performance.

Node.js usa um modelo de E/S (entrada e saída ou I/O, em inglês) não bloqueante, é
orientado a eventos (Event Driven) e extremamente leve, rápido e eficiente.

Uma das suas principais caracterís cas é utilizar JavaScript como linguagem de
programação, o que é interessante, pois, historicamente, JavaScript sempre foi uma
linguagem de sintaxe simples usada por web designers para construir sites.

Node.js utiliza JavaScript como linguagem de servidor, algo que torna sua curva de
aprendizado rápida, pois é uma linguagem amplamente conhecida e adotada
no mercado.
1.2 A Linguagem JavaScript
A linguagem JavaScript (não confundir com Java da Sun/Oracle) foi originalmente criada
pela Netscape em 1995.

Com a ascensão da internet, rapidamente ganhou força e foi amplamente adotada como
linguagem de script para a construção de websites.

JavaScript é uma linguagem extremamente produtiva, dinâmica, não tipada (não precisa
declarar os pos das Variáveis) e interpretada, além de possuir suporte à Orientação a
Objetos.

JavaScript evoluiu muito e não somente é usado nos browsers e na camada de

apresentação dos sites, mas também no servidor graças à popularização da plataforma
Node.js.

Uma das melhorias no Node.js ao adotar o motor JavaScript V8 do Chrome é que a engine
do Chrome compila o JavaScript, tornando a execução mais rápida, ao contrário do
JavaScript clássico, que é interpretado pelo browser.
1.3 Arquitetura não bloqueante
Diversas linguagens clássicas e amplamente adotadas pelo mundo, como Java, PHP, .NET, Ruby, Python
etc. possuem uma arquitetura multi-threading e bloqueante.

Para exemplificar, imagine um sistema web que tenha 1 milhão de acessos. Para cada acesso, é criada
uma thread para cuidar dessa requisição. Essa thread permanece travada até que a requisição termine.
Como os recursos e threads do sistema operacional são limitados, essa arquitetura apresenta problemas
para escalar para sistemas que possuem milhões de acessos e são utilizados em larga escala. Caso o
número de threads que o sistema operacional possui chegue ao limite, as requisições começam ser
enfileiradas, gerando um gargalo na resposta para o cliente, pois sempre uma requisição precisa
terminar para depois iniciar a próxima. Essa é a arquitetura síncrona.

Node.js possui uma proposta diferente, pois faz chamadas não bloqueantes (assíncronas), o que tem se
mostrado uma solução extremamente eficiente e com excelente performance.

Enquanto para escalar sistemas nas outras linguagens é muitas vezes preciso aumentar a capacidade
doservidor (memória e CPU), ou até mesmo adicionar mais servidores em algum balanceador de carga,
às vezes em Node.js é possível atender ao mesmo sistema com um hardware mais modesto, pois Node.js
faz melhor uso e gerenciamento do hardware disponível.
1.4 Single Thread e Event Loop
Quando o servidor Node.js é iniciado, possui uma única thread que fica escutando por
eventos chamada de Event Loop. Na prática, se chegarem 100 requisições, estas serão
enfileiradas e tratadas sequencialmente pelo Event Loop. Mas o segredo do Event
Loop é que faz isso rapidamente e logo delega a tarefa para threads secundárias
chamadas de workers.

Essas threads secundárias executam a tarefa em background, de modo assíncrono, e

quando terminam, enviam a resposta novamente para o Event Loop para ser
processado.

Esse modelo com o Event Loop recebendo as requisições e disparando tarefas

assíncronas tem demonstrado ser muito eficiente e, por isso, o Node.js se tornou
extremamente popular e tem caído nas graças dos desenvolvedores e empresas de
todo o mundo.
 1.5 Npm

O node.js utiliza o gerenciador de pacotes NPM (Node Package Manager), o que

confere muita produtividade para gerenciar os pacotes (libs) que serão utilizadas no
projeto.

O NPM é um repositório on-line (npmjs.com) repleto de bibliotecas e chamado por

linha de comando. Por exemplo, digamos que você precise de alguma biblioteca que
facilite a persistência em algum banco de dados relacional ou NoSQL.

Basta encontrá-la no repositório do NPM e referenciá-la no projeto. Com um simples

comando no terminal, conseguimos baixar ou atualizar a versão dessa biblioteca.
1.6 Instalação do Node.js

A instalação do Node.js é simples. Site oficial:

* Instalando o Node.js pelo gerenciador de pacote

https://nodejs.org/en/download/package-manager/

Nesta página, você pode selecionar o seu sistema operacional, como Windows, Linux e
Mac, e ver o tutorial apropriado. Muitas vezes, dependendo do sistema operacional, o
tutorial apenas vai redirecioná-lo para a página de download do Node.js, onde basta fazer
o download e instalar.

Atalho para a página do download

https: //nodejs.org/en/fdownload
1.6.1 Instalação do Node.js no Linux

sudo apt install nodejs

sudo apt install npm
node –version && npm --version
1.7 O terminal do Node
No terminal, digite node para abrir o console e, depois, 1+1 e <enter>. Veremos que o Node vai retornar a soma dos
números. Para encerrar o console, digite .exit e <enter>:

Retornou undefined pois a função console não possui retorno.

MAdSB1

Var: declaração de variável

Ao digitar a, o ambiente
retorna o valor da variável

A função console.log imprime no console.

Undefined: não existe valor de retorno para a função

console.log, portanto, o ambiente retorna undefined
Slide 20

MAdSB1 Marco Aurélio de Souza Birchal; 04/05/2020

2. JavaScript – variáveis e funções
// testevar1 - pag 23
// usando %s e %d para imprimir nome e soma
// OBS: funcoes sao declaradas com a palavra function
// para executar, basta chama-las com ()

function testeVar() {
var a = 1;
var b = 2;
var soma = a + b;
var nome = "Joao";
console.log("Olá %s, o resultado da soma é: %d", nome, soma);
}
// Executa a função testeVar()

testeVar()
2. JavaScript – variáveis e funções
// testevar2 - pag 24
// usando %s e %d para imprimir nome e soma
// acrescentando mais strings após as variáveis (concatenando)

function testeVar() {
var a = 1;
var b = 2;
var soma = a + b;
var nome = "Joao";
console.log("Olá %s, o resultado da soma é: %d", nome, soma, "que",
"legal!");
}
// Executa a função testeVar()

testeVar()
2. JavaScript – variáveis e funções

// testevar3 - pag 24
// tipos indefinidos
function testeVar() {
var a = 1;
var b = 2;
var soma = a + b;
var nome;
console.log("Olá %s, o resultado da soma é: %d", nome, soma);
}
// Executa a função testeVar()

testeVar()
2. JavaScript – variáveis e funções
// testevar4 - pag 25
// tipos indefinidos - continuacao
// observe as saídas da funcao typeof()

function testeVar() {
var a = 1;
var b = 2;
var soma = a + b;
var nome;
if(nome == undefined) {
console.log("Teste 1) O nome não foi inicializado.");
}
if(typeof(nome) == "undefined") {
console.log("Teste 2) O nome não foi inicializado.");
}
console.log("O tipo do nome é %s e o tipo da soma é %s", typeof(nome), typeof(soma));
console.log("Olá %s, o resultado da soma é: %d", nome, soma,"que","legal");
}
// Executa a função testeVar()
testeVar()
2. JavaScript – arrays (1)

// testeArray1 - criacao de arrays

function testeArray() {
var numeros = [1,2,3]
numeros.push(4);
numeros.push(5);
for(let i = 0; numeros.length > i; i++) {
console.log(numeros[i]);
}
}
// executa a funcao
testeArray();
2. JavaScript – arrays (2)
// pag. 27
// usando for/let

function testeArray() {
var numeros = [1,2,3]
numeros.push(4);
numeros.push(5);

for(let i in numeros) {
console.log(numeros[i]);
}
}
// executa a funcao
testeArray();
2. JavaScript – arrays (3)
// pag. 27
// usando a funcao map(callback) para percorrer o array
// a sintaxe => é usada para declarar uma funcao anonima

function testeArray() {
var numeros = [1,2,3]
numeros.push(4);
numeros.push(5);

numeros.map(n => console.log(n));

}
// executa a funcao

testeArray();
2. JavaScript – arrays (4)
// pag. 27
// usando a funcao map(callback) para percorrer o array
// a sintaxe => é usada para declarar uma funcao anonima

function testeArray() {
var numeros = [1,2,3]
numeros.push(4);
numeros.push(5);

//numeros.map(n => console.log(n));

numeros.map(n => {console.log(n)});
}
// executa a funcao

testeArray();
2. JavaScript – Classes e Objetos (1)
/* pag. 28
// Classes e objetos usando a palavra
// reservada Object
*/
function objetos1() {
var pessoa = Object()
pessoa.nome = "joao";
pessoa.hello = function() {
return "Hello Pessoa!";
}
console.log(pessoa);
console.log(pessoa.nome);
console.log(pessoa.hello()); cap2 birchal$ node objetos1.js
} { nome: 'joao', hello: [Function] }
joao
Hello Pessoa!
// chamando a funcao bfb916ea:cap2 birchal$
objetos1();
2. JavaScript – Classes e Objetos (2)
/* pag. 29
// Classes e objetos declarando uma variavel
// e usando {} para delimitar escopo
*/

function objetos2() {
var pessoa = {
nome : 'Joao',
hello: function() {
return "Hello Pessoa!";
}
}
console.log(pessoa);
console.log(pessoa.nome); cap2 birchal$ node objetos2.js
console.log(pessoa.hello()); { nome: 'joao', hello: [Function] }
joao
} Hello Pessoa!
// chamada a funcao bfb916ea:cap2 birchal$
objetos2();
2. JavaScript – Classes e Objetos (3)
/* pag. 29
// Classes e objetos declarando uma funcao com o nome
// da classe/objeto. Operador new() e this para criar
// variáveis e metodos dentro do escopo da funcao
*/

function Pessoa() { // a função pessoa é como se fosse um objeto

this.nome = "joao";
this.hello = function() {
return "Hello Pessoa!";
}
}
function objetos3() {
var pessoa = new Pessoa();
console.log(pessoa); cap2 birchal$ node objetos3.js
console.log(pessoa.nome); { nome: 'joao', hello: [Function] }
console.log(pessoa.hello()); joao
Hello Pessoa!
}
bfb916ea:cap2 birchal$
objetos3();
 2. JavaScript – Classes e Objetos (4) /* pag. 30
// Classes e objetos usando a palavra reservada class
// Melhor aproximacao de OO verdadeira
// pode-se criar construtores
// nao precisa da palavra function para criar funcoes
*/

class Pessoa {
constructor() {
this.nome = "Joao";
}
static hello() {
return "Hello Pessoa!";
}

}
function objetos4() {
cap2 birchal$ node objetos4.js var pessoa = new Pessoa();
{ nome: 'joao', hello: [Function] } console.log(pessoa);
joao console.log(pessoa.nome);
Hello Pessoa! console.log(Pessoa.hello());
bfb916ea:cap2 birchal$ }
// chamada da funcao
objetos4();
3. Introdução aos WEB Services
Web services são utilizados como forma de integração e comunicação de sistemas, de
modo que um sistema possa realizar uma chamada para um serviço de outro sistema
com o objetivo de obter informações. Tais chamadas podem enviar e receber
informações em diversos formatos, sendo, atualmente, os mais populares XML
(eXtensible Markup Language) e JSON (JavaScript Object Notation).

Uma das grandes vantagens na construção de web services é que permitem acessar os
serviços de forma padronizada e independente da linguagem de programação. Por
exemplo, é possível escrever um web service em Node, mas consumi-lo em qualquer
outra linguagem, como Java, C#, PHP, Python etc.

Esse conceito trouxe um grande avanço na forma que os sistemas são construídos, pois
permite separar e quebrar o sistema em partes, arquitetura conhecida como
microsserviços (microservices).
3.1 O formato JSON

http://livrowebservices.com.br/rest/carros
3.2. Web services RESTful
O REST (Representational State Transfer) é uma técnica de desenvolvimento de web
services fortemente baseada nos métodos do protocolo HTTP.
O termo RESTful foi criado para indicar que determinado sistema ou serviço segue os
princípios do REST. Por exemplo, sabe-se que:
• GET é utilizado para consulta;
• POST é utilizado para inserir;
• PUT é utilizado para atualizar;
• DELETE é utilizado para deletar.

NOTA: Web Services também são chamados de APIs, portanto é comum dizer que se
vai receber uma API para acessar determinado serviço.
3.2. Web services RESTful
Características do REST:
• Cada requisição ao serviço deve retornar o conteúdo sem manter estado, ou seja,
uma requisição é independente da outra.
• Tem um conjunto de operações padronizadas (GET, POST, PUT e DELETE).
• Utiliza uma URI (Uniform Resource Identifier), i.e., uma sintaxe universal para
identificar recursos. No REST, cada recurso deve conter uma URI para ser possível
consultar informações sobre ele.
• Utilização de tipos de conteúdo (mime-type) para solicitar e retornar conteúdo. Esse
recurso permite que o cliente do serviço especifique se deseja que o conteúdo seja
retornado em XML ou JSON, por exemplo.

Nota: qual é a diferença entre REST e RESTfuI? REST é um conjunto de técnicas de

desenvolvimento de web services fortemente atreladas ao protocolo HTTP e a diversos
padrões já existentes da web. Pode-se dizer que um web service é RESTful se tiver sido
construído com base nos conceitos de REST.
3.3. Métodos do protocolo HTTP (GET, POST, PUT, DELETE)
Web services REST estão fortemente acoplados aos conceitos do protocolo HTTP. Em
termos gerais, existem quatro métodos com os quais se pode trabalhar ao desenvolver
web services em REST:

Método Descrição
GET Método mais comum de requisição. Deve ser utilizado para serviços de consultas. O limite de
caracteres na URL é de 2045, mas isso pode variar conforme o browser. Por isso, é uma boa prática
passar poucos parâmetros na URL. Sempre que um endereço de uma página é digitado no
browser, uma requisição do tipo GET é feita.
POST O POST deve ser utilizado para enviar dados ao servidor, como um formulário de login, um
cadastro de usuários, upload de fotos etc. No REST, o POST é utilizado para enviar dados ao web
service com o objetivo de inserir informações no banco de dados.
PUT No REST, o método PUT deve ser utilizado para atualizar registros. Sua requisição é parecida com o
POST.
DELETE No REST, o método DELETE deve ser utilizado para excluir um registro. Sua ruisição é parecida
com o GET.
3.3.1 GET
• Primeiramente, sempre que se digitar uma URL no browser, isso será um GET.
• Se copiarmos e colarmos esse endereço em outra aba do browser, o mesmo resultado
aparecerá, ou seja, isso é uma requisição feita por GET, onde basta copiar a URL com
os parâmetros enviados e pronto.
• Quando a chamada é feita via GET, todos os parâmetros necessários para realizar a
chamada devem ser informados na URL.
• A vantagem do GET é sua simplicidade e a desvantagem é que o limite de caracteres
na URL é de 2045, mas isso pode variar conforme o browser.
3.3.2 POST
• O POST geralmente é usado em formulários de login, cadastros etc. para enviar
informações para o servidor.
• Web Services que precisam salvar informações também costumam receber os dados
via POST.
• A vantagem do POST é que não existe limite de caracteres, portanto também pode
ser utilizado para upload de arquivos.
• A desvantagem é que tecnicamente é um pouco mais difícil, pois os dados precisam
ser enviados no corpo da requisição do protocolo HTTP.
GET versus POST:
Um dos primeiros conceitos que se deve entender é a diferença sobre chamar um web
service via GET ou POST.
Ao digitar uma URL no browser, é gerada uma requisição HTTP do tipo GET.
Já ao submeter um formulário, pode-se configurar o envio por GET ou POST, e o POST
envia os parâmetros no corpo da requisição HTTP.
3.4. Um WEB Service com o método GET
Exemplo: pode-se fazer um GET nesta URL para buscar todos os carros cadastrados:

http://livrowebservices.com.br/rest/carros

Ou consultar apenas os carros clássicos:

http://livrowebservices.com.br/rest/carros/tipo/classicos

Ou ainda consultar algum carro pelo id:

http://livrowebservices.com.br/rest/carros/1
3.5 Códigos de retorno de uma resposta HTTP
• Sempre que uma requisição HTTP é feita, seja para acessar uma página no browser,
seja para chamar um web service, um código numérico é retornado, indicando o
resultado da requisição.

• É comum retornarmos o código 200 (0K), para indicar que a requisição foi bem-
sucedida, ou o código 500 (erro de servidor), para indicar uma falha.
3.6 Tipo de conteúdo (mime-type ou content-type)
Um web service REST pode definir o seu tipo de entrada e retorno, sendo comum utilizar
JSON para ambos.
• Por exemplo, um web service que salva carros, pode fazer um POST enviando um
JSON no corpo da requisição:
{ "nome": "Ferrari FF", "desc": "A Ferrari FF é um carro muito fera" }
Este web service poderia responder com status 200 (0K) no cabeçalho e retornar um
JSON com uma mensagem de sucesso:
{ "msg": "Carro salvo com sucesso" }
• Ou o web service poderia retornar o status 500 no caso de erro de servidor com
alguma mensagem:
{ "msg": "Erro ao salvar o carro" }

• Mas o mais importante é que o web service se comunica utilizando o formato JSON,
cujo tipo mime-type é conhecido como application/json.
3.6 Tipo de conteúdo (mime-type ou content-type)
• Nada impede que um web service receba um texto ou XML na entrada da requisição
e retorne um JSON, ou vice-versa. Tudo isso é configurável, mas é claro que é bom
seguir um padrão para não haver confusão.
• Atualmente, o mais comum é o padrão JSON.
• Conhecer os tipos de conteúdo (mime-type) é importante porque existem casos em
que se pode querer que sua página retorne uma planilha Excel ou arquivo PDF, uma
imagem ou um arquivo compactado. Para cada um destes tipos, existe um tipo de
conteúdo.
• Esses tipos de conteúdo são sempre informados no cabeçalho do protocolo HTTP,
seja na entrada, seja na resposta.
3.6 Tipo de conteúdo (mime-type ou content-type)

Código Tipo de arquivo ou conteúdo

application/json JSON
application/xml XML
application/zip ZIP
application/pdf PDF
text/plain TXT
text/html HTML
Image/jpeg JPEG
4. Node Básico
4.1 Criando um servidor HTTP
o HTTP é um protocolo de comunicação utilizado para sistemas web que pode receber e
enviar informações.
Os dados são recebidos sempre em um objeto chamado de request e a resposta é
sempre enviada por um objeto chamado de response.
// Carrega o módulo HTTP – importação da biblioteca HTTP (pag.43) – exemplo1.js
var http = require('http');

// Cria um servidor HTTP que vai responder "Hello World" para todas requisições.
var server = http.createServer(function (request, response) {
// Define o cabeçalho (header) com o tipo da resposta
response.writeHead(200, {"Content-Type": "text/plain"});

// Mensagem de retorno
response.end("Hello World Node!\n");
});
// Porta que o servidor vai escutar
server.listen(3000);
// Mensagem ao iniciar o servidor
console.log("Servidor iniciado em http://localhost:3000/");
4.2 Detalhes da função createServer
O node possui um paradigma de programação funcional em que uma função pode ser
passada como parâmetro de outra função:

var server = http.createServer ( function (request, response ) {

função 1 função 2 (função de callback)

A função createServer tem como retorno um objeto do tipo http.server e recebe como
parâmetro a função call-back descrita em function(request,response)

Uma outra forma de passar a função como argumento seria criar uma função call-back
que representa a função de retorno.

Assim, essa função pode ser passada como parâmetro para a função
http.createServer([requestListener])

Nota: Uma função de call-back é chamada de forma assíncrona como resposta a algum
evento
// exemplo2.js
//Carrega o módulo HTTP – importação da biblioteca HTTP (pag. 45)
var http = require('http');

var callback = function (request, response) {

// Define o cabeçalho (header) com o tipo da resposta
response.writeHead(200, {"Content-Type": "text/plain"});

// Mensagem de retorno
response.end("Hello World Node callback!\n");
};

// Cria um servidor HTTP que vai responder "Hello World" para todas requisições.
var server = http.createServer(callback);

// Porta que o servidor vai escutar

server.listen(3000);

// Mensagem ao iniciar o servidor

console.log("Servidor iniciado em http://localhost:3000/");
4.3. Adicionando rotas no servidor HTTP
URL: Uniform Resource Locator – endereço do recurso (servidor)
URI – Uniform Resource Identifier – é o path – caminho até o recurso do web servisse,
dentro do servidor – também chamado de rota.

http://localhost:3000/teste1

URL: http://localhost:3000
URI:/teste1

Cada rota pode retornar um conteúdo diferente, bastando mapear cada uma delas no
código.

Exemplo: Código com duas rotas -> rota raiz / e rota /carros
// Carrega os módulos (pag. 46)
var http = require('http');
var url = require('url')
// Função de callback para o servidor HTTP
var callback = function (request, response) {
// Cabeçalho (header) com o tipo da resposta + UTF-8 como charset
response.writeHead(200, {"Content-Type": "text/plain; charset=utf-8"});
// Faz o parser da URL separando o caminho (path)
var parts = url.parse(request.url);
// Verifica o path (verifica a rota)
if(parts.path == '/') {
response.end("Site na raiz.");
} else if(parts.path == '/carros') {
response.end("Você digitou o path /carros.");
} else {
response.end("Path não mapeado: " + parts.path);
}
}
// Cria um servidor HTTP que vai responder "Hello World" para todas requisições.
var server = http.createServer(callback);
// Porta que o servidor vai escutar
server.listen(3000);
// Mensagem ao iniciar o servidor
console.log("Servidor iniciado em http://localhost:3000/");
4.4. WEB service simples com arquivos
O objetivo deste exemplo é retornar o arquivo JSON correspondente à rota informada:
http://localhost:3000/carros/classicos
http://localhost:3000/carros/esportivos
http://localhost:3000/carros/luxo

Para tanto, os arquivos .json devem estar no mesmo diretório do programa node .js.

A função readFile(response, file) faz a leitura do arquivo JSON e envia o seu conteúdo na
resposta (response) da página.
// Carrega os módulos – hello.js - (pag. 48)
var http = require('http');
var url = require('url')
var fs = require('fs');
// Função para ler um arquivo e escrevê-lo na response.
function readFile(response,file) {
// Faz a leitura do arquivo de forma assíncrona
fs.readFile(file, function(err, data) {
// Quando ler, escreve na response o conteúdo do arquivo JSON.
response.end(data);
});
}
// Função de callback para o servidor HTTP
function callback(request, response) {
// Cabeçalho (header) com o tipo da resposta + UTF-8 como charset
response.writeHead(200, {"Content-Type": "application/json; charset=utf-8"});
// Faz o parser da URL separando o caminho (path)
var parts = url.parse(request.url);
var path = parts.path;
// Verifica o path
if (path == '/carros/classicos') {
// Retorna o JSON dos carros cássicos
readFile(response,"carros_classicos.json");
} else if (path == '/carros/esportivos') {
// Retorna o JSON dos carros esportivos
readFile(response,"carros_esportivos.json");
} else if (path == '/carros/luxo') {
// Retorna o JSON dos carros luxo
readFile(response,"carros_luxo.json");
} else {
response.end("Path não mapeado: " + path);
}
}
// Cria um servidor HTTP que vai responder "Hello World" para todas requisições.
var server = http.createServer(callback);
// Porta que o servidor vai escutar
server.listen(3000);
// Mensagem ao iniciar o servidor
console.log("Servidor iniciado em http://localhost:3000/");
4.5. Criando um servidor TCP (Socket)
Este exemplo demonstra a criação de um servidor de nível mais baixo que o HTTP,
usando sockets TCP para se criar um servidor cujo cliente poderia ser um telnet client.
// hello-tcp.js – (pag.51)
// Carrega o módulo net
var net = require('net');
// Contador para testes
var count = 1;
// Cria o servidor TCP
var server = net.createServer(function (socket) {
// Mensagem de log quando algum cliente conectar
console.log("Cliente conectou do IP: " + socket.remoteAddress);
// Escreve a resposta e termina a conexão do cliente.
socket.end("Hello World TCP: " + (count++) + "\n");
});
// Inicia o servidor
server.listen(3000, "localhost");
// Mensagem ao iniciar o servidor
console.log("Servidor TCP iniciado...");
4.5.1. Criando um servidor TCP (Socket) de CHAT
https:/gist.github.com/graphicbeacon/10422384
5. NPM
5.1 Criando um servidor HTTP
• O npm (https://npnjs.con) é um gerenciador de pacotes global para JavaScript que
permite que os desenvolvedores distribuam gratuitamente seus pacotes (bibliotecas).
• Todo projeto npm é configurado pelo arquivo package.json, que fica na raiz do
projeto. É nele que são declaradas todas as dependências do projeto, ou seja, os
pacotes de terceiros que são utilizados.
• Até o momento, fizemos testes simples com arquivos .js e executamos com o
comando node, mas, para os próximos projetos, criaremos um projeto Node com o
npm. Isso facilitará adicionar novos pacotes como dependências à medida que formos
avançando nos exemplos.
• Para criar um projeto com o npm, digite o comando npn init na pasta que deseja criar
o projeto. Ao fazer isso, você deverá responder a algumas perguntas sobre o nome do
projeto, versão, nome do autor, licença etc. Se preferir, basta pressionar <enter> para
aceitar a sugestão do assistente. Caso contrário, digite o texto que preferir.
5.2 Comando npm start
Na raiz do projeto que criamos anteriormente, digite o comando npn start. Neste
momento, obteremos um erro como resposta:

$ npn start
npm ERR! missing script: start

Isso acontece porque esse comando dispara o script inicial que deve ser executado
pelo npm e, de fato, ainda não configuramos nenhum.

Para adicionar um script inicial, adicione mais uma linha dentro de scripts, com o
atributo start, e não se esqueça da vírgula ao quebrar a linha