Node js Uma nova abordagem da linguagem JavaScript

Prévia do material em texto

Node.js 
Uma nova abordagem 
da linguagem Javascript 
De estudante para estudante 
 Material do grupo SoftwareOriginSP 
2016 
Fundado do grupo SoftwareOriginSP: Guilherme Guerra 
[NODE.JS UMA NOVA ABORDAGEM DA 
LINGUAGEM JAVASCRIPT] 20 de março de 2016 
 
Grupo SoftwareOriginSP 
 Página 2 
 
 O grupo SoftwareOriginSP, é um grupo independente fundado no 
fim do ano de 2015, sem iniciativa do gorvenamental. Seu principal interesse é seguimenta da 
criação de jogos para diversas plataformas tanto desktop ou móbile. Entretanto, adquirimos 
alguns conceitos fundamentais que são estabelecidos para fazer ferramentas para as pessoas, 
entre elas são: ferramentas para web, sendo sites dinâmicos, e entre outras que podam 
contribuir na comunicação e da evolução do aspecto humano. 
 As tecnologias feitas pelo grupo são de alta telecomunição, para que as pessoas possam se 
comunicar em qualquer lugar e a qualquer momento. Usamos ferramentas totalmente aceitas 
no mercado tecnológico. 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
Contatos do grupo: 
E-mail: guilhermeguerra96@outlook.com 
G-mail: guilhermeguerra96@gmail.com 
[NODE.JS UMA NOVA ABORDAGEM DA 
LINGUAGEM JAVASCRIPT] 20 de março de 2016 
 
Grupo SoftwareOriginSP 
 Página 3 
 
Telefone: (11) 2037-1232 
1° Capítulo 
Instalando e cofigurando o Node.Js 
no ambiente Windows 
Sobre o node.js 
 O node.js nasceu em meados de 2009 sendo o seu criador Ryan Dahl e uma equipe de 14 
desenvolvedores que pretendiam criar uma plataforma para facilitar a criação de aplicações 
real-time e de alta escalabilidade. 
 O objetivo principal do node.js é "fornecer uma maneira fácil de criar programas de rede 
escaláveis" solucionando o principal problema das aplicações atuais feitas em Java, PHP ou 
.NET, pois essas aplicações iniciam um processo para cada conexão que é acompanhado de 
aproximadamente de 2MB de memória, desta forma limitando o número de acessos pela 
quantidade de memória da máquina. Para contornar este problema são criados vários 
servidores para tornar a aplicação mais escalável. O node.js veio para solucionar este 
problema mudando a forma que é feito as conexões no servidor, pois ao invés de iniciar um 
encadeamento em cada conexão será criado um processo que não necessita que o bloco de 
memória fique alocado a este processo. 
Algumas característica do node.js 
Threads não bloqueantes: uma das melhores características do node.js onde não há um 
controle de concorrências entre os recursos disponíveis para os processos. Nas linguagens 
tradicionais como JAVA e .NET gerenciam as suas threads colocando em fila de execução onde 
os processos que necessitam utilizar o mesmo recurso esperam a sua vez par usufruir do 
recurso. 
Programação Orientada à eventos I\O: existem diversas bibliotecas para se trabalhar com os 
protocolos HTTP, HTTPS, Web Sockets (para aplicações real-time), entre outros protocolos. 
Mecanismo V8: node.js roda Javascript no lado do servidor utilizando o mecanismo V8 
(mecanismo Javascript do Google utilizado no Chrome). Podendo utilizar todo o poder da 
ECMAScript5 
Módulos: contém vários módulos para facilitar o desenvolvimento de aplicações como o 
módulo de sockets, manipulação de arquivos, url, banco de dados NoSQL, entre outros. 
[NODE.JS UMA NOVA ABORDAGEM DA 
LINGUAGEM JAVASCRIPT] 20 de março de 2016 
 
Grupo SoftwareOriginSP 
 Página 4 
 
Sobre o socket.io 
 O socket.io é um modulo do node.js que permiti fazer comunicação bidirecional utilizando 
as APIs de transporte nativas dos browsers. Resumidamente este modulo que irá proporcionar 
o real-time criando uma conexão com o servidor permitindo que haja a troca de informações 
entre Client e Server sem a necessidade de solicitar um novo request. 
 A troca de informações entre Server e Client é feitas através de eventos onde cada ponta 
deve monitorar um determinado evento que será disparado. Na parte de exemplos irei 
detalhar com maiores informações como funciona o disparo dos eventos entre o Server e 
Client. 
 
Pré-requisitos 
Executável do Node.js v.0.8.6 (Última versão se encontra no site.) 
Python v.3.2.3 (Última versão se encontra no site.) 
Servidor Web. 
 Estarei utilizando o WAMP como servidor Web local para demonstração do exemplo, caso 
não tenha um servidor Web local e queira instalar o WAMP pode efetuar a instalação e 
configuração utilizando este poste sobre Instalando e configurando o WAMP. 
 
Instalando e configurando o node.js 
 A instalação do node.js no Windows 7 é muito tranquila, pois segue o padrão das 
instalações for Windows os passos NNF (Next Next Finish) ou PPR (Próximo próximo e 
reiniciar). Baixe o executável do node.js através do site oficial. A versão v0.8.6 se encontra do 
site e poderá baixa e executa em direfentes versões do sistemas operacionais do Windows. 
 
[NODE.JS UMA NOVA ABORDAGEM DA 
LINGUAGEM JAVASCRIPT] 20 de março de 2016 
 
Grupo SoftwareOriginSP 
 Página 5 
 
 
 Após o download execute o aplicativo de instalação. Nesta instalação será instalado o 
node.js, alguns módulos nativos e seu gerenciador de pacotes o NPM (Node Package 
Manager). Este gerenciador servirá para a isntalação dos demais módulos para a utilização no 
node.js como o nosso caso o socket.io. Vamos aos passos da instalação. 
 
1º passo - Tela de instalação do node.js: esta tela informa sobre a instalação do node.js para 
continuar clique no botão "Next" 
 
2º passo - Licença de uso do node.js: nesta tela está descrito a licença do node.js para 
instalação deve ser selecionado a opção "I accept the terms in the License Agreement" e clique 
[NODE.JS UMA NOVA ABORDAGEM DA 
LINGUAGEM JAVASCRIPT] 20 de março de 2016 
 
Grupo SoftwareOriginSP 
 Página 6 
 
no botão "Next" caso apareça uma mensagem solicitando a confirmação da instalação 
selecione a opção para continuar com o wizard. 
 
3º passo - Conclusão da instalação do node.js: se tudo der certo a imagem abaixo deve ser 
exibida assim confirmando a instalação do node.js. Clique no botão "Finish" para finalizar o 
wizard. 
 
4º passo - Permissão de acesso: O node.js será instalado no diretório padrão dos aplicativos 
do Windows. No meu caso este será instalado em "C:\Program Files\nodejs". Precisamos dar 
permissão para esta pasta para a instalação dos demais módulos do node.js no nosso caso o 
socket.io. Para dar permissão a pasta vá no diretório de instalação do node.js e clique com o 
botão direito do mouse na pasta "nodejs" e vá na opção "Propriedades": 
[NODE.JS UMA NOVA ABORDAGEM DA 
LINGUAGEM JAVASCRIPT] 20 de março de 2016 
 
Grupo SoftwareOriginSP 
 Página 7 
 
 
Clique na aba "Segurança" no campo "Nome de grupos ou de usuários" você deverá dar 
permissão ao Grupo de Usuários, então clique no botão "Editar" sendo exibida a tela conforme 
imagem abaixo: 
 
 Selecione a opção "Usuários (NOME_DO_COMPUTADOR\Usuários)" e abaixo no campo 
"Permissões para Usuários" clique na coluna "Permitir" no checkbox "Controle total" sendo 
marcado o campo "Modificar" automaticamente. Clique botão "OK" retornando para a tela 
[NODE.JS UMA NOVA ABORDAGEM DA 
LINGUAGEM JAVASCRIPT] 20 de março de 2016 
 
Grupo SoftwareOriginSP 
 Página 8 
 
das propriedades da pasta, clique novamente em "Ok" sendo fechado a tela o retornado para 
a pasta de instalação do node.jsInstalando o Python 
 Quando necessitamos instalar algum módulo do node.js como o nosso caso o socket.io o 
gerenciador de pacotes do Node.js (NPM) utiliza na versão Windows o Visual Studio ou o 
Python, desta forma antes de instalar o módulo socket.io devemos instalar o Python. Baixe o 
executável para a sua versão através deste link. Após o download execute o arquivo baixado 
(python-3.2.3.msi). 
1º passo - Permitindo execução: caso seja solicitado a execução deste aplicativo clique em 
"Executar": 
 
2º passo - Selecionando o tipo de instalação: nesta tela é informado se esta instalação será 
para todos os usuários ou somente para o usuário que este instalando o aplicativo. Deixe a 
opção "Install for all users" e clique em "Next": 
[NODE.JS UMA NOVA ABORDAGEM DA 
LINGUAGEM JAVASCRIPT] 20 de março de 2016 
 
Grupo SoftwareOriginSP 
 Página 9 
 
 
3º passo - Selecionando diretório de instalação: neste passo você poderá informar um 
diretório default para a instalação do Python, no meu caso deixarei o default "C:\Python32\". 
Caso queira alterar escolha a sua pasta e clique no botão "Next" para prosseguir: 
 
4º passo - Customizando a instalação: neste passo você poderá informar o que deseja ou não 
na sua instalação. Em minha instalação deixei as opções como estão. Após a customização 
clique em "Next": 
[NODE.JS UMA NOVA ABORDAGEM DA 
LINGUAGEM JAVASCRIPT] 20 de março de 2016 
 
Grupo SoftwareOriginSP 
 Página 10 
 
 
5º passo - Finalizando a instalação: Neste ponto o sistema está instalando o aplicativo caso 
seja informado uma mensagem para execução do aplicativo clique em "Sim". A tela de 
finalização da instalação é exibida clique na opção "Finish" para finalizar a instalação. 
 
 
Reiniciando o Windows 
 Este não é um passo que gostaria de estar colocando neste tutorial, mas em minhas últimas 
três instalações tudo ocorreu corretamente só após reiniciar o Windows. Então antes de 
continuar reinicie o seu SO para que as devidas configurações sejam efetivadas. 
 
 
Instalando o socket.io 
 Com a instalação do node.js o seu gerenciador de pacotes (NPM) já está instalado e pronto 
para ser usado assim podemos instalar os demais módulos para a utilização do node.js. 
Por padrão as instalações dos módulos eu utilizo a mesma pasta onde efetuei a instalação do 
node.js que no meu caso foi em "C:\Program Files\nodejs". Assim abra o prompt do 
Windows (WinKey + R e digite cmd) e navegue até a pasta da sua instalação utilizando os 
comandos: cd .. para voltar uma estrutura e cd NOME_DA_PASTA para acessar uma pasta. A 
instalação do módulo será feita através do comando "npm install socket.io". 
Vá no prompt e digite o comando acima e pressione ENTER, se tudo der certo deverá ser 
informado a mensagem do sucesso da instalação. 
 
[NODE.JS UMA NOVA ABORDAGEM DA 
LINGUAGEM JAVASCRIPT] 20 de março de 2016 
 
Grupo SoftwareOriginSP 
 Página 11 
 
 
 Fique atento as mensagens que são exibidas no prompt, pois caso ocorra algum erro será 
demonstrada uma mensagem. 
Neste momento temos tudo que precisamos para utilizar o node.js com socket.io. Então 
vamos aos exemplos para testarmos os aplicativos instalados. 
 
Botando a mão na massa 
 Nesta parte do tutorial iremos ver através dos exemplos como podemos utilizar o node.js e 
o socket.io. Os arquivos de exemplos serão executados pelo console (prompt do Windows) 
utilizando o executável "node". Para demonstração irei salvar os arquivos de exemplos na 
pasta de instalação do node.js que no meu caso está em "C:\Program Files\nodejs". Então 
vamos os exemplos. 
 
 O famoso "Hello world": este exemplo que foi tirado do site oficial do node.js irá exibir o 
texto "Hello word" no browser do usuário conectado no servidor, porém fiz algumas 
alterações para demonstrar de uma forma mais detalhada o funcionamento de cada parte do 
código. Crie um arquivo com o nome "hello_world.js" na pasta de instalação do node.js com o 
conteúdo abaixo: 
 
// Requisitando os módulos 
var http = require('http'); 
 
/** 
 * Função que irá ser chamada a cada conexão com o Node.js 
 * @param {http.ServerRequest} req Instância do request da requisição 
 * @param {http.ServerResponse} resp Instância do response da requisição 
 */ 
var onRequest = function (request, response) { 
 // Informando o tipo do cabeçalho da página 
 response.writeHead(200, {'Content-Type': 'text/plain'}); 
 
 // Escrevendo um texto no response 
 response.write('Hello World\n'); 
[NODE.JS UMA NOVA ABORDAGEM DA 
LINGUAGEM JAVASCRIPT] 20 de março de 2016 
 
Grupo SoftwareOriginSP 
 Página 12 
 
 
 // Encerrando o response 
 response.end(); 
}; 
 
// Criando o servidor informando a função de callback para o request 
var server = http.createServer(onRequest); 
 
// Iniciando o servidor na porta 1337 
server.listen(1337, '127.0.0.1'); 
 
// Informando no console (prompt do Windows) a informação 
console.log('Server running at http://127.0.0.1:1337/'); 
 
 Com o arquivo criado abra o prompt do Windows e navegue até a pasta da instalação (ou a 
pasta onde se encontra o arquivo). Digite o comando "node hello_world.js" e pressione 
ENTER, se tudo der certo será exibido o texto no prompt "Server running at 
http://127.0.0.1:1337/" conforme imagem abaixo: 
 
Detalhando o código: 
 Linha #2: nesta linha é carregado o módulo HTTP do node.js utilizando o método require. 
Este método irá retornar o Object referente ao módulo solicitado. 
 Linhas #9 a #18: criada a função que será executada a cada conexão no servidor. Esta 
função irá receber dois parâmetros um sendo o request da conexão e outro o response da 
requisição. Através do response podemos exibir as informações no browser do usuário. 
[NODE.JS UMA NOVA ABORDAGEM DA 
LINGUAGEM JAVASCRIPT] 20 de março de 2016 
 
Grupo SoftwareOriginSP 
 Página 13 
 
 Linha #11: nesta linha utilizando o método writeHead para informar o status code da página 
(no nosso caso 200) e informando no segundo parâmetro o content type (tipo do conteúdo) da 
página. 
 Linha #14: após informar qual será o content type da página será escrito o texto "Hello 
world" utilizando o método write do Objeto response no browser do usuário. 
 Linha #17: o método end do Objeto response deve ser chamado em todo request. Caso 
desejamos informar algo na página podemos informar no primeiro parâmetro o texto a ser 
exibido. Seguindo o mesmo raciocínio do método write. 
 Linha #21: aqui que a mágica acontece. Nesta linha estamos criando o nosso servidor 
utilizando o método createServer do módulo HTTP. Este método irá receber como parâmetro 
uma função que será chamada (executada) no evento request do servidor, ou seja, em toda 
requisição feita para o servidor. 
 Linha #24: com a referência do servidor criado podemos informar a porta que este irá 
escutar, assim utilizando o método listen informo a porta de conexão e o hostname do 
servidor. 
 Linha #27: uma forma de se debugar o código pelo console (prompt do Windows, Shell 
Linux, etc) é utilizando a função console.log() onde esta deve receber como parâmetro o valor 
a ser exibido no console. No nosso caso será somente exibida uma mensagem informando que 
o servidor está rodando no hostname e porta informada no método listen. 
 Utilizando socket.io: irei demonstrar um exemplo simples, mas detalhado de como utilizar 
o socket.io. Antes de demonstrar o exemplo gostaria de relembrar uma das características 
informadas no início deste post, sobre "Programação Orientada à eventos I\O (POE)". Quando 
estamos programando orientado a eventostemos que sempre estar pensando em callbacks, 
ou seja, uma forma de interagir com o sistema quando um certo evento é disparado. Será 
desta forma que iremos trabalhar com o socket.io. 
 "Então como funciona os eventos com o scoket.io?" Eventos serão disparados pelas duas 
pontas da aplicação (Server side e Client side) através do socket que foi aberto. Nos dois lados 
teremos um monitoramento (listeners) dos eventos que podem ser disparados. 
 
[NODE.JS UMA NOVA ABORDAGEM DA 
LINGUAGEM JAVASCRIPT] 20 de março de 2016 
 
Grupo SoftwareOriginSP 
 Página 14 
 
 Note pela imagem acima que o evento "userconected" é disparado pelo Client side 
informando ao Server que o usuário foi conectado, desta forma temos no server um 
monitoramento para este evento, onde através da função de callback será realizado uma 
interação com o sistema. Da mesma forma o Server side emite o evento "showmessage" para 
o Client, onde o socket deste possui um monitoramento do evento utilizando uma função de 
callback que irá interagir com a aplicação. 
 Quem já programa algum tempo com Javascript esta familiarizado com este tipo de 
programação, principalmente quem utiliza jQuery, ExtJS, Prototype, entre outros. Então vamos 
ao nosso exemplo para demonstrar os conceitos informados acima. 
 
 1º Passo - Criando a estrutura no Server side: como no primeiro exemplo iremos criar um 
arquivo na pasta de instação do node.js com o nome "socketio_exemplo.js" com o conteúdo 
abaixo: 
/** 
 * Função que irá ser chamada a cada conexão com o node.js 
 * @param {ServerRequest} request Instância do request da requisição 
 * @param {ServerResponse} response Instância do response da requisição 
 */ 
var onRequest = function (request, response) { 
 // Informando o tipo do cabeçalho da página 
 response.writeHead(200, {'Content-Type': 'text/html'}); 
 
 // Mensagem exibida no console há cada requisição 
 console.log('Usuário conectado no Server!!!'); 
 
 // Encerrando o response 
 response.end(); 
}; 
 
// Requisitando os módulos 
var http = require('http').createServer(onRequest), 
 io = require('socket.io').listen(http); 
 
// Informando a porta para ser monitorada pelo Server 
http.listen(8088, '127.0.0.1'); 
/** 
 * Evento "connection" que ocorre quando um usuário conecta no socket.io 
 * @param {SocketObject} socket Objeto do socket conectado 
 */ 
io.sockets.on('connection', function(socket){ 
 /** 
 * Evento "userconected" que ocorre quando a página é carregada. 
 */ 
 socket.on('userconected', function(){ 
[NODE.JS UMA NOVA ABORDAGEM DA 
LINGUAGEM JAVASCRIPT] 20 de março de 2016 
 
Grupo SoftwareOriginSP 
 Página 15 
 
 // Enviando a mensagem só para o socket atual 
 socket.emit('showmessage', 'Usuário conectado no socket!!!'); 
 
 // Servidor responde o mesmo resultado via broadcast. 
 socket.broadcast.emit('showmessage', 'Outro usuário foi conectado'); 
 }); 
 
 /** 
 * Evento "disconnect" emitido quando o usuário recarregar ou sair da página 
 */ 
 socket.on('disconnect', function(){ 
 // Resposta do servidor via broadcast. 
 socket.broadcast.emit('showmessage', 'Um usuário saiu ou recarregou à página!!!'); 
 }); 
}); 
 
Detalhando o código: 
 Linhas #6 a #15: é informado a função de callback que será chamada em toda requisição ao 
node.js na porta 8088. 
 Linhas #18 e #19: são requisitados os dois módulos http e o socket.io. Sendo criado o 
servidor do node.js utilizando a função "onRequest" e informando para o socket.io escutar a 
conexão do módulo http. 
 Linha #22: informando para o servidor qual a porta e IP que este irá ser executado. 
 Linhas #28 e #47: este bloco será executado a toda conexão efetuada com o socket.io 
através do Client. Note que informamos utilizando o método "on" o nome do evento a ser 
monitorado e a função de callback que será executada quando esse evento for disparado pelo 
Client. 
 Na função de callback utilizando o parâmetro do socket passado na conexão é atachado 
dois eventos no socket ("userconected" e "disconnect"), desta forma o Server irá monitorar 
esses dois eventos que serão emitidos pelo Client. 
 Linhas #32 a #38: é informado através do método "on" o monitoramento do 
evento "userconected" onde este utilizando o método "emit" do socket será enviado uma 
mensagem para o usuário referente ao socket passado via parâmetro para o 
evento "connection". Já na linha #37 será enviada uma mensagem para todos os usuários 
conectados, menos o usuário do socket corrente. O método "broadcast" envia uma 
mensagem para todos os demais canais/usuários que estão conectados no Server menos o 
usuário do socket atual. 
 Linhas #43 a #46: é informado através do método "on" o monitoramento do 
evento "disconnect" onde este irá emitir uma mensagem para os demais usuários conectados 
informando que o usuário referente ao atual socket saiu da página. 
Pelo código conseguimos ver como utilizar o monitoramento dos eventos utilizando os 
métodos: 
- on: para informar o evento a ser monitorado e a função de callback que será executada 
quando o evento for disparado pelo Client. Note que nenhuma das funções 
recebem parâmetros pelo Client, mas podemos também informar parâmetros para o Server 
assim como informamos para o Cliente (linha #34 é um exemplo disso). 
- emit: este método irá emitir o evento para o Client/Server. Nele devemos informar no 
primeiro parâmetro o nome do evento e os demais itens informados serão os parâmetros que 
[NODE.JS UMA NOVA ABORDAGEM DA 
LINGUAGEM JAVASCRIPT] 20 de março de 2016 
 
Grupo SoftwareOriginSP 
 Página 16 
 
o Client/Server irá receber na função de callback. 
- broadcast: este atributo utilizando em conjunto com o método "emit" irá emitir o evento 
para todos os usuários conectados menos o atual usuário. 
 
2º Passo - Criando a estrutura no Client side: neste passo iremos criar uma página HTML para 
demonstrar o monitoramento dos eventos disparados pelo Server side. Como mencionado no 
início do poste irei utilizar um servidor Web local para a demonstração do exemplo com 
socket.io. Então vamos a configuração. 
- Crie uma pasta no DOCUMENT_ROOT do seu servidor Web com o nome "socketio_exemplo" 
crie um arquivo HTML com o nome "socket.html" e com o conteúdo abaixo: 
 
<!DOCTYPE html> 
<html> 
<head> 
 <title>Exemplo utilizando socket.io</title> 
 <meta charset="utf-8" /> 
 <meta http-equiv="Content-Type" content="text/html; charset=UTF-8" /> 
 
 <!-- CSS --> 
 <style type="text/css"> 
 h2 { 
 color: #439; 
 font-size: 120%; 
 } 
 </style> 
<!-- JS --> 
 <script type="text/javascript" src="http://localhost:8088/socket.io/socket.io.js"></script> 
 <script type="text/javascript"> 
 // Criando a conexão com o Socket.io 
 var socket = io.connect('http://localhost:8088',{ 
 'reconnect': true 
 ,'reconnection delay': 500 
 ,'max reconnection attempts': 1000 
 ,'secure': false 
 }); 
 
 // Emitindo o evento para o Server 
 socket.emit('userconected'); 
 
 // Listeners 
/** 
 * Monitorando o evento "showmessage" que será disparado pelo Server 
 * @param {String} msg Mensagem a ser exibida 
 */ 
 socket.on('showmessage', function(msg){ 
 var messageEl = document.getElementById('message-info'); 
 
 // Exibindo a mensagem enviada 
 messageEl.innerHTML += msg; 
[NODE.JS UMA NOVA ABORDAGEM DA 
LINGUAGEM JAVASCRIPT] 20 de março de 2016 
 
Grupo SoftwareOriginSP 
 Página 17}); 
 </script> 
</head> 
<body> 
 <h2>Mensagens do socket.io</h2> 
 <div id="message-info"></div> 
</body> 
</html> 
 
Detalhando o código: 
 Neste ponto irei detalhar somente as linhas de código que fazem a mágica acontecer, pois 
no mais é só HTML e CSS. 
 Linha #17: nesta linha estamos solicitando o arquivo JS do socket para o Server. Note que 
utilizamos o mesmo IP e porta que foi informado na configuração do socket no Server. 
 Linhas #20 a #25: neste bloco que estamos criando a conexão com o socket no Server, neste 
momento que é disparado o evento "connection". Há algumas opções que podemos passar 
para a criação do socket. Abaixo a informação de cada atributo: 
- reconnect (bool): que irá informar se o socket irá tentar se conectar caso perca a conexão 
com o Server. 
- reconnection delay (int): informa o tempo em milissegundos que será o delay da tentativa de 
conexão. 
- max reconnection attemps (int): informa o valor máximo de tentativas de conexão com o 
Server. 
- secure (bool): informando se a conexão com o Server irá utilizar criptografia (conexões 
HTTPS). 
 Linha #28: utilizando o método "emit" dispara o evento "userconnected" para o Server. 
 Linhas #36 a #41: neste bloco utilizando o método "on" é informado o monitoramento do 
evento "showmessage" que será disparado pelo Server passando como parâmetro a 
mensagem a ser exibida no browser do usuário. 
 Linha #37: utilizando o método "getElementById" do JS resgatamos a referência da DIV 
onde iremos inserir o texto da mensagem enviada pelo Server. 
 Linha #40: utilizando a propriedade "innerHTML" do elemento inserimos o texto que é 
informado pelo Server. 
3º Passo - Rodando o exemplo: para executar o nosso exemplo primeiro temos que iniciar o 
serviço do node.js através do nosso arquivo "socketio_exemplo.js", assim pelo prompt do 
Windows vá na pasta de instalação do node.js e execute o comando "node 
socketio_exemplo.js" (sem aspas) e pressione ENTER. 
 
[NODE.JS UMA NOVA ABORDAGEM DA 
LINGUAGEM JAVASCRIPT] 20 de março de 2016 
 
Grupo SoftwareOriginSP 
 Página 18 
 
 
 Veja a mensagem escrita no console (prompt do Windows) informando que o socket.io foi 
iniciado. 
Agora iremos acessar o nosso arquivo "socket.html" pelo servidor Web no browser 
digite http://localhost/socketio_exemplo/socket.html exibindo o conteúdo conforme abaixo: 
 
 O texto "Usuário conectado no socket!!!" é exibido através do monitoramento feito nas 
linhas #36 a #41 do arquivo "socket.html". 
[NODE.JS UMA NOVA ABORDAGEM DA 
LINGUAGEM JAVASCRIPT] 20 de março de 2016 
 
Grupo SoftwareOriginSP 
 Página 19 
 
 
 A imagem acima demonstra as mensagens que estão sendo exibidas no prompt do Window 
informando o usuário conectado. Note no texto grifado em vermelho. Neste trecho o socket 
está emitindo uma mensagem para o Client utilizando o evento "showmessage" passando 
como parâmetro a mensagem a ser exibida no DIV. 
 Abra outro navegador e digite http://localhost/socketio_exemplo/socket.html será exibido 
a mensagem "Outro usuário foi conectado" no primeiro browser aberto e no último será 
exibido a mensagem "Usuário conectado no socket!!!". 
 
 Se você olhar novamente para o prompt do Windows verá as mensagens enviadas para os 
dois sockets conectados 
 
 Pela imagem podemos ver que a mensagem "Usuário conectado no socket!!!" é disparada 
duas vezes uma para o primeiro browser (Chrome) e outra para o segundo browser (Firefox), 
[NODE.JS UMA NOVA ABORDAGEM DA 
LINGUAGEM JAVASCRIPT] 20 de março de 2016 
 
Grupo SoftwareOriginSP 
 Página 20 
 
já a mensagem "Outro usuário foi conectado" foi enviada somente para o socket já conectado 
(Chrome). 
 
 
 
 
 
 
 
 
 
 
 
 
2° Capítulo 
Instalando o node.js no ambiente Linux e em um servidor Ubuntu 14.04 
Introdução 
 
 O Node.js é uma plataforma Javascript para programação do lado servidor, que permite aos 
usuários construírem aplicações de rede rapidamente. Ao levar o Javascript tanto ao front-end 
quanto ao back-end, o desenvolvimento pode ser mais consistente e ser projetado dentro do 
mesmo sistema. 
Neste guia, vamos mostrar a você como começar com o Node.js em um servidor Ubuntu 14.04. 
Se você estiver buscando criar um ambiente de produção Node.js, confira este link How To Set 
Up a Node.js Application for Production. 
 
Como Instalar a Versão Distro-Stable 
 
 O Ubuntu 14.04 contém uma versão do Node.js em seus repositórios padrão que pode ser 
utilizada para fornecer facilmente uma experiência consistente entre múltiplos servidores. A 
versão nesses repositórios é a 0.10.25. Esta não é a última versão, mas deve ser bastante 
estável. 
 Para obter esta versão, temos apenas que utilizar o gerenciador de pacotes apt. Devemos 
atualizar nosso índice de pacotes e, então, instalar através dos repositórios: 
 
sudo apt-get update 
sudo apt-get install nodejs 
 
[NODE.JS UMA NOVA ABORDAGEM DA 
LINGUAGEM JAVASCRIPT] 20 de março de 2016 
 
Grupo SoftwareOriginSP 
 Página 21 
 
 Se o pacote no repositório satisfaz suas necessidades, isto é tudo que você precisa fazer 
para ter o Node.js configurado. Em muitos casos, você vai querer também instalar o npm, que 
é o gerenciador de pacotes do Node.js. Você pode fazer isto digitando: 
 
sudo apt-get install npm 
 
 Isto o permitirá instalar facilmente módulos e pacotes para utilizar com o Node.js. 
Devido a um conflito com outro pacote, o executável dos repositórios do Ubuntu é chamado 
nodejs em vez de node. Tenha isso em mente quando estiver executando software. 
 
Abaixo, discutiremos alguns métodos mais flexíveis de instalação. 
Como Instalar Utilizando um PPA 
 
 Uma alternativa que pode lhe trazer a versão mais recente do Node.js é adicionar um PPA 
(arquivo de pacotes pessoais) mantido pelo NodeSource. Isto terá provavelmente versões mais 
atualizadas do Node.js do que os repositórios oficiais do Ubuntu. 
 Primeiro, você precisa instalar o PPA de modo a obter acesso ao seu conteúdo: 
 
curl -sL https://deb.nodesource.com/setup | sudo bash - 
 
 O PPA será adicionado à sua configuração e o seu cache local de pacotes será atualizado 
automaticamente. Depois de executar o script de configuração do nodesource, você pode 
instalar o pacote Node.js da mesma forma que você fez acima: 
 
sudo apt-get install nodejs 
 
 O pacote nodejs contém o binário nodejs bem como o npm, de forma que você não precisa 
instalar o npm separadamente. Contudo, para que alguns pacotes do npm funcionem (tais 
como aqueles que requerem compilação do fonte), você precisará 
instalar o pacote build-essentials: 
 
sudo apt-get install build-essential 
 
Como Instalar Utilizando o NVM 
 
 Uma alternativa para instalação do Node.js através do apt é usar uma ferramenta 
especialmente projetada, chamada nvm, que significa "Node.js version manager" ou 
"Gerenciador de Versão do Node.js". 
 Usando o nvm você pode instalar múltiplas versões, auto-contidas do Node.js que o 
permitirá controlar seu ambiente mais facilmente. Ele dará a você acesso sob demanda às mais 
novas versões do Node.js, mas também o permitirá apontar versões prévias que suas 
aplicações podem depender. 
 Para começar, precisaremos obter os pacotes de software do nosso repositório Ubuntu, que 
nos permitirão compilar pacotes de fontes. O script nvm aproveitará estas ferramentas para 
construir os componentes necessários: 
[NODE.JS UMA NOVA ABORDAGEM DA 
LINGUAGEM JAVASCRIPT] 20 de março de 2016 
 
Grupo SoftwareOriginSP 
 Página 22sudo apt-get update 
sudo apt-get install build-essential libssl-dev 
 
 Uma vez que os pacotes requeridos estejam instalados, você pode baixar o script de 
instalação do nvm da página do projeto GitHub. O número de versão pode ser diferente, mas 
em geral, você pode baixar e o instalar com a seguinte sintaxe: 
 
curl https://raw.githubusercontent.com/creationix/nvm/v0.16.1/install.sh | sh 
 
 Isto irá baixar o script e o executar. Ele irá instalar o software dentro de um subdiretório do 
seu diretório home em ~/.nvm. Ele irá adicionar também as linhas necessárias ao seu arquivo 
~/.profile para utilizar o arquivo. 
 Para obter acesso à funcionalidade do nvm, você precisará sair e se logar novamente, ou 
você pode varrer o arquivo ~/.profile de modo que sua sessão atual saiba sobre as alterações: 
 
source ~/.profile 
 
Agora que você tem o nvm instalado, você pode instalar versões isoladas do Node.js. 
 
nvm ls-remote 
 
. . . 
 v0.11.6 
 v0.11.7 
 v0.11.8 
 v0.11.9 
v0.11.10 
v0.11.11 
v0.11.12 
v0.11.13 
 
 Como você pode ver, a versão mais recente no momento da redação deste artigo é a 
v0.11.13. Você pode instalá-la digitando: 
 
nvm install 0.11.13 
 
 Usualmente, o nvm irá utilizar a versão mais recente instalada. Você pode dizer 
explicitamente ao nvm para utilizar a versão que acabamos de baixar digitando: 
 
nvm use 0.11.13 
 
 Quando você instala o Node.js utilizando o nvm, o executável é chamado node. Você pode 
ver a versão atualmente sendo utilizada pelo shell digitando: 
 
node -v 
 
[NODE.JS UMA NOVA ABORDAGEM DA 
LINGUAGEM JAVASCRIPT] 20 de março de 2016 
 
Grupo SoftwareOriginSP 
 Página 23 
 
v.0.11.13 
 
Se você tiver múltiplas versões do Node.js, você pode ver o que está instalado digitando: 
 
nvm ls 
 
Se desejar tornar padrão uma das versões, você pode digitar: 
 
nvm alias default 0.11.13 
 
 Esta versão será automaticamente selecionada quando uma nova sessão for iniciada. Você 
também pode referenciá-la pelo apelido desta maneira: 
 
nvm use default 
 
 Cada versão do Node.js irá manter o controle de seus próprios pacotes e tem npm 
disponível para gerenciá-los. 
 Você pode ter pacotes de instalação do npm para o diretório ./node_modules do projeto 
Node.js utilizando o formato normal: 
 
npm install Express 
 
 Se você deseja instalá-lo globalmente (disponível para outros projetos utilizando a mesma 
versão de Node.js), você pode adicionar o flag -g: 
 
npm install -g Express 
 
Isto instalará o pacote em: 
 
~/.nvm/node_version/lib/node_modules/package_name 
 
 Instalando globalmente permitirá a você executar comandos através da linha de comando, 
mas você terá que vincular o pacote em sua esfera local para exigi-lo de dentro de um 
programa: 
 
npm link Express 
 
Você pode aprender mais sobre as opções disponíveis com o nvm digitando: 
 
nvm help 
 
 
 
 
 
 
 
 
[NODE.JS UMA NOVA ABORDAGEM DA 
LINGUAGEM JAVASCRIPT] 20 de março de 2016 
 
Grupo SoftwareOriginSP 
 Página 24 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
3° Capítulo 
Primeiros passos com node.js 
 
O que é Node.js? 
 
 Node.js é uma plataforma para desenvolvimento de aplicações server-side baseadas em 
rede utilizando JavaScript e o V8 JavaScript Engine, ou seja, com Node.js podemos criar uma 
variedade de aplicações Web utilizando apenas código em JavaScript. 
Em uma primeira análise essa informação pode não parecer tão interessante, uma vez que 
existem diversas outras maneiras em que esses tipos de serviços podem ser implementados. 
Mas se pensarmos um pouco mais sobre as demandas de aplicações na internet e o modo em 
que o código em JavaScript pode ser estruturado, vamos nos deparar com uma gama de novas 
possibilidades para desenvolvimento Web, e provavelmente nos juntar à crescente 
comunidade que tem adotado essa plataforma. 
Embora Node.js tenha muito em comum com os servidores tradicionais como Apache e IIS, 
podemos entender melhor essa relação se considerarmos as diferenças. Node.js é 
extremamente simples, por isso pode não ser a solução ideal para todos os casos. Enquanto os 
servidores tradicionais são mais robustos e preparados para situações mais complexas, e isso 
invariavelmente vai consumir mais recursos das máquinas do que Node.js. 
 
[NODE.JS UMA NOVA ABORDAGEM DA 
LINGUAGEM JAVASCRIPT] 20 de março de 2016 
 
Grupo SoftwareOriginSP 
 Página 25 
 
O web server ‘Olá mundo!’ 
 
Ok, então vamos construir alguma coisa. 
 
 Nosso primeiro exemplo é um servidor que retorna a string ‘Olá mundo’ para qualquer 
requisição. Para fazer isso utilizando Node você vai precisar de criar um arquivo JavaScript que 
pode ser chamado olanode.js e de três minutos do seu tempo. 
Escreva o seguinte código no seu arquivo: 
 
1. var http = require('http'); 
2. http.createServer(function(req,res) { 
3. res.writeHead(200, { 'Content-Type': 'text/plain; charset=utf-8' }); 
4. res.end('Olá mundo!'); 
5. }).listen(3000); 
6. console.log('Servidor iniciado em localhost:3000. Ctrl+C para encerrar…'); 
Para executar o seu programa Node basta o seguinte comando no seu terminal: 
1. $ node olanode.js 
 Para testar seu servidor você pode acessar localhost:3000 no seu navegador ou utilizar linha 
de comando com o comando curl (em uma nova instância do terminal) como mostrado a 
seguir: 
1. $ curl http://0.0.0.0:3000/ 
2. > Olá mundo! 
 Caso você prefira retornar algum html válido para o navegador, basta alterar 'text/plain' 
para 'text/html' no código acima e utilizar uma tag html legal como <h2>, como foi feito a 
seguir: 
1. var http = require('http'); 
2. http.createServer(function(req,res) {
 
3. res.writeHead(200, { 'Content-Type': 'text/html; charset=utf-8' }); 
4. res.end('<h2> Olá mundo! </h2>'); 
5. }).listen(3000); 
6. console.log('Servidor iniciado em localhost:3000 . Ctrl+C para encerrar…’); 
Orientado a eventos e não obstrutivo 
Orientado a eventos 
 
 Vamos aproveitar este momento de euforia após a construção do seu primeiro servidor 
para aprender um pouco mais sobre Node.js. 
 Quando estamos desenvolvendo com Node.js devemos utilizar uma abordagem orientada a 
eventos, isso quer dizer que o desenvolvedor precisa conhecer os eventos que serão emitidos 
em diferentes momentos da execução e também saber como ouvi-los para executar as 
operações necessárias. 
[NODE.JS UMA NOVA ABORDAGEM DA 
LINGUAGEM JAVASCRIPT] 20 de março de 2016 
 
Grupo SoftwareOriginSP 
 Página 26 
 
 Um bom exemplo de orientação a eventos está na construção de interfaces de usuário. 
Muitas vezes utilizamos elementos como por exemplo os botões que ao serem clicados 
emitem um evento do tipo click ao qual podemos ouvir e executar alguma operação. 
 No nosso exemplo anterior utilizamos esse conceito quando chamamos método listen do 
objeto do tipo web server e passamos como parâmetro a porta 3000, com isso fizemos que a 
nossa aplicação ouvisse ao evento que é emitido sempre que alguém faz uma requisição no 
localhost:3000 e a nossa resposta foi servir a string ou a página html. Este evento é chamado 
request. 
 Para ilustrar estes conceitos, podemos escrever o nosso exemplo anterior em uma sintaxe 
alternativa da seguinte forma: 
1. var http = require('http'); 
2. var server = http.createServer(); 
3. server.on('request', function(req,res) {
 
4. res.writeHead(200, { 'Content- Type': 'text/html; charset=utf-8' }); 
5. res.end('<h2> Olá mundo! </h2>'); 
6. }); 
7. server.listen(3000); 
8. console.log('Servidor iniciado em localhost:3000. Ctrl+C para encerrar…’);Dessa forma podemos ver claramente a maneira em que o Node.js opera para servir a sua 
página. Utilizamos o método on do nosso objeto server para ouvir ao evento request e fazer as 
operações. E definimos que estamos servindo na porta 3000. 
Não obstrutivo 
 
 Todos os recursos presentes no Node.js e também a maioria das bibliotecas feitas para ele 
adotaram um padrão não obstrutivo de escrever código, isso quer dizer que em Node.js você 
geralmente vai conseguir estruturar seu código de uma maneira que operações que não 
dependem de nada que está sendo executado possam ser executadas de forma independente. 
 Para mostrar um pouco como isso funciona, vamos um programa que escreve duas frases 
no terminal, porém uma dessas frases precisa ser carregada da memória antes de ser 
impressa. 
1. var frase; 
2. carregaFrase = function (callback) { 
3. setTimeout(function() { 
4. //Simula leitura da frase no banco de dados. 
5. frase = "Minha frase obstrutiva"; 
6. callback(); 
7. }, 3000) 
8. } 
9. imprimeFrase = function () { 
10. console.log(frase); 
11. } 
12. carregaFrase(imprimeFrase); 
13. console.log(“Olá"); 
[NODE.JS UMA NOVA ABORDAGEM DA 
LINGUAGEM JAVASCRIPT] 20 de março de 2016 
 
Grupo SoftwareOriginSP 
 Página 27 
 
 
 Nesse exemplo foi criada uma função chamada carregaFrase cujo objetivo é ler uma 
determinada frase de uma fonte de dados, e uma outra função chamada imprimeFrase que 
imprime o valor de uma determinada variável no console. Como dependemos da leitura da 
frase na fonte de dados para imprimir o valor, passamos a função que imprime como 
parâmetro para a função de leitura para que possamos executar essa função quando a leitura 
for concluída. Esse tipo de função que é passada como parâmetro dessa maneira é chamada 
de callback. 
 Ao executar este exemplo com Node.js ou qualquer mecanismo JavaScript você vai 
perceber que a frase “Olá” será impressa antes da outra frase mesmo estando posicionada 
depois no código, isso se deve ao fato de sua execução não depender de nada enquanto a 
execução da outra frase depende de uma operação que leva 3 segundos. 
 Este é um exemplo extremamente simples de como criar um código não obstrutivo, 
portanto use sua imaginação para imaginar cenários em que isso pode ser útil. 
Observe que no nosso primeiro exemplo com Node.js tanto a função on quanto a função 
createServer podem receber uma função de callback. 
 
4° Capítulo 
Uma previa introdução sobre a plataforma node.js 
 
Já tenho o Node instalado, e agora o que fazer? 
 
 Uma vez instalado, agora você tem acesso a um novo comando chamado node. Você pode 
usar o comando node de duas formas diferentes. A primeira é sem argumentos. Isto irá abrir 
um shell interativo (REPL: read-eval-print-loop), onde você pode executar código JavaScript 
puro. 
 
$ node 
> console.log('Hello World'); 
Hello World 
undefined 
 
 No exemplo acima eu digitei console.log('Hello World') dentro do shell e apertei enter. O 
Node vai então executar o código e nós podemos ver nossa mensagem registrada. Ele também 
imprime undefined pelo fato de sempre mostrar o valor de retorno de cada comando, e 
console.log não retorna nada. 
[NODE.JS UMA NOVA ABORDAGEM DA 
LINGUAGEM JAVASCRIPT] 20 de março de 2016 
 
Grupo SoftwareOriginSP 
 Página 28 
 
 A outra forma de rodar o Node é fornecendo a ele um arquivo JavaScript para execução. 
Isto será na maioria das vezes a maneira como você irá utilizá-lo. 
 
hello.js 
console.log('Hello World'); 
$ node hello.js 
Hello World 
 
 Neste exemplo, eu movi o comando console.log() para dentro de um arquivo e então passei 
este arquivo para o comando node como um argumento. O Node então roda o JavaScript 
contido neste arquivo e imprime "Hello World". 
 
Fazendo Algo Útil 
 
 Rodar código JavaScript é divertido e tal, mas não é muito útil. Ai é onde o Node.js também 
inclui um poderoso conjunto de bibliotecas (módulos) para se fazer coisas reais. No primeiro 
exemplo eu vou abrir um arquivo de registros e analisá-lo. 
example-log.txt 
 
2013-08-09T13:50:33.166Z A 2 
2013-08-09T13:51:33.166Z B 1 
2013-08-09T13:52:33.166Z C 6 
2013-08-09T13:53:33.166Z B 8 
2013-08-09T13:54:33.166Z B 5 
 
 O que esses dados registrados significam não importa, mas basicamente cada mensagem 
contém uma data, uma letra e um valor. Eu quero somar os valores para cada letra. 
 
A primeira coisa que nós precisamos fazer é ler o conteúdo do arquivo. 
 
my-parser.js 
 
// Carregando o módulo fs (filesystem) 
var fs = require('fs'); 
 
// Leia o conteúdo do arquivo para a memória 
fs.readFile('example-log.txt', function ( err, logData ) { 
 
 // Se um erro ocorrer, será lançada uma 
 // exceção, e a aplicação irá ser encerrada 
 if ( err ) throw err; 
[NODE.JS UMA NOVA ABORDAGEM DA 
LINGUAGEM JAVASCRIPT] 20 de março de 2016 
 
Grupo SoftwareOriginSP 
 Página 29 
 
 
 // logData é um Buffer, converta-o para string 
 var text = logData.toString(); 
}); 
 
 Felizmente o Node.js faz a entrada e saída (I/O) do arquivo facilmente com o módulo 
embutido filesystem (fs). O módulo fs tem uma função chamada readFile que pega o caminho 
de um arquivo e um callback. O callback vai ser invocado quando o arquivo for lido por 
completo. O dado do arquivo vem na forma de um Buffer, que é basicamente um array de 
bytes. Nós podemos convertê-lo para uma string usando a função toString(). 
Agora vamos adicionar o parsing (analisador). 
 
my-parser.js 
// Carregando o módulo fs (filesystem) 
var fs = require('fs'); 
 
// Leia o conteúdo do arquivo para a memória 
fs.readFile('example-log.txt', function ( err, logData ) { 
 
 // Se um erro ocorrer, será lançada uma 
 // exceção, e a aplicação irá ser encerrada 
 if ( err ) throw err; 
 
 // logData é um Buffer, converta para string 
 var text = logData.toString(); 
 
 var results = {}; 
 
 // Quebrando o arquivo em linhas 
 var lines = text.split( '\n' ); 
 
lines.forEach(function ( line ) { 
 var parts = line.split( ' ' ); 
 var letter = parts[ 1 ]; 
 var count = parseInt( parts[ 2 ] ); 
 
 if ( !results[ letter ] ) { 
 results[ letter ] = 0; 
 } 
 
 results[ letter ] += parseInt( count ); 
 }); 
 
 console.log( results ); 
 // { A: 2, B: 14, C: 6 } 
}); 
[NODE.JS UMA NOVA ABORDAGEM DA 
LINGUAGEM JAVASCRIPT] 20 de março de 2016 
 
Grupo SoftwareOriginSP 
 Página 30 
 
 Agora vamos passar este arquivo como um argumento para o comando node e ele vai 
imprimir o resultado e sair. 
 
$ node my-parser.js 
{ A: 2, B: 14, C: 6 } 
 
 Eu uso muito o Node.js para scripts como este. É uma alternativa muito mais simples e 
poderosa que os scripts bash. 
Callbacks Assíncronos 
 Como você viu no exemplo anterior, o padrão típico do Node.js é o uso de callbacks 
assíncronos. Basicamente você está dizendo a ele para fazer algo e quando isso estiver 
terminado ele irá chamar sua função (callback). Isto porque o Node é de thread única. 
Enquanto você está esperando pelo disparo do callback, o Node pode fazer outras coisas ao 
invés de bloquear até que a requisição esteja terminada. 
 Isso é especialmente importante para servidores web. Isto é muito comum em aplicações 
web modernas para acessar banco de dados. Enquanto você espera pelo retorno do banco de 
dados, o Node pode processar mais requisições. Isso permite que você manipule milhares de 
conexões conjuntas com pequenos acréscimos, comparado a criar uma thread separada para 
cada conexão. 
 
Fazendo Algo Útil - Servidor HTTP 
 
 Comodisse anteriormente, o Node não faz nada por si só. Um dos módulos embutidos 
tornam a criação de servidores HTTP simples muito fácil, que é o exemplo na página inicial do 
Node.js. 
 
my-web-server.js 
 
var http = require('http'); 
 
http.createServer(function ( req, res ) { // req = requisição, res = resposta 
 
 res.writeHead( 200, { 'Content-Type': 'text/plain' } ); 
 res.end( 'Hello World\n' ); 
}).listen( 8080 ); 
 
console.log( 'Servidor rodando na porta 8080' ); 
 
 Quando eu digo básico, quero dizer básico mesmo. Este não é um servidor HTTP completo. 
Ele não pode servir qualquer arquivo HTML ou de imagem. De fato, não importa sua 
requisição, ela vai retornar 'Hello World'. No entanto, você pode rodar isto e verá em seu 
navegador no endereço http://localhost:8080 o texto "Hello World". 
[NODE.JS UMA NOVA ABORDAGEM DA 
LINGUAGEM JAVASCRIPT] 20 de março de 2016 
 
Grupo SoftwareOriginSP 
 Página 31 
 
 
$ node my-web-server.js 
 
 Você pode ter percebido uma coisa diferente agora. Sua aplicação node.js não fechou. Isto 
acontece pois você criou um servidor e sua aplicação node vai continuar rodando e 
respondendo as requisições até que você mesmo mate o processo. 
 Se você quiser ter um servidor web completo, você terá que fazer este trabalho. Você deve 
checar o que foi requisitado, ler os arquivos apropriados e enviar o conteúdo de volta. Pessoas 
já fizeram este trabalho duro para você. 
 
Fazendo Algo Útil – Express 
 
 Express é um framework que torna a criação de sites normais muito simples. A primeira 
coisa que você tem que fazer é instalá-lo. Juntamente com o comando node, você também 
tem acesso a um comando chamado npm. Esta ferramenta permite que você acesse uma 
enorme coleção de módulos criados pela comunidade, e um deles é o Express. 
 
$ cd /my/app/location 
$ npm install express 
 
 Quando você instala um módulo, ele vai ser colado em uma pasta chamada node_modules 
dentro do diretório da sua aplicação. Você pode agora requisitar (require) este módulo como 
um módulo embutido. Vamos criar um arquivo estático básico usando o Express. 
 
my-static-file-server.js 
 
var express = require('express'); 
 app = express(); 
 
app.use(express.static(__dirname + '/public')); 
 
app.listen(8080); 
$ node my-static-file-server.js 
 
 Agora você tem um servidor de arquivos estáticos bastante eficiente. Tudo que você colocar 
dentro da pasta /public poderá ser requisitado pelo seu navegador e será mostrado. HTML, 
imagens, enfim, tudo. Por exemplo, se você colocar uma imagem chamada my-image.png 
dentro da pasta public, você pode acessá-la usando seu navegador no endereço 
http://localhost:8080/my-image.png. Claro que o Express tem vários outros recursos, mas 
você pode olhá-los a medida que continua desenvolvendo. 
 
[NODE.JS UMA NOVA ABORDAGEM DA 
LINGUAGEM JAVASCRIPT] 20 de março de 2016 
 
Grupo SoftwareOriginSP 
 Página 32 
 
NPM 
 
 Nós usamos um pouco o NPM nas seções anteriores, mas eu quero enfatizar o quão 
importante esta ferramenta se faz no desenvolvimento para Node.js. Existem milhares de 
módulos disponíveis que resolvem quase todos os problemas típicos que você encontra. 
Lembre-se de checar o NPM antes de re-inventar a roda. Não é inédito para uma aplicação 
Node ter dezenas de dependências. 
 No exemplo anterior nós instalamos o Express manualmente. Se você tiver muitas 
dependências, essa não será uma forma muito interessante de instalá-las. É por isso que o 
NPM faz uso do arquivo package.json. 
 
package.json. 
 
{ 
 "name" : "MyStaticServer", 
 "version" : "0.0.1", 
 "dependencies" : { 
 "express" : "3.3.x" 
 } 
} 
 
 Um arquivo package.json contém um resumo da sua aplicação. Existem vários campos 
disponíveis, sendo este apenas o mínimo. A seção dependencies (dependências) descreve o 
nome e a versão dos módulos que você gostaria de instalar. Neste caso eu vou aceitar 
qualquer versão do Express 3.3. Você pode listar quantas dependências quiser nesta seção. 
 Agora, ao invés de instalar cada dependência em separado, nós podemos rodar um simples 
comando e instalar todas elas. 
 
$ npm install 
 
 Quando você roda este comando, o npm vai verificar na pasta atual pelo arquivo 
package.json. Se ele encontrar um, então irá instalar cada dependência listada. 
 
Organização do Código 
 
 Até agora só usamos um único arquivo, que não é muito sustentável. Na maioria das 
aplicações, seu código vai ser dividido em vários arquivos. Não existe nenhuma norma ou 
organização imposta dizendo para onde os arquivos vão. Isto não é Rails. Não há conceitos de 
views e controllers acontecendo aqui. Você pode fazer o que quiser. 
 Vamos refatorar o script de análise de registros (log parsing). Ele será muito mais testável e 
manutenível se nós separarmos a lógica de análise (parsing) dentro de um arquivo próprio. 
 
[NODE.JS UMA NOVA ABORDAGEM DA 
LINGUAGEM JAVASCRIPT] 20 de março de 2016 
 
Grupo SoftwareOriginSP 
 Página 33 
 
parser.js 
 
// Construtor Parser 
var Parser = function () { 
 
}; 
 
// Analisa o texto especificado 
Parser.prototype.parse = function ( text ) { 
 
 var results = {}; 
 
 // Quebra o arquivo em linhas 
 var lines = text.split('\n'); 
 
 lines.forEach(function ( line ) { 
 var parts = line.split( ' ' ); 
 var letter = parts[ 1 ]; 
 var count = parseInt( parts[2] ); 
 
 if ( !results[ letter ] ) { 
 results[ letter ] = 0; 
 } 
results[ letter ] += parseInt( count ); 
 }); 
 
 return results; 
}; 
 
// Exportando o construtor Parser neste módulo 
module.exports = Parser; 
 
 O que eu fiz foi criar um novo arquivo para conter a lógica da análise dos registros. Isto é 
apenas JavaScript puro e existe várias formas de se encapsular este código. Eu escolhi por 
definir um novo objeto JavaScript pois assim é mais fácil de se fazer testes unitários. 
 A parte importante para isso é a linha module.exports. Isso diz ao Node que você está 
exportando deste arquivo. Neste caso exportei um construtor, então os usuários podem criar 
instâncias do meu objeto Parser. Você pode exportar qualquer coisa que quiser. 
 
Agora vamos ver como importar este arquivo e fazer uso do novo objeto Parser. 
 
my-parser.js 
 
[NODE.JS UMA NOVA ABORDAGEM DA 
LINGUAGEM JAVASCRIPT] 20 de março de 2016 
 
Grupo SoftwareOriginSP 
 Página 34 
 
// Requisitando o arquivo parser.js 
var Parser = require('./parser'); 
 
// Carregandoo módulo fs (filesystem) 
var fs = require('fs'); 
 
// Lendo o conteúdo do arquivo para a memória 
fs.readFile('example-log.txt', function ( err, logData ) { 
 
 // Se um erro ocorrer, irá ser lançada 
 // a exceção e a app será encerrada 
 if ( err ) throw err; 
 
 // logData é um Buffer, converta-o para string 
 var text = logData.toString(); 
 
 // Criando uma instância do objeto Parser 
 var parser = new Parser(); 
 
 // Chame a função parse 
 console.log( parser.parse( text ) ); 
 // { A: 2, B: 14, C: 6 } 
}); 
 Arquivos são incluídos da mesma forma que os módulos, exceto que você inclui um 
caminho ao invés de um nome. A extensão .js é implícita, então você pode omití-la se quiser. 
 Tendo sido exportado um construtor, é isso que vai ser retornado da declaração require. Eu 
posso agora criar instâncias do meu objeto Parser e usá-las. 
 
 
 
 
 
 
 
 
 
 
 
 
[NODE.JS UMA NOVA ABORDAGEM DA 
LINGUAGEM JAVASCRIPT] 20 de março de 2016 
 
Grupo SoftwareOriginSP 
 Página 356° Capítulo 
Conceitos Básicos sobre Criação de uma Aplicação Cordova 
 Instale o Cordova em seu sistema local para encapsular uma aplicação HTML5 como 
aplicação móvel nativa com o NetBeans IDE. Você usará npm, o gerenciador de pacote NodeJS, 
para instalar e atualizar o Cordova. Confirme também se o Git está instalado em seu sistema 
local e configurado corretamente. O Cordova usa o Git para recuperar em um repositório 
qualquer arquivo de código-fonte Cordova quando você encapsula a aplicação como móvel 
nativa. 
A maioria das etapas a seguir deste exercício serão executadas na janela do terminal. 
1. Faça download e instale o Node.js, se não estiver instalado. 
Você pode fazer o download do instalador no site do Node.js. 
2. Abra uma janela de terminal. 
3. Execute o comando a seguir para confirmar se o Node.js está instalado. 
$ node -v 
Se o node.js estiver instalado, você verá uma versão impressa na janela do terminal. 
[NODE.JS UMA NOVA ABORDAGEM DA 
LINGUAGEM JAVASCRIPT] 20 de março de 2016 
 
Grupo SoftwareOriginSP 
 Página 36 
 
Observações. 
 Se estiver protegido por proxy, você precisará configurar o node.js para usar o proxy 
no acessar à rede. Execute os comandos a seguir para configurar o proxy, substituindo 
http://proxy:8080 pelo seu proxy. 
 $ sudo npm config set proxy http://proxy:8080 
$ sudo npm config set https-proxy http://proxy:8080 
Execute o seguinte comando para exibir as definições de configuração atuais. 
$ npm config list 
 Para obter informações adicionais sobre a configuração do node.js, consulte 
https://npmjs.org/doc/config.html. 
 Execute o comando a seguir para instalar o Cordova. 
$ npm install -g cordova 
Observações. 
 Confirme se a configuração do proxy está correta, caso veja uma mensagem de erro na 
janela do terminal quando executar o comando de instalação. 
 Você pode executar o seguinte comando que atualiza o Cordova para a versão mais 
recente. 
$ npm update -g cordova 
 Execute o seguinte comando para confirmar se o Cordova está instalado e exibir a 
versão. 
$ cordova --version 
Se o Cordova estiver instalado, você verá uma versão impressa na janela do terminal. 
 Faça o download e instale o sistema de controle de versão Git se não estiver instalado. 
Você pode fazer o download do instalador no site do Git. 
Observação. Adicione o Git à variável de ambiente Path. 
 Execute o comando a seguir para confirmar se o Git foi instalado. 
$ git --version 
[NODE.JS UMA NOVA ABORDAGEM DA 
LINGUAGEM JAVASCRIPT] 20 de março de 2016 
 
Grupo SoftwareOriginSP 
 Página 37 
 
1. Se o Git estiver instalado, você verá uma versão impressa na janela do terminal. 
Observações. 
 Se estiver protegido por proxy, você precisará configurar o Git para usar o proxy no 
acessar à rede. Execute os comandos a seguir para configurar o proxy, substituindo 
http://proxy:8080 pelo seu proxy. 
 $ git config --global http.proxy http://proxy:8080 
$ git config --global https.proxy http://proxy:8080 
Execute o seguinte comando para exibir as definições de configuração atuais. 
$ git config --list 
 Para obter informações adicionais sobre a configuração do Git, consulte as instruções 
de configuração em http://git-scm.com/book/en/Getting-Started-First-Time-Git-Setup. 
 Agora você tem todas as ferramentas de que precisa para desenvolver e encapsular uma 
aplicação móvel nativa no IDE. No próximo exercício, você usará o assistente de Novo Projeto 
para criar a aplicação. 
 
Criando uma Aplicação Cordova 
 
 Neste exercício, você usará o assistente de Novo Projeto no IDE para criar uma nova 
aplicação Cordova. Crie uma aplicação Cordova selecionando o modelo Hello World do 
Cordova como modelo de site no assistente de Novo Projeto. O Cordova é uma aplicação 
HTML5 com algumas bibliotecas e arquivos de configuração adicionais. Se você tiver uma 
aplicação HTML5 existente, poderá usar a janela Propriedades do Projeto no IDE para 
adicionar os códigos-fonte do Cordova e outros arquivos exigidos para encapsular a aplicação 
como Cordova. 
 Neste tutorial, você criará um projeto HTML5 bem básico que tem um arquivo index.html e 
alguns arquivos JavaScript e CSS. Você selecionará algumas bibliotecas jQuery JavaScript 
quando criar o projeto no assistente. 
1. Selecione Arquivo > Novo Projeto (Ctrl-Shift-N; ⌘-Shift-N no Mac) no menu 
principal para abrir o assistente Novo Projeto. 
[NODE.JS UMA NOVA ABORDAGEM DA 
LINGUAGEM JAVASCRIPT] 20 de março de 2016 
 
Grupo SoftwareOriginSP 
 Página 38 
 
2. Selecione a categoria HTML5 e, em seguida, selecione Aplicação Cordova. 
Clique em Próximo. 
 
3. Digite CordovaMapApp como Nome do Projeto e especifique o diretório no seu 
computador onde você quer salvar o projeto. Clique em Próximo. 
4. Na Etapa 3. Modelo de Site, confirme se Fazer Download do Modelo On-line 
está selecionado e se o modelo Cordova Hello World está selecionado na lista. 
Clique em Próximo. 
[NODE.JS UMA NOVA ABORDAGEM DA 
LINGUAGEM JAVASCRIPT] 20 de março de 2016 
 
Grupo SoftwareOriginSP 
 Página 39 
 
 
 
 
1. Observação: Você deve estar on-line para criar um projeto baseado em um dos 
modelos on-line da lista. 
2. Na Etapa 4. Arquivos JavaScript, selecione as bibliotecas JavaScript jquery e 
jquery-mobile no painel Disponível e clique no botão de seta para a direita ( > ) 
para mover as bibliotecas selecionadas para o painel Selecionado do 
assistente. Por default, as bibliotecas são criadas na pasta js/libraries do 
projeto. Para este tutorial, você utilizará as versões "minimizadas" das 
bibliotecas JavaScript. 
 Você pode usar o campo de texto no painel para filtrar a lista de bibliotecas 
JavaScript. Por exemplo, digite jq no campo para ajudá-lo a encontrar as 
bibliotecas jquery. Você pode usar Ctrl-clique nos nomes das bibliotecas para 
selecionar várias bibliotecas. 
[NODE.JS UMA NOVA ABORDAGEM DA 
LINGUAGEM JAVASCRIPT] 20 de março de 2016 
 
Grupo SoftwareOriginSP 
 Página 40 
 
 
1. Observações. 
 Você pode clicar no número de versão da biblioteca na coluna Versão para 
abrir uma janela pop-up que permite selecionar a ordem das versões de 
biblioteca. Por default, o assistente exibe a versão mais recente. 
 As versões minimizadas das bibliotecas JavaScript são versões compactadas e o 
código não é abrangente quando exibido em um editor. 
 Na Etapa 5. Suporte a Cordova, use os valores padrão. Clique em Finalizar 
para concluir o assistente. 
 Quando você clicar em Finalizar, o IDE criará o projeto e exibirá um nó para 
o projeto na janela Projetos,e abrirá o arquivo index.html no editor 
[NODE.JS UMA NOVA ABORDAGEM DA 
LINGUAGEM JAVASCRIPT] 20 de março de 2016 
 
Grupo SoftwareOriginSP 
 Página 41 
 
 
 Se você expandir a pasta js/libs na janela Projetos, poderá ver que as bibliotecas JavaScript 
que você especificou no assistente do Novo Projeto foram automaticamente adicionadas ao 
projeto. Você pode remover uma Biblioteca JavaScript de um projeto clicando com o botão 
direito do mouse no arquivo JavaScript e escolhendo Deletar no menu pop-up. 
Para adicionar uma biblioteca JavaScript a um projeto, clique com o botão 
direito do mouse no nó do projeto e escolha Propriedades para abrir a janela 
Propriedades do Projeto. Você pode adicionar bibliotecas no painel Bibliotecas 
JavaScript da janela Propriedades do Projeto. Como alternativa, é possível 
copiar um arquivo JavaScript que está no sistema local diretamente na pasta js. 
Agora você pode testara execução do projeto e ver se ele foi implantado no 
emulador do seu dispositivo móvel de destino. 
7. Clique no ícone de seleção do browser na barra de ferramentas e confirme se o seu 
emulador de dispositivo móvel de destino está selecionado na coluna Cordova da 
tabela. Na coluna Cordova, você pode selecionar o Emulador do Android ou do iOS 
(exige OS X e XCode). 
[NODE.JS UMA NOVA ABORDAGEM DA 
LINGUAGEM JAVASCRIPT] 20 de março de 2016 
 
Grupo SoftwareOriginSP 
 Página 42 
 
 
8. Clique no ícone Executar na barra de ferramentas. 
Quando você escolhe Executar, o IDE implanta a aplicação Cordova no emulador. 
 
Observação. Se você estiver implantando no Simulador do iOS, o simulador deverá ser aberto 
automaticamente. Se estiver implantando a aplicação em um emulador do Android, você 
precisará configurar e iniciar o emulador antes de executar a aplicação. Para ver um screencast 
que demonstre a implantação de uma aplicação Cordova no emulador do Android, assista ao 
Vídeo de Conceitos Básicos sobre Desenvolvimento Cordova. 
Modificando a Aplicação 
 Neste exercício, você editará os arquivos index.html e index.js. Você substituirá o código 
gerado pelo modelo Cordova Hello World pelo código de exibição de um mapa do local atual 
na aplicação. Além disso, modificará a configuração padrão do Cordova para remover os plug-
ins do Cordova que não são necessários na aplicação. 
 
Editando o Arquivo HTML 
 
 Neste exercício, edite o arquivo HTML no editor de código-fonte para adicionar referências 
a bibliotecas e arquivos CSS e para adicionar os elementos da página. 
[NODE.JS UMA NOVA ABORDAGEM DA 
LINGUAGEM JAVASCRIPT] 20 de março de 2016 
 
Grupo SoftwareOriginSP 
 Página 43 
 
1. Abra index.html no editor (se ainda não estiver aberto). 
No editor, você pode ver que o IDE gerou um código baseado no modelo Cordova 
Hello World. 
2. No editor, adicione referências a bibliotecas JavaScript e arquivos CSS do jQuery que 
foram adicionados quando você criou o projeto. Adicione o seguinte código (em 
negrito) entre as tags de abertura e fechamento <head>. 
3. <html> 
4. <head> 
5. <meta charset=UTF-8"> 
6. <meta name="format-detection" content="telephone=no" /> 
7. <meta name="viewport" content="user-scalable=no, initial-scale=1, maximum-
scale=1, minimum-scale=1, width=device-width, height=device-height, target-
densitydpi=device-dpi"> 
8. <link rel="stylesheet" type="text/css" href="css/index.css" /> 
9. 
10. <link rel="stylesheet" href="js/libs/jquery-mobile/jquery.mobile.min.css"/> 
11. <script type="text/javascript" src="js/libs/jquery/jquery.min.js"></script> 
12. <script type="text/javascript" src="js/libs/jquery-
mobile/jquery.mobile.min.js"></script> 
13. <title>Hello World</title> 
14. </head> 
15. <body> 
16. </html> 
 
 Adicione o link a seguir à API JavaScript do Google Maps entre as tags <head>. 
<script type="text/javascript" src="http://www.google.com/jsapi"></script> 
Observação. Este é um link para a v2 obsoleta da API JavaScript. Este JavaScript 
funcionará para fins de demonstração neste tutorial, mas você deve usar a 
versão mais nova em uma aplicação real. 
[NODE.JS UMA NOVA ABORDAGEM DA 
LINGUAGEM JAVASCRIPT] 20 de março de 2016 
 
Grupo SoftwareOriginSP 
 Página 44 
 
 Remova todo o código entre as tags <body>, exceto os seguintes links para 
os arquivos JavaScript index.js e cordova.js. 
 <body> 
 
 <script type="text/javascript" src="cordova.js"></script> 
 <script type="text/javascript" src="js/index.js"></script> 
 
 </body> 
 </html> 
 O arquivo index.js foi gerado automaticamente quando você criou o projeto. 
O arquivo pode ser visto sob o nó js na janela Projetos. Você modificará o 
código em index.js posteriormente no tutorial. 
 O cordova.js não é visto na janela Projetos porque é gerado na criação da 
aplicação Cordova. 
5. Adicione o seguinte código (em negrito) entre as tags body. 
6. <body> 
7. <div data-dom-cache="false" data-role="page" id="mylocation"> 
8. <div data-role="header" data-theme="b"> 
9. <h1 id="header">Searching for GPS</h1> 
10. <a data-role="button" class="ui-btn-right" 
onclick="showAbout()">About</a> 
11. </div> 
12. 
13. <div data-role="content" style="padding:0;"> 
14. <div id="map" style="width:100%;height:100%; z-index:50"> 
15. </div> 
16. 
17. </div> 
18. <div data-role="footer" data-theme="b" data-position="fixed" > 
19. <h4>Google Maps</h4> 
[NODE.JS UMA NOVA ABORDAGEM DA 
LINGUAGEM JAVASCRIPT] 20 de março de 2016 
 
Grupo SoftwareOriginSP 
 Página 45 
 
20. </div> 
21. </div> 
22. <div data-dom-cache="false" data-role="page" id="about"> 
23. <div data-role="header" data-theme="b"> 
24. <a data-role="button" data-rel="back" href="#mylocation" data-
icon="arrow-l" data-iconpos="left" class="ui-btn-left">Back</a> 
25. <h1>About</h1></div> 
26. <div data-role="content" id="aboutContent"> 
27. </div> 
28. <div data-role="footer" data-theme="b" data-position="fixed" > 
29. <h4>Created with NetBeans IDE</h4> 
30. </div> 
31. </div> 
32. <script type="text/javascript" src="cordova.js"></script> 
33. <script type="text/javascript" src="js/index.js"></script> 
34. </body> 
35. </html> 
Modificando a Configuração do Cordova 
Neste exercício, você modificará a lista de plug-ins do Cordova que são instalados na aplicação. 
1. Na janela Projetos, clique com o botão direito do mouse no nó do projeto e escolha 
Propriedades no menu pop-up. 
2. Selecione Cordova na lista de categorias. 
[NODE.JS UMA NOVA ABORDAGEM DA 
LINGUAGEM JAVASCRIPT] 20 de março de 2016 
 
Grupo SoftwareOriginSP 
 Página 46 
 
 
1. Use a guia Aplicação para exibir e editar os detalhes de configuração do 
Cordova sobre a aplicação que são especificados em config.xml. 
2. Clique na guia Plug-ins do painel Cordova. 
 A guia Plug-ins contém dois painéis. O painel Disponível exibe uma lista dos 
plug-ins do Cordova que estão disponíveis atualmente. 
 O painel Selecionado exibe uma lista dos plug-ins que são instalados na 
aplicação. Por padrão, todos os plug-ins são instalados quando você usa o 
modelo Cordova Hello World para criar a aplicação. A maioria das aplicações 
não exige todos os plug-ins. Você pode usar a guia Plug-ins na janela 
Propriedades do Projeto para remover os plug-ins que não são exigidos pela 
aplicação. 
Observação. É possível também editar os plug-ins instalados editando o 
arquivo nbproject/plugins.properties no editor. 
3. Remova todos os plug-ins exceto API do Dispositivo, Caixas de Diálogo 
(Notificações) e Localização Geográfica. Clique em OK. 
[NODE.JS UMA NOVA ABORDAGEM DA 
LINGUAGEM JAVASCRIPT] 20 de março de 2016 
 
Grupo SoftwareOriginSP 
 Página 47 
 
 
Editando o Arquivo JavaScript 
 Neste exercício, você removerá o código JavaScript gerado pelo modelo e adicionará alguns 
métodos simples para exibir o mapa da sua localização atual. 
1. Abra o index.js no editor. 
O IDE gerou um código padronizado em index.js quando você criou o projeto. Nessa 
aplicação, você pode removertodo o código gerado. 
2. Substitua o código gerado pelo seguinte código. Salve as alterações. 
3. var map; 
4. var marker; 
5. var watchID; 
6. 
7. $(document).ready(function() { 
8. document.addEventListener("deviceready", onDeviceReady, false); 
9. //uncomment for testing in Chrome browser 
10. // onDeviceReady(); 
[NODE.JS UMA NOVA ABORDAGEM DA 
LINGUAGEM JAVASCRIPT] 20 de março de 2016 
 
Grupo SoftwareOriginSP 
 Página 48 
 
11. }); 
12. 
13. function onDeviceReady() { 
14. $(window).unbind(); 
15. $(window).bind('pageshow resize orientationchange', function(e) { 
16. max_height(); 
17. }); 
18. max_height(); 
19. google.load("maps", "3.8", {"callback": map, other_params: 
"sensor=true&language=en"}); 
20. } 
21. function max_height() { 
22. var h = $('div[data-role="header"]').outerHeight(true); 
23. var f = $('div[data-role="footer"]').outerHeight(true); 
24. var w = $(window).height(); 
25. var c = $('div[data-role="content"]'); 
26. var c_h = c.height(); 
27. var c_oh = c.outerHeight(true); 
28. var c_new = w - h - f - c_oh + c_h; 
29. var total = h + f + c_oh; 
30. if (c_h < c.get(0).scrollHeight) { 
31. c.height(c.get(0).scrollHeight); 
32. } else { 
33. c.height(c_new); 
34. } 
35. } 
36. function map() { 
37. var latlng = new google.maps.LatLng(50.08, 14.42); 
38. var myOptions = { 
39. zoom: 15, 
[NODE.JS UMA NOVA ABORDAGEM DA 
LINGUAGEM JAVASCRIPT] 20 de março de 2016 
 
Grupo SoftwareOriginSP 
 Página 49 
 
40. center: latlng, 
41. streetViewControl: true, 
42. mapTypeId: google.maps.MapTypeId.ROADMAP, 
43. zoomControl: true 
44. }; 
45. map = new google.maps.Map(document.getElementById("map"), myOptions); 
46. 
47. google.maps.event.addListenerOnce(map, 'tilesloaded', function() { 
48. watchID = navigator.geolocation.watchPosition(gotPosition, null, {maximumAge: 
5000, timeout: 60000, enableHighAccuracy: true}); 
49. }); 
50. } 
51. 
52. // Method to open the About dialog 
53. function showAbout() { 
54. showAlert("Google Maps", "Created with NetBeans 7.4"); 
55. } 
56. ; 
57. 
58. function showAlert(message, title) { 
59. if (window.navigator.notification) { 
60. window.navigator.notification.alert(message, null, title, 'OK'); 
61. } else { 
62. alert(title ? (title + ": " + message) : message); 
63. } 
64. } 
65. 
66. function gotPosition(position) { 
67. map.setCenter(new google.maps.LatLng(position.coords.latitude, 
position.coords.longitude)); 
[NODE.JS UMA NOVA ABORDAGEM DA 
LINGUAGEM JAVASCRIPT] 20 de março de 2016 
 
Grupo SoftwareOriginSP 
 Página 50 
 
68. 
69. var point = new google.maps.LatLng(position.coords.latitude, 
position.coords.longitude); 
70. if (!marker) { 
71. //create marker 
72. marker = new google.maps.Marker({ 
73. position: point, 
74. map: map 
75. }); 
76. } else { 
77. //move marker to new position 
78. marker.setPosition(point); 
79. } 
80. } 
E depois de editado o código é só executar para ver o resultado. 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
[NODE.JS UMA NOVA ABORDAGEM DA 
LINGUAGEM JAVASCRIPT] 20 de março de 2016 
 
Grupo SoftwareOriginSP 
 Página 51 
 
 
 
 
 
 
 
 
 
 
7° Capítulo 
Conceitos finais 
 JavaScript tornou-se, nos últimos anos, o herói subestimado do desenvolvimento de 
aplicativos da web. Esse reconhecimento vem sendo encarado com surpresa por 
desenvolvedores de software acostumados a considerar JavaScript uma "linguagem de 
brinquedo". Embora haja linguagens mais populares (no sentido de que desenvolvedores 
clamam sua lealdade a elas), o status exclusivo de JavaScript como a linguagem de script 
padrão, independente de navegador, fez com que ela pudesse perdurar. Para desenvolvimento 
na web no lado do cliente, é provavelmente a linguagem mais usada no mundo. 
 JavaScript também tem lugar em scripts do lado do servidor, e esse nicho está crescendo. 
Embora tenha havido tentativas de JavaScript no lado do servidor no passado, nenhuma gerou 
tanta animação quanto Node.js, ou Node. 
 Projetado para auxiliar desenvolvedores a criar programas de rede escaláveis, Node é um 
ambiente de programação do lado do servidor que praticamente reinventou JavaScript para 
uma nova geração de desenvolvedores. Para muitos desenvolvedores Java, a principal atração 
do Node é sua abordagem nova para a simultaneidade de software. Embora a plataforma Java 
continue evoluindo em sua abordagem da simultaneidade (com melhorias muito esperadas 
em Java 7 e Java 8), o fato é que Node atende uma necessidade, e faz isso da forma mais leve 
que muitos desenvolvedores Java adotaram recentemente. Como os scripts do lado do cliente 
com JavaScript, os scripts do lado do servidor no ambiente Node são bons porque funcionam, 
e funcionam em uma área na qual muitos desenvolvedores Java enfrentam desafios 
atualmente. 
[NODE.JS UMA NOVA ABORDAGEM DA 
LINGUAGEM JAVASCRIPT] 20 de março de 2016 
 
Grupo SoftwareOriginSP 
 Página 52 
 
 Apresento a revolução dos scripts do lado do servidor que é o Node. Começaremos com 
uma visão geral arquitetural do que torna o Node especial, e em seguida eu mostrarei como 
desenvolver rapidamente um aplicativo da web escalável que usa MongoDB para persistência 
de dados. Você verá em primeira mão como o Node é divertido, e como ele pode ser usado 
rapidamente para montar um aplicativo da web funcional. 
 
A simultaneidade conduzida por evento de Node 
 
 Node é um ambiente de E/S escalável, conduzido por evento, desenvolvido com base no 
mecanismo JavaScript V8 do Google. Google V8 na verdade compila JavaScript em código de 
máquina nativo antes da execução, o que resulta em desempenho extremamente rápido no 
tempo de execução — algo que não é geralmente associado a JavaScript. Dessa forma, Node 
permite desenvolver rapidamente aplicativos de rede extremamente rápidos e altamente 
simultâneos. 
 E/S conduzida por evento pode soar estranho para um desenvolvedor Java, mas não é tão 
novo assim. Em vez do modelo de programação multiencadeado com o qual estamos 
acostumados na plataforma Java, a abordagem de Node para simultaneidade tem um único 
encadeamento, com a adição de um loop de eventos. Esse desenvolvimento do Node permite 
E/S sem bloqueio ou assíncrona. No Node, chamadas que geralmente bloqueariam, como 
espera por resultados de consulta de banco de dados, não bloqueiam. Em vez de esperar que 
atividades caras de E/S sejam concluídas, um aplicativo Node emite um retorno de chamada. 
Quando um recurso é retornado, o retorno de chamada anexado é chamado de forma 
assíncrona. 
 A simultaneidade simplesmente funciona em programas Node. Se eu quisesse executar o 
cenário anterior na plataforma Java, poderia escolher entre abordagens complexas e 
demoradas — de encadeamentos tradicionais a bibliotecas mais novas em Java NIO e até o 
pacote java.util.concurrent melhorado e atualizado. Embora a simultaneidade de Java seja 
eficiente, pode ser difícil de entender — o que se traduz em código! Em comparação, o 
mecanismo de retorno de chamada do Node está integrado na linguagem; não são necessários 
desenvolvimentos especiais como synchronized para fazê-la funcionar. O modelo