O que é o Node.js e por que usá-lo?

• Alto desempenho: graças ao V8, o Node.js executa código JavaScript de forma extremamente rápida.

• Escalabilidade: o modelo assíncrono e event-driven permite lidar com múltiplas conexões simultâneas.

• Ecossistema rico: o npm conta com milhares de pacotes prontos para otimizar o desenvolvimento.

O que é o Event Loop e por que você precisa dominá-lo?

Como funciona o Event Loop?

console.log("Início");
setTimeout(() => console.log("Timeout"), 0);
console.log("Fim");

Início
Fim
Timeout

O "Timeout" é executado por último porque o setTimeout é assíncrono e passa pela fila de eventos antes de ser executado.

Como evitar bloqueios no Event Loop?

• Evite funções síncronas como fs.readFileSync().

• Use process.nextTick() e setImmediate() para melhorar a performance.

• Utilize Worker Threads para tarefas intensivas.

Async/Await: seu novo superpoder

fs.readFile("arquivo.txt", (err, data) => {
  if (err) {
    console.error("Erro ao ler arquivo");
  } else {
    console.log(data.toString());
  }
});

fs.promises.readFile("arquivo.txt")
  .then(data => console.log(data.toString()))
  .catch(err => console.error("Erro ao ler arquivo", err));

async function lerArquivo() {
  try {
    const data = await fs.promises.readFile("arquivo.txt");
    console.log(data.toString());
  } catch (err) {
    console.error("Erro ao ler arquivo", err);
  }
}
lerArquivo();

O uso de try/catch ajuda a tratar erros de forma eficiente.

Multiplicando a força do seu servidor com Cluster

const cluster = require("cluster");
const http = require("http");
const numCPUs = require("os").cpus().length;

if (cluster.isMaster) {
  console.log(`Processo mestre ${process.pid} está rodando`);

  for (let i = 0; i < numCPUs; i++) {
    cluster.fork();
  }

  cluster.on("exit", (worker) => {
    console.log(`Worker ${worker.process.pid} morreu, criando um novo...`);
    cluster.fork();
  });
} else {
  http.createServer((req, res) => {
    res.writeHead(200);
    res.end("Hello World");
  }).listen(8000);

  console.log(`Worker ${process.pid} iniciou`);
}

Benefícios do uso do Cluster:

• Melhor aproveitamento dos recursos do servidor ao usar múltiplos núcleos.

• Maior estabilidade: Se um worker falhar, ele pode ser reiniciado sem derrubar toda a aplicação.

• Escalabilidade horizontal: Combinado com balanceadores de carga, o cluster possibilita maior flexibilidade para crescer sua aplicação.

Performance de elite: evitando os vilões do desempenho

Evite operações bloqueantes

const fs = require("fs");
fs.readFile("arquivo.txt", "utf8", (err, data) => {
  if (err) throw err;
  console.log(data);
});

Utilize caching

const redis = require("redis");
const client = redis.createClient();

client.get("chave", (err, valor) => {
  if (valor) {
    console.log("Valor do cache:", valor);
  } else {
    // Consultar banco de dados e armazenar no cache
    client.set("chave", "resultado da consulta", "EX", 3600);
  }
});

Otimize consultas ao banco de dados

const { Pool } = require("pg");
const pool = new Pool({ connectionString: "postgres://usuario:senha@localhost/banco" });

async function obterUsuarios() {
  const { rows } = await pool.query("SELECT * FROM usuarios");
  return rows;
}

Use Worker Threads para tarefas pesadas

const { Worker } = require("worker_threads");

function iniciarWorker(script, callback) {
  const worker = new Worker(script);
  worker.on("message", callback);
  worker.on("error", (err) => console.error("Erro no worker:", err));
}

iniciarWorker("worker.js", (resultado) => console.log("Resultado do processamento:", resultado));

Monitore e analise performance

Próximos passos

Agora é sua vez: comece a aplicar essas dicas e torne-se um desenvolvedor Node.js de sucesso!