O que é Node.js?

O Node.js é um ambiente de código aberto para servidor, construído sobre o motor JavaScript V8 do Chrome. Ele fornece um ambiente de E/S (assíncrono) e de tempo de execução multiplataforma, orientado a eventos, com a finalidade de construir uma aplicação do lado do servidor altamente escalável utilizando JavaScript.

O Node.js pode ser usado para construir diferentes tipos de aplicações, tais como aplicação de linha de comando, aplicação web, aplicação de chat em tempo real, servidor REST API, etc. No entanto, ele é usado principalmente para construir programas de rede como servidores web, similares ao PHP, Java ou ASP.NET.

Node.js foi escrito e introduzido por Ryan Dahl em 2009. Visite a Wikipedia para conhecer a história do Node.js.

Modelo de Servidor Web Tradicional

No modelo tradicional de servidor web, cada pedido é tratado por um thread dedicado do pool de threads. Se nenhuma thread estiver disponível no pool de threads em qualquer momento, então o pedido aguarda até a próxima thread disponível. O thread dedicado executa uma determinada solicitação e não retorna ao pool de threads até completar a execução e retornar uma resposta.

Modelo de processamento Node.js

O Node.js processa as solicitações dos usuários de forma diferente quando comparado a um modelo tradicional de servidor web. O Node.js roda em um único processo e o código da aplicação roda em um único thread e, portanto, precisa de menos recursos do que outras plataformas.

Todas as solicitações do usuário ao seu aplicativo web serão tratadas por um único tópico e todo o trabalho de E/S ou trabalho de longa duração será realizado de forma assíncrona para uma determinada solicitação. Portanto, este único tópico não tem de esperar que a solicitação seja concluída e é livre para tratar da próxima solicitação. Quando o trabalho de E/S assíncrona é concluído, ele processa a solicitação e envia a resposta.

Um loop de eventos está constantemente atento para que os eventos sejam levantados para um trabalho assíncrono e executando a função callback quando o trabalho for concluído. Internamente, o Node.js usa libev para o loop de eventos que, por sua vez, usa o pool de threads C++ interno para fornecer E/S assíncrona.

O modelo de processo Node.js aumenta o desempenho e a escalabilidade com algumas advertências. O Node.js não é adequado para uma aplicação que realiza operações de CPU intensiva como processamento de imagens ou outro trabalho pesado de computação porque leva tempo para processar uma solicitação e, portanto, bloqueia a única thread.

Thread Pool

É um conjunto de threads pré-instanciadas prontas para uso. Elas não costumam ser liberadas, e ficam lá disponíveis (em idle) para reciclagem.

Pools geralmente provêem:

Melhor performance quando se executam um grande número de tarefas devido a um overhead reduzido de chamadas por tarefa
Uma forma de limitar recursos consumidos (incluindo threads) ao executar uma coleção de tarefas
Um programa com milhares de threads pode sofrer em desempenho

O básico de Node.js

O Node.js suporta JavaScript. Portanto, a sintaxe JavaScript no Node.js é similar à sintaxe JavaScript do navegador.

Visite a seção JavaScript para saber mais sobre a sintaxe JavaScript em detalhes.

Primitive Types

Node.js inclui os seguintes tipos primitivos:

String
Number
Boolean
Undefined
Null
RegExp

Object Literal

var obj = {
    authorName: 'Nicolas Oliveira',
    language: 'Node.js'
}

Functions

function Display(x) { 
    console.log(x);
}

Display(100);

Node.js Module

Módulo no Node.js é uma funcionalidade simples ou complexa organizada em um ou vários arquivos JavaScript que podem ser reutilizados em toda a aplicação Node.js.

Cada módulo no Node.js tem seu próprio contexto, portanto não pode interferir com outros módulos ou poluir o escopo global. Além disso, cada módulo pode ser colocado em um arquivo .js separado sob uma pasta separada.

O Node.js implementa módulos CommonJS padrão. O CommonJS é um grupo de voluntários que definem padrões JavaScript para servidor web, desktop e aplicativo de console.

Node.js includes three types of modules:

Core Modules
Módulos Locais
Módulos de Terceiros

Módulos Locais

Módulos locais são módulos criados localmente na sua aplicação Node.js. Estes módulos incluem diferentes funcionalidades da sua aplicação em ficheiros e pastas separados. Você também pode empacotá-lo e distribuí-lo via NPM, para que a comunidade Node.js possa usá-lo. Por exemplo, se você precisa se conectar ao MongoDB e buscar dados, então você pode criar um módulo para ele, que pode ser reutilizado em sua aplicação.

Escrevendo um Módulo simples

Vamos escrever um módulo de registo simples que registre a informação, avisando ou introduzindo um erro no console.

No Node.js, o módulo deve ser colocado em um arquivo JavaScript separado. Então, crie um arquivo Log.js e escreva o seguinte código no mesmo.

var log = {
            info: function (info) { 
                console.log('Info: ' + info);
            },
            warning:function (warning) { 
                console.log('Warning: ' + warning);
            },
            error:function (error) { 
                console.log('Error: ' + error);
            }
    };

module.exports = log

No exemplo acima de módulo de registo, criamos um objeto com três funções - info(), warning() e error(). No final, atribuímos este objeto ao module.exports. O module.exports no exemplo acima expõe um objeto de log como um módulo.

O módulo.exports é um objeto especial que é incluído em todos os arquivos JS na aplicação Node.js por padrão. Utilize o module.exports ou exportações para expor uma função, objeto ou variável como um módulo no Node.js.

Carregando o Módulo Local

Para usar módulos locais em sua aplicação, você precisa carregá-la usando a função require() da mesma forma que o módulo central. Entretanto, você precisa especificar o caminho do arquivo JavaScript do módulo. O exemplo a seguir demonstra como usar o módulo de registro acima contido no Log.js.

var myLogModule = require('./Log.js');

myLogModule.info('Node.js started');

No exemplo acima, o app.js está usando o módulo de log. Primeiro, ele carrega o módulo de registro usando a função require() e o caminho especificado onde o módulo de registro é armazenado. O módulo de registro está contido no arquivo Log.js na pasta raiz. Então, nós especificamos o caminho ./Log.js na função require(). O '.' denota uma pasta raiz.

A função require() retorna um objeto de log porque o módulo de log expõe um objeto em Log.js usando o module.exports. Então agora você pode usar o módulo de registro como um objeto e chamar qualquer uma de suas funções usando notação de pontos, por exemplo, myLogModule.info() ou myLogModule.warning() ou myLogModule.error() Execute o exemplo acima usando o prompt de comando:

    $ node app.js
    Info: Node.js started

Módulo de Exportação no Node.js

Na seção anterior, você aprendeu como escrever um módulo local usando o module.exports. Nesta seção, você aprenderá como expor diferentes tipos como um módulo usando o module.exports.

O module.exports ou exports é um objeto especial que é incluído em cada arquivo JS na aplicação Node.js por padrão. module.exports é uma variável que representa o módulo atual e exports é um objeto que será exposto como um módulo. Portanto, o que quer que você atribua ao module.exports ou exports, será exposto como um módulo.

Vamos ver como expor diferentes tipos como um módulo usando o module.exports.

Exportar literais

Como mencionado acima, a exportação é um objeto. Portanto, expõe tudo o que lhe foi atribuído como um módulo. Por exemplo, se você atribuir uma cadeia de caracteres literal, então ele irá expor essa cadeia de caracteres literalmente como um módulo.

O exemplo seguinte expõe uma mensagem de string simples como um módulo em Message.js.

module.exports = 'Hello world';

//ou

exports = 'Hello world';

Agora, importe este módulo de mensagem e use-o como mostrado abaixo.

var msg = require('./Messages.js');

console.log(msg);

Execute o exemplo acima e veja o resultado como mostrado abaixo.

$ node app.js
Hello World

Exportar um Objeto

exports é um objeto. Portanto, você pode anexar propriedades ou métodos a ele. O exemplo seguinte expõe um objeto com uma propriedade string no arquivo Message.js.

// Message.js
exports.SimpleMessage = 'Hello world';

//ou

module.exports.SimpleMessage = 'Hello world';

No exemplo acima, nós anexamos uma propriedade "SimpleMessage" ao objeto de exportação. Agora, importe e use este módulo como mostrado abaixo.

// app.js
var msg = require('./Messages.js');

console.log(msg.SimpleMessage);

No exemplo acima, a função require() irá retornar um objeto { SimpleMessage : 'Hello World'} e atribuí-lo à variável msg. Então, agora você pode usar a função msg.SimpleMessage.

Execute o exemplo acima escrevendo node app.js no prompt de comando e veja a saída como mostrado abaixo.

$ node app.js
Hello World

Da mesma forma que acima, você pode expor um objeto com função. O exemplo a seguir expõe um objeto com função de log como um módulo.

// Log.js
module.exports.log = function (msg) { 
    console.log(msg);
};

O módulo acima irá expor um objeto - { log : function(msg){ console.log(msg); } } . Use o módulo acima como mostrado abaixo.

// app.js
var msg = require('./Log.js');

msg.log('Hello World');

Execute e veja a saída no prompt de comando como mostrado abaixo.

    $ node app.js
    Hello World

Você também pode anexar um objeto ao module.exports como mostrado abaixo.

// data.js
module.exports = {
    firstName: 'James',
    lastName: 'Bond'
}

// app.js
var person = require('./data.js');
console.log(person.firstName + ' ' + person.lastName);