Indroducao NodeJS

Prévia do material em texto

Artigo Original: AN ABSOLUTE BEGINNER'S GUIDE TO NODE.JS•
Tradução: Eric Douglas•
Veja uma versão atualizada desse artigo aqui
Não existe uma escassez de tutoriais para Node.js, mas a maioria deles cobrem casos de uso específicos ou tópicos 
que são aplicáveis só se você já tiver um conhecimento prático do Node. Eu vejo vários comentários que se parecem 
com coisas do tipo: "Eu fiz o download do node, agora o que fazer?" Este tutorial responde esta questão e explica 
como iniciar bem do princípio.
O que é Node.js?
Muitos iniciantes em Node tem a dúvida de o quê exatamente ele é, e a descrição em nodejs.org definitivamente não 
ajuda.
Uma coisa importante de se perceber é que o Node não é um servidor web. Por ele próprio, não se tem nada. Ele 
não funciona como o Apache. Não existe um arquivo de configuração onde você o aponta para seus arquivos html. 
Se você quer que o Node seja um servidor HTTP, você tem que escrever um servidor HTTP (com a ajuda das 
bibliotecas incluídas). O Node.js é somente outra forma de executar código em seu computador. Ele é simplesmente 
um JavaScript runtime (ambiente de execução de código JavaScript).
Instalando o Node.js
Guia Para Absolutos Iniciantes em Node.js
terça-feira, 12 de julho de 2016 20:32
 Página 1 de Indroducao-NodeJS 
Node.js é muito simples de ser instalado. Se você estiver usando Windows ou Mac, os instaladores estão disponíveis 
napágina de download.
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.
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 debibliotecas (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;
// 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ódulofs 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().
 Página 2 de Indroducao-NodeJS 
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 }
});
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 é dethread ú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
Como disse anteriormente, o Node não faz nada por si só. Um dos módulos embutidos tornam a criação 
de servidores HTTPsimples 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 my-web-server.js
 Página 3 de Indroducao-NodeJS 
$ 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çãode 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çohttp://localhost:8080/my-image.png. Claro que o Express tem vários outros recursos, 
mas você pode olhá-los a medida que continua desenvolvendo.
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 
 Página 4 de Indroducao-NodeJS 
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.
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
// 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 }
 Página 5 de Indroducao-NodeJS 
 // { 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.
Resumo
Esperamos que este tutorial tenha feito a ponte entre a parte de fazer o download do Node.js e construir sua primeira 
ferramenta. O Node.js é uma tecnologia extremamenta poderosa e flexível que pode resolver uma vastidão de tipos 
de problemas.
Eu quero que cada um de vocês se lembre que o Node.js é somente limitado pela sua imaginação. As bibliotecas de seu núcleo foram 
cuidadosamente projetadas para fornecer as peças do quebra-cabeça necessárias para se construir qualquer fotografia. Combine-as com 
módulos disponíveis no NPM e será incrível o quão rápido você poderá começar a construir aplicações muito complexas e atraent es.
De <https://github.com/ericdouglas/traduz-ai/blob/master/nodejs/001-guia-para-iniciantes-absolutos-em-nodejs.md> 
 Página 6 de Indroducao-NodeJS 
Artigo Original: THE DEAD-SIMPLE STEP-BY-STEP GUIDE FOR FRONT-END DEVELOPERS TO GETTING 
UP AND RUNNING WITH NODE.JS, EXPRESS, JADE, AND MONGODB
•
Tradução: Eric Douglas•
Configure uma Aplicação Full Stack JavaScript e a tenha funcionando em 30 minutos. Faça-
a conversar com seu banco de dados em outros 30.
Você pode encontrar/forkar este tutorial e todo o projeto de exemplo no Github.
Introdução
Existem aproximadamente cem milhões de tutorials na web para obter um "Hello World!" com Node.js. Isto é ótimo! 
Isto é especialmente bom se seu objetivo é comprimentar o mundo e depois abandonar sua carreira na web e 
passar o resto da sua vida como um jóquei, ou qualquer outra coisa. Isto realmente não descreve muitos de nós, 
então vamos olhar por mais tutoriais.
Em minha experiência, o "próximo nível" de tutoriais que achamos estão 30 níveis acima destes. Vamos de um 
"Hello World" para uma construção de um sistema inteiro de blog com comentários. Isto também é ótimo, mas 
muitas vezes estes tutoriais assumem que o leitor tem um sólido conhecimento básico, e então eles soltam um 
monte de funções sobre você de uma só vez. Eu aprendo melhor fazendo um monte de etapas intermediárias, 
menores, e não acho que sou o único.
Eu não sou o único, certo?
Bom, boa notícia a todos! Eu li e fiz muitos tutoriais, até que as coisas finalmente funcionaram. Tenho um projeto 
web rodando que usa Node.js, o framework Express, o pré-processador de HTML chamado Jade e o MongoDB 
para os dados. Sou capaz de ler e escrever a partid do banco de dados. A partir disso, o céu é o limite.
Aqui está o acordo: Vou mostrar à você como pegar todas essas coisas e configurá-las. Vouassumir que você é 
um desenvolvedor front-end que conhece o suficiente de HTML5/CSS3/JavaScript para que eu não tenha que 
explicá-los.
Seu aplicativo vai ficar bonito, vai se conectar com um DB (banco de dados), ele vai obter alguns resultados, e vai 
fazer coisas com estes resultados. E por diversão também vamos fazê-lo salvar dados no DB. Através de tudo isso, 
eu irei explicar o que o código faz, e como escrevê-lo, ao invés de somente fornecer a você funções massantes 
para olhar. Vamos partir de nada instalado, para uma aplicação que manipula banco de dados em uma linguagem 
que você compreende totalmente, e a fundação necessária para construir funcionalidades adicionais para sua app. 
E vamos fazer isso aproximadamente em 60 minutos entre instalação e codificação. Isso é impressionante? Sugiro 
que sim.
Vamos lá!
PARTE 1 - 15 MINUTOS DE INSTALAÇÃO
Se você está realmente começando do zero, então ter tudo rodando leva um pouco de tempo. Nada disso é difícil. 
Eu rodo o Windows 8 na minha máquina, então isso pode ser um pouco diferente no Mac, Ubuntu ou qualquer outro 
sistema *nix, mas é basicamente a mesma coisa em todos os casos.
PASSO 1 - INSTALANDO NODE.JS
Isso é realmente fácil. Vá para o site do Node.js e clique no grande botão verde Install. Ele irá detectar seu sistema 
Simples Guia Passo-a-Passo Para Desenvolvedores Front-
End Iniciarem Com Node.js, Express, Jade e MongoDB
terça-feira, 12 de julho de 2016 20:31
 Página 7 de Indroducao-NodeJS 
Abra o prompt de comando•
cd até o diretório em que você deseja manter suas aplicações de teste•
Isso é realmente fácil. Vá para o site do Node.js e clique no grande botão verde Install. Ele irá detectar seu sistema 
operacional (SO) e dar a você o instalador apropriado (se por algum motivo isso não ocorrer, clique no botão de 
download e pegue o que você precisa). Rode o instalador. É isso, você instalou o Node.js e o, igualmente 
importante, NPM - Node Package Manager - que permite que você adicione todo tipo de complemento ao Node de 
forma rápida e fácil.
PASSO 2 - INSTALANDO O EXPRESS
Agora que temos o Node rodando, nós precisamos do resto das coisas para criar, realmente, um website que 
funcione. Para fazer isso, vamos instalar o Express, que é um framework que pega o Node a partir de uma 
aplicação simples e o transforma em algo que se comporta mais como um servidor web que todos nós usamos (e 
talvez um pouco mais que isso). Nós precisamos iniciar com o Express, pois iremos utilizar 
seu scaffolding (estrutura) para obter todo o resto que queremos (mais sobre isso em um instante). Então, digite 
isso:
$ npm install -g express
Isso instala algumas funcionalidades do núcleo do Express junto com a instalação do Node, tornando -o disponível 
globalmente, então podemos usá-lo em qualquer lugar que quisermos. Você vai ver um monte de texto em seu 
prompt de comando, vários http 304 e GETs. Tudo bem. O Express está agora instalado e disponível.
PASSO 3 - CRIANDO UM PROJETO EXPRESS
Vamos usar Express e Jade, mas não o pré-processador CSS Stylus (que as pessoas geralmente usam nesta 
configuração). Temos que usar o Jade ou outro motor de templates para ter acesso aos dados baseados em 
Node/Express. Jade não é difícil de se aprender se você já conhece HTML. Apenas lembre-se que você realmente 
tem que ter atenção a indentação, ou coisas vão sair muito erradas.
De qualquer forma, continue no seu diretório onde está armazenando sua aplicação node e digite isso:
$ express --sessions nodetest1
Aperte enter e veja o que acontece. Irá aparecer algo como isso:
eo_op:~/estudos/nodejs $ express --sessions nodetest1
create : nodetest1
create : nodetest1/package.json
create : nodetest1/app.js
create : nodetest1/routes
create : nodetest1/routes/index.js
create : nodetest1/routes/user.js
create : nodetest1/views
create : nodetest1/views/layout.jade
create : nodetest1/views/index.jade
create : nodetest1/public/images
create : nodetest1/public/javascripts
create : nodetest1/public
create : nodetest1/public/stylesheets
create : nodetest1/public/stylesheets/style.css
install dependencies:
$ cd nodetest1 && npm install
run the app:
$ node app
PASSO 4 - EDITANDO AS DEPENDÊNCIAS
Tudo bem, agora que temos uma estrutura básica, mas ainda não terminamos. Você vai notar que a rotina de 
instalação do Express criou um arquivo chamado package.json em seu diretório nodetest1. Abra este arquivo, ele 
vai parecer com isso:
{
 "name": "application-name",
 "version": "0.0.1",
 "private": true,
 Página 8 de Indroducao-NodeJS 
 "private": true,
 "scripts": {
 "start": "node app.js"
 },
 "dependencies": {
 "express": "3.4.8",
 "jade": "*"
 }
}
Este é um arquivo básico JSON que descreve seu aplicativo e suas dependências. Nós precisamos adicionar 
algumas coisas a ele. Especificamente, o MongoDB e Monk. Vamos fazer nosso objeto dependencies se parecer 
com isso:
"dependencies": {
 "express": "3.4.4",
 "jade": "*",
 "mongodb": "*",
 "monk": "*"
}
PASSO 5 - INSTALAR AS DEPENDÊNCIAS
Agora definimos nossas dependências e estamos prontos para começar. Note que o astericos diz ao NPM "pegue a 
última versão" quando você roda a instalação, que estamos prestes a fazer.
Volte para seu prompt de comando, cd para o diretório nodetest1 e digite isso:
$ npm install
Será impresso uma tonelada de coisas. Isto por causa que está sendo lido nosso arquivo JSON que acabamos de 
editar e a instalação de todas as coisas listadas no objeto dependencies (sim, incluindo o Express - nós instalamos 
o material de alto nível usando a flag -g, mas ainda temos que instalar algum código que será necessário para este 
projeto em particular). Uma vez que o NPM percorreu seu caminho, você terá um diretório node_modules que contém 
todas as suas dependências para este tutorial.
Agora você tem uma aplicação em pleno funcionamento e esperando para ser rodada. Vamos testá -la! Vá para o 
diretório nodetest1 e digite:
$ node app.js
Aperte enter. Você vai obter isso:
Express server listening on port 3000
Incrível! Abra seu navegador e digite http://locahost:3000. Agora você verá a página de boas vindas do Express.
Você tem agora seu próprio servidor web com Node.js, com a engine Express e o pré-processador Jade instalados. 
Não é tão difícil, né?
PARTE 2 - OK. LEGAL. VAMOS FAZER O "HELLO WORLD!"
Abra seu editor de texto ou IDE favorita. Eu gosto muito do Sublime Text. Vá para o diretório nodetest1 e abra o 
arquivoapp.js. Esse é como o coração da sua app. Não há muitas surpresas lá. Aqui temos uma parte do que você 
irá ver lá:
var express = require('express');
 Página 9 de Indroducao-NodeJS 
var express = require('express');
var routes = require('./routes');
var user = require('./routes/user');
var http = require('http');
var path = require('path');
Isso cria muitas variáveis básicas do JavaScript e as liga a certos pacotes, dependências, funcionalidades do Node 
e rotas. Rotas são como uma espécie de combinação de modelos e controladores nesta configuração - elas 
direcionam o tráfico e também contém alguma lógica de programação (você pode estabelecer uma arquitetura MVC 
mais tradicional com o Express se você quiser. Isso está fora do escopo deste artigo). Voltando ao momento onde 
nós configuramos este projeto, o Express criou todas essas coisas para nós. Vamos ignorar totalmente a 
rota user por agora e trabalhar somente na rota de nível superior (controlado por nodetest1/routes/index.js).
nodetest1/app.js
var app = express();
Isto é importante, pois configura o Express e atribui nossa variável app a ele. A próxima seção usa esta variável 
para configurar um monte de coisas do Express.
nodetest1/app.js
// todos ambientes
app.set('port', process.env.PORT || 3000 );
app.set( 'views', path.join( __dirname, 'views' ) );
app.set( 'view engine', 'jade' );
app.use( express.favicon() );
app.use( express.logger( 'dev' ) );
app.use( express.bodyParser() );
app.use( express.methodOverride() );
app.use( app.router );
app.use( express.static( path.join( __dirname, 'public' ) ) );
Isso configura a porta, que diz ao app onde encotrar as views, que engine usar para renderisar estas views (Jade), 
e chama alguns métodos para deixar as coisas funcionando. Note também que a linha final está dizendo ao 
Express para servir objetos estáticos no diretório public. Por exemplo, as imagens no 
diretório ../nodetest1/public/images. Mas elas são acessadas pela url http://localhost:3000/images.
NOTA: Você vai precisar mudar esta linha:
app.js
app.use( express.bodyParser() );
para:
app.use( express.urlencoded() );
Em razão de evitar alguns avisos em seu console Node quando você rodar a aplicação. Isto é devido a algumas 
mudanças futuras do Express e seus plugins. Se você não fizer esta mudança, sua aplicação vai continuar rodando, 
mas você irá ver texto sobre futuras desaprovações (deprecations) toda vez que você rodar isso.
app.js
// development only
if ( 'development' == app.get( 'env' ) ) {
 app.use( express.errorHandler() );
}
Isso permite que você faça alguma checagem de erro durante o desenvolvimento. É importante, mas pela proposta 
deste tutorial não vamos fazer nada com isso.
app.js
app.get( '/', routes.index );
app.get( '/users', user.list );
Isso diz a app quais rotas usar quando uma URI particular é solicitada. Note que a variável "user" está declarada 
acima, e é mapeada para /routes/user.js - nós vamos chamar a função de lista definida neste arquivo. Ou 
estaríamos se estivéssemos acessando a página de usuários, mas estamos ignorando-a, lembra?
 Página 10 de Indroducao-NodeJS 
estaríamos se estivéssemos acessando a página de usuários, mas estamos ignorando-a, lembra?
app.js
http.createServer( app ).listen( app.get( 'port' ), function () {
 console.log( 'Express server listening on port ' + app.get( 'port' ) );
} );
Por último, mas não menos importante, isso cria nosso servidor http e o lança. Bons tempos!
Agora então, vamos fazer algumas coisas. Não vamos fazer apenas um "Hello, World!" na nossa página index. Ao 
invés disso, vamos usar essa oportunidade para aprender um pouco mais sobre rotas e ver como o Jade trabalha 
para colocar as páginas em conjunto. Primeiro, vamos adicionar uma linha para manipular uma nova URI. Em baixo 
da seção app.get() no arquivo app.js, adicione esta linha:
app.get( '/helloworld', routes.helloworld );
Aperte ctrl c para encerrar o app.js em sua linha de comando, e então reinicie o processo e vá 
atéhttp://localhost:3000/helloworld. Você deve obter um interessante erro do node e uma quebra na linha de 
comando. Isto porque nós não modificamos nossa rota para manipular esta requisição. Vamos fazer isso! Em seu 
editor de texto, abra sua pasta routes, encontre index.js e abra-o. Ele vai se parecer com isso:
index.js
/*
* GET home page.
*/
exports.index = function( req, res ){
 res.render( 'index', { title: 'Express' });
};
Muito escasso, certo? Vamos adicionar uma nova página. Minha abordagem preferida é adicionar um novo arquivo 
de rota para o diretório de nível superior, mas nós não criamos um diretório helloworld completo nas views, então 
vamos apenas usar a rota index. No fim do arquivo, adicione este código:
exports.helloworld = function ( req, res ) {
 res.render( 'helloworld', { title: 'Hello, World!' } );
};
Isso é tudo que temos que fazer para rotear esta URI, mas nós não temos nenhuma página para 
o res.render renderizar. É ai que o Jade entra. Abra sua pasta views, e então abra o arquivo index.jade. Antes de 
fazer qualquer coisa, salve este arquivo como helloworld.jade.
Agora dê uma olhada no código:
helloworld.jade
extends layout
block content
 h1= title
 p Welcome to #{title}
Isso é muito simples. Ele usa o extends e faz o arquivo layoud.jade como um template, e então dentro do 
bloco contentdefinido no arquivo layout, ele altera o header e o p (parágrafo). Note o uso da variável title que 
configuramos acima, em nossa rota index.js. Isso significa que não temos que mudar sempre o texto para mostrar 
coisas diferentes na página home. Mas vamos mudar um pouco de qualquer forma para:
p Hello, World! Welcome to #{title}
Salve o arquivo, vá para o terminal e encerre sua aplicação ctrl c. Agora digite:
node app.js
É importante mencionar: mudanças nos templates Jade não necessitam do reinício do servidor, mas basicamente 
toda vez que você mudar um arquivo .js, como app.js ou um arquivo de rota, você vai precisar reiniciar para ver as 
mudanças.
Agora, com o servidor reiniciado, navegue até http://localhost:3000/helloworld e divirta-se com o texto 
 Página 11 de Indroducao-NodeJS 
Agora, com o servidor reiniciado, navegue até http://localhost:3000/helloworld e divirta-se com o texto 
completamente estúpido mostrado:
Ok! Agora temos nossa rota nos levando para nossa view. Vamos fazer alguma modelagem. Eu vou dar um 
momento para você, caso precise reparar seu cabelo ou maquiagem.
Nota do tradutor: (Y) AUSHDUHASUDHUASHDUAHSUDHAUSHDUHASUDHUASHD
PARTE 3 - CRIANDO NOSSO DB E LENDO ALGO DELE
PASSO 1 - INSTALAR MONGODB
Vamos deixar um pouco nosso editor de texto e ir para nosso terminal. Bem, primeiro vamos para nosso browser, 
no endereço http://mongodb.org/ e fazer o download do Mongo. Click no link de downloads no menu principal e 
pegue a versão de produção que se encaixa com seu sistema. Para o Windows 8 com um processador 64 -bit, nós 
vamos usar o "64-bit *2008R2+". Isso irá lhe fornecer um arquivo .zip, que você deve descompactar para um 
diretório temporário. Então você pode criar um diretório no qual o Mongo vai permanecer pra sempre depois de 
armazenar o Mongo. Você pode usarc:\mongo ou c:\program files\mongo ou qualquer outra coisa louca que você 
quiser. Isso não importa na verdade - O Mongo é bem pequeno, e vamos armazenar nosso banco de dados no 
nosso diretório nodetest1.
De qualquer forma, copie os arquivos da pasta bin dentro do seu diretório temporário para onde você quer que o 
Mongo fique, e você está pronto. Você instalou o Mongo. Agora vamos fazer isso funcionar.
PASSO 2 - RODANDO MONGOD e MONGO
No seu diretório nodetest1, cria um subdiretório chamado data. Então navegue até o diretório em que você colocou 
seus arquivos do MongoDB. Deste diretório, digite o seguinte:
mongod --dbpath c:\node\nodetest1\data
Você vai ver que o servidor Mongo inicia. Pode demorar um pouco se for a primeira vez, porque ele tem que fazer 
algumas pre-alocações de espaço e algumas tarefas de limpeza. Uma vez que isso disser "[initandlisten] waiting for 
connections on port 27017", tudo está feito. Não há nada mais para se fazer; o servidor está rodando. Agora você 
pode abrir um segundo terminal. Navegue novamente até o diretório de instalação do Mongo, e digite:
mongo
Você vai ver algo assim:
c:\mongo>mongo
MongoDB shell version: 2.4.5
connecting to: test
Adicionalmente, se você está prestando atenção em sua instância mongod, você vai ver que ele menciona que a 
conexão foi estabilizada. Tudo certo, você tem o MongoDB funcionando, e conectou a ele com o client. Nós vamos 
usar o client manualmente para trabalhar no nosso banco de dados, mas não é necessário para rodar o website. 
Somente o mongod é necessário para isso.
PASSO 3 - CRIANDO UM BANCO DE DADOS
Não se preocupe com "connecting to: test"... este é apenas o db padrão decidido pelo MongoDB para ser usado se 
 Página 12 de Indroducao-NodeJS 
Não se preocupe com "connecting to: test"...este é apenas o db padrão decidido pelo MongoDB para ser usado se 
você não especificar um na linha de comando, o qual não fizemos porque não é importante por agora. Na verdade, 
ele nem mesmo cria o db "test", a menos que você adicione um registro. Seria totalmente correto trabalhar neste db 
por agora, mas vamos criar um próprio nós mesmos. No seu console Mongo, digite o seguinte:
use nodetest1
Agora estamos usando o db nodetest1. Igualmente ao test, nada existe ainda. Para criar o db, temos que adicionar 
algum dado. Vamos começar fazendo isso diretamente pelo Mongo Client.
PASSO 4 - ADICIONANDO ALGUNS DADOS
O que mais gosto sobre o MongoDB é que ele usa JSON em sua estrutura, que significa que isso foi 
instantâneamente familiar para mim. Se você não está acostumando com JSON, você terá que fazer alguma leitura, 
pois isso está fora do escopo deste tutorial.
Vamos adicionar um registro para nossa coleção. Para a proposta deste tutorial, vamos apenas ter um simples db 
com nomes de usuários e endereços de e-mail. O formato de nossos dados vão ser dessa forma:
{
 "_id" : 1234,
 "username" : "cwbuecheler",
 "email" : "cwbuecheler@nospam.com"
}
Você pode criar sua própria atribuição _id se você realmente quiser, mas eu acho melhor deixar para o Mongo fazer 
estas coisas. Isso vai fornecer um identificador único para cada simples entrada do nível superior da sua coleção. 
Vamos adicionar uma e ver como isso funciona. No seu Mongo client, digite isso:
db.usercollection.insert({ "username" : "testuser1", "email" : "testuser1@tesdomain.com" })
Algo importante de se notar aqui: este db significa nosso banco de dados, que como mencionado acima, nós 
definimos como nodetest1. A parte usercollection é nossa coleção. Note que não existe um passo onde nós 
criamos a coleção "usercollection". Isso porque a primeira vez que adicionamos isso, ele já irá se auto -criar. Prático. 
Ok, aperte enter. Assumingo que tudo ocorreu corretamente, você deve ver... nada. Isso não é muito animador, 
então digite isso:
db.usercollection.find().pretty()
No caso de você estar curioso, o método .pretty() nos fornece quebra de linha. Isso vai retornar:
{
 "_id" : ObjectId("5202b481d2184d390cbf6eca"),
 "username" : "testuser1",
 "email" : "testuser1@testdomain.com"
}
Exceto, claro, que seu ObjectID vai ser diferene deste mencionado, pois o Mongo vai gerará -lo automaticamente. 
Isto é tudo que temos que escrever para o MongoDB a partir do client app, e se você já trabalhou com serviços 
JSON antes, você provavelmente estará pensando "ó, wow, isso será fácil de implementar na web." ... você está 
certo!
Uma nota rápida sobre a estrutura do DB: obviamente ao longo da jornada você não vai armazenar nada em nível 
alto. Existem toneladas de recursos na internet para o projetos de esquema para o MongoDB. Google é seu amigo!
Agora que temos um registro, vamos adicionar um pouco mais. Em seu console Mongo, digite o seguinte:
newstuff = [{ "username" : "testuser2", "email" : "testuser2@testdomain.com" }, { "username" : "testuser3", 
"email" : "testuser3@testdomain.com" }]
db.usercollection.insert(newstuff);
Note que, sim, nós passamos um array com múltiplos objetos para nossa coleção. Prático! Outro uso 
dedb.usercollection.find().pretty() vai mostrar todos os três registros:
{
 "_id" : ObjectId("5202b481d2184d390cbf6eca"),
 "username" : "testuser1",
 Página 13 de Indroducao-NodeJS 
 "username" : "testuser1",
 "email" : "testuser1@testdomain.com"
}
{
 "_id" : ObjectId("5202b49ad2184d390cbf6ecb"),
 "username" : "testuser2",
 "email" : "testuser2@testdomain.com"
}
{
 "_id" : ObjectId("5202b49ad2184d390cbf6ecc"),
 "username" : "testuser3",
 "email" : "testuser3@testdomain.com"
}
Agora, vamos começar realmente a interagir com o servidor web e o site que configuramos anteiormente.
PASSO 5 - LIGANDO O MONGO COM O NODE
Aqui é onde a borracha encontra o asfalto. Vamos começar a criar uma página que apenas mostra nossas entradas 
no DB de forma bem ligeira. Aqui o HTML que vamos gerar:
<ul>
 <li><a href="mailto:testuser1@testdomain.com">testuser1</a></li>
 <li><a href="mailto:testuser2@testdomain.com">testuser2</a></li>
 <li><a href="mailto:testuser3@testdomain.com">testuser3</a></li>
</ul>
Eu sei que isso não é ciência astronáutica, mas esta é a questão. Vamos fazer apenas um simples ler -e-escrever 
do DB neste tutorial, não tentar fazer um website inteiro. Primeiramentem precisamos adicionar algumas linhas no 
nosso arquivo principalapp.js - o coração e a alma da nossa app - em favor de realmente nos conectar-mos a 
instância MongoDB. Abra o arquivoapp.js e no topo dele você vai ver:
var express = require('express');
var routes = require('./routes');
var user = require('./routes/user');
var http = require('http');
var path = require('path');
Agora adicione estas 3 linhas:
var express = require('express');
var routes = require('./routes');
var user = require('./routes/user');
var http = require('http');
var path = require('path');
// Novo código
var mongo = require('mongodb');
var monk = require('monk');
var db = monk('localhost:27017/nodetest1');
Estas linhas dizem que nossa app vai conversar com o MongoDB, e vamos usar o Monk para fazer isso, e nosso 
banco de dados está localizado em localhost:27017/nodetest1. Note que 27017 é a porta que sua instância 
MongoDB deve estar rodando. Se por algum motivo você a mudou, obviamente use esta porta então. Agora olhe 
para a parte de baixo do arquivo, onde você tem isso:
app.get('/', routes.index);
app.get('/users', user.list);
app.get('/helloworld', routes.helloworld);
Adicione a seguinte linha no final:
app.get('/userlist', routes.userlist(db));
Esta linha diz que quando o usuário navegar para /userlist, nós vamos passar a variável "db" (nosso objeto do 
banco de dados) para a rota userlist. Mas nós NÃO temos uma rota userlist ainda, então vamos criar uma.
PASSO 6 - PUXANDO DADOS DO MONGO E MOSTRANDO-OS
Abra o arquivo nodetest1/routes/index.js em seu editor. Ele tem a rota index, e a rota /helloworld. Vamos adicionar 
uma terceira:
exports.userlist = function(db) {
 return function(req, res) {
 Página 14 de Indroducao-NodeJS 
 return function(req, res) {
 var collection = db.get('usercollection');
 collection.find({},{},function(e, docs){
 res.render('userlist', {
 "userlist" : docs
 });
 });
 };
};
Ok... Isso está ficando bem complicado. Tudo que isso está realmente fazendo, porém, é rodar uma função que 
envolve para passarmos nossa variável db, e então fazer a página renderizar como os outros dois "exports" neste 
arquivo de rota. Nós então dizemos em cada coleção que queremos usar ('usercollection') e fazer um find, então 
retornando o resultado como a variável docs. Uma vez que temos estes documentos, nós então vamos renderizar 
uma userlist (que vai precisar de um template Jade correspondente), dando isso a esta userlist para que ela possa 
trabalhar, e passando nosso documento do db como variável.
Vamos agora configurar nosso template Jade. Navegue até nodetest1/views e abra index.jade. Após isso, salve 
imediatamente este arquivo como userlist.jade. Então edite o HTML para se parecer com isso:
extends layout
block content
 h1.
 User List
ul
 each user, i in userlist
 li
 a(href='mailto:#{user.email}')= user.username
Isto está dizendo que vamos receber um conjunto de documentos chamado de userlist do nosso arquivo roteador, e 
então para entrada (nomeado 'user' durante o loop), vamos pegar o valor 'email' e 'username' do objeto e colocar 
em nosso html. Nós também temos a contagem - i - útil,mas neste caso nós não precisamos dela.
Tudo está configurado. Salve o arquivo, e vamos reiniciar nosso servidor node. Se lembra de como fazer isso? Vá 
para o terminal e aperte ctrl c para encerrar o processo de app.js se ele ainda estiver rodando. Então digite:
$ node app.js
Agora abra o seu navegador e vá para http://localhost:3000/userlist e maravilhe-se com o resultado.
Você está agora puxando dados do DB e mostrando na sua página web. Muito bom!
Há mais uma coisa que eu gostaria muito de cobrir neste tutorial, mas como ele já está tão longo quanto a Bíblia, 
vou explicar brevemente isso aqui. Você pode facilmente mudar sua view userlist de uma página manipulada pelo 
Express e template Jade para uma boa e velha resposta JSON. Você pode então acessar isso com AJAX e 
manipular no lado do cliente, com jQuery por exemplo, ao invés de no lado do servidor. Eu não vou me opor se 
você quiser fazer assim, mas não posso cobrir isso, então vou apenas apontar o caminho para res.json e dizer "siga 
por aqui, não é tão difícil".
Vamos acabar com isso.
PARTE 4 - O SANTO GRAAL - ESCREVENDO NO DB
Escrever no banco de dados não é difícil. Essencialmente nós precisamos configurar uma rota que pega um POST, 
 Página 15 de Indroducao-NodeJS 
Escrever no banco de dados não é difícil. Essencialmente nós precisamos configurar uma rota que pega um POST, 
ao invés de um GET. Nós podemos usar AJAX aqui, e honestamente é minha preferência na maioria das vezes... 
mas este é realmente um tutorial diferente, então vamos manter uma abordagem de colocar e mostrar resultados. 
Mais uma vez, não tão difícil adaptar essas coisas para funcionarem da maneira que você quer.
PASSO 1 - CRIE SUA ENTRADA DE DADOS
Vamos passar rapidamente aqui: dois inputs feios e sem estilo mais um botão submit. Estilo 1996. Após isso, 
vamos começar com o app.get(); e então dar algo para ser pego. Abra o app.js e encontre a parte das 
chamadas app.get(), e adicione isso no final delas:
app.get('/newuser', routes.newuser);
Então você vai ter:
app.get('/', routes.index);
app.get('/users', user.list);
app.get('/helloworld', routes.helloworld);
app.get('/userlist', routes.userlist(db));
// Novo código
app.get('/newuser', routes.newuser);
Como todas as requisições app.get, nós precisamos ajustar a rota para reconhecer o que servir. 
Abra routes/index.js e adicione o seguinte:
exports.newuser = function ( req, res ) {
 res.render( 'newuser', { title: 'Add New User' } );
};
Agora nós apenas precisamos de um template. Abra views/index.jade, salve como newuser.jade, e substitua todo o 
arquivo com este conteúdo:
extends layout
block content
 h1= title
 form#formAddUser( name='adduser', method='post', action='/adduser' )
 input#inputUserName( type='text', placeholder='username', name='username' )
 input#inputUserEmail( type='text', placeholder='useremail', name='useremail' )
 button#btnSubmit( type='submit' ) submit
Aqui nós criamos um formulário com o ID "formAddUser" (eu gosto de nomear meus IDs com o tipo de coisa que 
ele está identificando. É uma peculiaridade pessoal). O method é o post e a action é adduser. Bastante simples. 
Abaixo disso nós definimos nossos dois inputs e nosso botão.
Se você reiniciar o servidor node e ir para http://localhost:3000/newuser, você vai ver nosso formulário em toda 
sua glória.
PASSO 2 - CRIANDO NOSSAS FUNÇÕES DB
Ok, o mesmo processo de antes. Primeiro vamos editar o app.js, então nosso arquivo route, e então nosso 
template Jade. Exceto que não existe um template Jade aqui porque nós estamos postando e então encaminhando. 
Veja abaixo. Vai tudo fazer sentido! Vamos começar: Abra app.js e mais uma vez encontre a pilha de 
chamadas app.get:
app.get('/', routes.index);
app.get('/users', user.list);
 Página 16 de Indroducao-NodeJS 
app.get('/users', user.list);
app.get('/helloworld', routes.helloworld);
app.get('/userlist', routes.userlist(db));
app.get('/newuser', routes.newuser);
Agora adicione o seguinte em baixo desta lista:
app.post('/adduser', routes.adduser(db));
Note que isso é um app.post, não um app.get. Se você quer separar essa parte dos app.get com um comentário ou 
nova linha, eu não vou lhe impedir. Vamos configurar nossa rota.
Volte para routes/index.js para criarmos nossa função de inserção. Essa é grande, então eu comentei o código 
bem cuidadosamente. Aqui está:
exports.adduser = function (db) {
 return function (req, res) {
// Pega os valores do form. Eles dependem do atributo "name"
 var userName = req.body.username;
 var userEmail = req.body.useremail;
// Configura nossa coleção
 var collection = db.get('usercollection');
// Envia ao DB
 collection.insert({
 "username" : userName,
 "email" : userEmail
 }, function (err, doc) {
 if (err) {
 // Se isso falhar, retorna um erro
 res.send("Ocorreu um problema ao adicionar informação ao banco de dados");
 }
 else {
 // Se funcionar, configura o header para a barra de endereço não continuar dizendo /adduser
 res.location("userlist");
 // E depois a página de sucesso
 res.redirect("userlist");
 }
 }); 
 };
};
Obviamente no mundo real você vai querer de uma tonelada a mais de validação, checagem de erros, e coisas do 
tipo. Você vai querer checar por nomes de usuários e emails duplicados, por exemplo, e também checar se a 
entrada de email parece com uma legítima. Mas isso vai funcionar por agora. Como você pode ver, adicionando os 
dados com sucesso ao DB, vamos em seguida retornar o usuário a página userlist, onde ele deve ver a nova 
entrada adicionada.
Existem formas mais suvaes de se fazer isso? Com certeza, porém vamos ficar nessa forma básica por agora. 
Agora, vamos adicionar alguns dados!
PASSO 3 - CONECTANDO E ADICIONANDO DADOS AO SEU BANCO DE DADOS
Assegure-se que o mongod está rodando! Então volte para seu terminal, encerre o processo do servidor node e 
volte a rodá-lo, reiniciando-o:
$ node app.js
Assumindo que seu servidor está rodando, e deve estar, retorne para o navegador e vá 
para http://localhost:3000/newusernovamente. Temos nosso empolgante formulário, exatamente como antes, 
exceto que agora vamos preencher com alguns valores antes de enviarmos ele. Eu coloquei o username como 
"noderocks" e o email como "noderocks@rockingnode.com"... você pode colocar o que quiser.
 Página 17 de Indroducao-NodeJS 
Clique em submit, e veja... voltamos ao /userlist e essa é nossa nova entrada!
Estamos oficialmente lendo e escrevendo a partir do nosso banco de dados MongoDB usando Node.js, Express e 
Jade. Você é agora o que as crianças chamam de desenvolvedor "full stack" (provavelmente não um BOM, por 
enquanto, mas eu não prometi isso).
Parabéns. Sério. Se você seguiu todo este caminho, e se realmente prestou atenção no que você fez e não apenas 
copiou e colou código, você deve ter agora uma compreensão sólida de rotas e views, ler do banco de dados e 
postar no DB. Isso étudo que você precisa para começar a desenvolver qualquer app que você queira. Eu não sei 
você, mas acho isso realmente muito legal.
PARTE 5 - PRÓXIMOS PASSOS
A partir daqui, existem milhões de diferentes direções que você pode seguir. Você pode checar sobre Mongoose, 
que é outro pacote de manipulador Mongo para Node/Express. É maior que o Monk, mas também faz mais coisas. 
Você pode checar sobre Stylus, o pré-processador CSS que vem com o Express. Você pode pesquisar "Node 
Express Mongo Tutorial" e ver algumas coisas. Apenas continue explorando e construindo!
Eu espero que este tutorial tenha sido útil. Eu o escreviporque eu poderia ter usado isso quando comecei, e não 
consegui encontrar algo parecido com este nível, ou tenha quebrado as coisas em longos, longos, looongos 
detalhes. Se você chegou até aqui, obrigado por isso!
Veja o fim do artigo original para ler a lista de agradecimentos e indicações. Link
De <https://github.com/ericdouglas/traduz-ai/blob/master/nodejs/002-simples-guia-nodejs-jade-express-mongodb.md> 
 Página 18 de Indroducao-NodeJS 
por Cosme Lopes
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.
Outra importante diferença está no fato do Node ser single threaded. 
Embora isso possa parecer uma desvantagem em um primeiro 
momento, o que percebemos ao desenvolver com Node.js é que isso 
simplifica extremamente a construção da aplicação, e 
por Node.js utilizar uma abordagem não obstrutiva, essa diferença vai 
ser imperceptível na maioria dos casos.
V8 JavaScript Engine
É o interpretador de JavaScript open source implementado 
pelo Google em C++ e utilizado peloChrome. O que sem dúvidas gera 
uma grande expectativa em relação ao desempenho do Node.js.
Instalando o Node.js
A instalação do Node.js é extremamente simples graças ao fato de 
o V8 JavaScript Engine ser completamente multi-plataforma, tudo 
que você precisa fazer é visitar a página oficial do Node.js, clicar em 
“INSTALL” e seguir as instruções.
O que é Node.js e saiba os primeiros passos
terça-feira, 12 de julho de 2016 22:22
 Página 19 de Indroducao-NodeJS 
“INSTALL” e seguir as instruções.
Após a instalação, basta executar o seguinte comando no seu terminal 
para verificar se foi instalado corretamente:
$ node -v1.
> v0.10.262.
deve retornar a versão do node que foi instalada, como por 
exemplo v0.10.26.
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:
var http = require('http');1.
http.createServer(function(req,res) {2.
res.writeHead(200, { 'Content-Type': 'text/plain; charset=utf-8' }); 3.
res.end('Olá mundo!');4.
}).listen(3000);5.
console.log('Servidor iniciado em localhost:3000. Ctrl+C para encerrar…');6.
Para executar o seu programa Node basta o seguinte comando no seu 
terminal:
 Página 20 de Indroducao-NodeJS 
$ node olanode.js1.
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:
$ curl http://0.0.0.0:3000/1.
> Olá mundo!2.
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:
var http = require('http');1.
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.
7.
console.log('Servidor iniciado em localhost:3000. Ctrl+C para encerrar…’);8.
Agora basta voltar ao seu navegador e ver o resultado.
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.
 Página 21 de Indroducao-NodeJS 
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.
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 nolocalhost:3000 e a nossa resposta foi servir a string ou a 
página html. Este evento é chamadorequest.
Para ilustrar estes conceitos, podemos escrever o nosso exemplo 
anterior em uma sintaxe alternativa da seguinte forma:
var http = require('http');1.
2.
var server = http.createServer();3.
4.
server.on('request', function(req,res) {5.
res.writeHead(200, { 'Content-Type': 'text/html; charset=utf-8' }); 6.
res.end('<h2> Olá mundo! </h2>');7.
});8.
9.
server.listen(3000);10.
11.
console.log('Servidor iniciado em localhost:3000. Ctrl+C para encerrar…’);12.
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 
 Página 22 de Indroducao-NodeJS 
escreve duas frases no terminal, porém uma dessas frases precisa ser 
carregada da memória antes de ser impressa.
var frase;1.
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.
10.
imprimeFrase = function () {11.
console.log(frase);12.
}13.
14.
carregaFrase(imprimeFrase);15.
16.
console.log(“Olá");17.
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 tipode 
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çãocreateServer podem receber uma função 
de callback.
Conclusão
Espero que este tutorial tenha sido o suficiente para provocar o seu 
interesse em aprender mais sobre Node.js. Portanto visite 
a documentação do Node.js para obter mais informações e exemplos 
de aplicações dessa plataforma e também a página da Joyent, 
 Página 23 de Indroducao-NodeJS 
de aplicações dessa plataforma e também a página da Joyent, 
patrocinadora oficial do projeto.
E finalmente, Node.js é um projeto open source, portanto você pode 
visualizar o código fonte e contribuir no repositório do Node.js no 
GitHub.
De <http://tableless.com.br/o-que-nodejs-primeiros-passos-com-node-js/> 
 Página 24 de Indroducao-NodeJS 
A primeira encarnação do JavaScript viveu no navegador. Mas este é o contexto. Isso define o que você pode fazer com a linguagem, mas isso 
não fala muito sobre o que a linguagem em si pode fazer. JavaScript é uma linguagem completa: você pode usar isso em muitos contextos e 
fazer de tudo, com isso você pode alcançar o que as outras linguagens consegue.
Node.js é realmente só mais um contexto: isso permite você rodar código JavaScript em backend, fora do navegador.
A fim de executar o JavaScript que você pretende rodar em backend, ele precisa ser interpretado e executado. Isso é o queNode.js faz, fazendo 
uso da Máquina Virtual V8 da Google, o mesmo ambiente de execução do JavaScript usado pelo Google Chrome.
Além disso, Node.js vem com muitos módulos úteis, então você não precisa escrever tudo do começo, por exemplo alguma função que escreva 
uma string no console.
Portanto, Node.js é de fato duas coisas: um ambiente de execução e uma biblioteca.
Você pode aprofundar-se cada vez mais neste mundo e descobrir como é fácil e divertido desenvolver aplicações altamente escaláveis em 
JavaScript com Node. O primeiro passo é instalar o Node e a maneira mais fácil de conseguir isso é instalando o Node.js através do gerenciador 
de pacotes, porém você também vai poder instalar o Node.js através do GitHub.
Feito isso, desenvolva sua primeira aplicação, com apenas 6 linhas de código, através do Exemplo Hello World em Node.js. Você perceberá 
como é fácil e divertido o desenvolvimento com JavaScript no servidor e não só isso, ele também é altamente eficiênte e escalável por ser um 
servidor orientado a eventos não bloqueante.
Caso você queira conhecer mais sobre eventos e como desenvolver aplicações orientadas a eventos, você pode ler o artigo explicando eventos 
em Node que poderá te ensinar muito sobre eventos.
É claro que tem muito mais a ser descoberto no Node e o objetivo deste artigo é te dar apenas o gostinho bom do prazer de desenvolver em 
Node, não deixe de acompanhar as comunidades de Node.js e de assinar nosso Feed de notícias para se aprofundar cada vez mais no assunto e 
ser você também um entusiásta desta tecnologia.
Comunidades de Node.js
A comunidade internacional de Node.js mantem uma lista sobre node no Google groups, criada por Urban Hafner em Junho de 2009, onde é 
postado exemplos, discussões, anúncios entre outros assuntos sobre o Node.js. Mas se você está com alguma dúvida você primeiro deve visitar 
a página wiki do node.js e procurar lá, sua dúvida possívelmente já deve ter sido respondida. Estas páginas são em inglês mas são fundamentais 
para se ter um conhecimento aprofundado do que está ocorrendo de mais recente no mundo Node.
A comunidade brasileira de Node.js também mantém uma lista no Google gorups chamada nodebr, criada por Emerson Macedo em Setembro 
de 2010. Todas as postagens estão em português e a comunidade assídua está sempre disposta à esclarecer as dúvidas de desenvolvedores 
brasileiros.
Caso você compreenda um pouco de inglês, você pode acessar o site nodecasts e assistir um podcast destinados a iniciantes no mundo Node.
O que é Node.js?
Node.js é uma plataforma construída sobre o motor JavaScript do Google Chrome para facilmente construir aplicações de rede rápidas e 
escaláveis. Node.js usa um modelo de I/O direcionada a evento não bloqueante que o torna leve e eficiente, ideal para aplicações em tempo 
real com troca intensa de dados através de dispositivos distribuídos.
Na JSConf 2009 Européia, um programador jovem chamado Ryan Dahl, apresentou um projeto em que estava trabalhando. Este projeto era 
uma plataforma que combinava a máquina virtual JavaScript V8 da Google e um laço de eventos. O projeto apontava para uma direção 
diferente das outras plataformas em JavaScript que rodam no servidor: todos I/O primitivos são orientado a evento. Aproveitando o poder e a 
simplicidade do Javascript, isso tornou tarefas difíceis de escrever aplicações assíncronas em tarefas fáceis. Desde quando foi aplaudido de pé 
no final do seu discurso, o projeto de Dahl tem recebido uma popularidade e uma aprovação sem precedentes.
Que problema o Node pode resolver?
Node estabeleceu o objetivo número um que é “fornecer uma maneira fácil para construir programas de rede escaláveis”. Qual é o problema 
com os programas servidores atuais? Vamos fazer os cálculos. Em linguagens como Java™ e PHP, cada conexão cria uma nova thread que 
potencialmente tem anexado 2 MB de memória com ela. Em um sistema que tenha 8 GB de RAM, isso põe o número máximo teórico de 
conexões concorrentes a cerca de 4.000 usuários. E quando o número de usuários aumenta, se você quer que sua aplicação web suporte mais 
usuários, você tem que adicionar mais e mais servidores. Somado a estes custos também podem haver possíveis problemas técnicos: um 
usuário pode usar diferentes servidores para cada requisição, então cada recurso compartilhado deve ser compartilhado para todos os 
servidores. Por todas estas rações, o gargalho em toda a arquitetura de aplicações web (incluindo velocidade de tráfego, velocidade do 
processador e velocidade da memória) é o número de conexões concorrentes que o servidor pode manipular.
Node resolve esta questão trocando a maneira como a conexão é tratada no servidor. Ao invés de criar uma nova OS thread a cada conexão (e 
alocar a memória anexa a ela), cada conexão dispara um evento executado dentro da engine de processos do Node. Node afirma que nunca vai 
dar deadlock, já que não há bloqueios permitidos, e ele não bloqueia diretamente para chamadas de I/O. Node também alega que um servidor 
JavaScript no servidor com Node.js
quarta-feira, 13 de julho de 2016 02:00
 Página 25 de Indroducao-NodeJS 
dar deadlock, já que não há bloqueios permitidos, e ele não bloqueia diretamente para chamadas de I/O. Node também alega que um servidor 
rodando ele pode suportar dezenas de milhares de conexões simultâneas.
Então, agora que você tem um programa que pode manipular dezenas de milhares de conexões simultâneas, o que você pode realmente fazer 
com o Node? Seria incrível se você tivesse uma aplicação web que necessitasse desta quantidade de conexões. Este é um daqueles tipos de 
problema: “se você tem um problema, não é mais um problema”.
O que Node definitivamente não é?
Sim, Node é um servidor de programas. Entretanto o produto base do Node definitivamente não é como o Apache ou o Tomcat. Estes 
servidoressão basicamente servidores ready-to-install e estão prontos para instalar aplicativos instantâneamente. Você pode subir e rodar um 
servidor em um minuto com estes produtos. Node definitivamente não é isso. Parecido com como o Apache pode adicionar um módulo PHP 
para permitir desenvolvedores criarem páginas da web dinâmicas, e um módulo SSL para conexões seguras, Node tem o conceito de módulos 
que podem ser adicionados no núcleo do Node. Há literalmente centenas de módulos para rodarem com o Node, e a comunidade é bastante 
ativa em produzir, publicar e atualizar dezenas de módulos por dia.
Como o Node funciona
O Node roda em uma JavaScript V8 VM. Mas espere, JavaScript no servidor? Isso, você leu certo. JavaScript no lado do servidor pode ser um 
conceito novo para todos que trabalharam exclusivamente com o JavaScript no lado do cliente, mas a idéia em sí não é tão absurda - porque 
não usar a mesma linguagem de programação no cliente que você usa no servidor?
O que é V8? O motor JavaScript V8 é o motor que a Google usa com seu navegador Chrome. Poucas pessoas pensam sobre o que realmente 
acontece com o JavaScript no lado do cliente. Bem, a engine JavaScript realmente interpreta o código e o executa. Com o V8 a Google criou um 
ultra-rápido interpretador escrito em C++, com um outro aspecto único: você pode baixar a engine e incorporá-la em qualquer aplicação 
desejada. Isso não está restrito em rodar em um navegador. Então Node atualmente usa o motor JavaScript V8 escrito pela Google e propõe 
que seja usado no servidor. Perfeito! Para que criar uma nova linguagem quando há uma boa solução já disponível?
Programação orientada a Evento
Muitos programadores foram ensinados a acreditar que a programação orientada a objetos é um modelo de programação perfeito e a não 
usarem nada mais. Node utiliza o que é chamado modelo de programação orientada a evento.
Programação orientada a evento no lado do cliente com jQuery:
// jQuery code on the client-side showing how Event-Driven programming works
// When a button is pressed, an Event occurs - deal with it
// directly right here in an anonymous function, where all the
// necessary variables are present and can be referenced directly
$("#myButton").click(function(){
 if ($("#myTextField").val() != $(this).val())
 alert("Field must match button text");
});
O lado do servidor na verdade não é diferente do lado do cliente. Claro que não há botões sendo pressionados e não há campos de texto sendo 
escritos, mas em um nível mais alto, os eventos estão ocorrendo. Uma conexão é feita - evento! Dado é recebido através da conexão - evento! 
Data parou de chegar através da conexão - evento!
Por que é que este tipo de configuração é ideal para o Node? JavaScript é uma excelente linguagem para programação orientada a evento, 
porque ela permite funções anônimas e encerramentos, e o mais importante, a sintaxe é familiar para quase todos que já programaram na 
vida. As funções de callback que são chamadas quando um evento ocorre podem ser escritas no mesmo lugar onde você captura o evento. Fácil 
para desenvolver, fácil para manter. Sem frameworks complicados de Orientação a Objeto, sem interfaces, nenhum potencial para o excesso 
de arquitetura de qualquer coisa. Basta escutar um evento, escrever uma função de callback, e o Node toma conta de tudo.
De <http://nodebr.com/pagina7/> 
 Página 26 de Indroducao-NodeJS 
Antes de tentar entender o funcionamento do Node.js temos que compreender uma característica do JavaScript herdada da programação 
funcional. No JavaScript você pode, por exemplo, passar uma função como parâmetro. Vamos ver alguns exemplos práticos para ver como isso 
funciona na prática.
Podemos fazer alguma coisa como isso no JavaScript:
function falar(palavra) {
 console.log(palavra);
}
function executar(funcao, valor) {
 funcao(valor);
}
executar(falar, "Oi JavaScript!");
Se executarmos nosso código vamos receber a saída impressa no console Oi JavaScript!. Você pode testar este exemplo utilizando seu prompt de 
comando. O Node.js é um ambiente de execução para usar o JavaScript fora do navegador também! Você pode acessar digitando o comando 
node no seu console e inicia o console interativo REPL, como no exemplo:
> function falar(palavra) {
... console.log(palavra);
...}
undefined
> function executar(funcao, valor){
... funcao(valor);
... }
undefined
> executar(falar, "Oi JavaScript!");
Oi JavaScript!
undefined
E o nosso console imprimiu a saída esperada: Oi JavaScript!
Vamos entender o que está acontecendo neste contexto. O que fizemos aqui foi passar a função falar como o primeiro parâmetro da 
função executar. Isso é bem diferente de passar o valor retornado return pela função falar. A função falar, então, se tornou uma variável de 
nome funcao dentro da função executar, e executar pode chamar a função contida na variável adicionando os parênteses na variável: funcao().
E o que são estes undefined no console? Para cada comando dado no console do Node na linha seguinte é impresso o valor retornado return deste 
comando. Vamos analisar com calma: o primeiro comando foi definir a função falar, após a definição retornou undefined, o segundo comando foi 
definir a função executar, que também retornou undefined, o terceiro comando que executou a função executar, que executou a 
função falar contida na variável funcao, que acabou por executar a funçãoconsole.log que imprime no console uma string, mas a 
função executar em si não tem nenhum valor de retorno, então retornou undefined.
Nós podemos passar uma função como parâmetro para outra função usando seu nome, como foi visto no exemplo. Após entender este
conceito veremos no exemplo a seguir que esta é a maneira indireta de se fazer isso, nós não precisamos definir a função para depois passar ela 
como parâmetro, nós podemos definir e passar a função como parâmetro para outra função no mesmo lugar.
function executar(funcao, valor) {
 funcao(valor);
}
executar( function(palavra) { console.log(palavra) }, "Oi JavaScript!");
Neste exemplo nós definimos a função que nós queremos passar para executar no lugar onde a função espera receber seu primeiro parâmetro. 
Aqui nós não precisamos nem dar um nome à função passada, por isso esta função é chamada de função anônima.
Com estes exemplos podemos observar que no JavaScript é possível passar uma função como parâmetro quando chamamos outra função, e 
podemos fazer isso atribuindo nossa função à uma variável que pode ser passada, ou simplesmente definindo nossa função bem onde estamos 
chamando a função que vai recebê-la como parâmetro, usando uma função anônima.
JavaScript e você
Antes de começarmos a falar sobre assuntos técnicos, vamos usar este post para falar sobre você e seu relacionamento com oJavaScript.
Se você, como eu, começou a desenvolver páginas em HTML, há muito tempo atrás, escrevendo documentos HTML estáticos. E foi através dele 
que você se esbarrou pela primeira vez numa coisa engraçada chamada JavaScript, mas você só o usou de maneira muito simples, adicionando 
alguma interatividade nas suas páginas da web.
E de repente as páginas com conteúdo estático começaram a ficar defasadas, então você começou a buscar como funcionava as coisas com um 
servidor montando as páginas da web por você, você buscava saber como construir web sites complexos, então você aprendeu uma linguagem 
de programação como PHP, Ruby, Java e começou a escrever o código de backend (que rodava no servidor).
Entretanto nessa caminhada você provavelmente passou os olhos no JavaScript e viu com ele a introdução ao jQuery, Prototypee similares, 
coisas mais avançadas na terra do JavaScript, e então você começa a perceber que essa linguagem é mais do que um simples window.open().
De qualquer forma, isso tudo pertencia as coisas do frontend, e embora tenha sido bom ter o jQuery ao seu dispor sempre que você quisessetemperar sua página da web, no final do dia você era, no melhor dos casos, um usuário JavaScript, mas não um desenvolvedor JavaScript.
E então veio o Node.js. JavaScript no lado do servidor, super excitante não é mesmo?
Passando função como parâmetro no JavaScript com 
Node.js
quarta-feira, 13 de julho de 2016 01:59
 Página 27 de Indroducao-NodeJS 
E então veio o Node.js. JavaScript no lado do servidor, super excitante não é mesmo?
Você decidiu que estava na hora de aprender o verdadeiro potencial do bom e velho JavaScript. Mas espere, escrever aplicações em Node.js é 
uma coisa e entender porque elas precisam ser escritas da maneira como são escritas significa entender JavaScript. E dessa vez entender de 
verdade.
Aqui esta o problema: Por causa do JavaScript de fato viver em dois, talvez três vidas (o pequeno e engraçãdo DHTML ajudou em meados da 
década de 90, o mais sério produto de frontend parecido com jQuery e semelhantes, e agora do lado do servidor), não é fácil achar informação 
que ajude você a aprender JavaScript da maneira “correta”, em contra partida escrever aplicações Node.js de certo modo ajuda você a sentir-se 
não somente usando o JavaScript, mas desenvolvendo emJavaScript.
Há poraí, é claro, excelentes documentações, a maioria deles em Inglês. Mas apenas documentações, algumas vezes, não é o bastante. Algumas 
pessoas se sentem mais confortáveis quando encontram tutoriais completos, bem explicativos, abordando desde assuntos para iniciantes até 
soluções sofisticadas, e, além disso, a maioria dos desenvolvedores brasileiros conseguem absorver melhor a informação aprendendo com 
documentação em português. Pensando nisto este blog comunitário foi criado, o objetivo dele é permitir uma ajuda mútua entre os 
desenvolvedores da comunidade brasileira de desenvolvedores Node.
Exemplo Hello World em Node.js
Este é um programa rápido para garantir que tudo está instalado e funcionando corretamente:
var http = require('http');
http.createServer(function (req, res) {
 res.writeHead(200, {'Content-Type': 'text/plain'});
 res.end('Hello Node.JS!');
}).listen(8080);
console.log('Server running at http://localhost:8080/');
Rode o código com o comando de linha do Node em seu prompt de comando:
> node hello_node.js
Server running at http://localhost:8080/
Agora quando você acessar o endereço http://localhost:8080/ com seu navegador você ler um caloroso Hello Node.JS!
Parabéns você instalou o Node.js com sucesso e está pronto para mergulhar nos nós assíncronos do Node.
Instalando Node.js através do GitHub
Este é um post prático que mostra como instalar o Node.js usando o repositório Git no GitHub.
Mac
Se você está usando o excelente gerenciador de pacotes homebrew do Mac, você pode instalar Node com apenas um comando:brew install node.
Caso contrário, siga os passos abaixo: - Instale o Xcode - Instale o Git - Rode os seguintes comandos em seu prompt de comandos:
git clone git://github.com/ry/node.git
cd node
./configure
make
sudo make install
Ubuntu
No Ubuntu você vai os seguir dois passos abaixo para instalar o Node através do repositório git:
Instale todas as dependências:•
sudo apt-get install g++ curl libssl-dev apache2-utils
sudo apt-get install git-core
Rode os seguintes comandos:•
git clone git://github.com/ry/node.git
cd node
./configure
make
sudo make install
Windows
Atualmente você deve usar o cygwin para instalar o Node no Windows. Para fazer isso siga os passos abaixo:
Instalar cygwin.•
Usar o setup.exe na pasta do cygwin para instalar os seguintes pacotes:•
devel → openssl
devel → g++-gcc
devel →make
python → python
devel → git
Abra a linha de comando do cygwin com Start > Cygwin > Cygwin Bash Shell.•
Rode os comandos abaixo para baixar e construir o Node.•
git clone git://github.com/ry/node.git
cd node
 Página 28 de Indroducao-NodeJS 
cd node
./configure
make
sudo make install
Você pode verificar se a instalação foi bem concluída com um simples exemplo Hello World em Node.js!
Instalando o Node.js através do gerenciador de pacotes
Este post é um guia prático para a instalação do Node.js através do gerenciador de pacotes.
Debian
Para o Debian Squeeze, sua melhor aposta é em compilar o Node você mesmo (como root):
apt-get install make python g++
mkdir ~/nodejs && cd $_
wget -N http://nodejs.org/dist/node-latest.tar.gz
tar xzvf node-latest.tar.gz && cd `ls -rd node-v*`
./configure
make install
Ubuntu
Para instalar o Node no Ubuntu, digite as seguintes linhas de comando para instalar a versão estável atual do Node na versão estável atual do 
Ubuntu:
sudo apt-get install python-software-properties
sudo add-apt-repository ppa:chris-lea/node.js
sudo apt-get update
sudo apt-get install nodejs npm
Caso você precise compilar os módulos Node C++:
sudo apt-get install nodejs-dev
openSUSE
Primeiro adicione o repositório:
sudo zypper ar http://download.opensuse.org/repositories/devel:/languages:/nodejs/openSUSE_11.4/ NodeJSBuildService
Então instale os pacotes:
sudo zypper in nodejs nodejs-devel
Atente para a versão do seu openSUSE, caso queira você pode ver as versões disponíveis no repositório do openSUSE. Você pode verificar qual 
sua versão do openSUSE com o comando:
more /etc/SuSE-release
SuSE Linux 9.1 (i586)
VERSION = 9.1
Amazon Linux
Primeiro instale o repositório:
sudo yum localinstall --nogpgcheck http://nodejs.tchol.org/repocfg/amzn1/nodejs-stable-release.noarch.rpm
Então instale os pacotes:
sudo yum install nodejs-compat-symlinks npm
Windows
Para usuários Windows, você pode simplesmente fazer o download do instalador do node.js e seguir os passos para a instalação.
Você também pode utilizar o chocolatey para instalar Node no Windows usando o comando:
cinst nodejs
Ou para fazer uma instalação completa com o gerenciador de pacotes NPM do Node:
cinst nodejs.install
Você pode verificar se a instalação foi bem concluída com um simples exemplo Hello World em Node.js!
De <http://nodebr.com/pagina6/> 
 Página 29 de Indroducao-NodeJS 
Em JavaScript existem duas funções temporizadoras embutidas (built-in timer functions), setTimeout e setInterval que podem ser usadas para 
chamar funções de retorno (callback functions) após um determinado tempo. Veja um exemplo de uso abaixo:
setTimeout(function() { console.log("setTimeout: Ja passou 1 segundo!"); }, 1000);
setInterval(function() { console.log("setInterval: Ja passou 1 segundo!"); }, 1000);
Este código imprime a seguinte saída:
setTimeout: Ja passou 1 segundo!
setInterval: Ja passou 1 segundo!
setInterval: Ja passou 1 segundo!
setInterval: Ja passou 1 segundo!
setInterval: Ja passou 1 segundo!
...
Você pode ver que os parâmetros são os mesmos para as duas funções. O segundo parâmetro é um número que diz quanto tempo de espera, 
em milisegundos, vai passar antes de chamar a função passada como primeiro parâmetro. A diferença entre as duas funções é 
que setTimeout chama a função passada apenas uma vez, enquanto setInterval vai chamar a função passada indefinidamente sempre no intervalo 
de tempo passado.
Você vai poder perceber que o laço de eventos(event loop) do Node vai sempre tentar chamar sua função no tempo pré-determinado por você, 
porém ele nem sempre vai acertar com precisão milimétrica, pois como o Node roda em apenas uma thread e seu contexto pode estar 
processando outra função no momento que ele deveria chamar sua função e ele vai precisar processar esta função até o final antes de chamar 
a próxima função do laço de eventos (event loop). Por isso é muito importante que você sempre escreva funções não bloqueantes para sua 
aplicação em Node, assim você estará aproveitando todas as vantagens do Node.
Você deve ficar atento com a função setInterval porque ela pode causar alguns