Apresentando o Node.js por Giovanni Bassi
- O NodeJS tem somente 5 anos e foi criado em 2009 por Ryal Dahl.
- A instalação do Node.js é bastante simples em praticamente todos os sistemas operacionais.
- Linux
- Utilizar o gerenciador de pacotes padrão de sua distribuição como apt-get ou yum.
- Utilizar o Node Version Manager ou NVM para ** gerenciar as versões ** do NodeJS.
- Mac
- Utilizar o gerenciador de pacotes como o
brew
- Utilizar o NVM
- Utilizar o instalador
- Utilizar o gerenciador de pacotes como o
- Windows
- Utilizar o instalador
- Linux
- Utilizar o NVM é muito prático e útil para manter diferentes versões.
- As versões pares são as estáveis (0.8 e 0.10) e ímpares são instáveis (0.11).
- Na versão 0.11 já existe algumas novidades do ECMAScript 6.
- O primeiro contato com o Node.js pode ser feito através do REPL digitando
node
no terminal. - Pode-se utilizar CoffeeScript digitando
coffee
no terminal. - Não existe padrão estabelecido para módulos em JavaScript. No NodeJS utiliza-se o CommonJS.
- Utiliza-se
module.exports
para declarar e consumir módulos.
module.exports = {
soma: function (a,b) { return a + b; }
}
- O Node.js possui módulos nativos e escrito em JavaScript. Os módulossão síncronos.
- alguns exemplos de módulos são Console, HTTP, Streams, Eventos, OS, etc.
- Utiliza-se pacotes para a distribuição de módulos através no NPM.
- Um pacote é uma reunião de vários módulos.
- Para o versionamento dos módulos utiliza-se o Semantic Versioning.
- O registro de módulos é aberto e todos podem registrar e instalar módulos.
- Nas aplicações recomenda-se utilizar pacotes locais.
- Os pacotes globais ficam instalados num diretório específico.
- Utiliza-se pacotes globais somente ferramentas como
coffee
,grunt
,gulp
,mocha
. - Utiliza-se o arquivo
package.json
para a definição de um módulo. - No
package.json
informa-se nome, versão, repositório, dependências, autor, licença. - O sistema de pacotes locais permite diferentes versões para um mesmo pacote.
/app
/node_module
/dep_a
/dep_z (0.5)
/dep_b
/dep_z (0.9)
- Para iniciar um módulo ou projeto utiliza-se o comando
npm init
. - Instalar todas as dependências do projeto utiliza-se o comando
npm install
. - Para instalar um módulo utiliza-se o comando
npm install <module>
ounpm install <module> --save
. - Utiliza-se
NodeJS
para criar tarefas automatizadas que anteriormente poderia ser escritas em shell script. - Para rodar uma aplicação em Node.js basta iniciar o servidor. Após cada alteração do arquivo é necessário reiniciar a aplicação.
- Para automatizar este processo utiliza-se o nodemon que pode ser instalado através do comando
npm install nodemon -g
. - O Node.js possui um debugger nativo acessível via linha de comando. Ele é um pouco complexo e quase ninguém usa.
- É recomendável delegar o processo de debugger a uma ferramenta terceira.
- A natureza assíncrona do JavaScript torna alguns testes mais difíceis de escrever.
- Usa-se callback e promises para resolver o problema.
- Existem várias ferramentas de testes para Node.js. Atualmente a mais utilizada é o Mocha.
- Existem ferramentas para testes de unidade, integrados ou de aceitação.
- Existem várias IDEs e editores para desenvolver em Node.js ou JavaScript como WebStorm, VIM, Sublime Text e fluxo de trabalho envolve algumas janelas de terminais abertas.
- Recomenda-se utilizar um automatizador de tarefas para tarefas que são executadas com frequência como build, deploy, testes, compilação entre outros.
- As principais ferramentas de automatização de tarefas são o Grunt (mais conhecido e utilizado) e o Gulp (mais novo e com versões inovadoras).
- Recomenda-se não versionar o diretório
node_modules
ou dependências. - Se precisar saber exatamente o que rodar utiliza-se o comando
npm shinkwrap
. - Recomenda-se não versionar pacotes de front-end, este tarefa deve ser delegada ao Bower.
- Recomenda-se também não versionar o JavaScript gerado por transpilers.
- Para rodar o Node.js em produção é necessário levar em consideração:
- o Node.js não é multi-thread então deve-se utilizar várias instâncias
- o gerenciamento é um pouco complexo e utiliza-se ferramentas para o gerenciamento
- Ele é independente do servidor web
- Alguns mitos de como o Node.js não escala é refutado observando sua utilização nas empresas.
- Recomenda-se não fazer coisas que dependam de alto uso de CPU.
- Pode-se utilizar várias linguagens CoffeeScript, TypeScript e Clojure.
- O NodeJS utiliza threads não-bloqueantes e isso é muito bom para o desempenho como em aplicações realtime, por exemplo.
Node.js para frontenders por Paulo Pires
- O NodeJS é uma ferramenta interessante pois permite executar JS no servidor, hardware ou desktop.
- É importante conhecer a diferença entre o JavaScript executado no servidor e no navegador.
- É bastante utilizado em ferramentas de front-end como Grunt, Gulp e Bower.
- No Node.js não existe métodos e eventos de navegadores como
onload
,getElementById
entre outros. - Utiliza-se o comando
npm publish
para publicar um pacote do Node.js. - É muito fácil publicar e utilizar um módulo em NodeJS.
Why frameworks por Guilherme de Souza
- No começo era difícil encontrar referências sobre Node.js.
- Problemas iniciais e insegurança com servidores web, conexão com banco de dados, servir arquivos estáticos.
- Frozen spots são pedaços de códigos que não devem ser alteradas.
- Hot spots são pedaços de códigos que devem ser alterados.
- Benefícios de utilizar um framework para desenvolvimento:
- possui uma organização pré-definida
- utiliza a arquitetura MVC
- facilita a conexão com o banco de dados, criar modelos e rotas
- Code Activism
- Expose Yourself e publique seu código no GitHub.
- Ordine é uma biblioteca para enfileiramento de callbacks.
Linha de comando por Marcos Bergamo
- Para utilizar o Node.js em linha de comando basta adicionar o
#!/usr/bin/env node
. - O Node.js fornece os objetos como
process
por padrão para utilização. - Utilizar o Node.js no terminal é uma tarefa bem fácil e possui diversos módulos que facilitam estas tarefas.
Testando com Node.js por Ciro Costa
- É importante testar as aplicações.
- Ao corrigir um bug, cinco outros nascem.
- O JavaScript é dinâmica, fracamente tipada e bastante aberta. Neste, liberdade pode levar a problemas.
- Esforços para melhorar com padrões, bibliotecas e testes.
- O teste compara o estado e comportamento do produto contra oráculos.
- Para quê testar?
- Feedback rápido
- ao alterar alguma coisa, saber se tudo continua funcionando da maneira esperada
- Incerteza
- diminui a incerteza com os testes, pois dados os parâmetros testa-se os resultados
- ao encontrar algum erro não coberto, adiciona-se nos testes e realiza a implementação
- Design de código
- Ao começar testando, promove-se a melhor arquitetura do código
- Regressão
- Evitar regressão do código ao consertar um problema e aparecer cinco outros
- Documentação
- Os testes funcionam como documentação pois eles sempre estarão atualizados pois fazem parte do workflow de desenvolvimento
- Feedback rápido
- O Mocha é o test runner e o Chai é a biblioteca das asserções.
- Asserções são afirmações para verificar um verdade.
- O
describe()
é o agrupamento dos testes. - O
it()
coloca-se as especificações, ou seja, onde são verificadas as asserções. - Coloca-se a quantidade de espectativas necessárias para organização dos seus testes.
- Em Node.js o primeiro argumento dos callbacks são sempre erros e os restantes são os valores retornados.
- O Mocha parte do princípio que seus callbacks não devem demorar mais que um período de tempo definido.
- Para navegadores utiliza-se o Jasmine e QUnit.
- Pode-se utilizar o Mocha e Chai no navegador e realiza as configurações para informar o "sabor" dos testes que está realizando.
- O Mocha realiza vários tipos de verificações vazamento de memória, variáveis globais entre outros.
- O Karma é utilizado para realizar testes com navegadores como Chrome, Firefox e PhantomJS.
- Utiliza-se o SinonJS e espiões para fazer testes com Ajax.
- O método
beforeEach()
é um método de setup para o SinonJS preparar os testes. - Pode-se utilizar o Protractor para testes de interface com AngularJS.
- Todo código é testável e pode ser automatizado com o Grunt ou Gulp.
Introdução ao MongoDB e Node.js Jean Carlo Nascimento
- MongoDB é um banco de dados NoSQL.
- É feito em C++ e usa o V8 como engine de JavaScript.
- Não possui um esquema (schemaless) e é delegado para a aplicação.
- Não possui junções em MongoDB.
- Possui sharding, réplicas e GridFS.
- Ele pode ser instalado com o binário ou através de gerenciador de pacotes.
- Utiliza-se o comando
mongo
para acessar a linha de comando do MongoDB. - Cria-se a base de dados e pode-se adicionar coleções.
- O JavaScript é case sensitive e necessita de expressão regular para consultas.
- Recomenda-se utilizar o Mongoose como middleware entre o MongoDB e o NodeJS.
- Para instalar o Mongoose utiliza-se o comando
npm install mongoose --save
. - Pode-se utilizar um ouvinte da conexão do Mongoose para
connected
,disconnected
,open
,error
entre outras.
mongoose.connection.on("connected", function(){
console.log("Conectado!");
});
- Para criar o esquema no Mongoose.
var Schema = mongoose.Schema;
var BeerSchema = new Schema({
name: {type: String, default: ''},
description: {type: String, default: ''},
abv: {type: Number, min: 0},
created_at: {type: Date, default: Date.now}
});
- Para criar um modelo no Mongoose.
var BeerModel = mongoose.model('Beer', BeerSchema);
var dados = {};
var beer = new BeerModel(dados);
beer.save(function(error, data){
// ...
});
BeerModel.find({}, function(err, data) {
// ...
});
BeerModel.remove({_id: a1sasdhjb34b23jhb432});