Introdução ao NodeJS

Globalcode – Open4education
Apresentando NodeJS
Giovanni Bassi
giovanni@lambda3.com.br
@giovannibassi

Agenda
O que é NodeJS
Modelo assíncrono
Instalando
Módulos
Pacotes
Scripting
Processo de desenvolvimento, debug, testes
Rodando em produção
Mitos, verdades e dúvidas

JavaScript no Servidor
Não é baseado em threads
Eficiente e altamente escalável

Quem usa?

O que é NodeJS
Ambiente de execução e bibliotecas para rodar
JavaScript
Independente de qualquer navegador
Multiplataforma (Linux, Windows, Mac, etc)
Open Source (https://github.com/joyent/node)
Single threaded

Modelo assíncrono
Loop de eventos com uma única thread

Node é…

O que é NodeJS
Servidor
Não só http ou https
Cliente
App desktop: excelente opção multiplataforma
Ambiente de desenvolvimento para frontend web

História
Somente 5 anos de vida (criado em 2009)
Lead e criador: Ryan Dahl
2010: começa a ganhar mais popularidade
2011
surge NPM
suporte nativo a Windows
2012: Novo lead: Isaac Schlueter (npm)
2014
Novo lead: Timothy Fontaine
“bug fixing, performance tuning, staying up to date with the V8
engine”

Instalando
Linux:
baixe os binários
use nvm (node version manager) ou outro similar
use o seu gestor de pacotes favorito (geralmente está
desatualizado)
Windows:
baixe o instalador (ou o binário)
use o chocolatey
Mac:
baixe o instalador ou o binário
Todos: baixe e compile

Instalando (NVM)
Muito útil para manter diferentes versões do Node
na mesma máquina
Para baixar a última versão estável:
nvm install 0.10
Para usar uma versão:
nvm use 0.10
Para deixar a versão 0.10 imediatamente
disponível:
nvm alias default 0.10
Disponível somente em Linux

Sistemas de versões
Pares: estáveis
0.8, 0.10
Ímpares: instáveis/experimentais
0.9, 0.11 (ex: já com novidades do EcmaScript 6)
Obs: Pode mudar no futuro

Primeiro contato: REPL
Abra uma janela de terminal e digite simplesmente
“node”:

Node como ferramenta para JavaScript
Abra uma janela de terminal e digite simplesmente
“coffee”:

Módulos (declarando e consumindo)
//math.js
module.exports = {
soma: function (a, b) { return a + b; }
}
//outro.js
var math = require('./math');
math.soma(1, 2); //3

Módulos nativos
O Node vem com uma série de módulos nativos, a
maioria escrito em JavaScript
Path, Console, HTTP, Streams, Eventos, OS, etc...
API bem documentada em http://nodejs.org/api/

Pacotes
Gerenciados pelo NPM
NPM vem com as instalações padrão do node, mas pode ser
atualizado separadamente
npm install npm -g
http://npmjs.org
Quase 90k pacotes
400M de downloads por mês
Empacotam módulos
Utilizam Semver (http://semver.org)
Registry aberto, qualquer um pode registrar pacotes
Suporta “pacotes corporativos”

Pacotes (dependências)
Sempre locais
Há pacotes globais, mas nunca são carregados pela sua
aplicação, mas usados para criar scripts de execução
global
coffee, grunt, gulp, mocha, azure
Ficam no diretório node_modules da sua aplicação

Pacotes (Package.json)
Define um módulo
Informa:
Nome e versão do módulo
Versão do node suportada pelo módulo
Endereço do repositório
Dependências de produção, desenvolvimento
Scripts (run, teste, deploy, etc)
Etc...

Exemplo de package.json
{
"name": "projeto",
"version": "0.0.0",
"description": "",
"main": "index.js",
"scripts": {
"test": "echo "Error: no test specified" && exit 1"
},
"author": "",
"license": "ISC"
}

Pacotes (dependências)
/suaapp
/node_modules
/dep_a (versão 1.0)
/node_modules
/dep_z (versão 3.0)
/dep_b (versão 1.0)
/node_modules
/dep_z (versão 4.0)
O único sistema de módulos e pacotes que
permite versões diferentes de subdependências

NPM
Iniciar um módulo/projeto (vai criar o package.json)
npm init <dir>
Instalar todas as dependências do projeto
npm install
Instalar um módulo
npm install <modulo>
e gravar isso no package.json
--save
ou como dependência de desenvolvimento
--save-dev
Atualizar tudo
npm update

DEMO
REPL
npm init
npm install
require

Scripting
Bem mais fácil escrever JavaScript/CoffeeScript do
que Bash
Inicie com um shebang apontando pro node e
diverta-se:
#!/usr/bin/env node
console.log('hello tdc');
Ou com coffee:
#!/usr/bin/env coffee
console.log 'hello tdc'

Processo de desenvolvimento
Inicie o servidor com:
node <seuarquivo.js>
Altere o arquivo
Pare e reinicie o servidor
Isso pode ficar muito chato, então use o nodemon
ou algo parecido
npm install nodemon -g

Debug
Há um debugger nativo, acessível via linha de
comando
node debug <seuarquivo.js>
Complexo de usar, na prática ninguém usa
Ao iniciar dessa forma a aplicação para de imediato
Mais fácil delegar o acesso a uma ferramenta mais
avançada
node --debug <seuarquivo.js>
Ou --debug-brk
Abra o node-inspector
Abra o Chrome no endereço indicado e use o F12 que
você já conhece

DEMO
Debug

Testes
A natureza assíncrona do JavaScript torna os
testes mais difíceis de escrever
Usa-se callbacks e promisses para resolver o problema
Uma série de frameworks existem, atualmente o
Mocha é o mais utilizado
Desde testes de unidade simples, até testes de
integração usando Selenium, ou ainda testes de
código front-end (utilizando JSDom)

Testes (exemplo com Mocha e CoffeeScript)
describe 'The cart', ->
beforeEach -> Cart.get().clear()
it 'delivers a list of carts when get is run without args', ->
carts = Cart.get()
expect(carts.length).to.equal 0
it 'throws when a cart with empty string is requested', ->
expect(-> Cart.get('')).to.throw
it 'delivers the same cart when the store slug is the same', ->
cart = Cart.get('store_1')
otherCart = Cart.get('store_1')
expect(cart).to.equal otherCart
it 'delivers different carts when the store slug isnt the same', ->
otherCart = Cart.get('store_2')
expect(cart).not.to.equal otherCart
it 'is empty when cleared', ->
expect(cart.items.length).to.equal 0

IDE? Editor de texto?
Há IDEs se esforçando (Visual Studio, Idea,
WebStorm)
A maioria usa editores de texto (VIM, Emacs,
Sublime)
O fluxo de trabalho costuma envolver alguns
terminais abertos e um editor de textos

Automatizador de tarefas
Coisas que você faz toda hora podem e devem ser
automatizadas
Build, deploy, testes, compilação
As principais ferramentas são o Grunt (mais
conhecido e utilizado) e o Gulp (mais novo e com
visão inovadora)

Versionando
Não versione o diretório node_modules
se precisar saber exatamente o que vai rodar utilize o
`npm shrinkwrap`
Não versione pacotes de front-end também (deixe
o trabalho pro Bower)
Se estiver usando um transpiler, não versione o
JavaScript
A não ser que você esteja criando um pacote

Node para quem usa Java, C#, Ruby...
Mesmo se você não vai usar Node no servidor
você pode usar Node se estiver em um projeto
com JavaScript (geralmente web)
Compilação de código (CoffeeScript, LESS, etc)
Rodar testes front-end
Otimização requirejs, browserify, webpack, etc
Deploy
Execução de testes
Gestão de pacotes de front-end usando Bower

Rodando em produção
Independente de Apache, nginx, IIS ou qualquer
outro servidor web
Mas normalmente atrás de um deles
Você executa o node diretamente
Lembre-se: single threaded
Há gestores de execução para lidar com
Restart
Multiplos núcleos
Falhas

Node como ferramenta cross-platform
Node permiter cruzar o gap entre as plataformas
Windows não tem `which`, então:
npm install which --g
Diversas empresas estão considerando usar o
node para fazer seu ferramental de linha de
comando em node para ser multiplataforma
Exemplo: Azure
npm install azure-cli

Mitos, verdades,
dúvidas

NodeJS não escala
Mito

NodeJS não é assim
tão rápido quando
dizem
Depende. Mas em geral é sim. Mas deixa eu explicar.

Vi um benchmark e o
nodejs ficou pra trás
Não olhe benchmarks. Já explico porque.

Preciso codar em
JavaScript?
Não. Code em CoffeeScript, TypeScript, Clojure...

DEMO Express
(Só se deu tempo)

Dúvidas?

Obrigado!
Giovanni Bassi
giovanni@lambda3.com.br
@giovannibassi

Introdução ao NodeJS

Mais conteúdo relacionado

Mais procurados

Semelhante a Introdução ao NodeJS

Mais de Giovanni Bassi

Introdução ao NodeJS