Node.

js
• Download http://nodejs.org/en
> node –v
v8.7.0
> npm –v
5.4.2

Node.js é um ambiente de desenvolvimento (paltaforma) do lado do

servidor, de código aberto, multi-plataforma, que corre JavaScript.

Visual Studio Code

version 1.17
w3schools – JavaScipt Tutorial – JavaScript Objects – JavaScript Functions
https://www.w3schools.com/js/default.asp

w3schools – Node.js Tutorial - Node.js MongoDB

https://www.w3schools.com/nodejs/default.asp

tutorialspoint – Node.js Tutorial

(PDF Version – 140 páginas: Web Module [99-103], Express Framework [104-125], RESTfull API [126-132])
https://www.tutorialspoint.com/nodejs/

Ultra fast applications using Node.js

https://openclassrooms.com/courses/ultra-fast-applications-using-node-js/installing-node-js

Node.js Tutorial in VS Code

https://code.visualstudio.com/docs/nodejs/nodejs-tutorial

Build a RESTful API Using Node and Express 4

https://scotch.io/tutorials/build-a-restful-api-using-node-and-express-4

Easy Node Authentication: Setup and Local

https://scotch.io/tutorials/easy-node-authentication-setup-and-local
 Funcionamento assíncrono (código não bloqueante)
Uma função callback é chamada quando uma dada tarefa termina
Ficheiro input.txt: Tutorials Point

Exemplo de código bloqueante: Exemplo de código não bloqueante:

Ficheiro mainSync.js: Ficheiro mainAsync.js:
var fs = require("fs"); var fs = require("fs");

var data = fs.readFileSync('input.txt'); fs.readFile('input.txt', function (err, data) {

if (err) return console.error(err);
console.log(data.toString()); console.log(data.toString());
console.log("Program Ended"); });
console.log("Program Ended");
Node.js> node mainSync
Tutorials Point Node.js> node mainAsync
Program Ended Program Ended
Tutorials Point
 Funcionamento assíncrono (código não bloqueante)
var fs = require("fs"); Código equivalente:
var fs = require("fs");
fs.readFile('input.txt’, var callback = function (err, data) {
function (err, data) { if (err) return console.error(err);
if (err) return console.error(err); console.log(data.toString());
console.log(data.toString()); }
} fs.readFile('input.txt’, callback);
); console.log("Program Ended");
console.log("Program Ended");

• A função function(err, data) é uma função anónima e enviada como último argumento da
função readFile().
• A função readFile() é uma função assíncrona, inicia a leitura e retorna.
• Em seguida o programa executa a instrução console.log(“Program Ended”).
• A função readFile() emite um evento “fim de leitura” quanto termina a leitura.
• A função callback function(err, data) só é invocada quando ocorre o evento “fim de leitura”.
• Deste modo o programa não executa as tarefas na ordem em que estão escritas.
 Padrão observer
Node.js é uma aplicação com um único thread, mas suporta
concorrência através do conceito de eventos e callbacks.

Para manter a concorrência Node.js usa funções assíncronas e o padrão

observer.

A thread Node mantém um ciclo de eventos e sempre que uma tarefa

termina, dispara o evento correspondente que sinaliza a execução da
função listener do evento.
Ficheiro evento.js
var eventos = require('events'); // Importa o módulo events
var eventEmitter = new eventos.EventEmitter(); // Cria um objeto eventEmitter
var listener1 = function() { // Cria um listener
console.log('Execução da função listener.');
}
eventEmitter.on('evento1', listener1); // Liga evento1 com o listener
eventEmitter.emit('evento1'); // Dispara o evento evento1
console.log("Fim do Programa.");

// Output:
> node evento
Execução da função listener.
Fim do Programa.
 Tratamento de eventos
1- Criar uma função callback com o código a ser executado quando
ocorrer o evento (criar o listener)
var listener1 = function() {
console.log('Execução da função listener 1.’);
}

2- Registar a função callback no emissor do evento para um dado evento

(adicionar um listener no fim do array de listeners para o evento
específico)
on(event, listener1) ou addListener(event, listner1)

3- Quando o emissor emite o evento a função callback é executada

eventEmitter.emit('evento1');
Numa aplicação Node:
• Qualquer função assíncrona aceita uma função callback como último
parâmetro
• Uma função callback aceita um objeto error como primeiro
parâmetro

var fs = require("fs"); • fs.readFile() é uma função

assíncrona que lê o conteúdo de um
fs.readFile('input.txt’, ficheiro.
function (err, data) { • Se durante a leitura ocorrer um
if (err) return console.error(err); erro, a leitura termina e um objeto
console.log(data.toString()); erro é passado à função callback.
} • Se durante a leitura não ocorre
); erro, quando a operação de leitura
console.log("Program Ended"); termina um objeto data contendo o
conteúdo da leitura é passado à
função callback
Uma aplicação servidora Node.js corre num único thread.
Embora só possa realizar uma tarefa de cada vez, Node.js é muito
eficiente a tratar muitos pedidos simultaneamente, devido à sua
natureza orientada a eventos.
• Se no processamento de um pedido inicia a realização de uma
operação mais demorada, o programa retorna e passa para o
próximo pedido.
• Quando a operação mais demorada termina, lança um evento e
Node.js continua a processar esse pedido.
Ficheiro server.js:
var http = require('http');

http.createServer(function (req, res) {

res.writeHead(200, {'Content-Type': 'text/plain'});
res.end('Hello World!');
}).listen(8080);

O módulo http é carregado e retorna um objeto JavaScript (http), que permite

executar as funcionalidades disponíveis no módulo.
A função createServer() executa um programa servidor que escuta no porto 8080.
A função callback anónima function(req, res) é invocada sempre que um pedido é
recebido pelo servidor. Contém 2 parâmetros:
• O primeiro, “req”, é um objeto que contém toda a informação do pedido,
• O segundo, “res”, é um objeto que devemos preencher com a resposta a enviar.
Ficheiro server.js:
var http = require('http');
var url = require('url');
var fs = require('fs');

http.createServer(function (req, res) {

var q = url.parse(req.url, true);
var filename = "." + q.pathname;
fs.readFile(filename, function(err, data) {
if (err) {
res.writeHead(404, {'Content-Type': 'text/html'});
return res.end("404 Not Found");
}
res.writeHead(200, {'Content-Type': 'text/html'});
res.write(data);
return res.end();
});
}).listen(8080);

Ficheiro verao.html: Ficheiro inverno.html:

<!DOCTYPE html> <!DOCTYPE html>
<html> <html>
<body> <body>
<h2>Verão</h2> <h2>Inverno</h2>
</body> </body>
</html> </html>
Ficheiro server.js:
var http = require('http');
var url = require('url');
var querystring = require('querystring');

http.createServer(function (req, res) {

var q = url.parse(req.url, true);
console.log("href=" + q.href);
console.log("pathname=" + q.pathname);
console.log("search=" + q.search);
var querystringObject = q.query;
for (param in querystringObject) {
console.log("param["+param+"]=" + querystringObject[param]);
}
res.writeHead(200, {'Content-Type': 'text/plain'});
res.write(q.href);
return res.end();
}).listen(8080);
 Express
Express é um framework Node.js para aplicações web

Node.js > npm install express –save // Node.js > express --version => 4.15.5
Node.js > npm install body-parser –save // midleware para tratar JSON e dados
Node.js > npm install cookie-parser –save // para tratar cookies
Node.js > npm install multer --save // midleware para multipart/form-data

Por omissão instala no diretório corrente (locally) – em ./node_modules

Para poder usar no próprio programa com require(‘modulo1’) devemos instalar na raiz
do projeto (locally)
Com o parâmetro –g instala globalmente (globally) – em …/AppData/Roaming/npm