Aprendendo Node

Shelley Powers

Novatec

Authorized Portuguese translation of the English edition of Learning Node, 2nd Edition, ISBN 9781491943120 © 2016 Shelly Powers. This translation is published and sold by permission of O'Reilly Media, Inc., which owns or controls all rights to publish and sell the same.

Tradução em português autorizada da edição em inglês da obra Learning Node, 2nd Edition, ISBN 9781491943120 © 2016 Shelly Powers. Esta tradução é publicada e vendida com a permissão da O'Reilly Media, Inc., detentora de todos os direitos para publicação e venda desta obra. © Novatec Editora Ltda. 2017.

Todos os direitos reservados e protegidos pela Lei 9.610 de 19/02/1998. É proibida a reprodução desta obra, mesmo parcial, por qualquer processo, sem prévia autorização, por escrito, do autor e da Editora.

Editor: Rubens Prates Tradução: : Henrique Cesar Ulbrich/Design for Context Revisão gramatical: Priscila A. Yoshimatsu Editoração eletrônica: Carolina Kuwabata ISBN: 978-85-7522-540-0 Histórico de impressões: Janeiro/2017

Primeira edição

Novatec Editora Ltda.

Rua Luís Antônio dos Santos 110 02460-000 – São Paulo, SP – Brasil Tel.: +55 11 2959-6529 Email: novatec@novatec.com.br Site: www.novatec.com.br Twitter: twitter.com/novateceditora Facebook: facebook.com/novatec LinkedIn: linkedin.com/in/novatec

capítulo 1

Ambiente do Node

Esqueça tudo o que já ouviu sobre o Node ser uma ferramenta para usar só no servidor. É bem verdade que ele é usado principalmente em aplicações no servidor, mas pode também ser instalado em qualquer máquina e usado para qualquer fim, permitindo rodar aplicações localmente em seu PC ou mesmo em tablets, smartphones ou microcontroladores.

Tenho o Node instalado em meu servidor Linux, mas também o coloquei em todos os meus PCs com Windows 10 e até em meu microcontrolador Raspberry Pi. Possuo um tablet Android a mais e planejo testar o Node nele, algo que já fiz com meu microcontrolador Arduino Uno, e já estou fazendo experiências para incorporar o Node em meu sistema de automação residencial graças ao canal Makers do serviço IFTTT. No PC uso o Node como um ambiente de testes para o JavaScript e como uma interface para o ImageMagick para editar automaticamente muitas fotos de uma vez só. O Node é minha principal ferramenta para qualquer operação em lote que eu precise fazer, tanto no servidor quanto no PC. Obviamente, uso o Node também para tarefas típicas de servidor quando preciso de uma interface web independente do meu Apache, ou para providenciar um processo exclusivo para o backend de alguma aplicação web.

O que quero dizer com tudo isso é: o ambiente criado pelo Node é rico em funcionalidade e alcance. Para explorar esse ambiente, temos que começar pelo início: a instalação do Node.

IFTTT IFTTT é um serviço maravilhoso na nuvem que permite conectar eventos e ações vindos de um número enorme de empresas, serviços e produtos usando uma lógica condicional simples, do tipo if-then. Cada ponto de conexão de uma receita é um canal, incluindo o já citado Maker Channel (https://ifttt.com/maker).

18

Capítulo 1 ■ Ambiente do Node

19

Instalando o Node O melhor lugar para começar é a página de downloads do Node.js (https://nodejs. org/en/download/). Aqui podemos baixar os binários (executáveis pré-compilados) para as arquiteturas Windows, OS X, SunOS, Linux e ARM. A página também oferece instaladores para arquiteturas específicas que podem simplificar drasticamente o processo de instalação – especialmente no Windows. Se seu ambiente é específico para desenvolvimento, o melhor é baixar o código-fonte e compilar o Node diretamente. É como prefiro fazer em meu servidor Ubuntu.

Podemos também instalar o Node usando o gerenciador de pacotes (“loja de software”) de sua arquitetura. Ir por esse caminho é útil não apenas para instalar o Node, mas também para mantê-lo atualizado (falaremos mais sobre isso ainda neste capítulo, na seção “Node: a versão LTS e o processo de atualização”, na página 31).

Se decidir compilar o Node localmente em sua máquina, será preciso configurar um ambiente adequado para a compilação, além das ferramentas apropriadas. Por exemplo, no Ubuntu (que é um Linux), precisaremos rodar o seguinte comando no terminal para instalar as ferramentas necessárias ao Node: apt-get install make g++ libssl-dev git

Há algumas diferenças de comportamento quando instalamos o Node nas várias arquiteturas. Por exemplo, quando o instalamos no Windows, o instalador não providencia somente o Node, mas também cria um terminal de comandos especial para acessá-lo em sua máquina. O Node é um programa de linha de comando e não tem uma interface gráfica como os aplicativos mais comuns para Windows.

Caso queira usá-lo para programar um Arduino, é preciso instalar também o Johnny-Five (http://johnny-five.io).

Aceite os defaults do mundo Windows Sempre aceite o local-padrão de instalação e as opções default quando instalar o Node no Windows. O instalador adiciona o Node à variável PATH, o que significa que podemos digitar node no terminal sem precisar informar o caminho completo.

Caso esteja instalando o Node no Raspberry Pi, baixe a versão apropriada da arquitetura ARM, por exemplo, ARMv6 para o Raspberry Pi original e ARMv7 para o Raspberry Pi 2, mais recente. Uma vez baixado, extraia o binário a partir do arquivo .tar.gz e copie a aplicação para /usr/local:

20

Aprendendo Node wget https://nodejs.org/dist/v4.0.0/node-v4.0.0-linux-armv7l.tar.gz tar -xvf node-v4.0.0-linux-armv7l.tar.gz cd node-v4.0.0-linux-armv7l sudo cp -R * /usr/local/

Sempre podemos, também, configurar um ambiente de desenvolvimento e compilar o Node diretamente.

Node em ambientes inesperados A respeito do Node no Arduino e Raspberry Pi, discutiremos seu funcionamento em ambientes heterodoxos, como a Internet das Coisas (Internet of Things, IoT), no Capítulo 12.

Diga “olá mundo” com o Node Você acabou de instalar o Node e naturalmente quer experimentá-lo. Há uma tradição entre os programadores de que seu primeiro programa em uma linguagem seja o famoso “Hello World”. O programa, em geral, escreve as palavras “Hello World” no dispositivo-padrão de saída, demonstrando como uma aplicação pode ser criada, executada e a maneira como processa entrada e saída.

O Node não foge à tradição: é esse o programa que o site oficial do Node.js inclui na sinopse da documentação. E também será nossa primeira aplicação neste livro, mas com alguns melhoramentos.

Um Hello World básico Primeiro, vejamos como é o “Hello World” incluído na documentação do Node.

Para recriar a aplicação, digite o código em JavaScript a seguir em um novo documento de texto. Use o editor de texto que preferir. No Windows costumo usar o Notepad++, e no Linux uso o Vim. var http = require('http'); http.createServer(function (request, response) { response.writeHead(200, {'Content-Type': 'text/plain'}); response.end('Hello World\n'); }).listen(8124); console.log('Server running at http://127.0.0.1:8124/');

Capítulo 1 ■ Ambiente do Node

21

Grave o arquivo com o nome hello.js. Para executá-lo, abra um terminal se estiver no Linux ou no OS X, ou uma janela do Node Command se estiver no Windows.

Navegue até o diretório no qual salvou o arquivo e digite o comando a seguir para rodar a aplicação: node hello.js

O resultado será mostrado no próprio terminal, graças à chamada à função console.log(): Server running at http://127.0.0.1:8124/

Agora, abra um navegador e digite http://localhost:8124/ ou http://127.0.0.1:8124 na barra de endereços (se você estiver hospedando o Node em um servidor remoto, digite o domínio apropriado). O que aparecerá é uma página simples e sem graça com o texto “Hello World” logo no início, como mostrado na Figura 1.1.

Figura 1.1 – Sua primeira aplicação em Node.

Se estiver rodando a aplicação no Windows, é bem possível que receba um alerta do Windows Firewall, como mostrado na Figura 1.2. Desative a opção para Redes Públicas (Public networks), ative a versão de Redes Privadas (Private networks) e depois clique no botão Permitir Acesso (Allow access).

Não é necessário repetir esse processo no Windows: o sistema se lembrará da sua escolha.

Para interromper o programa, você pode tanto fechar o terminal, ou a janela de comandos se estiver no Windows (daqui em diante vamos chamar tudo de terminal, ok?), quanto pressionar Ctrl-C. Quando a aplicação foi executada, estava rodando em primeiro plano. Isso significa que não podemos usar o terminal enquanto a aplicação estiver ativa. Também significa que, quando fechamos o terminal, o processo do Node é encerrado.

22

Aprendendo Node

Figura 1.2 – Permitindo o acesso à aplicação do Node no Windows.

Executando o Node para todo o sempre Por enquanto, rodar o Node em primeiro plano é o melhor a fazer.

Estamos aprendendo a usar a ferramenta, ainda não queremos que a aplicação esteja disponível externamente para qualquer um e queremos poder encerrá-la sempre que necessário. No Capítulo 11, veremos como criar um ambiente de execução mais robusto para o Node.

Voltemos ao código do Hello World. O JavaScript cria um servidor web que mostra uma página, acessada pelo navegador, com as palavras “Hello World”. Esse exercício demonstra uma série de componentes-chave em uma aplicação Node.

Primeiro, inclui o módulo necessário para ativar um servidor HTTP simples, cujo nome, bastante adequado, é HTTP. Alguma funcionalidade que não exista nativamente no Node pode ser incorporada por meio de módulos, exportando funcionalidades específicas que podem ser usadas pela aplicação (ou por outro módulo). O conceito é semelhante ao das bibliotecas em outras linguagens. var http = require('http');

Módulos do Node, módulos nativos (core) e o módulo http O módulo HTTP é um dos módulos nativos (core modules) do Node, que são o objetivo principal deste livro. Veremos mais sobre os módulos do Node, bem como o seu gerenciamento, no Capítulo 3. O módulo HTTP será examinado no Capítulo 5.

Capítulo 1 ■ Ambiente do Node

23

O módulo é importado usando a instrução require do Node, e o resultado é atribuído a uma variável local. Uma vez importado, sua variável pode ser usada para instanciar o servidor web com a função http.createServer()1. Nos parâmetros da função, vemos uma das estruturas de código fundamentais do Node: a função de retorno, mais conhecida como callback (Exemplo 1.1). É essa função anônima que está passando a solicitação web para que o código processe; também é ela que devolve a resposta à solicitação.

Exemplo 1.1 – A função de callback do Hello World http.createServer(function (request, response) { response.writeHead(200, {'Content-Type': 'text/plain'}); response.end('Hello World\n'); }).listen(8124);

O JavaScript funciona em uma única thread, e o Node emula um ambiente assíncrono em um ambiente com uma única thread por meio de um laço de eventos (event loop), com funções de callback associadas que são chamadas sempre que um evento específico é disparado. No Exemplo 1.1, quando uma solicitação web é recebida, a função de callback é chamada.

A mensagem do console.log() é mostrada no terminal assim que a função criadora do servidor é chamada. O programa não termina aí e fica esperando que uma solicitação web seja feita, bloqueando o terminal enquanto espera. console.log('Server running at http://127.0.0.1:8124/');

Laços de eventos e funções de callback Veremos mais detalhes sobre os laços de eventos do Node, seu suporte à programação assíncrona e as funções de callback no Capítulo 2.

Uma vez que o servidor foi criado e recebeu uma solicitação, a função de callback envia ao navegador um cabeçalho em texto puro com um status 200, escreve a mensagem de Hello World e encerra a resposta.

Parabéns! Você criou seu primeiro servidor web no Node com apenas algumas linhas de código. Não é algo particularmente útil, a não ser que seu único interesse 1 N. do T.: Sendo uma função de um objeto, o nome mais adequado para createServer seria método, embora função não esteja errado. Observe também que a autora batizou a variável com o mesmo nome do módulo, embora isso não seja obrigatório, pois funcionaria com qualquer outro nome.

Por exemplo, var servidorWeb = require('http');. Obviamente, você precisaria substituir também http.createServer por servidoWeb.createServer.

24

Aprendendo Node

seja acenar para o mundo. Ao longo deste livro, aprenderemos a fazer aplicações de maior utilidade usando o Node, mas antes de deixar o Hello World para trás, que tal modificá-lo para que fique mais interessante?

Um Hello World “tunado” Enviar uma mensagem estática demonstra, em primeiro lugar, que a aplicação funciona, e em segundo lugar, como criar um servidor web simples. Esse exemplo trivial também demonstra alguns elementos-chave de uma aplicação em Node.

Contudo, sempre podemos enriquecê-la um pouquinho, deixando-a mais divertida. Pensando nisso, ajustei o código aqui e ali para criar uma segunda aplicação com alguns truques bacanas.

O código mexido está no Exemplo 1.2. Nele modifiquei a aplicação original para analisar a solicitação entrante em busca de uma query string. O nome na string é extraído e usado para determinar o tipo de conteúdo devolvido. Praticamente qualquer nome que usarmos retornará uma resposta personalizada, mas se a query for name=burningbird teremos uma imagem. Se nenhuma query string estiver presente, ou se nenhum nome for passado a ela, a variável recebe o valor-padrão ‘world‘.

Exemplo 1.2 – Hello World melhorado var http = require('http'); var fs = require('fs'); http.createServer(function (req, res) { var name = require('url').parse(req.url, true).query.name; if (name === undefined) name = 'world'; if (name == 'burningbird') { var file = 'phoenix5a.png'; fs.stat(file, function (err, stat) { if (err) { console.error(err); res.writeHead(200, {'Content-Type': 'text/plain'}); res.end("Sorry, Burningbird isn't around right now \n"); } else { var img = fs.readFileSync(file); res.contentType = 'image/png'; res.contentLength = stat.size; res.end(img, 'binary');

Capítulo 1 ■ Ambiente do Node

25

} }); } else { res.writeHead(200, {'Content-Type': 'text/plain'}); res.end('Hello ' + name + '\n'); } }).listen(8124); console.log('Server running at port 8124/');

O resultado de acessar a aplicação web com a query string ?name=burningbird é mostrado na Figura 1.3.

Figura 1.3 – Olá, passarinho!

Não há muito código a mais, mas existem diferenças notáveis entre o Hello World básico e a versão melhorada. Logo no início, um novo módulo é convocado na aplicação, de nome fs. É o módulo File System (sistema de arquivos), e nos encontraremos com ele muitas vezes nos próximos capítulos. Existe ainda um terceiro módulo, mas sua chamada é bem diferente das outras duas: var name = require('url').parse(req.url, true).query.name;

As propriedades de um módulo podem ser encadeadas, e com isso podemos importá-lo e usar suas funções na mesma linha. Isso acontece com bastante frequência no módulo URL, cuja única finalidade é oferecer recursos utilitários para manipular URLs.

26

Aprendendo Node

Os nomes dos parâmetros de solicitação e resposta são abreviados, respectivamente, para req e res, a fim de facilitar seu acesso. Depois de analisar a solicitação para extrair o valor de name, a primeira coisa que fazemos é testá-lo para determinar se é undefined. Se for, o valor é ajustado para o padrão, world. Se existir um valor definido para name, é testado novamente para ver se é burningbird. Se não for, a resposta é parecida com o que tínhamos na aplicação mais simples, com a exceção de que o nome informado é repassado à mensagem de retorno.

Se o nome for burningbird, entretanto, estamos lidando com uma imagem em vez de um texto. O método fs.stat() não apenas verifica se o arquivo existe, como também devolve um objeto com informações sobre o arquivo, incluindo seu tamanho. Esse valor é usado para criar o cabeçalho.

Se o arquivo de imagem não existir, a aplicação lida com a situação com graça e leveza, emitindo uma mensagem informando que o pássaro flamejante foi dar uma voltinha, além de uma mensagem de erro no console, usando o método console.error() desta vez: { [Error: ENOENT: no such file or directory, stat 'phoenix5a.png'] errno: -2, code: 'ENOENT', syscall: 'stat', path: 'phoenix5a.png' }

Se a imagem existir, será lida e atribuída a uma variável, que por sua vez será devolvida na resposta. Os valores do cabeçalho serão reajustados de acordo.

O método fs.stats() usa a estrutura-padrão de código2 para callbacks do Node com o valor do erro no primeiro parâmetro – frequentemente chamado de errback. Entretanto, o trecho que lê a imagem pode tê-lo feito coçar a cabeça. Não parece certo, pelo menos não como as outras funções do Node que vimos neste capítulo (e provavelmente na maioria dos exemplos encontrados na internet). A diferença é que estou usando uma função síncrona, readFileSync(), em vez da versão assíncrona, readFile().

O Node suporta ambas as versões, síncrona e assíncrona, da maioria das funções para manipulação de sistemas de arquivos encontradas no módulo File System.

2 N. do T.: Em português, as palavras standard, default e pattern são traduzidas normalmente como “padrão”. Entretanto, em programação, especialmente em JavaScript, cada uma tem um significado diferente. Pior ainda, são comumente usadas juntas duas a duas, e em algumas situações, as três juntas (“the default standard pattern”, o pesadelo de qualquer tradutor). Por isso, neste livro, standard é traduzido como padrão, não traduzimos default (é sempre default, termo que qualquer programador conhece) e pattern é traduzido como “estrutura-padrão de”. Code pattern, portanto, ficaria “estrutura-padrão de código”, e design pattern ficaria “estrutura-padrão de projeto”. A outra tradução usual para pattern, “modelo”, também gera confusão com os modelos de dados (data models), por isso não foi usada.

Capítulo 1 ■ Ambiente do Node

27

Geralmente, usar uma operação assíncrona do Node em uma solicitação web é considerado tabu, mas o recurso está lá para quem precisar. A versão assíncrona do mesmo trecho de código é mostrada no Exemplo 1.3. fs.readFile(file, function(err,data) { res.contentType = 'image/png'; res.contentLength = stat.size; res.end(data, 'binary'); });

Como escolher qual usar? Em algumas circunstâncias, as operações de leitura e gravação em disco podem não causar impacto no desempenho, independentemente do tipo de função usada. Nesses casos, a função síncrona é mais limpa e fácil de usar. Ela também evita muito código aninhado – um problema típico do sistema de callback do Node, o qual detalharemos no Capítulo 2.

Embora eu não empregue tratamento de exceções neste exemplo, as funções síncronas permitem o uso de try...catch. Não podemos usar esse tradicional tratamento de erros com as funções assíncronas (por isso mesmo o valor do erro é o primeiro parâmetro da função anônima de callback).

Entretanto, a lição mais importante a ser aprendida com esse segundo exemplo é que nem todo I/O do Node precisa ser assíncrono.

Buffers, I/O assíncrono e os módulos File System e URL Estudaremos o módulo URL em detalhes no Capítulo 5 e o módulo File System no Capítulo 6. Contudo, observe que o módulo File System será usado em todos os capítulos do livro. O conceito de buffers e do processamento assíncrono será explicado no Capítulo 2.

Opções de linha de comando do Node Nas últimas duas seções, o Node foi chamado no terminal sem ativar nenhuma opção. Antes de continuar, gostaria de mostrar algumas dessas opções. Outras mais serão introduzidas ao longo do livro sempre que necessário.

Para descobrir todas as opções e argumentos disponíveis, use a ajuda embutida, grafada como -h ou --help: $ node --help

28

Aprendendo Node

Isso lista todas as opções disponíveis e mostra a sintaxe correta a seguir quando executamos uma aplicação no Node: Usage: node [options] [ -e script | script.js ] [arguments] node debug script.js [arguments]

Para saber a versão do Node, use o comando: $ node -v

ou $ node --version

Para verificar a sintaxe de uma aplicação em Node, use a opção -c. Isso verifica a sintaxe do seu código sem que a aplicação precise ser executada: $ node -c script.js

ou $ node --check script.js

Para descobrir quais são as opções do V8, digite: $ node --v8-options

Isso devolve várias opções, incluindo --harmony, usada para habilitar por completo os recursos Harmony do JavaScript, o que inclui toda a funcionalidade ES6 que já foi implementada, mas ainda não está disponível por padrão nas versões LTS ou Current.

Uma opção de que gosto muito é -p ou --print, que pode analisar uma linha de um programa em Node3 e mostrar o resultado. Ela é especialmente útil quando estamos verificando as propriedades ambientais do processo, que discutiremos melhor no Capítulo 2. Um exemplo é a linha a seguir, que mostra todos os valores da propriedade process.env: $ node -p "process.env"

3 N. do T.: Dizer que um programa ou script está escrito “em Node” não é completamente correto, mas é o tipo de simplificação tolerada tanto em inglês quanto em português. Como já deve estar claro neste ponto, o Node é um framework para trazer o JavaScript (uma linguagem notoriamente “de navegador”) para o servidor. Não se programa “em Node”, propriamente, mas sim “em JavaScript, sobre o framework Node”. Entretanto, coloquialmente é comum ouvir os programadores falarem dessa forma, e a própria autora, que tem um estilo de texto bastante leve e descontraído, usa assim.

Capítulo 1 ■ Ambiente do Node

29

Ambientes de hospedagem do Node À medida que aprendemos sobre o Node, nos contentamos em testá-lo em nosso próprio ambiente local, seja ele Windows, OS X ou Linux. Quando chegar o momento de abrir sua aplicação a um público maior, será preciso encontrar um ambiente para rodar a aplicação em Node, como uma rede virtual privativa (VPN), a alternativa que costumo usar, ou um provedor de hospedagem que ofereça suporte a aplicações Node. O primeiro requer alguma experiência em administrar servidores conectados à internet, enquanto o segundo pode limitar o que nossa aplicação em Node pode ou não fazer.

Hospedando o Node em seu próprio servidor, VPS ou provedor de hospedagem Hospedar o Node no mesmo servidor que roda seu site no WordPress acabará se mostrando um beco sem saída, por conta das necessidades especiais do Node.

Você não precisa, necessariamente, ter acesso administrativo ou root no servidor para rodar o Node, mas deveria. Além disso, muitos provedores de hospedagem não ficarão muito felizes caso sua aplicação use várias portas de comunicação, o que pode comprometer dos sistemas da empresa.

Todavia, hospedar o Node em um servidor privativo virtual (Virtual Private Server, ou VPS) é bastante simples, como é o meu caso na Linode, que acesso por VPN. Em um VPS, o assinante tem acesso ao usuário root e, portanto, tem controle total e absoluto sobre a máquina virtual, desde que não coloque em risco os outros usuários que possam estar na mesma máquina física. Muitas empresas que oferecem VPSs garantem que cada conta individual é completamente isolada das demais, e que nenhuma conta consegue “sugar” todos os recursos do sistema compartilhado4.

Entretanto, o problema com um VPS é semelhante ao que teria se pudesse manter seu próprio servidor físico: é você mesmo quem tem de administrar e manter o servidor. Isso inclui instalar e configurar o sistema de email e o servidor web alternativo, normalmente um Apache ou Nginx (https://www.nginx.com), além de lidar com firewalls, segurança, email etc. Não é nada trivial.

Ainda assim, caso se sinta à vontade administrando todos os aspectos de um ambiente conectado à internet, um VPS é uma opção econômica para hospedar uma aplicação em Node – ou, pelo menos, até que ela esteja pronta para entrar em produção, e nesse caso vale a pena considerar hospedá-la em uma solução na nuvem (cloud hosting).

4 N. do T.: Em um VPS, cada assinante possui sua própria máquina virtual, mas várias dessas máquinas virtuais compartilham a mesma máquina física.

30

Aprendendo Node

Nas nuvens Hoje em dia, uma aplicação fatalmente acabará residindo em um servidor em nuvem (cloud server) sem muita modificação em relação aos computadores individuais ou pertencentes a um grupo. As aplicações em Node se dão muito bem em implementações baseadas na nuvem.

Quando uma aplicação em Node está hospedada na nuvem, o que fazemos, na realidade, é criar a aplicação em nosso próprio servidor ou estação de trabalho, testá-la para ter certeza de que faz o que queremos e depois remetê-la ao servidor na nuvem. Um servidor Node em nuvem permite criar a aplicação Node exatamente como queremos, usando os recursos de qualquer banco de dados (ou qualquer outro recurso) que desejemos, mas sem ter de administrar o próprio servidor diretamente. Podemos nos concentrar apenas na aplicação do Node sem nos preocupar com servidores de FTP ou email, ou qualquer tipo de manutenção.

Git e GitHub: pré-requisitos para desenvolvimento em Node Se você nunca usou o Git, um sistema de controle de código-fonte, será preciso instalá-lo em seus ambientes e aprender como usar. Toda a evolução de código em aplicações Node, incluindo o envio da versão final para o servidor na nuvem, acontece pelo Git. O Git é um software livre de código aberto, gratuito e fácil de instalar. Podemos acessar o software pelo seu site oficial (https://git-scm.com). Há inclusive um guia interativo (https://try.github.io/levels/1/challenges/1) que podemos usar para aprender os comandos básicos do Git, hospedado no site GitHub. Aliás, sempre que há Git, há também GitHub. O código-fonte do próprio Node.js é mantido no GitHub, onde também estão a maioria, senão todos, os módulos do Node. O código-fonte para os exemplos deste livro também estão disponíveis no GitHub. O GitHub (https://github.com) é provavelmente o maior repositório de código-fonte open source do mundo. Definitivamente, é o centro do universo quando se trata de Node. Ele pertence a uma empresa privada, mas está disponível gratuitamente para a maioria dos usuários. A empresa por trás do GitHub oferece excelente documentação (https://help.github.com/categories/bootcamp/) sobre como usar o site, e há muitos livros e tutoriais para ajudar a aprender tanto Git quanto GitHub. Dentre eles, podemos destacar um livro gratuito e disponível para download sobre Git (https://git-scm.com/book/en/v2), bem como os livros Version Control with Git (O’Reilly), de Loeliger e McCullough, e Introdução ao GitHub (Novatec), de autoria de Bell e Beer.

Capítulo 1 ■ Ambiente do Node

31

O paradigma para hospedar uma aplicação em Node nas nuvens é bastante semelhante em praticamente todos os provedores desse tipo de serviço. Primeiro, crie a aplicação em Node, seja localmente, na sua estação de trabalho, seja em um servidor próprio. Quando estiver pronto para testar em um ambiente semelhante ao de produção, é hora de começar a procurar um bom provedor de serviços em nuvem. Para a maioria dos que conheço, basta se cadastrar, criar um projeto e especificar que é baseado em Node, caso o serviço seja capaz de hospedar ambientes diferentes. Talvez você precise especificar quais outros recursos serão necessários, como, por exemplo, bancos de dados.

Quando estiver tudo pronto para a implementação, enviamos a aplicação à nuvem.

Normalmente, usamos o Git para isso, ou então uma ferramenta fornecida pelo provedor de nuvem. Por exemplo, o ambiente de cloud da Microsoft, o Azure, usa o Git para enviar a aplicação de seu ambiente local para a nuvem, enquanto o Google Cloud Platform fornece sua própria caixa de ferramentas para esse processo.

Encontrando um provedor Embora não seja tão atualizado, um bom lugar para procurar um provedor de hospedagem para projetos Node é a página do GitHub criada para esse fim (https://github.com/nodejs/node-v0.xarchive/wiki/Node-Hosting).

Node: a versão LTS e o processo de atualização Em 2014, o mundo do Node ficou perplexo (ou, pelo menos, alguns de nós ficamos) quando um grupo de mantenedores do Node se separaram da comunidade, criando uma dissidência do Node.js chamada io.js. A razão para esse desentendimento foi política: o pessoal do io.js considerava que a Joyent, empresa que mantinha o Node, estava vagarosa demais no processo de passar a governança do projeto para a comunidade.

O grupo também reclamava que a Joyent estava atrasada em providenciar o suporte para as constantes atualizações do V8, a “máquina” JavaScript por trás do Node.

Felizmente, os dois grupos resolveram suas diferenças e reuniram esforços em um único produto novamente, ainda chamado de Node.js. Agora, o Node é mantido por uma organização não governamental sem fins lucrativos, a Node Foundation, sob os auspícios da Linux Foundation. Como resultado, a base de código de ambos os grupos foi combinada, e, em vez de ganhar a versão 1.0, sua versão inicial estável se tornou o Node 4.0, representando o “devagar e sempre” do Node em direção à versão 1.0 e a rapidez do io.js, que chegou à versão 3.0 antes da reunião.

32

Aprendendo Node

A nova semântica de versões do Node Um resultado dessa união foi a adoção de um calendário bastante rigoroso de lançamentos para o Node, baseado em semântica de versões (semantic versioning, ou Semver, http://semver.org), que é bastante conhecida dos usuários do Linux. Cada nova versão lançada pelo modelo Semver tem três grupos de números, cada um com um significado específico. Por exemplo, no momento em que escrevo estas linhas, a versão do Node.js em meu servidor Linux é 4.3.2, que se traduz como: • A versão (major release, chamada coloquialmente em português de “versão grande”) é 4. Esse número só será aumentado quando uma mudança muito grande for feita no Node, tão grande que se torna incompatível com a anterior.

• A revisão (minor release, ou “versão pequena”) é 3. Esse número aumenta sempre que novas funcionalidades são adicionadas ao Node, mas ele continua compatível com as revisões anteriores da versão 4.

• A atualização (patch release) é 2. Esse número muda quando uma correção de segurança ou outras correções forem aplicadas, e também é compatível com as versões anteriores.

Estou usando, na minha estação de trabalho Windows, a versão estável (Stable) 5.7.1, e faço testes de código em uma máquina Linux com a versão atual (Current) 6.0.0.

A Node Foundation também suporta um ciclo de lançamentos mais coeso, embora mais problemático, do que o ciclo normal atualize-no-dia-ou-perca-o-bonde a que estamos acostumados. Esse ciclo começou com a primeira versão LTS (Long-Term Support) do Node.js v4, que será suportado até abril de 2018. A Node Foundation lançou sua primeira versão Stable, o Node.js v5, no final de outubro de 2015. O Node 5.x.x teve suporte apenas até abril de 2016, quando foi substituído pelo Node.js v6. A estratégia agora é ter uma versão Current (o nome Stable não existe mais) a cada seis meses, mas apenas as versões pares virarão LTS, como o Node v4.

Lançamento da versão 6.0.0 como Current Em abril de 2016, foi lançada a versão 6.0.0 do Node, que substituiu a versão 5.x, e que será transformada na nova LTS em outubro de 2016. A Node Foundation substituiu por Current a antiga designação da versão em desenvolvimento ativo, antigamente chamada de Stable.

Depois de abril de 2018, o Node v4 entrará em modo de manutenção. Nesse meio tempo, haverá novas atualizações compatíveis com versões antigas (conhecidas

Capítulo 1 ■ Ambiente do Node

33

como semver-major bumps), bem como atualizações para correção de bugs e falhas de segurança.

Qual versão o livro usa?

Este livro usa a versão LTS, ou seja, o Node.js v4. Há notas indicando as diferenças entre v4 e v5/v6, sempre que necessário.

Independentemente de qual versão LTS você decida usar, sempre será necessário atualizá-la quando sair alguma correção de segurança ou de bugs. Atualizar a versão “grande” para um novo semver-major bump é algo que apenas você, ou sua organização, pode decidir como fazer. Entretanto, a atualização será sempre compatível com versões anteriores, e o impacto será apenas no funcionamento interno do Node.

Ainda assim, é uma boa ideia passar antes por um plano de atualização e testes.

Qual versão você deve usar? Em um ambiente corporativo, o melhor é adotar a versão LTS, que no momento em que escrevo é o Node.js v4. Contudo, se o seu ambiente empresarial puder se adaptar mais rapidamente às mudanças que causam impacto, você pode ter acesso aos recursos mais modernos do V8 e do Node se usar a versão Current mais recente.

O mundo mágico dos ambientes de teste e produção Estudaremos os procedimentos de teste e depuração do Node, bem como outros processos de desenvolvimento e produção, no Capítulo 11.

Atualizando o Node Agora que o calendário de novas versões do Node é mais apertado, mantê-lo atualizado é ainda mais crítico. Felizmente, o processo de upgrade é indolor, além de oferecer alternativas.

Podemos verificar a versão atual com o comando: node -v

Se estiver usando um instalador de pacotes, basta empregar o procedimento-padrão de atualização. Dessa forma, o Node e outros softwares em seu sistema são atualizados (o comando sudo não é necessário no Windows): sudo apt-get update sudo apt-get upgrade --show-upgraded

34

Aprendendo Node

Se estiver usando outro instalador de pacotes, siga as instruções associadas a ele descritas no site oficial do Node. Negligenciar esse procedimento pode levar a uma falta de sincronia entre o seu Node e a versão mais atual.

Também podemos usar o npm para atualizar o Node, usando a sequência de comandos a seguir: sudo npm cache clean -f sudo npm install -g sudo n stable

Para instalar a versão mais atual do Node no Windows, OS X ou Raspberry Pi, baixe o instalador a partir da página de downloads do Node.js e execute. A nova versão é instalada por cima da anterior.

Gerenciador de versões do Node Em ambientes Linux ou OS X, podemos usar o Node Version Manager, cujo comando é nvm (https://github.com/creationix/nvm), para manter o Node atualizado.

O Node Package Manager (npm, https://www.npmjs.com) é atualizado com mais frequência que o próprio Node. Para atualizar apenas ele, rode o seguinte comando: sudo npm install npm -g n

Esse comando instala a versão mais nova da aplicação. Podemos verificar a nova versão pelo comando: npm -v

Entretanto, tenha em mente que isso pode causar problemas, especialmente se o ambiente é compartilhado por uma equipe. Se os membros da equipe estiverem usando a versão do npm que foi instalada com o Node e você atualizar só ele manualmente, podem ocorrer resultados inconsistentes de compilação não muito fáceis de descobrir.

Veremos o npm com mais profundidade no Capítulo 3. Por ora, note que podemos manter todos os módulos do Node atualizados com o comando a seguir: sudo npm update -g

Capítulo 1 ■ Ambiente do Node

35

Node, V8 e ES6 Por trás do Node existe um “motor” JavaScript. Para a maioria das aplicações, esse motor (em inglês, “engine”) é o V8. Originalmente criado pelo Google para o Chrome, o código-fonte do V8 foi aberto ao público em 2008. O V8 foi criado para melhorar o desempenho do JavaScript, incorporando um compilador just-in-time (JIT) que traduz o código em JavaScript para código de máquina, em vez de interpretá-lo. O JavaScript foi, por muitos anos, uma linguagem interpretada. O V8 foi escrito em C++.

Até a Microsoft tem uma dissidência do Node.js A Microsoft fez uma divisão (fork) do Node para criar uma versão que usa seu próprio engine de JavaScript, chamado Chakra, especialmente para ser usado em sua visão sobre como a Internet das Coisas (IoT) deve ser. Mais sobre esse fork no Capítulo 12.

Quando o Node v4.0 foi lançado, funcionava sobre o V8 na versão 4.5, a mesma versão do engine usado no Chrome. Os mantenedores do Node estão comprometidos a adotar as versões futuras do V8 à medida que forem lançadas, o que significa que o Node, hoje, suporta muitos dos novos recursos do ECMA-262 (ECMAScript 2015 ou, simplesmente, ES6).

Suporte do Node v6 ao V8 O Node v6 suporta o V8 na versão 5.0, e novas versões do Node adotarão as novas versões do V8 correspondentes.

Nas versões mais antigas do Node, para acessar os novos recursos do ES6, era preciso usar a flag harmony (--harmony) quando a aplicação fosse executada: node --harmony app.js

Hoje, o suporte aos recursos do ES6 é baseado nos seguintes critérios (informação retirada diretamente da documentação do Node.js): • Todos os recursos de shipping, que o V8 considera estáveis, estão ativados por default no Node.js e não precisam de nenhuma flag na hora da execução.

• Recursos staged, que são recursos quase finalizados, mas que ainda não são considerados estáveis o suficiente pela equipe do V8, só são ativados pela flag de execução: --es_staging (ou seu sinônimo, --harmony).

• Recursos in-progress podem ser ativados individualmente pela sua respectiva flag harmony (por exemplo, --harmony_destructuring), embora isso seja expressamente desencorajado, a não ser para testes.

36

Aprendendo Node

Veremos o suporte ao ES6 no Node e como usar de forma eficaz os diferentes recursos no Capítulo 9. Por ora, saiba que os recursos ES6 a seguir são apenas alguns dos suportados pelo Node, de fábrica: • Classes • Promessas • Símbolos • Funções-vetor • Geradores • Coleções • let • O operador spread

Avançado: os complementos do Node em C/C++ Com o Node instalado, e depois que você teve a chance de brincar um pouco com ele, pode estar se perguntando o que, exatamente, você instalou.

Apesar de a linguagem que usamos para criar aplicações em Node ser o JavaScript, a maior parte do próprio Node é, na verdade, escrita em C++. Normalmente essa informação é irrelevante para a maioria das aplicações que usamos, mas se você conhecer C/C++ pode estender a funcionalidade do Node com complementos (em inglês, add-ons) escritos nessas linguagens.

Escrever um complemento para o Node não é o mesmo que escrever uma aplicação tradicional em C/C++. Para começar, existem bibliotecas, como o próprio V8, que você deverá acessar. Além disso, um add-on do Node não é compilado com as ferramentas que você usaria normalmente.

A documentação do Node para complementos mostra um exemplo Hello World de add-on. Verifique o código do exemplo curto, que deve parecer bastante familiar para quem já programou em C/C++. Uma vez escrito o código, é preciso usar a ferramenta node-gyp para compilar o add-on, criando um arquivo .node.

Primeiro, é criado um arquivo de configuração chamado binding.gyp, que usa um formato semelhante a JSON para oferecer informações sobre o add-on: { "targets": [ {

Capítulo 1 ■ Ambiente do Node

37

"target_name": "addon", "sources": [ "hello.cc" ] } ] }

A configuração do add-on é executada com o seguinte comando: node-gyp configure

Isso cria o arquivo de configuração apropriado (um Makefile no Unix, um vcxproj no Windows) e o coloca no diretório build/. Para compilar o novo add-on do Node, execute o comando: node-gyp build

O add-on compilado é instalado no diretório build/release e está agora disponível para uso. Podemos importá-lo para qualquer aplicação da mesma forma que os outros complementos já instalados no Node por padrão (que veremos no Capítulo 3).

Mantendo módulos nativos do Node Embora faça parte do escopo deste livro, se você tiver interesse em criar módulos nativos do Node (os add-ons), esteja ciente das diferenças entre plataformas. Por exemplo, a Microsoft tem instruções especiais para módulos nativos no Azure (https:// azure.microsoft.com/en-us/documentation/articles/nodejs-use-nodemodules-azure-apps/ ), e o mantenedor do popular módulo nativo node-serialport escreveu um artigo detalhando as dificuldades por que passou enquanto mantinha esse módulo (http://www. voodootikigod.com/on-maintaining-a-native-node-module/ ).

Obviamente, se você nunca viu C/C++, pode querer criar módulos usando JavaScript mesmo, e veremos como fazer isso no Capítulo 3. Contudo, se conhecer essas duas linguagens, um add-on pode ser bem mais eficaz, especialmente para alguma necessidade específica do sistema.

Um aspecto a considerar e sempre ter em mente é o turbilhão de alterações drásticas pelas quais o Node passou desde a versão 0.8 até a nova versão 6.x. Para conter quaisquer problemas que possam ocorrer, é preciso instalar o NAN, ou Native Abstractions for Node.js (https://github.com/nodejs/nan). Esse arquivo de cabeçalho ajuda a suavizar as diferenças entre as versões do Node.js.