Runtimes (NodeJS)

Node.js é um ambiente de execução JavaScript de código aberto, baseado no motor V8 do Google Chrome, que permite executar código JavaScript no lado do servidor. Diferentemente dos ambientes tradicionais de JavaScript que são executados em navegadores, o Node.js possibilita a criação de aplicações de servidor, ferramentas de linha de comando e muito mais.

Características Principais

1. Arquitetura Orientada a Eventos

Node.js utiliza um modelo de I/O não bloqueante e orientado a eventos, o que o torna eficiente e adequado para aplicações em tempo real que precisam lidar com muitas conexões simultâneas.

const http = require('http');

const server = http.createServer((req, res) => {
  res.writeHead(200, {'Content-Type': 'text/plain'});
  res.end('Hello World\n');
});

server.listen(3000, () => {
  console.log('Servidor rodando em http://localhost:3000/');
});

2. Single-Threaded com Event Loop

Node.js opera em uma única thread, utilizando um loop de eventos para gerenciar operações assíncronas. Isso permite que ele lide com múltiplas conexões concorrentes sem a sobrecarga de criar novas threads para cada conexão.

3. NPM (Node Package Manager)

O NPM é o gerenciador de pacotes do Node.js, que facilita o compartilhamento e a reutilização de código. É um dos maiores repositórios de software do mundo, com milhões de pacotes disponíveis.

# Inicializar um novo projeto
npm init

# Instalar um pacote
npm install express

# Instalar um pacote globalmente
npm install -g nodemon

# Executar scripts definidos no package.json
npm run start

4. Módulos

Node.js utiliza um sistema de módulos para organizar o código em arquivos separados, facilitando a manutenção e reutilização.

// Módulo math.js
exports.add = (a, b) => a + b;
exports.subtract = (a, b) => a - b;

// Uso do módulo
const math = require('./math');
console.log(math.add(5, 3)); // 8

Arquitetura do Node.js

1. Motor V8

O V8 é o motor JavaScript de código aberto desenvolvido pelo Google para o Chrome. O Node.js utiliza o V8 para interpretar e executar código JavaScript.

2. Libuv

Libuv é uma biblioteca de I/O assíncrono multiplataforma que fornece ao Node.js acesso ao sistema de arquivos, rede e outros recursos do sistema operacional de forma não bloqueante.

3. Módulos Nativos

Node.js inclui módulos nativos escritos em C++ que fornecem funcionalidades de baixo nível, como acesso ao sistema de arquivos, rede, criptografia, etc.

4. Módulos JavaScript

A biblioteca padrão do Node.js inclui módulos JavaScript que fornecem funcionalidades de alto nível, como HTTP, HTTPS, FS (sistema de arquivos), etc.

Módulos Principais

1. HTTP/HTTPS

Permite criar servidores HTTP e fazer requisições HTTP.

const http = require('http');

const server = http.createServer((req, res) => {
  res.writeHead(200, {'Content-Type': 'text/plain'});
  res.end('Hello World\n');
});

server.listen(3000);

2. FS (File System)

Fornece uma API para interagir com o sistema de arquivos.

const fs = require('fs');

// Leitura síncrona
const data = fs.readFileSync('arquivo.txt', 'utf8');
console.log(data);

// Leitura assíncrona
fs.readFile('arquivo.txt', 'utf8', (err, data) => {
  if (err) throw err;
  console.log(data);
});

// Usando Promises (Node.js 10+)
const fsPromises = require('fs').promises;

async function lerArquivo() {
  try {
    const data = await fsPromises.readFile('arquivo.txt', 'utf8');
    console.log(data);
  } catch (err) {
    console.error(err);
  }
}

3. Path

Fornece utilitários para trabalhar com caminhos de arquivo e diretório.

const path = require('path');

// Juntar segmentos de caminho
const fullPath = path.join('/diretorio', 'subdiretorio', 'arquivo.txt');

// Obter o nome do arquivo
const fileName = path.basename(fullPath);

// Obter a extensão do arquivo
const fileExt = path.extname(fullPath);

// Obter o diretório
const dirName = path.dirname(fullPath);

4. Events

Fornece uma implementação do padrão Observer através da classe EventEmitter.

const EventEmitter = require('events');

class MeuEmissor extends EventEmitter {}

const emissor = new MeuEmissor();

// Registrar um listener
emissor.on('evento', (a, b) => {
  console.log(a, b);
});

// Emitir um evento
emissor.emit('evento', 'a', 'b');

5. Stream

Fornece uma interface para trabalhar com fluxos de dados.

const fs = require('fs');

// Stream de leitura
const readStream = fs.createReadStream('arquivo.txt');
readStream.on('data', (chunk) => {
  console.log(`Recebido ${chunk.length} bytes de dados.`);
});
readStream.on('end', () => {
  console.log('Fim da leitura.');
});

// Stream de escrita
const writeStream = fs.createWriteStream('saida.txt');
writeStream.write('Hello, ');
writeStream.write('World!');
writeStream.end();

// Pipe (encadeamento de streams)
readStream.pipe(writeStream);

Frameworks e Bibliotecas Populares

1. Express

Express é um framework web minimalista e flexível para Node.js que fornece um conjunto robusto de recursos para aplicações web e móveis.

const express = require('express');
const app = express();
const port = 3000;

app.get('/', (req, res) => {
  res.send('Hello World!');
});

app.listen(port, () => {
  console.log(`Aplicação rodando em http://localhost:${port}`);
});

2. Nest.js

Nest.js é um framework para construir aplicações server-side eficientes e escaláveis em Node.js, inspirado no Angular.

import { Controller, Get } from '@nestjs/common';

@Controller('cats')
export class CatsController {
  @Get()
  findAll(): string {
    return 'This action returns all cats';
  }
}

3. Socket.io

Socket.io é uma biblioteca que permite comunicação em tempo real, bidirecional e baseada em eventos entre navegadores web e servidores.

const io = require('socket.io')(server);

io.on('connection', (socket) => {
  console.log('Um usuário se conectou');

  socket.on('chat message', (msg) => {
    io.emit('chat message', msg);
  });

  socket.on('disconnect', () => {
    console.log('Usuário desconectado');
  });
});

4. Mongoose

Mongoose é uma biblioteca de modelagem de objetos MongoDB para Node.js.

const mongoose = require('mongoose');
mongoose.connect('mongodb://localhost:27017/test');

const Cat = mongoose.model('Cat', { name: String });

const kitty = new Cat({ name: 'Zildjian' });
kitty.save().then(() => console.log('meow'));